inference_and_visualization_resnet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notes\n",
    "\n",
    "This notebook is for inference and visualizations. \n",
    "\n",
    "You can either load images from a dataloader(see Sec. 1) or from a local path(see Sec. 2).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "import json\n",
    "import numpy as np\n",
    "import mlx.core as mx\n",
    "from main import build_model_main\n",
    "from util.slconfig import SLConfig\n",
    "from datasets import build_dataset\n",
    "from util.visualizer import COCOVisualizer\n",
    "from util import box_ops\n",
    "import util.misc as utils\n",
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialize and Load Pre-trained Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_config_path = \"config/DINO/DINO_4scale.py\" # change the path of the model config file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/sachinraja/Code/DINO_DETR_MLX/util/pytorch_weights_to_mlx.py:198: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  pytorch_weights_flattened = torch.load(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "DINO(\n",
       "  (transformer): DeformableTransformer(\n",
       "    (encoder): TransformerEncoder(\n",
       "      (params.encoder_layer): DeformableTransformerEncoderLayer(\n",
       "        (self_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.0): DeformableTransformerEncoderLayer(\n",
       "        (self_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.1): DeformableTransformerEncoderLayer(\n",
       "        (self_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.2): DeformableTransformerEncoderLayer(\n",
       "        (self_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.3): DeformableTransformerEncoderLayer(\n",
       "        (self_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.4): DeformableTransformerEncoderLayer(\n",
       "        (self_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.5): DeformableTransformerEncoderLayer(\n",
       "        (self_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (decoder): TransformerDecoder(\n",
       "      (params.decoder_layer): DeformableTransformerDecoderLayer(\n",
       "        (cross_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (self_attn): MultiHeadAttention(\n",
       "          (query_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (key_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (out_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout4): Dropout(p=0.0)\n",
       "        (norm3): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (params.norm): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      (layers.0): DeformableTransformerDecoderLayer(\n",
       "        (cross_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (self_attn): MultiHeadAttention(\n",
       "          (query_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (key_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (out_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout4): Dropout(p=0.0)\n",
       "        (norm3): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.1): DeformableTransformerDecoderLayer(\n",
       "        (cross_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (self_attn): MultiHeadAttention(\n",
       "          (query_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (key_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (out_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout4): Dropout(p=0.0)\n",
       "        (norm3): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.2): DeformableTransformerDecoderLayer(\n",
       "        (cross_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (self_attn): MultiHeadAttention(\n",
       "          (query_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (key_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (out_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout4): Dropout(p=0.0)\n",
       "        (norm3): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.3): DeformableTransformerDecoderLayer(\n",
       "        (cross_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (self_attn): MultiHeadAttention(\n",
       "          (query_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (key_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (out_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout4): Dropout(p=0.0)\n",
       "        (norm3): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.4): DeformableTransformerDecoderLayer(\n",
       "        (cross_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (self_attn): MultiHeadAttention(\n",
       "          (query_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (key_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (out_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout4): Dropout(p=0.0)\n",
       "        (norm3): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (layers.5): DeformableTransformerDecoderLayer(\n",
       "        (cross_attn): MSDeformAttn(\n",
       "          (sampling_offsets): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (attention_weights): Linear(input_dims=256, output_dims=128, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (output_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout1): Dropout(p=0.0)\n",
       "        (norm1): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (self_attn): MultiHeadAttention(\n",
       "          (query_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (key_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (value_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "          (out_proj): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        )\n",
       "        (dropout2): Dropout(p=0.0)\n",
       "        (norm2): LayerNorm(256, eps=1e-05, affine=True)\n",
       "        (linear1): Linear(input_dims=256, output_dims=2048, bias=True)\n",
       "        (dropout3): Dropout(p=0.0)\n",
       "        (linear2): Linear(input_dims=2048, output_dims=256, bias=True)\n",
       "        (dropout4): Dropout(p=0.0)\n",
       "        (norm3): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      )\n",
       "      (norm): LayerNorm(256, eps=1e-05, affine=True)\n",
       "      (ref_point_head): MLP(\n",
       "        (layers.0): Linear(input_dims=512, output_dims=256, bias=True)\n",
       "        (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "      )\n",
       "      (bbox_embed.0): MLP(\n",
       "        (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "      )\n",
       "      (bbox_embed.1): MLP(\n",
       "        (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "      )\n",
       "      (bbox_embed.2): MLP(\n",
       "        (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "      )\n",
       "      (bbox_embed.3): MLP(\n",
       "        (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "      )\n",
       "      (bbox_embed.4): MLP(\n",
       "        (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "      )\n",
       "      (bbox_embed.5): MLP(\n",
       "        (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "        (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "      )\n",
       "      (class_embed.0): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "      (class_embed.1): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "      (class_embed.2): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "      (class_embed.3): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "      (class_embed.4): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "      (class_embed.5): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "    )\n",
       "    (tgt_embed): Embedding(900, 256)\n",
       "    (enc_output): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (enc_output_norm): LayerNorm(256, eps=1e-05, affine=True)\n",
       "    (enc_out_bbox_embed): MLP(\n",
       "      (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "      (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "      (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "    )\n",
       "    (enc_out_class_embed): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "  )\n",
       "  (label_enc): Embedding(92, 256)\n",
       "  (dn_encoder): DNEncoder(\n",
       "    (label_enc): Embedding(92, 256)\n",
       "  )\n",
       "  (input_proj.0): Sequential(\n",
       "    (layers.0): Conv2d(512, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=True)\n",
       "    (layers.1): GroupNorm(32, 256, eps=1e-05, affine=True, pytorch_compatible=False)\n",
       "  )\n",
       "  (input_proj.1): Sequential(\n",
       "    (layers.0): Conv2d(1024, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=True)\n",
       "    (layers.1): GroupNorm(32, 256, eps=1e-05, affine=True, pytorch_compatible=False)\n",
       "  )\n",
       "  (input_proj.2): Sequential(\n",
       "    (layers.0): Conv2d(2048, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=True)\n",
       "    (layers.1): GroupNorm(32, 256, eps=1e-05, affine=True, pytorch_compatible=False)\n",
       "  )\n",
       "  (input_proj.3): Sequential(\n",
       "    (layers.0): Conv2d(2048, 256, kernel_size=(3,), stride=(2, 2), padding=(1, 1), dilation=1, bias=True)\n",
       "    (layers.1): GroupNorm(32, 256, eps=1e-05, affine=True, pytorch_compatible=False)\n",
       "  )\n",
       "  (backbone): Joiner(\n",
       "    (layers.0): Backbone(\n",
       "      (body): ResNet(\n",
       "        (conv1): Conv2d(3, 64, kernel_size=(7,), stride=(2, 2), padding=(3, 3), dilation=1, bias=False)\n",
       "        (bn1): FrozenBatchNorm2d()\n",
       "        (relu): ReLU()\n",
       "        (maxpool): MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "        (layers.0): Sequential(\n",
       "          (layers.0): Bottleneck(\n",
       "            (conv1): Conv2d(64, 64, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(64, 64, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(64, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "            (downsample): Sequential(\n",
       "              (layers.0): Conv2d(64, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "              (layers.1): FrozenBatchNorm2d()\n",
       "            )\n",
       "          )\n",
       "          (layers.1): Bottleneck(\n",
       "            (conv1): Conv2d(256, 64, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(64, 64, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(64, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.2): Bottleneck(\n",
       "            (conv1): Conv2d(256, 64, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(64, 64, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(64, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (layers.1): Sequential(\n",
       "          (layers.0): Bottleneck(\n",
       "            (conv1): Conv2d(256, 128, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(128, 128, kernel_size=(3,), stride=(2, 2), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(128, 512, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "            (downsample): Sequential(\n",
       "              (layers.0): Conv2d(256, 512, kernel_size=(1,), stride=(2, 2), padding=(0, 0), dilation=1, bias=False)\n",
       "              (layers.1): FrozenBatchNorm2d()\n",
       "            )\n",
       "          )\n",
       "          (layers.1): Bottleneck(\n",
       "            (conv1): Conv2d(512, 128, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(128, 128, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(128, 512, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.2): Bottleneck(\n",
       "            (conv1): Conv2d(512, 128, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(128, 128, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(128, 512, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.3): Bottleneck(\n",
       "            (conv1): Conv2d(512, 128, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(128, 128, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(128, 512, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (layers.2): Sequential(\n",
       "          (layers.0): Bottleneck(\n",
       "            (conv1): Conv2d(512, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(256, 256, kernel_size=(3,), stride=(2, 2), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(256, 1024, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "            (downsample): Sequential(\n",
       "              (layers.0): Conv2d(512, 1024, kernel_size=(1,), stride=(2, 2), padding=(0, 0), dilation=1, bias=False)\n",
       "              (layers.1): FrozenBatchNorm2d()\n",
       "            )\n",
       "          )\n",
       "          (layers.1): Bottleneck(\n",
       "            (conv1): Conv2d(1024, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(256, 256, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(256, 1024, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.2): Bottleneck(\n",
       "            (conv1): Conv2d(1024, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(256, 256, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(256, 1024, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.3): Bottleneck(\n",
       "            (conv1): Conv2d(1024, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(256, 256, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(256, 1024, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.4): Bottleneck(\n",
       "            (conv1): Conv2d(1024, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(256, 256, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(256, 1024, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.5): Bottleneck(\n",
       "            (conv1): Conv2d(1024, 256, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(256, 256, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(256, 1024, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (layers.3): Sequential(\n",
       "          (layers.0): Bottleneck(\n",
       "            (conv1): Conv2d(1024, 512, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(512, 512, kernel_size=(3,), stride=(2, 2), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(512, 2048, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "            (downsample): Sequential(\n",
       "              (layers.0): Conv2d(1024, 2048, kernel_size=(1,), stride=(2, 2), padding=(0, 0), dilation=1, bias=False)\n",
       "              (layers.1): FrozenBatchNorm2d()\n",
       "            )\n",
       "          )\n",
       "          (layers.1): Bottleneck(\n",
       "            (conv1): Conv2d(2048, 512, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(512, 512, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(512, 2048, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "          (layers.2): Bottleneck(\n",
       "            (conv1): Conv2d(2048, 512, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn1): FrozenBatchNorm2d()\n",
       "            (conv2): Conv2d(512, 512, kernel_size=(3,), stride=(1, 1), padding=(1, 1), dilation=1, bias=False)\n",
       "            (bn2): FrozenBatchNorm2d()\n",
       "            (conv3): Conv2d(512, 2048, kernel_size=(1,), stride=(1, 1), padding=(0, 0), dilation=1, bias=False)\n",
       "            (bn3): FrozenBatchNorm2d()\n",
       "            (relu): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (avgpool): AdaptiveAvgPool2d()\n",
       "        (fc): Linear(input_dims=2048, output_dims=1000, bias=True)\n",
       "      )\n",
       "    )\n",
       "    (layers.1): PositionEmbeddingSine()\n",
       "  )\n",
       "  (bbox_embed.0): MLP(\n",
       "    (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "  )\n",
       "  (bbox_embed.1): MLP(\n",
       "    (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "  )\n",
       "  (bbox_embed.2): MLP(\n",
       "    (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "  )\n",
       "  (bbox_embed.3): MLP(\n",
       "    (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "  )\n",
       "  (bbox_embed.4): MLP(\n",
       "    (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "  )\n",
       "  (bbox_embed.5): MLP(\n",
       "    (layers.0): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.1): Linear(input_dims=256, output_dims=256, bias=True)\n",
       "    (layers.2): Linear(input_dims=256, output_dims=4, bias=True)\n",
       "  )\n",
       "  (class_embed.0): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "  (class_embed.1): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "  (class_embed.2): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "  (class_embed.3): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "  (class_embed.4): Linear(input_dims=256, output_dims=91, bias=True)\n",
       "  (class_embed.5): Linear(input_dims=256, output_dims=91, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "args = SLConfig.fromfile(model_config_path) \n",
    "args.device = 'metal' \n",
    "model, criterion, postprocessors = build_model_main(args)\n",
    "model = utils.load_mlx_model_with_pytorch_weights(model, args.pytorch_weights_path, args.backbone, None)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load coco names\n",
    "with open('util/coco_id2name.json') as f:\n",
    "    id2name = json.load(f)\n",
    "    id2name = {int(k):v for k,v in id2name.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize Custom Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import datasets.transforms as T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = Image.open(\"./figs/idea.jpg\").convert(\"RGB\") # load image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform images\n",
    "transform = T.Compose([\n",
    "    T.RandomResize([800], max_size=1333),\n",
    "    T.ToTensor(),\n",
    "    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "])\n",
    "image, _ = transform(image, None)\n",
    "image = mx.array(image.numpy()).transpose(1, 2, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1199, 800, 3)\n"
     ]
    }
   ],
   "source": [
    "print(image.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict images\n",
    "output = model(image[None])\n",
    "output = postprocessors['bbox'](output, mx.array([[1.0, 1.0]]))[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'boxes': array([[0.753671, 0.638262, 1, 0.889454],\n",
      "       [0.751169, 0.300905, 0.999702, 0.540427],\n",
      "       [0.221359, 0.441168, 0.436835, 0.789937],\n",
      "       ...,\n",
      "       [0.956329, 0.590019, 1, 0.606367],\n",
      "       [0.426976, 0.477636, 0.609664, 0.578968],\n",
      "       [0.303678, 0.579364, 0.751804, 0.693615]], dtype=float32),\n",
      " 'labels': array([62, 72, 62, ..., 76, 62, 67], dtype=uint32),\n",
      " 'scores': array([0.886558, 0.740444, 0.700882, ..., 0.0225684, 0.0225316, 0.0224695], dtype=float32)}\n"
     ]
    }
   ],
   "source": [
    "pprint(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1199, 800, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize outputs\n",
    "thershold = 0.3 # set a thershold\n",
    "\n",
    "vslzr = COCOVisualizer()\n",
    "\n",
    "scores = output['scores']\n",
    "labels = output['labels']\n",
    "boxes = box_ops.box_xyxy_to_cxcywh(output['boxes'])\n",
    "select_mask = scores > thershold\n",
    "labels = np.asarray(labels)\n",
    "boxes = np.asarray(boxes)\n",
    "select_mask = np.asarray(select_mask)\n",
    "# image = np.asarray(image)\n",
    "print(image.shape)\n",
    "box_label = [id2name[int(item)] for item in labels[select_mask]]\n",
    "pred_dict = {\n",
    "    'boxes': boxes[select_mask],\n",
    "    'size': mx.array([image.shape[0], image.shape[1]]),\n",
    "    'box_label': box_label\n",
    "}\n",
    "vslzr.visualize(image, pred_dict, savedir=None, dpi=100)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.18"
  },
  "vscode": {
   "interpreter": {
    "hash": "0ad18b9cce5171a92b1ace78d675cb7cfe7b38ef1dfda11fe1bc29cba1874dd4"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}