{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Occasionally binding constraint model - Solved with ANN (PyTorch)\n",
    "\n",
    "This notebook solves the Bianchi model with occasionally binding collateral constraints using PyTorch.\n",
    "\n",
    "**Method**: Fischer-Burmeister complementarity with neural network approximation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup: Imports and Device Selection\n",
    "\n",
    "Check for CUDA availability and set computation device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Using device: cuda ---\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import time\n",
    "import quantecon as qe\n",
    "\n",
    "#optimizers\n",
    "from adabelief_pytorch import AdaBelief \n",
    "# from sophia.sophia import SophiaG\n",
    "\n",
    "\n",
    "# ============================================================================ #\n",
    "#                           0. DEVICE SELECTION                                #\n",
    "# ============================================================================ #\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(f\"--- Using device: {device} ---\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Calibration\n",
    "\n",
    "Standard Bianchi (2011) parameters:\n",
    "- σ: Risk aversion (2.0)\n",
    "- κ: Borrowing constraint (0.2808)\n",
    "- β: Discount factor (0.91)\n",
    "- ω: Weight on traded goods (0.31)\n",
    "- η: Elasticity of substitution (0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DTYPE = torch.float32\n",
    "\n",
    "# --- Structural parameters --- #\n",
    "σ = torch.tensor(2.0, dtype=DTYPE, device=device)\n",
    "κ = torch.tensor(0.2808, dtype=DTYPE, device=device)\n",
    "β = torch.tensor(0.91, dtype=DTYPE, device=device)\n",
    "ω = torch.tensor(0.31, dtype=DTYPE, device=device)\n",
    "η = torch.tensor(0.5, dtype=DTYPE, device=device)\n",
    "τ = torch.tensor(0.2, dtype=DTYPE, device=device)\n",
    "\n",
    "# --- State variables --- #\n",
    "yT = torch.tensor(1.0, dtype=DTYPE, device=device)\n",
    "yN = torch.tensor(1.0, dtype=DTYPE, device=device)\n",
    "\n",
    "# --- Grids --- #\n",
    "l_min, l_max = 0.1, 0.9\n",
    "n_l = 300\n",
    "l_grid_np = np.linspace(l_min, l_max, n_l, dtype=np.float32)\n",
    "l_grid = torch.tensor(l_grid_np, dtype=DTYPE, device=device)\n",
    "\n",
    "# --- Stochastic Processes (MODIFIED: All NumPy ops are now Float32) --- #\n",
    "# Government default cost process\n",
    "ν_bar = np.float32(1.82)\n",
    "ρ_ν   = np.float32(0.97)\n",
    "σ_ν   = np.float32(0.14)\n",
    "n_ν   = 5\n",
    "\n",
    "# Non performing loans process\n",
    "ϕ_bar = np.float32(0.021)\n",
    "ρ_ϕ   = np.float32(0.82)\n",
    "σ_ϕ   = np.float32(0.33)\n",
    "n_ϕ   = 5\n",
    "\n",
    "# Define the VAR(1) parameters as float32\n",
    "A = np.array([[ρ_ν, 0.0], [0.0, ρ_ϕ]], dtype=np.float32)\n",
    "Σ = np.array([[σ_ν**2, 0.0], [0.0, σ_ϕ**2]], dtype=np.float32)\n",
    "C = np.sqrt(Σ)\n",
    "n_shocks_grid = [n_ν, n_ϕ]\n",
    "\n",
    "# Discretize the VAR(1) process\n",
    "mc = qe.markov.discrete_var(A, C, grid_sizes=n_shocks_grid)\n",
    "S0_np = mc.state_values.astype(np.float32)\n",
    "Π_np = mc.P.astype(np.float32)\n",
    "\n",
    "# Transform the grid points, ensuring all operations maintain float32\n",
    "S_np = np.zeros_like(S0_np)\n",
    "S_np[:, 0] = S0_np[:, 0] + ν_bar\n",
    "S_np[:, 1] = np.exp(S0_np[:, 1] + np.log(ϕ_bar).astype(np.float32))\n",
    "\n",
    "n_s = S_np.shape[0]\n",
    "\n",
    "# Move final matrices to the selected device\n",
    "Π = torch.tensor(Π_np, dtype=DTYPE, device=device)\n",
    "S = torch.tensor(S_np, dtype=DTYPE, device=device)\n",
    "\n",
    "# --- Interest rates --- #\n",
    "i_l = torch.tensor(0.05, dtype=DTYPE, device=device)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Economic Functions\n",
    "\n",
    "Core equilibrium conditions:\n",
    "- `du_dcT`: Marginal utility of traded consumption\n",
    "- `price_nt`: Price of non-traded goods (from intratemporal optimality)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def du_dcT(ct, yn):\n",
    "    return torch.where(\n",
    "        ct > 0,\n",
    "        ω * ct**(-1/η) * (ω*ct**((η-1)/η) + (1-ω)*yn**((η-1)/η))**((1-σ*η)/(η-1)),\n",
    "        torch.tensor(999_999.0, dtype=DTYPE, device=device)\n",
    "    )\n",
    "\n",
    "def price_nt(ct, yn):\n",
    "    return (1-ω)/ω * (torch.max(ct, torch.tensor(1e-9, device=device)) / yn)**(1/η)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network Architecture\n",
    "\n",
    "**Input**: 3D state (l, ν, φ)  \n",
    "**Output**: Policy l' ∈ [0.1, 0.9]  \n",
    "**Layers**: 3 → 256 → 128 → 1 (ReLU activations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31mPlease check your arguments if you have upgraded adabelief-pytorch from version 0.0.5.\n",
      "\u001b[31mModifications to default arguments:\n",
      "\u001b[31m                           eps  weight_decouple    rectify\n",
      "-----------------------  -----  -----------------  ---------\n",
      "adabelief-pytorch=0.0.5  1e-08  False              False\n",
      ">=0.1.0 (Current 0.2.0)  1e-16  True               True\n",
      "\u001b[34mSGD better than Adam (e.g. CNN for Image Classification)    Adam better than SGD (e.g. Transformer, GAN)\n",
      "----------------------------------------------------------  ----------------------------------------------\n",
      "Recommended eps = 1e-8                                      Recommended eps = 1e-16\n",
      "\u001b[34mFor a complete table of recommended hyperparameters, see\n",
      "\u001b[34mhttps://github.com/juntang-zhuang/Adabelief-Optimizer\n",
      "\u001b[32mYou can disable the log message by setting \"print_change_log = False\", though it is recommended to keep as a reminder.\n",
      "\u001b[0m\n",
      "Weight decoupling enabled in AdaBelief\n",
      "Rectification enabled in AdaBelief\n"
     ]
    }
   ],
   "source": [
    "class PolicyNetwork(nn.Module):\n",
    "    def __init__(self, state_dim, q1, q2, policy_dim, l_min, l_max, t_sigmoid):\n",
    "        super(PolicyNetwork, self).__init__()\n",
    "        self.l_min = l_min\n",
    "        self.l_max = l_max\n",
    "        self.T_sigmoid = t_sigmoid\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(state_dim, q1), nn.ReLU(),\n",
    "            nn.Linear(q1, q2), nn.ReLU(),\n",
    "            nn.Linear(q2, policy_dim)\n",
    "        )\n",
    "    def forward(self, x):\n",
    "        x = self.layers(x)\n",
    "        return self.l_min + (self.l_max - self.l_min) * torch.sigmoid(x / self.T_sigmoid)\n",
    "\n",
    "# --- Model Architecture --- #\n",
    "state_dim = 3\n",
    "policy_dim = 1\n",
    "Q1 = 256\n",
    "Q2 = 128\n",
    "T_sigmoid = 1.0\n",
    "\n",
    "model = PolicyNetwork(state_dim, Q1, Q2, policy_dim, l_min, l_max, T_sigmoid).to(device)\n",
    "\n",
    "# --- Hyperparameters --- #\n",
    "learning_rate_initial = 1e-3\n",
    "learning_rate_final = 1e-6\n",
    "epochs = 50000\n",
    "epochs_warmup = 30000\n",
    "batch_size = 32\n",
    "huber_delta = 0.1\n",
    "\n",
    "# --- Optimizer --- #\n",
    "# optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate_initial)\n",
    "# optimizer = torch.optim.SophiaH(model.parameters(), lr=learning_rate_initial)\n",
    "optimizer = AdaBelief(model.parameters(), lr=learning_rate_initial)\n",
    "# optimizer = SophiaG(model.parameters(), lr=learning_rate_initial)\n",
    "\n",
    "# --- State Space Normalization --- #\n",
    "shock_min = torch.min(S, dim=0, keepdim=True)[0]\n",
    "shock_max = torch.max(S, dim=0, keepdim=True)[0]\n",
    "shock_range = shock_max - shock_min\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## State Normalization and Sampling\n",
    "\n",
    "Normalize shock variables while keeping debt in original scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_state(batch):\n",
    "    l = batch[:, 0:1]\n",
    "    shocks = batch[:, 1:3]\n",
    "    normalized_shocks = (shocks - shock_min) / shock_range\n",
    "    return torch.cat([l, normalized_shocks], dim=1)\n",
    "\n",
    "def sample_states(batch_size):\n",
    "    loans = np.random.rand(batch_size, 1).astype(np.float32) * (l_max - l_min) + l_min\n",
    "    shock_indices = np.random.randint(0, n_s, size=batch_size)\n",
    "    shocks = S_np[shock_indices, :]\n",
    "    return np.hstack([loans, shocks]), shock_indices\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss Function: Fischer-Burmeister\n",
    "\n",
    "The Fischer-Burmeister function handles complementarity slackness:\n",
    "\n",
    "$$\\text{FB}(a, b) = a + b - \\sqrt{a^2 + b^2}$$\n",
    "\n",
    "Where:\n",
    "- a = Euler equation residual\n",
    "- b = Constraint slack (borrowing limit - debt)\n",
    "\n",
    "At optimum: FB = 0 (works whether constraint binds or not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "huber_loss_fn = nn.HuberLoss(reduction='mean', delta=huber_delta)\n",
    "\n",
    "def ann_loss(m, batch, shock_indices):\n",
    "    current_batch_size = batch.shape[0]\n",
    "    normalized_batch = normalize_state(batch)\n",
    "    l, ϕ = batch[:, 0:1], batch[:, 2:3]\n",
    "    lp = m(normalized_batch)\n",
    "    ct = yT * (1 - τ) - l * (1.0 - ϕ) + lp / (1.0 + i_l)\n",
    "    pn = price_nt(ct, yN)\n",
    "\n",
    "    # --- Vectorized Expectation Calculation ---\n",
    "    lp_expanded = lp.repeat_interleave(n_s, dim=0)\n",
    "    S_tiled = S.repeat(current_batch_size, 1)\n",
    "    state_prime_unnormalized = torch.cat([lp_expanded, S_tiled], dim=1)\n",
    "    lpp = m(normalize_state(state_prime_unnormalized))\n",
    "    ϕ_p_tiled = S_tiled[:, 1:2]\n",
    "    ct_prime = yT * (1 - τ) - lp_expanded * (1.0 - ϕ_p_tiled) + lpp / (1.0 + i_l)\n",
    "    future_marg_utils = du_dcT(ct_prime, yN).view(current_batch_size, n_s)\n",
    "    E_λp = torch.matmul(future_marg_utils, Π)\n",
    "    E_λp_final = E_λp[torch.arange(current_batch_size), shock_indices].unsqueeze(1)\n",
    "    \n",
    "    # --- Fischer-Burmeister Residual ---\n",
    "    λ = du_dcT(ct, yN)\n",
    "    borr_const = κ * (pn * yN + yT * (1 - τ))\n",
    "    epsilon = 1e-9\n",
    "    a_norm = 1.0 - (β * E_λp_final * (1.0 + i_l)) / (λ + epsilon)\n",
    "    b_norm = 1.0 - lp / (borr_const + epsilon)\n",
    "    fb_residual = a_norm + b_norm - torch.sqrt(a_norm**2 + b_norm**2)\n",
    "    loss = huber_loss_fn(fb_residual, torch.zeros_like(fb_residual))\n",
    "    return loss\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Loop\n",
    "\n",
    "Train for 50,000 epochs with:\n",
    "- Initial learning rate: 1e-3\n",
    "- Final learning rate: 1e-6 (after epoch 30,000)\n",
    "- Optimizer: AdaBelief\n",
    "- Batch size: 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Starting PyTorch ANN Training ---\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training Policy ANN::  60%|██████    | 30009/50000 [05:52<03:18, 100.73it/s, loss=2.32e-03, lr=1e-6] "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Switched to final learning rate: 1e-06 ---\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training Policy ANN:: 100%|██████████| 50000/50000 [09:36<00:00, 86.70it/s, loss=3.61e-05, lr=1e-6] "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Training Complete ---\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"--- Starting PyTorch ANN Training ---\")\n",
    "losses = []\n",
    "loop = tqdm(range(epochs), desc=\"Training Policy ANN:\")\n",
    "\n",
    "for epoch in loop:\n",
    "    if epoch == epochs_warmup:\n",
    "        print(f\"\\n--- Switched to final learning rate: {learning_rate_final} ---\")\n",
    "        for g in optimizer.param_groups:\n",
    "            g['lr'] = learning_rate_final\n",
    "\n",
    "    batch_np, shock_indices = sample_states(batch_size)\n",
    "    batch = torch.tensor(batch_np, dtype=DTYPE, device=device)\n",
    "\n",
    "    # 1st order optimizers (Adam, AdaBelief)\n",
    "    # optimizer.zero_grad()\n",
    "    # loss = ann_loss(model, batch, shock_indices)\n",
    "    # loss.backward()\n",
    "    # optimizer.step()\n",
    "\n",
    "    # 2nd order optimizers (sophia)\n",
    "    def closure():\n",
    "        optimizer.zero_grad()\n",
    "        loss = ann_loss(model, batch, shock_indices)\n",
    "        loss.backward()\n",
    "        return loss\n",
    "    loss = optimizer.step(closure)\n",
    "\n",
    "    losses.append(loss.item())\n",
    "    loop.set_postfix(loss=f\"{loss.item():.2e}\", lr=optimizer.param_groups[0]['lr'])\n",
    "\n",
    "print(\"--- Training Complete ---\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results Visualization\n",
    "\n",
    "Plot:\n",
    "1. Training loss convergence\n",
    "2. Policy function l'(l) - shows kink where constraint binds\n",
    "3. Kuhn-Tucker multiplier μ(l) - positive when constrained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plotting learned policy function...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def recover_multiplier(m, batch, shock_indices):\n",
    "    current_batch_size = batch.shape[0]\n",
    "    normalized_batch = normalize_state(batch)\n",
    "    l, ϕ = batch[:, 0:1], batch[:, 2:3]\n",
    "    lp = m(normalized_batch)\n",
    "    ct = yT * (1 - τ) - l * (1.0 - ϕ) + lp / (1.0 + i_l)\n",
    "    lp_expanded = lp.repeat_interleave(n_s, dim=0)\n",
    "    S_tiled = S.repeat(current_batch_size, 1)\n",
    "    state_prime_unnormalized = torch.cat([lp_expanded, S_tiled], dim=1)\n",
    "    lpp = m(normalize_state(state_prime_unnormalized))\n",
    "    ϕ_p_tiled = S_tiled[:, 1:2]\n",
    "    ct_prime = yT * (1 - τ) - lp_expanded * (1.0 - ϕ_p_tiled) + lpp / (1.0 + i_l)\n",
    "    future_marg_utils = du_dcT(ct_prime, yN).view(current_batch_size, n_s)\n",
    "    E_λp = torch.matmul(future_marg_utils, Π)\n",
    "    E_λp_final = E_λp[torch.arange(current_batch_size), shock_indices].unsqueeze(1)\n",
    "    λ = du_dcT(ct, yN)\n",
    "    μ = λ / (1.0 + i_l) - β * E_λp_final\n",
    "    return μ\n",
    "\n",
    "# --- Prepare data for plotting ---\n",
    "print(\"Plotting learned policy function...\")\n",
    "plot_ν_val = S_np[0, 0]\n",
    "plot_ϕ_val = S_np[0, 1]\n",
    "plot_grid_unnormalized_np = np.hstack([\n",
    "    l_grid_np.reshape(-1, 1),\n",
    "    np.full((n_l, 1), plot_ν_val, dtype=np.float32),\n",
    "    np.full((n_l, 1), plot_ϕ_val, dtype=np.float32)\n",
    "])\n",
    "plot_grid_unnormalized = torch.tensor(plot_grid_unnormalized_np, device=device)\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    learned_policy_tensor = model(normalize_state(plot_grid_unnormalized))\n",
    "    plot_shock_indices = np.zeros(n_l, dtype=int)\n",
    "    recovered_mu_tensor = recover_multiplier(model, plot_grid_unnormalized, plot_shock_indices)\n",
    "\n",
    "learned_policy = learned_policy_tensor.cpu().numpy()\n",
    "recovered_mu = recovered_mu_tensor.cpu().numpy()\n",
    "\n",
    "# --- Create plots ---\n",
    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))\n",
    "ax1.plot(np.log10(losses))\n",
    "ax1.set_title(\"Training Loss\")\n",
    "ax1.set_xlabel(\"Epoch\")\n",
    "ax1.set_ylabel(\"Loss (log10 scale)\")\n",
    "ax2.plot(l_grid_np, learned_policy.flatten(), label=\"Learned Policy l'(l)\")\n",
    "ax2.plot(l_grid_np, l_grid_np, 'k--', label=\"45-degree line\")\n",
    "ax2.set_title(\"Policy Function (at lowest shocks)\")\n",
    "ax2.set_xlabel(\"Current Loans (l)\")\n",
    "ax2.set_ylabel(\"Next Period's Loans (l')\")\n",
    "ax2.legend()\n",
    "ax3.plot(l_grid_np, recovered_mu.flatten(), label=\"Multiplier μ(l)\")\n",
    "ax3.axhline(0, color='k', linestyle='--')\n",
    "ax3.set_title(\"Recovered KT Multiplier (at lowest shocks)\")\n",
    "ax3.set_xlabel(\"Current Loans (l)\")\n",
    "ax3.set_ylabel(\"KT Multiplier (μ)\")\n",
    "ax3.legend()\n",
    "plt.tight_layout()\n",
    "# plt.savefig(\"results_pytorch.png\")\n",
    "# print(\"\\n--- Plot saved to results_pytorch.png ---\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpretation\n",
    "\n",
    "**Policy Function Kink**: Marks the transition from unconstrained to constrained borrowing\n",
    "\n",
    "**Multiplier μ**:\n",
    "- μ = 0: Interior solution (constraint not binding)\n",
    "- μ > 0: Constraint binds (household wants more debt)\n",
    "\n",
    "The kink location indicates the debt threshold for sudden stops."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}