analyze_results_sim.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from math import floor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get Rewards Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "def get_data(task):\n",
    "    if task == \"can\":\n",
    "        rewards_calib = np.load(\"results/can/20231023-221535/reward_array.npy\")\n",
    "        rewards_id = np.load(\"results/can/20231130-111845/reward_array.npy\")\n",
    "\n",
    "        first_1000 = np.load(\"results/can/20231031-171252/reward_array.npy\")\n",
    "        second_1000 = np.load(\"results/can/20231203-202805/reward_array.npy\")\n",
    "        third_1000 = np.load(\"results/can/20231212-210747/reward_array.npy\")\n",
    "        fourth_1000 = np.load(\"results/can/20231216-110713/reward_array.npy\")\n",
    "        rewards_conf = np.vstack((first_1000, second_1000, third_1000, fourth_1000))\n",
    "\n",
    "    elif task == \"lift\":\n",
    "        rewards_calib = np.load(\"results/lift/20231024-090916/reward_array.npy\")\n",
    "        rewards_id = np.load(\"results/lift/20231130-205904/reward_array.npy\")\n",
    "\n",
    "        first_1000 = np.load(\"results/lift/20231101-080157/reward_array.npy\")\n",
    "        second_1000 = np.load(\"results/lift/20231204-111548/reward_array.npy\")\n",
    "        third_1000 = np.load(\"results/lift/20231213-072340/reward_array.npy\")\n",
    "        fourth_1000 = np.load(\"results/lift/20231217-133544/reward_array.npy\")\n",
    "        rewards_conf = np.vstack((first_1000, second_1000, third_1000, fourth_1000))\n",
    "\n",
    "    elif task == \"square\":\n",
    "        rewards_calib = np.load(\"results/square/20231024-202730/reward_array.npy\")\n",
    "        rewards_id = np.load(\"results/square/20231201-083641/reward_array.npy\")\n",
    "\n",
    "        first_1000 = np.load(\"results/square/20231101-204443/reward_array.npy\")\n",
    "        second_1000 = np.load(\"results/square/20231204-204536/reward_array.npy\")\n",
    "        third_1000 = np.load(\"results/square/20231213-180353/reward_array.npy\")\n",
    "        fourth_1000 = np.load(\"results/square/20231218-170050/reward_array.npy\")\n",
    "        rewards_conf = np.vstack((first_1000, second_1000, third_1000, fourth_1000))\n",
    "\n",
    "    elif task == \"tool_hang\":\n",
    "        rewards_calib = np.load(\"results/tool_hang/20231026-074805/reward_array.npy\")\n",
    "        rewards_id = np.load(\"results/tool_hang/20231201-201152/reward_array.npy\")\n",
    "\n",
    "        first_1000 = np.load(\"results/tool_hang/20231104-122712/reward_array.npy\")\n",
    "        second_1000 = np.load(\"results/tool_hang/20231205-081001/reward_array.npy\")\n",
    "        third_1000 = np.load(\"results/tool_hang/20231214-081956/reward_array.npy\")\n",
    "        fourth_1000 = np.load(\"results/tool_hang/20231219-094335/reward_array.npy\")\n",
    "        rewards_conf = np.vstack((first_1000, second_1000, third_1000, fourth_1000))\n",
    "\n",
    "    elif task == \"transport\":\n",
    "        rewards_calib = np.load(\"results/transport/20231028-125917/reward_array.npy\")\n",
    "        rewards_id = np.load(\"results/transport/20231202-100530/reward_array.npy\")\n",
    "\n",
    "        first_1000 = np.load(\"results/transport/20231105-161859/reward_array.npy\")\n",
    "        second_1000 = np.load(\"results/transport/20231206-081844/reward_array.npy\")\n",
    "        third_1000 = np.load(\"results/transport/20231214-204506/reward_array.npy\")\n",
    "        fourth_1000 = np.load(\"results/transport/20231220-113209/reward_array.npy\")\n",
    "        rewards_conf = np.vstack((first_1000, second_1000, third_1000, fourth_1000))\n",
    "\n",
    "    # shuffle conf samples\n",
    "    np.random.shuffle(rewards_conf)\n",
    "    \n",
    "    return rewards_calib, rewards_conf, rewards_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Format Reward Data\n",
    "Each environment comes with its own rewards pre-defined:\n",
    " - Can: https://github.com/ARISE-Initiative/robosuite/blob/master/robosuite/environments/manipulation/pick_place.py#L275C1-L275C119\n",
    " - Lift: https://github.com/ARISE-Initiative/robosuite/blob/master/robosuite/environments/manipulation/lift.py#L210\n",
    " - Square: https://github.com/ARISE-Initiative/robosuite/blob/master/robosuite/environments/manipulation/nut_assembly.py#L255C23-L255C23\n",
    " - Tool Hang: https://github.com/ARISE-Initiative/robosuite/blob/master/robosuite/environments/manipulation/tool_hang.py#L203\n",
    " - Transport: https://github.com/ARISE-Initiative/robosuite/blob/master/robosuite/environments/manipulation/two_arm_transport.py#L225"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "def format_data(rewards_calib, rewards_conf, rewards_id):\n",
    "    # continuous performance metric is sum of stagewise rewards\n",
    "    cont_rewards_calib = np.sum(rewards_calib, axis=1)\n",
    "    cont_rewards_conf = np.sum(rewards_conf, axis=1)\n",
    "    cont_rewards_id = np.sum(rewards_id, axis=1)\n",
    "\n",
    "    # compute maximum reward\n",
    "    max_reward = max(max(cont_rewards_calib), max(cont_rewards_conf), max(cont_rewards_id))\n",
    "\n",
    "    # binary rewards: success = last stage reward = 1.0, failure otherwise\n",
    "    binary_rewards_calib = np.array(rewards_calib[:,-1] == 1.0, dtype=float)\n",
    "    binary_rewards_conf = np.array(rewards_conf[:,-1] == 1.0, dtype=float)\n",
    "    binary_rewards_id = np.array(rewards_id[:,-1] == 1.0, dtype=float)\n",
    "\n",
    "    return cont_rewards_calib, cont_rewards_conf, cont_rewards_id, binary_rewards_calib, binary_rewards_conf, binary_rewards_id, max_reward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estimate True Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "def estimate_true(cont_rewards_calib, cont_rewards_id, binary_rewards_calib, binary_rewards_id, max_reward):\n",
    "    # solve for calib CDF\n",
    "    CDF_xs = np.sort(cont_rewards_calib)\n",
    "    CDF_ys = np.arange(1, len(CDF_xs) + 1) / len(CDF_xs)\n",
    "\n",
    "    CDF_xs = np.insert(CDF_xs, 0, 0)\n",
    "    CDF_ys = np.insert(CDF_ys, 0, 0)\n",
    "    CDF_xs = np.append(CDF_xs, max_reward)\n",
    "    CDF_ys = np.append(CDF_ys, 1)\n",
    "\n",
    "    # solve for ID CDF\n",
    "    CDF_xs_id = np.sort(cont_rewards_id)\n",
    "    CDF_ys_id = np.arange(1, len(CDF_xs_id) + 1) / len(CDF_xs_id)\n",
    "\n",
    "    CDF_xs_id = np.insert(CDF_xs_id, 0, 0)\n",
    "    CDF_ys_id = np.insert(CDF_ys_id, 0, 0)\n",
    "    CDF_xs_id = np.append(CDF_xs_id, max_reward)\n",
    "    CDF_ys_id = np.append(CDF_ys_id, 1)\n",
    "\n",
    "    return CDF_xs, CDF_ys, CDF_xs_id, CDF_ys_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CDF Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "from scipy.special import smirnov\n",
    "\n",
    "def KS_dist(n, epsilon):\n",
    "    cdf_val = 1 - smirnov(n, epsilon)\n",
    "    return np.clip(cdf_val, 0, 1)\n",
    "\n",
    "def KS_epsilon(n, alpha, tol=1e-8):\n",
    "    # find smallest epsilon such that KS_dist(n, alpha, epsilon) >= 1-alpha\n",
    "    lb = 0\n",
    "    ub = 1\n",
    "    for i in range(100):\n",
    "        epsilon = (ub - lb) / 2 + lb\n",
    "        coverage = KS_dist(n, epsilon)\n",
    "        if coverage >= 1-alpha:\n",
    "            if coverage - (1-alpha) <= tol:\n",
    "                return epsilon\n",
    "            else:\n",
    "                ub = epsilon\n",
    "        else:\n",
    "            lb = epsilon\n",
    "    raise ValueError(\"Too few iterations on bisection search!\")\n",
    "\n",
    "def get_CDF_gap(CDF_xs, CDF_ys, CDF_bound_xs, CDF_ub):\n",
    "    # find largest gap between CDF and CDF_bound\n",
    "    gap = np.inf\n",
    "    for i in range(len(CDF_xs)):\n",
    "        x = CDF_xs[i]\n",
    "        y = CDF_ys[i]\n",
    "\n",
    "        # find index of first xb before x \n",
    "        for j in range(len(CDF_bound_xs)):\n",
    "            if CDF_bound_xs[j] > x:\n",
    "                idx = j-1\n",
    "                break\n",
    "        \n",
    "        if CDF_ub[idx] - y < gap:\n",
    "            gap = CDF_ub[idx] - y\n",
    "    \n",
    "    return gap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute Our Bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "from binomial_cis import binom_ci\n",
    "\n",
    "def compute_bounds(cont_rewards_conf, binary_rewards_conf, max_reward, n, alpha):\n",
    "    # set bound parameters\n",
    "    n_conf = cont_rewards_conf.shape[0]\n",
    "    epsilon = KS_epsilon(n, alpha)\n",
    "    n_bounds = floor(n_conf / n)\n",
    "\n",
    "    # initialize empty arrays for bounds\n",
    "    lbs = np.zeros(n_bounds)\n",
    "    CDF_bound_xs = np.zeros((n_bounds, n+2))\n",
    "    CDF_ubs = np.zeros((n_bounds ,n+2))\n",
    "\n",
    "    # compute each bound\n",
    "    iter = 0\n",
    "    for i in range(0, n_conf, n):\n",
    "        # compute lower bound on prob of success\n",
    "        k = np.sum(binary_rewards_conf[i:i+n])\n",
    "        lbs[iter] = binom_ci(k, n, alpha, 'lb', verbose=False)\n",
    "\n",
    "        # compute upper bound on CDF\n",
    "        CDF_bound_xs[iter,1:-1] = np.sort(cont_rewards_conf[i:i+n])\n",
    "        CDF_bound_xs[iter,-1] = max_reward\n",
    "        \n",
    "        CDF_ubs[iter,1:-1] = np.clip(np.arange(1, n+1) / n + epsilon, 0, 1)\n",
    "        CDF_ubs[iter,0] = epsilon\n",
    "        CDF_ubs[iter,-1] = 1\n",
    "        \n",
    "        iter += 1\n",
    "    \n",
    "    return CDF_bound_xs, CDF_ubs, lbs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get Monte Carlo Estimates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "def compute_mc_ests(cont_rewards_conf, binary_rewards_conf, max_reward, n):\n",
    "    # set bound parameters\n",
    "    n_conf = cont_rewards_conf.shape[0]\n",
    "    n_bounds = floor(n_conf / n)\n",
    "\n",
    "    # initialize empty arrays for bounds\n",
    "    p_hats = np.zeros(n_bounds)\n",
    "    CDF_mc_xs = np.zeros((n_bounds, n+2))\n",
    "    CDF_mc_ubs = np.zeros((n_bounds ,n+2))\n",
    "\n",
    "    # compute each bound\n",
    "    iter = 0\n",
    "    for i in range(0, n_conf, n):\n",
    "        # compute lower bound on prob of success\n",
    "        k = np.sum(binary_rewards_conf[i:i+n])\n",
    "        p_hats[iter] = k / n\n",
    "\n",
    "        # compute upper bound on CDF\n",
    "        CDF_mc_xs[iter,1:-1] = np.sort(cont_rewards_conf[i:i+n])\n",
    "        CDF_mc_xs[iter,-1] = max_reward\n",
    "        \n",
    "        CDF_mc_ubs[iter,1:-1] = np.clip(np.arange(1, n+1) / n, 0, 1)\n",
    "        CDF_mc_ubs[iter,-1] = 1\n",
    "        \n",
    "        iter += 1\n",
    "    \n",
    "    return CDF_mc_xs, CDF_mc_ubs, p_hats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Analyze Binomial Bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "def analyze_binom_bounds(binary_rewards_calib, lbs):\n",
    "    n_calib = binary_rewards_calib.shape[0]\n",
    "    p_true = np.sum(binary_rewards_calib) / n_calib\n",
    "\n",
    "    avg_coverage = np.mean(lbs <= p_true)\n",
    "    avg_excess_len = np.mean(np.clip(p_true - lbs, 0, 1))\n",
    "    return avg_coverage, avg_excess_len"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Analyze CDF Bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "metadata": {}
   },
   "outputs": [],
   "source": [
    "def analyze_cdf_bounds(CDF_xs, CDF_ys, CDF_bound_xs, CDF_ubs):\n",
    "    # check smallest difference between upper bound and true cdf\n",
    "    n_bounds = CDF_bound_xs.shape[0]\n",
    "    CDF_gaps = np.zeros(n_bounds)\n",
    "    for iter in range(n_bounds):\n",
    "        CDF_gaps[iter] = get_CDF_gap(CDF_xs, CDF_ys, CDF_bound_xs[iter,:], CDF_ubs[iter,:])\n",
    "    \n",
    "    avg_coverage = np.mean(CDF_gaps >= 0)\n",
    "    return avg_coverage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "metadata": {}
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# bounds: 100.0\n",
      "\n",
      "Theoretical Coverage:      0.95\n",
      "Binomial Average Coverage: 0.92\n",
      "CDF Average Coverage:      0.97\n",
      "Theoretical Shortage:      0.078\n",
      "Binomial Average Shortage: 0.079\n",
      "\n",
      "Theoretical Coverage:      0.95\n",
      "Binomial Average Coverage: 0.93\n",
      "CDF Average Coverage:      0.99\n",
      "Theoretical Shortage:      0.115\n",
      "Binomial Average Shortage: 0.115\n",
      "\n",
      "Theoretical Coverage:      0.95\n",
      "Binomial Average Coverage: 0.96\n",
      "CDF Average Coverage:      0.93\n",
      "Theoretical Shortage:      0.085\n",
      "Binomial Average Shortage: 0.075\n",
      "\n",
      "Theoretical Coverage:      0.95\n",
      "Binomial Average Coverage: 0.94\n",
      "CDF Average Coverage:      0.97\n",
      "Theoretical Shortage:      0.127\n",
      "Binomial Average Shortage: 0.123\n",
      "\n",
      "Theoretical Coverage:      0.95\n",
      "Binomial Average Coverage: 0.9\n",
      "CDF Average Coverage:      0.93\n",
      "Theoretical Shortage:      0.115\n",
      "Binomial Average Shortage: 0.105\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x875 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from binomial_cis import expected_shortage\n",
    "from binomial_cis.conf_intervals import llc_accept_prob\n",
    "\n",
    "def get_title(task):\n",
    "    if task == \"can\":\n",
    "        title = \"Can\"\n",
    "    elif task == \"lift\":\n",
    "        title = \"Lift\"\n",
    "    elif task == \"square\":\n",
    "        title = \"Square\"\n",
    "    elif task == \"tool_hang\":\n",
    "        title = \"Tool Hang\"\n",
    "    elif task == \"transport\":\n",
    "        title = \"Transport\"\n",
    "    return title\n",
    "\n",
    "\n",
    "n = 40\n",
    "alpha = 0.05\n",
    "print(\"# bounds:\", 4000/n)\n",
    "\n",
    "\n",
    "plt.figure(figsize=(4,1.75*5))\n",
    "for iter,task in enumerate([\"can\", \"lift\", \"square\", \"tool_hang\", \"transport\"]):\n",
    "    # get data\n",
    "    rewards_calib, rewards_conf, rewards_id = get_data(task)\n",
    "    cont_rewards_calib, cont_rewards_conf, cont_rewards_id, binary_rewards_calib, binary_rewards_conf, binary_rewards_id, max_reward = format_data(rewards_calib, rewards_conf, rewards_id)\n",
    "    CDF_xs, CDF_ys, CDF_xs_id, CDF_ys_id = estimate_true(cont_rewards_calib, cont_rewards_id, binary_rewards_calib, binary_rewards_id, max_reward)\n",
    "    CDF_bound_xs, CDF_ubs, lbs = compute_bounds(cont_rewards_conf, binary_rewards_conf, max_reward, n, alpha)\n",
    "    ES = expected_shortage(llc_accept_prob, alpha, n, np.mean(binary_rewards_calib))\n",
    "    title = get_title(task)\n",
    "\n",
    "    # get mc estimates\n",
    "    CDF_mc_xs, CDF_mc_ubs, p_hats = compute_mc_ests(cont_rewards_conf, binary_rewards_conf, max_reward, n)\n",
    "\n",
    "    # print empirical results\n",
    "    avg_coverage, avg_excess_len = analyze_binom_bounds(binary_rewards_calib, lbs)\n",
    "    avg_coverage_cdf = analyze_cdf_bounds(CDF_xs, CDF_ys, CDF_bound_xs, CDF_ubs)\n",
    "    print(\"\\nTheoretical Coverage:     \", 1-alpha)\n",
    "    print(\"Binomial Average Coverage:\", avg_coverage)\n",
    "    print(\"CDF Average Coverage:     \", avg_coverage_cdf)\n",
    "    print(\"Theoretical Shortage:     \", round(ES, 3))\n",
    "    print(\"Binomial Average Shortage:\", round(avg_excess_len, 3))\n",
    "\n",
    "    # binary plots\n",
    "    plt.subplot(5, 2, 2*iter+1)\n",
    "    y, x, _ = plt.hist(lbs, bins='auto', color=\"lightskyblue\")\n",
    "    y_mc, x_mc, _ = plt.hist(p_hats, bins='auto', color='grey', alpha=0.3)\n",
    "    plt.vlines(x = np.mean(binary_rewards_id), ymin=0, ymax=max(y.max(), y_mc.max()), linestyle=\"dashed\", color=\"coral\", label=\"ID\")\n",
    "    plt.vlines(x = np.mean(binary_rewards_calib), ymin=0, ymax=max(y.max(), y_mc.max()), linestyle=\"dashed\", color=\"purple\", label=\"OOD\")\n",
    "    plt.title(title)\n",
    "    plt.ylabel('Count')\n",
    "    plt.xlabel('Probability of Success')\n",
    "    plt.xlim(-0.1, 1.1)\n",
    "\n",
    "    # cdf plots\n",
    "    plt.subplot(5, 2, 2*iter + 2)\n",
    "    plt.step(CDF_xs_id, CDF_ys_id, where=\"post\", alpha=0.8, linestyle=\"dashed\", color=\"coral\", linewidth=0.75)\n",
    "    plt.step(CDF_xs, CDF_ys, where=\"post\", alpha=0.8, linestyle=\"dashed\", color=\"purple\", linewidth=0.75)\n",
    "    for i in range(CDF_bound_xs.shape[0]):\n",
    "        plt.step(CDF_bound_xs[i,:], CDF_ubs[i,:], where=\"post\", alpha=0.8, color=\"lightskyblue\", linewidth=.5)\n",
    "    \n",
    "    for i in range(CDF_bound_xs.shape[0]):\n",
    "        plt.step(CDF_mc_xs[i,:], CDF_mc_ubs[i,:], where=\"post\", alpha=0.1, color=\"grey\", linewidth=.5)\n",
    "    plt.title(title)\n",
    "    plt.xlabel(r'$r$')\n",
    "    plt.ylabel(r'$\\mathbb{P}($Reward $\\leq r)$')\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "# plt.savefig(\"media/all_tasks.svg\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "stochastic_verification",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}