dp.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Recursively defined actuarial models experience some performance issues when we do not do memoization. Consider a simulation of the expected number of policyholders starting with 1000 with an annual mortality rate of 1%.\n",
    "\n",
    "* `policies_inforce(t)` calls `policies_inforce(t-1)` twice, and `policies_inforce(t-1)` calls `policies_inforce(t-2)` twice.\n",
    "* We track the number of times each function is called, and can verify that the calls grow exponentially as a function of `t`.\n",
    "\n",
    "Try out some different numbers, but if you go too high you might have to wait a while."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaultdict(<function <lambda> at 0x105af5870>,\n",
      "            {'death': defaultdict(<class 'int'>,\n",
      "                                  {0: 16,\n",
      "                                   1: 8,\n",
      "                                   2: 4,\n",
      "                                   3: 2,\n",
      "                                   4: 1}),\n",
      "             'inforce': defaultdict(<class 'int'>,\n",
      "                                    {0: 32,\n",
      "                                     1: 16,\n",
      "                                     2: 8,\n",
      "                                     3: 4,\n",
      "                                     4: 2,\n",
      "                                     5: 1})})\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "from pprint import pprint\n",
    "\n",
    "call_count = defaultdict(lambda: defaultdict(int))\n",
    "\n",
    "def policies_inforce(t):\n",
    "    call_count['inforce'][t] += 1\n",
    "    if t == 0:\n",
    "        return 1000\n",
    "    return policies_inforce(t-1) - policies_death(t-1)\n",
    "\n",
    "def policies_death(t):\n",
    "    call_count['death'][t] += 1\n",
    "    return policies_inforce(t) * 0.01\n",
    "\n",
    "t = 5 # change me\n",
    "policies_inforce(t)\n",
    "\n",
    "pprint(call_count)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code defines two functions (`policies_inforce` and `policies_death`) and uses `call_count` to count the number of times each function is called for a specific input `t`. It does so with the help of `defaultdict` from the `collections` module. Let's break it down step by step:\n",
    "\n",
    "1. Import `defaultdict` from `collections` module:\n",
    "   `defaultdict` is a subclass of Python's built-in dictionary, which allows you to provide a default value for the keys that don't exist in the dictionary.\n",
    "\n",
    "2. Create a `call_count` defaultdict:\n",
    "   This creates a `defaultdict` of `defaultdict` where the inner dictionary has an integer default value of 0. It will store the counts of each function call with a specific input `t`.\n",
    "\n",
    "3. Define `policies_inforce(t)` function:\n",
    "   This function takes an integer `t` as input and calculates the number of policies in force recursively by subtracting the number of policies death from the previous time step. It starts with a base case: when `t` is 0, there are 1000 policies in force.\n",
    "\n",
    "4. Define `policies_death(t)` function:\n",
    "   This function takes an integer `t` as input and calculates the number of policy deaths for that time step. It does so by taking 1% (0.01) of the number of policies in force for the same time step.\n",
    "\n",
    "5. Set a value for `t`:\n",
    "   `t = 5` assigns the value 5 to the variable `t`. You can change this value to compute the number of policies in force for a different time step.\n",
    "\n",
    "6. Calculate policies in force for the given `t`:\n",
    "   `policies_inforce(t)` calls the function with the value of `t`, and it computes the number of policies in force for the given time step.\n",
    "\n",
    "7. Output `call_count`:\n",
    "   This displays the count of how many times each function is called with a specific input `t`.\n",
    "\n",
    "In this code, the main purpose is to compute the number of policies in force for a given time step and track how many times each function is called with different inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaultdict(<function <lambda> at 0x105af5900>,\n",
      "            {'death': defaultdict(<class 'int'>,\n",
      "                                  {0: 1,\n",
      "                                   1: 1,\n",
      "                                   2: 1,\n",
      "                                   3: 1,\n",
      "                                   4: 1}),\n",
      "             'inforce': defaultdict(<class 'int'>,\n",
      "                                    {0: 1,\n",
      "                                     1: 1,\n",
      "                                     2: 1,\n",
      "                                     3: 1,\n",
      "                                     4: 1,\n",
      "                                     5: 1})})\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "from pprint import pprint\n",
    "\n",
    "call_count = defaultdict(lambda: defaultdict(int))\n",
    "\n",
    "d1 = {}\n",
    "def policies_inforce(t):\n",
    "    if t in d1:\n",
    "        return d1[t]\n",
    "    call_count['inforce'][t] += 1\n",
    "    if t == 0:\n",
    "        d1[t] = 1000\n",
    "    else: \n",
    "        d1[t] = policies_inforce(t-1) - policies_death(t-1)\n",
    "    return d1[t]\n",
    "\n",
    "d2 = {}\n",
    "def policies_death(t):\n",
    "    if t in d2:\n",
    "        return d2[t]\n",
    "    call_count['death'][t] += 1\n",
    "    d2[t] = policies_inforce(t) * 0.01\n",
    "    return d2[t]\n",
    "\n",
    "t = 5 # change me\n",
    "policies_inforce(t)\n",
    "\n",
    "pprint(call_count)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this version of the code, caching is implemented using two dictionaries d1 and d2 to store the results of the policies_inforce and policies_death functions, respectively. This technique is called memoization. It helps to avoid redundant calculations by storing and reusing the results of function calls with the same input.\n",
    "\n",
    "Here's how caching works in this code:\n",
    "\n",
    "In the policies_inforce(t) function, before performing any calculations, the code checks if the result for the input t is already present in the d1 dictionary. If it is, the cached value is returned immediately.\n",
    "\n",
    "If the result is not cached, the function calculates the number of policies in force as in the previous version of the code. However, after performing the calculation, the result is stored in the d1 dictionary with the key t before returning it. This way, if the function is called again with the same t, the cached value can be returned without recalculating.\n",
    "\n",
    "Similarly, in the policies_death(t) function, the code checks if the result for the input t is already present in the d2 dictionary. If it is, the cached value is returned immediately.\n",
    "\n",
    "If the result is not cached, the function calculates the number of policy deaths as in the previous version of the code. The result is then stored in the d2 dictionary with the key t before returning it. This allows the function to reuse the cached value for the same t in future calls.\n",
    "\n",
    "The main benefit of caching is that it reduces the number of calculations required, especially in recursive functions with overlapping subproblems like these. By storing and reusing the results, the code can significantly reduce the number of calls to the policies_inforce and policies_death functions, making the program more efficient."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.10.8"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3411cb5569bfa654523dedf6435551f8541a03553b9c3c8049c1a736dce79a8c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}