Walkthrough.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Behavior Transformer Implementation Walkthrough\n",
    "Adapted from the original BeT code (https://github.com/notmahi/bet) and paper (https://arxiv.org/pdf/2206.11251)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Libraries Required**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "import torch.nn.functional as F\n",
    "from gpt import GPT, GPTConfig\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. K-Means Based (De/En)coder: $ a:= A_{\\lfloor a \\rfloor}$ + $ \\langle a \\rangle$\n",
    "The first component of a Behavior Transformer (BeT) is a K-means based encoder and decoder learned prior to the task training and testing.\n",
    "\n",
    "<img width=\"600px\" src=\"images/K-Mean.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Encoder:** Given an action $a$, the ecnoder component would discretize it into an action bin **$\\lfloor a \\rfloor$** and a residual action **$ \\langle a \\rangle $**, such that $ a := A_{\\lfloor a \\rfloor} + \\langle a \\rangle $.\n",
    "\n",
    "**Decoder:** Given an action bin **$\\lfloor a \\rfloor$** and the residual action **$ \\langle a \\rangle $**, it would output **a** given by $ a := A_{\\lfloor a \\rfloor} + \\langle a \\rangle $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderDecoder:\n",
    "\n",
    "    def __init__(self, action_dim, num_bins, actions):\n",
    "        self.action_dim = action_dim\n",
    "        self.num_bins = num_bins\n",
    "        # Note: Using sklearn for simplicity\n",
    "        self.kmeans = KMeans(n_clusters=self.num_bins) \n",
    "        self.kmeans.fit(actions.cpu())\n",
    "\n",
    "    def encode(self, action):\n",
    "\n",
    "        batch_size, sequence_length, action_dim = action.shape\n",
    "\n",
    "        # Reshaping to exclude batch size        \n",
    "        action = action.reshape((batch_size*sequence_length,action_dim))\n",
    "        \n",
    "        # Finding the action bin center\n",
    "        action_bin = self.kmeans.predict(action.cpu())\n",
    "        action_center = self.get_center(action_bin)\n",
    "\n",
    "        # Computing the action residual (action - action_center)\n",
    "        action_residual = action.to(DEVICE) - action_center.to(DEVICE)\n",
    "\n",
    "        # Reshaping to include batch size\n",
    "        action_residual = action_residual.reshape((batch_size, sequence_length, action_dim))\n",
    "        action_bin = action_bin.reshape((batch_size, sequence_length, 1))\n",
    "\n",
    "        # Returning the Action Bin and the Action Residual\n",
    "        return torch.tensor(action_bin,dtype=torch.int64), action_residual.to(torch.float)\n",
    "        \n",
    "    def decode(self, action_bin, action_residual):\n",
    "        action_center = self.get_center(action_bin.cpu()).to(DEVICE)\n",
    "        action = action_residual + action_center\n",
    "        # Returning the associated action\n",
    "        return action\n",
    "    \n",
    "    def get_center(self, action_bin):\n",
    "        return torch.tensor(self.kmeans.cluster_centers_[action_bin].squeeze())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tesing the Encoder/Decoder Component**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoded Action Bin Shape:\t torch.Size([1, 2, 1])\n",
      "Encoded Action Residual Shape:\t torch.Size([1, 2, 2])\n",
      "Original:\t [[[0.7842819690704346, 0.7286837100982666], [0.6952674388885498, 0.7302123308181763]]]\n",
      "Decoded Action:\t [[[0.7842819690704346, 0.728683739900589], [0.6952674388885498, 0.7302123606204987]]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
      "  super()._check_params_vs_input(X, default_n_init=10)\n",
      "/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/threadpoolctl.py:1019: RuntimeWarning: libc not found. The ctypes module in Python 3.8 is maybe too old for this OS.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "num_bins = 2\n",
    "batch_size = 1\n",
    "total_action_batch_size = 5\n",
    "sequence_length = 2\n",
    "action_dim = 2\n",
    "total_actions = 3\n",
    "\n",
    "actions = torch.rand((total_actions,action_dim))\n",
    "\n",
    "encoder_decoder = EncoderDecoder(action_dim,num_bins,actions)\n",
    "\n",
    "test_input = torch.rand((batch_size,sequence_length,action_dim))\n",
    "action_bin, action_residual = encoder_decoder.encode(test_input) # Expected Output is a [1.0, 2.0] residual\n",
    "print(\"Encoded Action Bin Shape:\\t\", action_bin.shape)\n",
    "print(\"Encoded Action Residual Shape:\\t\", action_residual.shape)\n",
    "decoded = encoder_decoder.decode(action_bin=action_bin,action_residual=action_residual)\n",
    "print(\"Original:\\t\", test_input.cpu().numpy().tolist())\n",
    "print(\"Decoded Action:\\t\", decoded.cpu().numpy().tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. nanoGPT for initial Action Bins $\\lfloor a \\rfloor$\n",
    "The second component of BeT is a transformer that takes the history of the last $L$ observations $[o_{i-L}, ... o_{i-1}, o_i]$ as an input, and outputs an initial predicted probability sequence of the fixed possible action bins of the next predicted action to get $\\lfloor a_{i+1} \\rfloor$. These will be used later to output the actual action bins logits.\n",
    "\n",
    "<img width=\"700px\" src=\"images/mingpt.jpeg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_gpt(observation_dim, num_bins, sequence_length):\n",
    "    gpt = GPT(GPTConfig(\n",
    "        block_size=sequence_length,\n",
    "        input_dim=observation_dim,\n",
    "        output_dim=num_bins,\n",
    "        n_layer=4,\n",
    "        n_head=4,\n",
    "        n_embd=72, \n",
    "    ))\n",
    "    return gpt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tesing the GPT**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 0.25M\n",
      "Observation Shape:\t\t torch.Size([1, 5, 1])\n",
      "Action Bins Logits Shape:\t torch.Size([1, 5, 10])\n"
     ]
    }
   ],
   "source": [
    "observation_dim = 1\n",
    "num_bins = 10\n",
    "sequence_length = 5\n",
    "gpt = make_gpt(observation_dim,num_bins,sequence_length)\n",
    "batch_size = 1\n",
    "\n",
    "observations_history = torch.rand((batch_size,sequence_length,observation_dim))\n",
    "logits = gpt(observations_history)\n",
    "\n",
    "print(\"Observation Shape:\\t\\t\", observations_history.shape)\n",
    "print(\"Action Bins Logits Shape:\\t\", logits.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Transformer Head for final Action Residuals $ \\langle a \\rangle $ and Bins $\\lfloor a \\rfloor$\n",
    "The last component of BeT takes the action bins $\\lfloor a \\rfloor$ logits outputed by the transformer and embeds them into a representation that includes the final action bin $\\lfloor a \\rfloor$ and action residual $ \\langle a \\rangle $\n",
    "\n",
    "<img width=\"700px\" src=\"images/head.jpeg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Head(nn.Module):\n",
    "\n",
    "    def __init__(self, num_bins, action_dim, drop_out=0.1):\n",
    "        super(Head, self).__init__()\n",
    "\n",
    "        self.num_bins = num_bins\n",
    "        self.action_dim = action_dim\n",
    "\n",
    "        linear_in_dim = num_bins\n",
    "        linear_out_dim = num_bins*(action_dim+1)\n",
    "        \n",
    "        self.layer = nn.Linear(linear_in_dim,linear_out_dim)\n",
    "        self.dropout = nn.Dropout(drop_out)\n",
    "       \n",
    "    def forward(self, transformer_logits):\n",
    "        \n",
    "        batch_size, sequence_length, num_bins = transformer_logits.shape\n",
    "        # Transformer Logits: (Batch_Size , Sequence_Length , Number_Action_Bins)\n",
    "\n",
    "        x = self.layer(transformer_logits)\n",
    "        action_data = self.dropout(x)\n",
    "        # Action Data: (Batch_Size , Sequence_Length , Number_Action_Bins*(Action_dim+1))\n",
    "\n",
    "        seq_action_bins_logits, all_seq_action_residuals = torch.split(action_data, [num_bins, num_bins * action_dim], dim=-1)\n",
    "        # Sequence Action Bins Logits:   (Batch_Size , Sequence_Length, Number_Action_Bins)\n",
    "        # All Sequence Action Residuals: (Batch_Size , Sequence_Length, Number_Action_Bins*Action_dim)\n",
    "        \n",
    "        # Softmaxing the seq_action_bins_logits action bins logits to get the probability per bin at every sequence index\n",
    "        seq_action_bins_probs = torch.softmax(seq_action_bins_logits,dim=-1)\n",
    "        seq_action_bins = torch.multinomial(seq_action_bins_probs.view(-1, num_bins), num_samples=1)\n",
    "        seq_action_bins = seq_action_bins.reshape((batch_size,sequence_length,1))\n",
    "        # Sequence Action Bins: (Batch_Size, Sequence_Length, 1)\n",
    "\n",
    "        # Keeping the action resiudals for the selected action bin\n",
    "        flat_all_seq_action_residuals = all_seq_action_residuals.reshape((batch_size*sequence_length, num_bins, action_dim))\n",
    "        flat_seq_action_residuals = flat_all_seq_action_residuals[torch.arange(flat_all_seq_action_residuals.shape[0]),seq_action_bins.flatten()]\n",
    "        seq_action_residuals = flat_seq_action_residuals.reshape((batch_size, sequence_length, action_dim))\n",
    "        # Sequence Action Residuals: (Batch_Size , Sequence_Length, Action_dim)\n",
    "\n",
    "        return {\"seq_action_bins\": seq_action_bins, \"seq_action_residuals\": seq_action_residuals, \"seq_action_bins_logits\": seq_action_bins_logits,}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tesing the Transformer Head**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Action Residuals Shape:\t\t torch.Size([5, 5, 3])\n",
      "Actions Bins Shape:\t\t torch.Size([5, 5, 1])\n",
      "Actions Bins Logits Shape:\t torch.Size([5, 5, 2])\n"
     ]
    }
   ],
   "source": [
    "batch_size = 5\n",
    "num_bins = 2\n",
    "sequence_length = 5\n",
    "action_dim = 3\n",
    "logits = torch.rand((batch_size,sequence_length,num_bins))\n",
    "\n",
    "head = Head(num_bins,action_dim)\n",
    "output = head(logits)\n",
    "seq_action_bins, seq_action_residuals, seq_action_bins_logits = output[\"seq_action_bins\"], output[\"seq_action_residuals\"], output[\"seq_action_bins_logits\"]\n",
    "\n",
    "print(\"Action Residuals Shape:\\t\\t\", seq_action_residuals.shape)\n",
    "print(\"Actions Bins Shape:\\t\\t\", seq_action_bins.shape)\n",
    "print(\"Actions Bins Logits Shape:\\t\", seq_action_bins_logits.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Focal Loss for Action Bins $\\lfloor a \\rfloor$\n",
    "\n",
    "$L_{focal}(p_t) = -(1 - p_t)^\\gamma \\log(p_t)$\n",
    "\n",
    "Focal loss is used to handle the class imbalance in action bins by assigning more weight for hard-to-classify examples inorder to be improve performance in predicting low-probability classes (important for multi-modal behavior distributions​​).\n",
    "\n",
    "<img width=\"700px\" src=\"images/loss.jpeg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Source: https://github.com/notmahi/miniBET/blob/main/behavior_transformer/bet.py\n",
    "\n",
    "class FocalLoss(nn.Module):\n",
    "\n",
    "    def __init__(self, gamma: float = 0, size_average: bool = True):\n",
    "        super(FocalLoss, self).__init__()\n",
    "        self.gamma = gamma\n",
    "        self.size_average = size_average\n",
    "\n",
    "    def forward(self, input, target):\n",
    "        logpt = F.log_softmax(input, dim=-1)\n",
    "        logpt = logpt.gather(1, target.view(-1, 1)).view(-1)\n",
    "        pt = logpt.exp()\n",
    "\n",
    "        loss = -1 * (1 - pt) ** self.gamma * logpt\n",
    "        if self.size_average:\n",
    "            return loss.mean()\n",
    "        else:\n",
    "            return loss.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Multi-Task (MT) Loss for Action Residuals $\\langle a \\rangle$\n",
    "\n",
    "The multi-task loss is calculated using only the action residuals associated to the choosen action bins at every step in the sequence. It is implemented directly as part of the learn() function in the BeT class down below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. BeT: Stitching all the Componenets Together \n",
    "\n",
    "Here, we combine the k-means based encoder/decoder, GPT, and head that we implemented earlier. Additionally, a training function for calculating the losses was added. \n",
    "\n",
    "<img width=\"1000px\" src=\"images/bet.jpeg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BeT(nn.Module):\n",
    "\n",
    "    def __init__(self, observation_dim, action_dim, num_bins, sequence_length, actions, gamma=2.0):\n",
    "        super(BeT, self).__init__()\n",
    "\n",
    "        self.observation_dim = observation_dim\n",
    "        self.action_dim = action_dim\n",
    "        self.num_bins = num_bins\n",
    "        self.sequence_length = sequence_length\n",
    "        \n",
    "        # Initializing the Encoder Decoder which is based on the K-Means\n",
    "        self.encoderDecoder = EncoderDecoder(action_dim, num_bins, actions)\n",
    "\n",
    "        # Initializing the GPT model to be used for sequence to sequence modeling\n",
    "        self.gpt = make_gpt(observation_dim,num_bins,sequence_length).to(DEVICE)\n",
    "        \n",
    "        # Initializing the Head that takes the sequence output of the GPT to return the action bin and action residual\n",
    "        self.head = Head(num_bins, action_dim).to(DEVICE)\n",
    "\n",
    "        # Residual Loss Function \n",
    "        self.residual_criterion = nn.MSELoss()\n",
    "\n",
    "        # Action Bins Loss Function \n",
    "        self.bin_criterion = FocalLoss(gamma)\n",
    "\n",
    "    def forward(self, observations_history, train_data=False):\n",
    "        \n",
    "        # (Batch Size, Sequence Lenght, Number of Action Bins)\n",
    "        gpt_logits = self.gpt(observations_history)\n",
    "\n",
    "        head_output = self.head(gpt_logits)\n",
    "        # Predicted Sequence Action Bins: (Batch_Size, Sequence_Length, 1)\n",
    "        predicted_seq_action_bins = head_output[\"seq_action_bins\"]\n",
    "        # Predicted Sequence Action Residuals: (Batch_Size, Sequence_Length, Action_dim)\n",
    "        predicted_seq_action_residuals = head_output[\"seq_action_residuals\"]\n",
    "        # Predicted Sequence Action Bins Logits: (Batch_Size, Sequence_Length, Number_Action_Bins)\n",
    "        seq_action_bins_logits = head_output[\"seq_action_bins_logits\"]\n",
    "\n",
    "        # Predicted Action: (Batch_Size, Action_dim)\n",
    "        predicted_action = self.encoderDecoder.decode(predicted_seq_action_bins[:,-1,0],predicted_seq_action_residuals[:,-1,:])\n",
    "\n",
    "        # No Training: Inference Only (No Loss Calculation)\n",
    "        if not train_data:\n",
    "            return predicted_action\n",
    "        # Training: Return Predicted Action and Training Required Data\n",
    "        else:\n",
    "            return {\"seq_action_bins_logits\":seq_action_bins_logits, \"predicted_seq_action_residuals\":predicted_seq_action_residuals}\n",
    "\n",
    "    def learn(self, observations_history, actions_history, optimizer, residual_loss_scale=1e3, eval=False):\n",
    "        \n",
    "        # Target Sequence Action Bins: (Batch_Size, Sequence_Length, Number_Action_Bins)\n",
    "        # Target Sequence Action Residuals: (Batch_Size, Sequence_Length, Action_Dims)\n",
    "        target_seq_action_bin, target_seq_action_residuals = self.encoderDecoder.encode(actions_history)\n",
    "\n",
    "        training_data = self.forward(observations_history, train_data=True)\n",
    "        # Predicted Sequence Action Residuals: (Batch_Size, Sequence_Length, Action_dim)\n",
    "        predicted_seq_action_residuals = training_data[\"predicted_seq_action_residuals\"]\n",
    "        # Predicted Sequence Action Bins Logits: (Batch_Size, Sequence_Length, Number_Action_Bins)\n",
    "        seq_action_bins_logits = training_data[\"seq_action_bins_logits\"]\n",
    "\n",
    "        # Residual Loss\n",
    "        action_residual_loss = self.residual_criterion(predicted_seq_action_residuals, target_seq_action_residuals)*residual_loss_scale\n",
    "\n",
    "        # Actions Bin Loss\n",
    "        seq_action_bins_logits = seq_action_bins_logits.reshape((-1,seq_action_bins_logits.shape[-1])).to(DEVICE)\n",
    "        target_seq_action_bin = target_seq_action_bin.reshape((-1,1)).to(DEVICE)\n",
    "        action_bins_loss = self.bin_criterion(seq_action_bins_logits, target_seq_action_bin)\n",
    "\n",
    "        # Total Loss = Actions Bin Loss + Residual Loss * Loss Scale\n",
    "        total_loss = action_bins_loss + action_residual_loss\n",
    "        \n",
    "        if eval == False:\n",
    "            # Training Step\n",
    "            optimizer.zero_grad()\n",
    "            total_loss.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(self.parameters(), max_norm=1.0)\n",
    "            optimizer.step()\n",
    "\n",
    "        return {\"total_loss\": total_loss, \"action_bins_loss\": action_bins_loss, \"action_residual_loss\": action_residual_loss}\n",
    "    \n",
    "    # Source: https://github.com/notmahi/miniBET/blob/main/behavior_transformer/bet.py\n",
    "    def create_optimizer(self, weight_decay, learning_rate, betas):\n",
    "        optimizer = self.gpt.configure_optimizers(\n",
    "            weight_decay=weight_decay,\n",
    "            learning_rate=learning_rate,\n",
    "            betas=betas,\n",
    "        )\n",
    "        optimizer.add_param_group({\"params\": self.head.parameters()})\n",
    "        return optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Testing the BeT Combined Componenet**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 0.25M\n",
      "Action Shape:  torch.Size([2, 3])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
      "  super()._check_params_vs_input(X, default_n_init=10)\n"
     ]
    }
   ],
   "source": [
    "num_bins = 2\n",
    "batch_size = 2\n",
    "total_action_batch_size = 5\n",
    "sequence_length = 10\n",
    "action_dim = 3\n",
    "total_actions = 100\n",
    "\n",
    "actions_collection = torch.rand((total_actions,action_dim)).to(DEVICE)\n",
    "bet = BeT(observation_dim, action_dim, num_bins, sequence_length, actions_collection).to(DEVICE)\n",
    "\n",
    "observations_history = torch.rand((batch_size,sequence_length,observation_dim)).to(DEVICE)\n",
    "predicted_action = bet(observations_history)\n",
    "print(\"Action Shape: \", predicted_action.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Training Test**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'total_loss': tensor(328.9534, grad_fn=<AddBackward0>),\n",
       " 'action_bins_loss': tensor(0.1941, grad_fn=<MeanBackward0>),\n",
       " 'action_residual_loss': tensor(328.7593, grad_fn=<MulBackward0>)}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bet_optimizer = bet.create_optimizer(weight_decay=0.2,learning_rate=0.01,betas=[0.9,0.999])\n",
    "\n",
    "observations_history = torch.rand((batch_size,sequence_length,observation_dim)).to(DEVICE)\n",
    "actions_history = torch.rand((batch_size,sequence_length,action_dim)).to(DEVICE)\n",
    "bet.learn(observations_history, actions_history, bet_optimizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multimodal Block Pushing Example Demo\n",
    "\n",
    "<img width=\"700px\" src=\"images/block_push.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing Required Libraries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "pybullet build time: Feb  1 2024 15:45:34\n",
      "WARNING:root:Carla not installed, skipping\n",
      "WARNING:root:Kitchen not installed, skipping\n"
     ]
    }
   ],
   "source": [
    "import gin\n",
    "import pybullet\n",
    "import numpy as np\n",
    "import os\n",
    "import gym\n",
    "from torch.utils.data import DataLoader, Dataset, random_split\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "gin.enter_interactive_mode()\n",
    "from envs.block_pushing.block_pushing_multimodal import BlockPushMultimodal\n",
    "os.environ['ASSET_PATH'] = 'envs/assets'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing Play Data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Action History:\t\t torch.Size([1000, 201, 2])\n",
      "Observations History:\t torch.Size([1000, 201, 16])\n",
      "Masks History:\t\t torch.Size([1000, 201])\n",
      "All Actions:\t\t torch.Size([201000, 2])\n"
     ]
    }
   ],
   "source": [
    "action_history = torch.tensor(np.load(\"envs/block_pushing_data/multimodal_push_actions.npy\")).to(torch.float).to(DEVICE)\n",
    "observation_history = torch.tensor(np.load(\"envs/block_pushing_data/multimodal_push_observations.npy\")).to(torch.float).to(DEVICE)\n",
    "observation_masks = torch.tensor(np.load(\"envs/block_pushing_data/multimodal_push_masks.npy\")).to(torch.float).to(DEVICE)\n",
    "all_actions = action_history.reshape((-1,action_history.shape[2])) # To fit the decoder/encoder\n",
    "\n",
    "print(\"Action History:\\t\\t\", action_history.shape)\n",
    "print(\"Observations History:\\t\", observation_history.shape)\n",
    "print(\"Masks History:\\t\\t\", observation_masks.shape)\n",
    "print(\"All Actions:\\t\\t\", all_actions.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Block Pushing Dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BlockPushingDataset(Dataset):\n",
    "    def __init__(self, action_history, observation_history, observation_masks, context=5):\n",
    "        self.action_history = action_history\n",
    "        self.observation_history = observation_history\n",
    "        self.observation_masks = observation_masks\n",
    "        self.context = context\n",
    "        \n",
    "        self.valid_indices = self._generate_valid_indices()\n",
    "\n",
    "        print(\"Number of Valid Points: \", len(self.valid_indices))\n",
    "        \n",
    "    def _generate_valid_indices(self):\n",
    "        valid_indices = []\n",
    "        for idx in range(len(self.action_history)):\n",
    "            for start in range(self.action_history.shape[1] - self.context + 1):\n",
    "                if all(self.observation_masks[idx, start:start + self.context]):\n",
    "                    valid_indices.append((idx, start))\n",
    "        return valid_indices\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.valid_indices)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        seq_idx, start = self.valid_indices[idx]\n",
    "        \n",
    "        action_seq = self.action_history[seq_idx, start:start + self.context]\n",
    "        observation_seq = self.observation_history[seq_idx, start:start + self.context]\n",
    "\n",
    "        return action_seq, observation_seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Valid Points:  112793\n"
     ]
    }
   ],
   "source": [
    "batch_size = 64\n",
    "\n",
    "dataset = BlockPushingDataset(action_history, observation_history, observation_masks, context=5)\n",
    "\n",
    "train_size = int(0.8 * len(dataset))\n",
    "test_size = len(dataset) - train_size\n",
    "train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Setting up the Model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/sklearn/cluster/_kmeans.py:1416: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
      "  super()._check_params_vs_input(X, default_n_init=10)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 0.26M\n"
     ]
    }
   ],
   "source": [
    "observation_dim = 16\n",
    "action_dim = 2\n",
    "num_bins = 24\n",
    "sequence_length = 5\n",
    "dataset_size = 1000\n",
    "\n",
    "bet = BeT(observation_dim, action_dim, num_bins, sequence_length, all_actions).to(DEVICE)\n",
    "optimizer = bet.create_optimizer(weight_decay=0.1,learning_rate=1e-4,betas=[0.9,0.999])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 350\n",
    "\n",
    "train_loss_history = []\n",
    "test_loss_history = []\n",
    "\n",
    "train_bin_loss_history = []\n",
    "train_residual_loss_history = []\n",
    "\n",
    "test_bin_loss_history = []\n",
    "test_residual_loss_history = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    \n",
    "    train_loss = 0.0\n",
    "    test_loss = 0.0\n",
    "    train_bins_loss = 0.0\n",
    "    train_residual_loss = 0.0\n",
    "    test_bins_loss = 0.0\n",
    "    test_residual_loss = 0.0\n",
    "    \n",
    "    total_train_idx = 0\n",
    "    total_test_idx = 0\n",
    "\n",
    "    for actions_sequence, observations_sequence in tqdm(train_loader, desc=f\"Training Epoch {epoch+1}/{epochs}\"):\n",
    "        \n",
    "        total_train_idx += actions_sequence.shape[0]\n",
    "\n",
    "        actions_sequence = actions_sequence.to(DEVICE)\n",
    "        observations_sequence = observations_sequence.to(DEVICE)\n",
    "\n",
    "        losses = bet.learn(observations_sequence, actions_sequence, optimizer)\n",
    "\n",
    "        total_loss = losses[\"total_loss\"].item()\n",
    "        action_bins_loss = losses[\"action_bins_loss\"].item()\n",
    "        action_residual_loss = losses[\"action_residual_loss\"].item()\n",
    "\n",
    "        train_loss += total_loss\n",
    "        train_bins_loss += action_bins_loss\n",
    "        train_residual_loss += action_residual_loss\n",
    "\n",
    "    for actions_sequence, observations_sequence in test_loader:\n",
    "\n",
    "        total_test_idx += actions_sequence.shape[0]\n",
    "\n",
    "        actions_sequence = actions_sequence.to(DEVICE)\n",
    "        observations_sequence = observations_sequence.to(DEVICE)\n",
    "\n",
    "        losses = bet.learn(observations_sequence, actions_sequence, optimizer, eval=True)\n",
    "\n",
    "        total_loss = losses[\"total_loss\"].item()\n",
    "        action_bins_loss = losses[\"action_bins_loss\"].item()\n",
    "        action_residual_loss = losses[\"action_residual_loss\"].item()\n",
    "\n",
    "        test_loss += total_loss\n",
    "        test_bins_loss += action_bins_loss\n",
    "        test_residual_loss += action_residual_loss\n",
    "    \n",
    "    train_loss_history.append(train_loss/total_train_idx)\n",
    "    test_loss_history.append(test_loss/total_test_idx)\n",
    "\n",
    "    train_bin_loss_history.append(train_bins_loss/total_train_idx)\n",
    "    train_residual_loss_history.append(train_residual_loss/total_train_idx)\n",
    "\n",
    "    test_bin_loss_history.append(test_bins_loss/total_test_idx)\n",
    "    test_residual_loss_history.append(test_residual_loss/total_test_idx)\n",
    "\n",
    "    \n",
    "    print(f\"Total Train Loss: {train_loss/total_train_idx:.4f} (Bins Loss: {train_bins_loss/total_train_idx:.4f}, Residuals Loss: {train_residual_loss/total_train_idx:.4f}\")\n",
    "    print(f\"Total Test Loss:  {test_loss/total_test_idx:.4f} (Bins Loss: {test_bins_loss/total_test_idx:.4f}, Residuals Loss: {test_residual_loss/total_test_idx:.4f}\")\n",
    "\n",
    "    # Saving Checkpoint\n",
    "    \n",
    "    np_test_loss_history = np.array(test_loss_history)\n",
    "    np_train_loss_history = np.array(train_loss_history)\n",
    "    np_test_bin_loss_history = np.array(test_bin_loss_history)\n",
    "    np_train_bin_loss_history = np.array(train_bin_loss_history)\n",
    "    np_test_residual_loss_history = np.array(test_residual_loss_history)\n",
    "    np_train_residual_loss_history = np.array(train_residual_loss_history)\n",
    "    \n",
    "    np.save(\"checkpoint/test_loss_history.npy\",np_test_loss_history)\n",
    "    np.save(\"checkpoint/train_loss_history.npy\",np_train_loss_history)\n",
    "    np.save(\"checkpoint/test_bin_loss_history.npy\",np_test_bin_loss_history)\n",
    "    np.save(\"checkpoint/train_bin_loss_history.npy\",np_train_bin_loss_history)\n",
    "    np.save(\"checkpoint/test_residual_loss_history.npy\",np_test_residual_loss_history)\n",
    "    np.save(\"checkpoint/train_residual_loss_history.npy\",np_train_residual_loss_history)\n",
    "    torch.save({'model_state_dict': bet.state_dict(),}, \"checkpoint/block_pushing_checkpoint\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_loss_history = np.load(\"checkpoints/test_loss_history.npy\")\n",
    "train_loss_history = np.load(\"checkpoints/train_loss_history.npy\")\n",
    "test_bin_loss_history = np.load(\"checkpoints/test_bin_loss_history.npy\")\n",
    "train_bin_loss_history = np.load(\"checkpoints/train_bin_loss_history.npy\")\n",
    "test_residual_loss_history = np.load(\"checkpoints/test_residual_loss_history.npy\")\n",
    "train_residual_loss_history = np.load(\"checkpoints/train_residual_loss_history.npy\")\n",
    "\n",
    "import pickle\n",
    "with open('checkpoints/bet.pkl', 'rb') as f:\n",
    "    bet = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fa5c22906a0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(test_loss_history[2:],'b')\n",
    "plt.plot(train_loss_history[2:],'r')\n",
    "plt.grid(True)\n",
    "plt.title(\"Loss Graph\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.legend([\"Test Loss\",\"Train Loss\"])\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(test_bin_loss_history[2:],'b')\n",
    "plt.plot(train_bin_loss_history[2:],'r')\n",
    "plt.grid(True)\n",
    "plt.title(\"Action Bins Loss Graph\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.legend([\"Test Action Bins Loss\",\"Train Action Bins Loss\"])\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(test_residual_loss_history[2:],'b')\n",
    "plt.plot(train_residual_loss_history[2:],'r')\n",
    "plt.grid(True)\n",
    "plt.title(\"Action Residuals Loss Graph\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.legend([\"Test Action Residuals Loss\",\"Train Action Residuals Loss\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Human Rendered Pybullet Evaluation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "matplotlib.use('TkAgg')  # Use TkAgg backend\n",
    "\n",
    "import gym\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "env = gym.make(\"BlockPushMultimodal-v0\")\n",
    "\n",
    "bet.eval()\n",
    "\n",
    "def pad_observation(obs, target_length=16):\n",
    "    flattened_obs = np.hstack([np.array(value).flatten() for value in list(obs.values())])\n",
    "    if len(flattened_obs) < target_length:\n",
    "        padded_obs = np.pad(flattened_obs, (0, target_length - len(flattened_obs)), 'constant')\n",
    "    else:\n",
    "        padded_obs = flattened_obs[:target_length]\n",
    "    return padded_obs\n",
    "\n",
    "\n",
    "observation = env.reset()\n",
    "observation_history = torch.zeros((5, 16))\n",
    "\n",
    "step_count = 0\n",
    "while True: \n",
    "\n",
    "    padded_observation = pad_observation(observation)\n",
    "    step_count += 1\n",
    "\n",
    "    if step_count <= 5:\n",
    "        observation_history[step_count - 1] = torch.tensor(padded_observation, dtype=torch.float)\n",
    "    else:\n",
    "        observation_history = torch.cat((observation_history[1:], torch.tensor(padded_observation, dtype=torch.float).unsqueeze(0)), dim=0)\n",
    "    \n",
    "    action = bet(observation_history.view((1,5,16))).detach().cpu().numpy()[0]\n",
    "    observation, reward, done, info = env.step(action)\n",
    "\n",
    "    if done:\n",
    "        observation = env.reset()\n",
    "        observation_history = torch.zeros((5, 16))\n",
    "        step_count = 0\n",
    "    \n",
    "    env.render()\n",
    "\n",
    "env.close()\n"
   ]
  }
 ],
 "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}