fsrs4anki_optimizer.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# FSRS4Anki v3.14.5 Optimizer"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "lurCmW0Jqz3s"
      },
      "source": [
        "[![open in colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-spaced-repetition/fsrs4anki/blob/v3.14.5/fsrs4anki_optimizer.ipynb)\n",
        "\n",
        "↑ Click the above button to open the optimizer on Google Colab.\n",
        "\n",
        "> If you can't see the button and are located in the Chinese Mainland, please use a proxy or VPN."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "wG7bBfGJFbMr"
      },
      "source": [
        "Upload your **Anki Deck Package (.apkg)** file or **Anki Collection Package (.colpkg)** file on the `Left sidebar -> Files`, drag and drop your file in the current directory (not the `sample_data` directory). \n",
        "\n",
        "No need to include media. Need to include scheduling information. \n",
        "\n",
        "> If you use the latest version of Anki, please check the box `Support older Anki versions (slower/larger files)` when you export.\n",
        "\n",
        "You can export it via `File -> Export...` or `Ctrl + E` in the main window of Anki.\n",
        "\n",
        "Then replace the `filename` with yours in the next code cell. And set the `timezone` and `next_day_starts_at` which can be found in your preferences of Anki.\n",
        "\n",
        "After that, just run all (`Runtime -> Run all` or `Ctrl + F9`) and wait for minutes. You can see the optimal parameters in section **2.3 Result**. Copy them, replace the parameters in `fsrs4anki_scheduler.js`, and paste them into the custom scheduling of your deck options (require Anki version >= 2.1.55).\n",
        "\n",
        "**NOTE**: The default output is generated from my review logs. If you find the output is the same as mine, maybe your notebook hasn't run there.\n",
        "\n",
        "**Contribute to SRS Research**: If you want to share your data with me, please fill this form: https://forms.gle/KaojsBbhMCytaA7h8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "iqP70_-3EUhi"
      },
      "outputs": [],
      "source": [
        "# Here are some settings that you need to replace before running this optimizer.\n",
        "\n",
        "filename = \"collection-2022-09-18@13-21-58.colpkg\"\n",
        "# If you upload deck file, replace it with your deck filename. E.g., ALL__Learning.apkg\n",
        "# If you upload collection file, replace it with your colpgk filename. E.g., collection-2022-09-18@13-21-58.colpkg\n",
        "\n",
        "# Replace it with your timezone. I'm in China, so I use Asia/Shanghai.\n",
        "# You can find your timezone here: https://gist.github.com/heyalexej/8bf688fd67d7199be4a1682b3eec7568\n",
        "timezone = 'Asia/Shanghai'\n",
        "\n",
        "# Replace it with your Anki's setting in Preferences -> Scheduling.\n",
        "next_day_starts_at = 4\n",
        "\n",
        "# Replace it if you don't want the optimizer to use the review logs before a specific date.\n",
        "revlog_start_date = \"2006-10-05\"\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bLFVNmG2qd06"
      },
      "source": [
        "## 1 Build dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EkzFeKawqgbs"
      },
      "source": [
        "### 1.1 Extract Anki collection & deck file"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KD2js_wEr_Bs",
        "outputId": "42653d9e-316e-40bc-bd1d-f3a0e2b246c7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Extract successfully!\n"
          ]
        }
      ],
      "source": [
        "import zipfile\n",
        "import sqlite3\n",
        "import time\n",
        "import tqdm\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import os\n",
        "from datetime import timedelta, datetime\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "import sys\n",
        "import torch\n",
        "from torch import nn\n",
        "from sklearn.utils import shuffle\n",
        "# Extract the collection file or deck file to get the .anki21 database.\n",
        "with zipfile.ZipFile(f'./{filename}', 'r') as zip_ref:\n",
        "    zip_ref.extractall('./')\n",
        "    print(\"Extract successfully!\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dKpy4VfqGmaL"
      },
      "source": [
        "### 1.2 Create time-series feature & analysis\n",
        "\n",
        "The following code cell will extract the review logs from your Anki collection and preprocess them to a trainset which is saved in `revlog_history.tsv`.\n",
        "\n",
        "The time-series features are important in optimizing the model's parameters. For more detail, please see my paper: https://www.maimemo.com/paper/\n",
        "\n",
        "Then it will generate a concise analysis for your review logs. \n",
        "\n",
        "- The `r_history` is the history of ratings on each review. `3,3,3,1` means that you press `Good, Good, Good, Again`. It only contains the first rating for each card on the review date, i.e., when you press `Again` in review and  `Good` in relearning steps 10min later, only `Again` will be recorded.\n",
        "- The `avg_interval` is the actual average interval after you rate your cards as the `r_history`. It could be longer than the interval given by Anki's built-in scheduler because you reviewed some overdue cards.\n",
        "- The `avg_retention` is the average retention after you press as the `r_history`. `Again` counts as failed recall, and `Hard, Good and Easy` count as successful recall. Retention is the percentage of your successful recall.\n",
        "- The `stability` is the estimated memory state variable, which is an approximate interval that leads to 90% retention.\n",
        "- The `factor` is `stability / previous stability`.\n",
        "- The `group_cnt` is the number of review logs that have the same `r_history`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J2IIaY3PDaaG",
        "outputId": "607916c9-da95-48dd-fdab-6bd83fbbbb40"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "revlog.csv saved.\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "2a546ebc8d7140c281b32621d3aa3c4b",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/30711 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Trainset saved.\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "8a908dd8861f4c23892cef2e4524b19b",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/98048 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Retention calculated.\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "01b8aa2900b648ddb67c23510dfd02dd",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/65809 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Stability calculated.\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "24b4e85469354882ae29f4a4d1f8f0d8",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/1215 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1:again, 2:hard, 3:good, 4:easy\n",
            "\n",
            "      r_history  avg_interval  avg_retention  stability  factor  group_cnt\n",
            "              1           1.7          0.765        1.0     inf       7997\n",
            "            1,3           3.9          0.876        4.4    4.40       4180\n",
            "          1,3,3           8.6          0.883        9.8    2.23       2725\n",
            "        1,3,3,3          18.2          0.858       14.1    1.44       1623\n",
            "      1,3,3,3,3          37.5          0.836       23.3    1.65        828\n",
            "    1,3,3,3,3,3          77.7          0.853       35.8    1.54        390\n",
            "  1,3,3,3,3,3,3         111.5          0.913       39.5    1.10        179\n",
            "              2           1.0          0.901        1.1     inf        240\n",
            "            2,3           3.5          0.946        8.3    7.55        201\n",
            "          2,3,3          11.1          0.890        7.1    0.86        160\n",
            "              3           1.5          0.962        5.4     inf       9136\n",
            "            3,3           3.9          0.966       15.3    2.83       6594\n",
            "          3,3,3           9.0          0.960       24.0    1.57       5174\n",
            "        3,3,3,3          19.4          0.942       43.3    1.80       3531\n",
            "      3,3,3,3,3          39.1          0.926       54.9    1.27       1929\n",
            "    3,3,3,3,3,3          76.1          0.930      106.1    1.93       1083\n",
            "  3,3,3,3,3,3,3         117.0          0.949      155.3    1.46        484\n",
            "3,3,3,3,3,3,3,3         127.2          0.970      616.8    3.97        103\n",
            "              4           3.8          0.966       12.1     inf      11599\n",
            "            4,3           8.1          0.975       39.2    3.24       7523\n",
            "          4,3,3          18.0          0.963       57.4    1.46       5331\n",
            "        4,3,3,3          33.3          0.952       84.1    1.47       3030\n",
            "      4,3,3,3,3          48.1          0.954      128.3    1.53       1367\n",
            "    4,3,3,3,3,3          66.2          0.958      113.3    0.88        511\n",
            "  4,3,3,3,3,3,3          75.7          0.978      114.7    1.01        254\n",
            "4,3,3,3,3,3,3,3         110.2          0.984      179.2    1.56        174\n",
            "Analysis saved!\n"
          ]
        }
      ],
      "source": [
        "if os.path.isfile(\"collection.anki21b\"):\n",
        "    os.remove(\"collection.anki21b\")\n",
        "    raise Exception(\n",
        "        \"Please export the file with `support older Anki versions` if you use the latest version of Anki.\")\n",
        "elif os.path.isfile(\"collection.anki21\"):\n",
        "    con = sqlite3.connect(\"collection.anki21\")\n",
        "elif os.path.isfile(\"collection.anki2\"):\n",
        "    con = sqlite3.connect(\"collection.anki2\")\n",
        "else:\n",
        "    raise Exception(\"Collection not exist!\")\n",
        "cur = con.cursor()\n",
        "res = cur.execute(\"SELECT * FROM revlog\")\n",
        "revlog = res.fetchall()\n",
        "\n",
        "df = pd.DataFrame(revlog)\n",
        "df.columns = ['id', 'cid', 'usn', 'r', 'ivl',\n",
        "              'last_lvl', 'factor', 'time', 'type']\n",
        "df = df[(df['cid'] <= time.time() * 1000) &\n",
        "        (df['id'] <= time.time() * 1000) &\n",
        "        (df['r'] > 0)].copy()\n",
        "df['create_date'] = pd.to_datetime(df['cid'] // 1000, unit='s')\n",
        "df['create_date'] = df['create_date'].dt.tz_localize(\n",
        "    'UTC').dt.tz_convert(timezone)\n",
        "df['review_date'] = pd.to_datetime(df['id'] // 1000, unit='s')\n",
        "df['review_date'] = df['review_date'].dt.tz_localize(\n",
        "    'UTC').dt.tz_convert(timezone)\n",
        "df.drop(df[df['review_date'].dt.year < 2006].index, inplace=True)\n",
        "df.sort_values(by=['cid', 'id'], inplace=True, ignore_index=True)\n",
        "type_sequence = np.array(df['type'])\n",
        "time_sequence = np.array(df['time'])\n",
        "df.to_csv(\"revlog.csv\", index=False)\n",
        "print(\"revlog.csv saved.\")\n",
        "df = df[df['type'] != 3].copy()\n",
        "df['real_days'] = df['review_date'] - timedelta(hours=next_day_starts_at)\n",
        "df['real_days'] = pd.DatetimeIndex(df['real_days'].dt.floor('D', ambiguous='infer', nonexistent='shift_forward')).to_julian_date()\n",
        "df.drop_duplicates(['cid', 'real_days'], keep='first', inplace=True)\n",
        "df['delta_t'] = df.real_days.diff()\n",
        "df.dropna(inplace=True)\n",
        "df['delta_t'] = df['delta_t'].astype(dtype=int)\n",
        "df['i'] = 1\n",
        "df['r_history'] = \"\"\n",
        "df['t_history'] = \"\"\n",
        "col_idx = {key: i for i, key in enumerate(df.columns)}\n",
        "\n",
        "\n",
        "# code from https://github.com/L-M-Sherlock/anki_revlog_analysis/blob/main/revlog_analysis.py\n",
        "def get_feature(x):\n",
        "    for idx, log in enumerate(x.itertuples()):\n",
        "        if idx == 0:\n",
        "            x.iloc[idx, col_idx['delta_t']] = 0\n",
        "        if idx == x.shape[0] - 1:\n",
        "            break\n",
        "        x.iloc[idx + 1, col_idx['i']] = x.iloc[idx, col_idx['i']] + 1\n",
        "        x.iloc[idx + 1, col_idx['t_history']] = f\"{x.iloc[idx, col_idx['t_history']]},{x.iloc[idx, col_idx['delta_t']]}\"\n",
        "        x.iloc[idx + 1, col_idx['r_history']] = f\"{x.iloc[idx, col_idx['r_history']]},{x.iloc[idx, col_idx['r']]}\"\n",
        "    return x\n",
        "\n",
        "tqdm.notebook.tqdm.pandas()\n",
        "df = df.groupby('cid', as_index=False, group_keys=False).progress_apply(get_feature)\n",
        "df = df[df['id'] >= time.mktime(datetime.strptime(revlog_start_date, \"%Y-%m-%d\").timetuple()) * 1000]\n",
        "df[\"t_history\"] = df[\"t_history\"].map(lambda x: x[1:] if len(x) > 1 else x)\n",
        "df[\"r_history\"] = df[\"r_history\"].map(lambda x: x[1:] if len(x) > 1 else x)\n",
        "df.to_csv('revlog_history.tsv', sep=\"\\t\", index=False)\n",
        "print(\"Trainset saved.\")\n",
        "\n",
        "def cal_retention(group: pd.DataFrame) -> pd.DataFrame:\n",
        "    group['retention'] = round(group['r'].map(lambda x: {1: 0, 2: 1, 3: 1, 4: 1}[x]).mean(), 4)\n",
        "    group['total_cnt'] = group.shape[0]\n",
        "    return group\n",
        "\n",
        "df = df.groupby(by=['r_history', 'delta_t'], group_keys=False).progress_apply(cal_retention)\n",
        "print(\"Retention calculated.\")\n",
        "df = df.drop(columns=['id', 'cid', 'usn', 'ivl', 'last_lvl', 'factor', 'time', 'type', 'create_date', 'review_date', 'real_days', 'r', 't_history'])\n",
        "df.drop_duplicates(inplace=True)\n",
        "df['retention'] = df['retention'].map(lambda x: max(min(0.99, x), 0.01))\n",
        "\n",
        "def cal_stability(group: pd.DataFrame) -> pd.DataFrame:\n",
        "    group_cnt = sum(group['total_cnt'])\n",
        "    if group_cnt < 10:\n",
        "        return pd.DataFrame()\n",
        "    group['group_cnt'] = group_cnt\n",
        "    if group['i'].values[0] > 1:\n",
        "        r_ivl_cnt = sum(group['delta_t'] * group['retention'].map(np.log) * pow(group['total_cnt'], 2))\n",
        "        ivl_ivl_cnt = sum(group['delta_t'].map(lambda x: x ** 2) * pow(group['total_cnt'], 2))\n",
        "        group['stability'] = round(np.log(0.9) / (r_ivl_cnt / ivl_ivl_cnt), 1)\n",
        "    else:\n",
        "        group['stability'] = 0.0\n",
        "    group['avg_retention'] = round(sum(group['retention'] * pow(group['total_cnt'], 2)) / sum(pow(group['total_cnt'], 2)), 3)\n",
        "    group['avg_interval'] = round(sum(group['delta_t'] * pow(group['total_cnt'], 2)) / sum(pow(group['total_cnt'], 2)), 1)\n",
        "    del group['total_cnt']\n",
        "    del group['retention']\n",
        "    del group['delta_t']\n",
        "    return group\n",
        "\n",
        "df = df.groupby(by=['r_history'], group_keys=False).progress_apply(cal_stability)\n",
        "print(\"Stability calculated.\")\n",
        "df.reset_index(drop = True, inplace = True)\n",
        "df.drop_duplicates(inplace=True)\n",
        "df.sort_values(by=['r_history'], inplace=True, ignore_index=True)\n",
        "\n",
        "if df.shape[0] > 0:\n",
        "    for idx in tqdm.notebook.tqdm(df.index):\n",
        "        item = df.loc[idx]\n",
        "        index = df[(df['i'] == item['i'] + 1) & (df['r_history'].str.startswith(item['r_history']))].index\n",
        "        df.loc[index, 'last_stability'] = item['stability']\n",
        "    df['factor'] = round(df['stability'] / df['last_stability'], 2)\n",
        "    df = df[(df['i'] >= 2) & (df['group_cnt'] >= 100)]\n",
        "    df['last_recall'] = df['r_history'].map(lambda x: x[-1])\n",
        "    df = df[df.groupby(['i', 'r_history'], group_keys=False)['group_cnt'].transform(max) == df['group_cnt']]\n",
        "    df.to_csv('./stability_for_analysis.tsv', sep='\\t', index=None)\n",
        "    print(\"1:again, 2:hard, 3:good, 4:easy\\n\")\n",
        "    print(df[df['r_history'].str.contains(r'^[1-4][^124]*$', regex=True)][['r_history', 'avg_interval', 'avg_retention', 'stability', 'factor', 'group_cnt']].to_string(index=False))\n",
        "    print(\"Analysis saved!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k_SgzC-auWmu"
      },
      "source": [
        "## 2 Optimize parameter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WrfBJjqCHEwJ"
      },
      "source": [
        "### 2.1 Define the model\n",
        "\n",
        "FSRS is a time-series model for predicting memory states."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "tdYp3GMLhTYm"
      },
      "outputs": [],
      "source": [
        "init_w = [1, 1, 5, -0.5, -0.5, 0.2, 1.4, -0.12, 0.8, 2, -0.2, 0.2, 1]\n",
        "'''\n",
        "w[0]: initial_stability_for_again_answer\n",
        "w[1]: initial_stability_step_per_rating\n",
        "w[2]: initial_difficulty_for_good_answer\n",
        "w[3]: initial_difficulty_step_per_rating\n",
        "w[4]: next_difficulty_step_per_rating\n",
        "w[5]: next_difficulty_reversion_to_mean_speed (used to avoid ease hell)\n",
        "w[6]: next_stability_factor_after_success\n",
        "w[7]: next_stability_stabilization_decay_after_success\n",
        "w[8]: next_stability_retrievability_gain_after_success\n",
        "w[9]: next_stability_factor_after_failure\n",
        "w[10]: next_stability_difficulty_decay_after_success\n",
        "w[11]: next_stability_stability_gain_after_failure\n",
        "w[12]: next_stability_retrievability_gain_after_failure\n",
        "For more details about the parameters, please see: \n",
        "https://github.com/open-spaced-repetition/fsrs4anki/wiki/Free-Spaced-Repetition-Scheduler\n",
        "'''\n",
        "\n",
        "\n",
        "class FSRS(nn.Module):\n",
        "    def __init__(self, w):\n",
        "        super(FSRS, self).__init__()\n",
        "        self.w = nn.Parameter(torch.FloatTensor(w))\n",
        "        self.zero = torch.FloatTensor([0.0])\n",
        "\n",
        "    def forward(self, x, s, d):\n",
        "        '''\n",
        "        :param x: [review interval, review response]\n",
        "        :param s: stability\n",
        "        :param d: difficulty\n",
        "        :return:\n",
        "        '''\n",
        "        if torch.equal(s, self.zero):\n",
        "            # first learn, init memory states\n",
        "            new_s = self.w[0] + self.w[1] * (x[1] - 1)\n",
        "            new_d = self.w[2] + self.w[3] * (x[1] - 3)\n",
        "            new_d = new_d.clamp(1, 10)\n",
        "        else:\n",
        "            r = torch.exp(np.log(0.9) * x[0] / s)\n",
        "            new_d = d + self.w[4] * (x[1] - 3)\n",
        "            new_d = self.mean_reversion(self.w[2], new_d)\n",
        "            new_d = new_d.clamp(1, 10)\n",
        "            # recall\n",
        "            if x[1] > 1:\n",
        "                new_s = s * (1 + torch.exp(self.w[6]) *\n",
        "                             (11 - new_d) *\n",
        "                             torch.pow(s, self.w[7]) *\n",
        "                             (torch.exp((1 - r) * self.w[8]) - 1))\n",
        "            # forget\n",
        "            else:\n",
        "                new_s = self.w[9] * torch.pow(new_d, self.w[10]) * torch.pow(\n",
        "                    s, self.w[11]) * torch.exp((1 - r) * self.w[12])\n",
        "        return new_s, new_d\n",
        "\n",
        "    def loss(self, s, t, r):\n",
        "        return - (r * np.log(0.9) * t / s + (1 - r) * torch.log(1 - torch.exp(np.log(0.9) * t / s)))\n",
        "\n",
        "    def mean_reversion(self, init, current):\n",
        "        return self.w[5] * init + (1-self.w[5]) * current\n",
        "\n",
        "\n",
        "class WeightClipper(object):\n",
        "    def __init__(self, frequency=1):\n",
        "        self.frequency = frequency\n",
        "\n",
        "    def __call__(self, module):\n",
        "        if hasattr(module, 'w'):\n",
        "            w = module.w.data\n",
        "            w[0] = w[0].clamp(0.1, 10)\n",
        "            w[1] = w[1].clamp(0.1, 5)\n",
        "            w[2] = w[2].clamp(1, 10)\n",
        "            w[3] = w[3].clamp(-5, -0.1)\n",
        "            w[4] = w[4].clamp(-5, -0.1)\n",
        "            w[5] = w[5].clamp(0, 0.5)\n",
        "            w[6] = w[6].clamp(0, 2)\n",
        "            w[7] = w[7].clamp(-0.2, -0.01)\n",
        "            w[8] = w[8].clamp(0.01, 1.5)\n",
        "            w[9] = w[9].clamp(0.5, 5)\n",
        "            w[10] = w[10].clamp(-2, -0.01)\n",
        "            w[11] = w[11].clamp(0.01, 0.9)\n",
        "            w[12] = w[12].clamp(0.01, 2)\n",
        "            module.w.data = w\n",
        "\n",
        "def lineToTensor(line):\n",
        "    ivl = line[0].split(',')\n",
        "    response = line[1].split(',')\n",
        "    tensor = torch.zeros(len(response), 2)\n",
        "    for li, response in enumerate(response):\n",
        "        tensor[li][0] = int(ivl[li])\n",
        "        tensor[li][1] = int(response)\n",
        "    return tensor\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8E1dYfgQLZAC"
      },
      "source": [
        "### 2.2 Train the model\n",
        "\n",
        "The `revlog_history.tsv` generated before will be used for training the FSRS model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jht0gneShowU",
        "outputId": "aaa72b79-b454-483b-d746-df1a353b2c8f"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "c60bde4ce73c4f06acdffb057a699ce6",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/227189 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tensorized!\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "e4b45b50f1c94872bbad0033489ef57e",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "pre-train:   0%|          | 0/28972 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "w: [1.0138, 2.293, 5.0, -0.5, -0.5, 0.2, 1.4, -0.12, 0.8, 2.0, -0.2, 0.2, 1.0]\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "1e8a944f8e4f4e1bb296c28a75815c9e",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "train:   0%|          | 0/198217 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "iteration: 1\n",
            "w: [1.0138, 2.293, 4.9984, -0.5016, -0.4984, 0.2016, 1.4016, -0.1184, 0.8016, 2.0016, -0.1984, 0.2016, 1.0016]\n",
            "iteration: 19822\n",
            "w: [1.014, 2.2933, 5.1691, -1.0277, -0.7665, 0.0152, 1.342, -0.0402, 0.7324, 1.8802, -0.3201, 0.371, 0.9729]\n",
            "iteration: 39643\n",
            "w: [1.014, 2.2933, 5.2118, -1.1435, -0.9297, 0.0035, 1.4016, -0.0258, 0.7873, 1.7984, -0.4012, 0.4907, 0.9433]\n",
            "iteration: 59464\n",
            "w: [1.014, 2.2933, 5.2249, -1.1889, -0.9963, 0.0307, 1.3829, -0.039, 0.7657, 1.7586, -0.438, 0.5368, 0.9664]\n",
            "iteration: 79285\n",
            "w: [1.014, 2.2933, 5.1679, -1.17, -0.9894, 0.0147, 1.3817, -0.0511, 0.7571, 1.7539, -0.4397, 0.5573, 0.9772]\n",
            "iteration: 99106\n",
            "w: [1.014, 2.2933, 5.1149, -1.1193, -1.043, 0.0156, 1.4083, -0.0752, 0.7805, 1.7371, -0.4488, 0.544, 1.0766]\n",
            "iteration: 118927\n",
            "w: [1.014, 2.2933, 5.0655, -1.1796, -0.9853, 0.008, 1.3749, -0.078, 0.7423, 1.7524, -0.4287, 0.569, 1.065]\n",
            "iteration: 138748\n",
            "w: [1.014, 2.2933, 5.0761, -1.2334, -1.0579, 0.0248, 1.3857, -0.0334, 0.7474, 1.714, -0.4627, 0.6198, 1.0413]\n",
            "iteration: 158569\n",
            "w: [1.014, 2.2933, 4.9431, -1.1478, -0.951, 0.008, 1.4207, -0.0523, 0.776, 1.7008, -0.4698, 0.5712, 0.9746]\n",
            "iteration: 178390\n",
            "w: [1.014, 2.2933, 4.9769, -1.2077, -0.9868, 0.0062, 1.3926, -0.0622, 0.7442, 1.7059, -0.4625, 0.6134, 1.0383]\n",
            "iteration: 198211\n",
            "w: [1.014, 2.2933, 5.0053, -1.2683, -1.0336, 0.0163, 1.4374, -0.0502, 0.7834, 1.6681, -0.4913, 0.622, 0.9617]\n",
            "\n",
            "Training finished!\n"
          ]
        }
      ],
      "source": [
        "model = FSRS(init_w)\n",
        "clipper = WeightClipper()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=5e-4)\n",
        "\n",
        "dataset = pd.read_csv(\"./revlog_history.tsv\", sep='\\t', index_col=None, dtype={'r_history': str ,'t_history': str} )\n",
        "dataset = dataset[(dataset['i'] > 1) & (dataset['delta_t'] > 0) & (dataset['t_history'].str.count(',0') == 0)]\n",
        "dataset['tensor'] = dataset.progress_apply(lambda x: lineToTensor(list(zip([x['t_history']], [x['r_history']]))[0]), axis=1)\n",
        "print(\"Tensorized!\")\n",
        "\n",
        "pre_train_set = dataset[dataset['i'] == 2]\n",
        "# pretrain\n",
        "epoch_len = len(pre_train_set)\n",
        "n_epoch = 1\n",
        "pbar = tqdm.notebook.tqdm(desc=\"pre-train\", colour=\"red\", total=epoch_len*n_epoch)\n",
        "\n",
        "for k in range(n_epoch):\n",
        "    for i, (_, row) in enumerate(shuffle(pre_train_set, random_state=2022 + k).iterrows()):\n",
        "        model.train()\n",
        "        optimizer.zero_grad()\n",
        "        output_t = [(model.zero, model.zero)]\n",
        "        for input_t in row['tensor']:\n",
        "            output_t.append(model(input_t, *output_t[-1]))\n",
        "        loss = model.loss(output_t[-1][0], row['delta_t'],\n",
        "                            {1: 0, 2: 1, 3: 1, 4: 1}[row['r']])\n",
        "        if np.isnan(loss.data.item()):\n",
        "            # Exception Case\n",
        "            print(row, output_t)\n",
        "            raise Exception('error case')\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        model.apply(clipper)\n",
        "        pbar.update()\n",
        "pbar.close()\n",
        "for name, param in model.named_parameters():\n",
        "    print(f\"{name}: {list(map(lambda x: round(float(x), 4),param))}\")\n",
        "\n",
        "train_set = dataset[dataset['i'] > 2]\n",
        "epoch_len = len(train_set)\n",
        "n_epoch = 1\n",
        "print_len = max(epoch_len*n_epoch // 10, 1)\n",
        "pbar = tqdm.notebook.tqdm(desc=\"train\", colour=\"red\", total=epoch_len*n_epoch)\n",
        "\n",
        "for k in range(n_epoch):\n",
        "    for i, (_, row) in enumerate(shuffle(train_set, random_state=2022 + k).iterrows()):\n",
        "        model.train()\n",
        "        optimizer.zero_grad()\n",
        "        output_t = [(model.zero, model.zero)]\n",
        "        for input_t in row['tensor']:\n",
        "            output_t.append(model(input_t, *output_t[-1]))\n",
        "        loss = model.loss(output_t[-1][0], row['delta_t'],\n",
        "                          {1: 0, 2: 1, 3: 1, 4: 1}[row['r']])\n",
        "        if np.isnan(loss.data.item()):\n",
        "            # Exception Case\n",
        "            print(row, output_t)\n",
        "            raise Exception('error case')\n",
        "        loss.backward()\n",
        "        for param in model.parameters():\n",
        "            param.grad[:2] = torch.zeros(2)\n",
        "        optimizer.step()\n",
        "        model.apply(clipper)\n",
        "        pbar.update()\n",
        "\n",
        "        if (k * epoch_len + i) % print_len == 0:\n",
        "            print(f\"iteration: {k * epoch_len + i + 1}\")\n",
        "            for name, param in model.named_parameters():\n",
        "                print(f\"{name}: {list(map(lambda x: round(float(x), 4),param))}\")\n",
        "pbar.close()\n",
        "\n",
        "w = list(map(lambda x: round(float(x), 4), dict(model.named_parameters())['w'].data))\n",
        "\n",
        "print(\"\\nTraining finished!\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BZ4S2l7BWfzr"
      },
      "source": [
        "### 2.3 Result\n",
        "\n",
        "Copy the optimal parameters for FSRS for you in the output of next code cell after running."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NTnPSDA2QpUu",
        "outputId": "49f487b9-69a7-4e96-b35a-7e027f478fbd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.014, 2.2933, 5.0049, -1.268, -1.0337, 0.0165, 1.438, -0.0498, 0.784, 1.6685, -0.4909, 0.6221, 0.9617]\n"
          ]
        }
      ],
      "source": [
        "print(w)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.4 Preview"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I_zsoDyTaTrT"
      },
      "source": [
        "You can see the memory states and intervals generated by FSRS as if you press the good in each review at the due date scheduled by FSRS."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iws4rtP1WKBT",
        "outputId": "890d0287-1a17-4c59-fbbf-ee54d79cd383"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1:again, 2:hard, 3:good, 4:easy\n",
            "\n",
            "first rating: 1\n",
            "rating history: 1,3,3,3,3,3,3,3,3,3,3\n",
            "interval history: 0,1,2,5,10,21,44,90,183,366,723\n",
            "difficulty history: 0,7.5,7.5,7.5,7.4,7.4,7.3,7.3,7.3,7.2,7.2\n",
            "\n",
            "first rating: 2\n",
            "rating history: 2,3,3,3,3,3,3,3,3,3,3\n",
            "interval history: 0,3,8,20,48,113,262,592,1312,2852,6085\n",
            "difficulty history: 0,6.3,6.3,6.2,6.2,6.2,6.2,6.2,6.1,6.1,6.1\n",
            "\n",
            "first rating: 3\n",
            "rating history: 3,3,3,3,3,3,3,3,3,3,3\n",
            "interval history: 0,6,17,47,127,333,846,2092,5036,11820,27080\n",
            "difficulty history: 0,5.0,5.0,5.0,5.0,5.0,5.0,5.0,5.0,5.0,5.0\n",
            "\n",
            "first rating: 4\n",
            "rating history: 4,3,3,3,3,3,3,3,3,3,3\n",
            "interval history: 0,8,26,81,242,696,1932,5184,13470,33947,83104\n",
            "difficulty history: 0,3.7,3.8,3.8,3.8,3.8,3.8,3.9,3.9,3.9,3.9\n",
            "\n"
          ]
        }
      ],
      "source": [
        "requestRetention = 0.9  # recommended setting: 0.8 ~ 0.9\n",
        "\n",
        "\n",
        "class Collection:\n",
        "    def __init__(self, w):\n",
        "        self.model = FSRS(w)\n",
        "\n",
        "    def states(self, t_history, r_history):\n",
        "        with torch.no_grad():\n",
        "            line_tensor = lineToTensor(list(zip([t_history], [r_history]))[0])\n",
        "            output_t = [(self.model.zero, self.model.zero)]\n",
        "            for input_t in line_tensor:\n",
        "                output_t.append(self.model(input_t, *output_t[-1]))\n",
        "            return output_t[-1]\n",
        "\n",
        "\n",
        "my_collection = Collection(w)\n",
        "print(\"1:again, 2:hard, 3:good, 4:easy\\n\")\n",
        "for first_rating in (1,2,3,4):\n",
        "    print(f'first rating: {first_rating}')\n",
        "    t_history = \"0\"\n",
        "    d_history = \"0\"\n",
        "    r_history = f\"{first_rating}\"  # the first rating of the new card\n",
        "    # print(\"stability, difficulty, lapses\")\n",
        "    for i in range(10):\n",
        "        states = my_collection.states(t_history, r_history)\n",
        "        # print('{0:9.2f} {1:11.2f} {2:7.0f}'.format(\n",
        "            # *list(map(lambda x: round(float(x), 4), states))))\n",
        "        next_t = max(round(float(np.log(requestRetention)/np.log(0.9) * states[0])), 1)\n",
        "        difficulty = round(float(states[1]), 1)\n",
        "        t_history += f',{int(next_t)}'\n",
        "        d_history += f',{difficulty}'\n",
        "        r_history += f\",3\"\n",
        "    print(f\"rating history: {r_history}\")\n",
        "    print(f\"interval history: {t_history}\")\n",
        "    print(f\"difficulty history: {d_history}\")\n",
        "    print('')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can change the `test_rating_sequence` to see the scheduling intervals in different ratings."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(tensor(5.6006), tensor(5.0049))\n",
            "(tensor(16.9302), tensor(5.0049))\n",
            "(tensor(47.3390), tensor(5.0049))\n",
            "(tensor(127.2266), tensor(5.0049))\n",
            "(tensor(332.7068), tensor(5.0049))\n",
            "(tensor(26.1266), tensor(7.0382))\n",
            "(tensor(4.7439), tensor(9.0379))\n",
            "(tensor(7.9659), tensor(8.9714))\n",
            "(tensor(13.1556), tensor(8.9059))\n",
            "(tensor(21.6355), tensor(8.8416))\n",
            "(tensor(36.0396), tensor(8.7783))\n",
            "(tensor(59.6686), tensor(8.7160))\n",
            "rating history: 3,3,3,3,3,1,1,3,3,3,3,3\n",
            "interval history: 0,6,17,47,127,333,26,5,8,13,22,36,60\n",
            "difficulty history: 0,5.0,5.0,5.0,5.0,5.0,7.0,9.0,9.0,8.9,8.8,8.8,8.7\n"
          ]
        }
      ],
      "source": [
        "test_rating_sequence = \"3,3,3,3,3,1,1,3,3,3,3,3\"\n",
        "requestRetention = 0.9  # recommended setting: 0.8 ~ 0.9\n",
        "easyBonus = 1.3\n",
        "hardInterval = 1.2\n",
        "\n",
        "t_history = \"0\"\n",
        "d_history = \"0\"\n",
        "for i in range(len(test_rating_sequence.split(','))):\n",
        "    rating = test_rating_sequence[2*i]\n",
        "    last_t = int(t_history.split(',')[-1])\n",
        "    r_history = test_rating_sequence[:2*i+1]\n",
        "    states = my_collection.states(t_history, r_history)\n",
        "    print(states)\n",
        "    next_t = max(1,round(float(np.log(requestRetention)/np.log(0.9) * states[0])))\n",
        "    if rating == '4':\n",
        "        next_t = round(next_t * easyBonus)\n",
        "    elif rating == '2':\n",
        "        next_t = round(last_t * hardInterval)\n",
        "    t_history += f',{int(next_t)}'\n",
        "    difficulty = round(float(states[1]), 1)\n",
        "    d_history += f',{difficulty}'\n",
        "print(f\"rating history: {test_rating_sequence}\")\n",
        "print(f\"interval history: {t_history}\")\n",
        "print(f\"difficulty history: {d_history}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.5 Predict memory states and distribution of difficulty\n",
        "\n",
        "Predict memory states for each review and save them in `prediction.tsv`.\n",
        "\n",
        "Meanwhile, it will count the distribution of difficulty."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "803dda4016eb454cb5d2d9fb32364092",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/120767 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "prediction.tsv saved.\n",
            "difficulty\n",
            "1     0.001862\n",
            "2     0.010942\n",
            "3     0.039359\n",
            "4     0.153581\n",
            "5     0.160223\n",
            "6     0.066641\n",
            "7     0.078490\n",
            "8     0.109512\n",
            "9     0.091813\n",
            "10    0.287576\n",
            "Name: count, dtype: float64\n"
          ]
        }
      ],
      "source": [
        "def predict_memory_states(group):\n",
        "    states = my_collection.states(*group.name)\n",
        "    group['stability'] = float(states[0])\n",
        "    group['difficulty'] = float(states[1])\n",
        "    group['count'] = len(group)\n",
        "    return pd.DataFrame({\n",
        "        'r_history': [group.name[1]], \n",
        "        't_history': [group.name[0]], \n",
        "        'stability': [round(float(states[0]),2)], \n",
        "        'difficulty': [round(float(states[1]),2)], \n",
        "        'count': [len(group)] \n",
        "    })\n",
        "\n",
        "prediction = dataset.groupby(by=['t_history', 'r_history']).progress_apply(predict_memory_states)\n",
        "prediction.reset_index(drop=True, inplace=True)\n",
        "prediction.sort_values(by=['r_history'], inplace=True)\n",
        "prediction.to_csv(\"./prediction.tsv\", sep='\\t', index=None)\n",
        "print(\"prediction.tsv saved.\")\n",
        "prediction['difficulty'] = prediction['difficulty'].map(lambda x: int(round(x)))\n",
        "difficulty_distribution = prediction.groupby(by=['difficulty'])['count'].sum() / prediction['count'].sum()\n",
        "print(difficulty_distribution)\n",
        "difficulty_distribution_padding = np.zeros(10)\n",
        "for i in range(10):\n",
        "    if i+1 in difficulty_distribution.index:\n",
        "        difficulty_distribution_padding[i] = difficulty_distribution.loc[i+1]"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3 Optimize retention to minimize the time of reviews\n",
        "\n",
        "Calculate the optimal retention to minimize the time for long-term memory consolidation. It is an experimental feature. You can use the simulator to get more accurate results:\n",
        "\n",
        "https://github.com/open-spaced-repetition/fsrs4anki/blob/main/fsrs4anki_simulator.ipynb"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "average time for failed cards: 25.0s\n",
            "average time for recalled cards: 8.0s\n",
            "terminal stability:  361.62\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "765cd1080dfe4f23b103ceb223a034ae",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/15 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "expected_time.csv saved.\n",
            "\n",
            "-----suggested retention (experimental): 0.84-----\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "base = 1.01\n",
        "index_len = 793\n",
        "index_offset = 200\n",
        "d_range = 10\n",
        "d_offset = 1\n",
        "r_time = 8\n",
        "f_time = 25\n",
        "max_time = 200000\n",
        "\n",
        "type_block = dict()\n",
        "type_count = dict()\n",
        "type_time = dict()\n",
        "last_t = type_sequence[0]\n",
        "type_block[last_t] = 1\n",
        "type_count[last_t] = 1\n",
        "type_time[last_t] = time_sequence[0]\n",
        "for i,t in enumerate(type_sequence[1:]):\n",
        "    type_count[t] = type_count.setdefault(t, 0) + 1\n",
        "    type_time[t] = type_time.setdefault(t, 0) + time_sequence[i]\n",
        "    if t != last_t:\n",
        "        type_block[t] = type_block.setdefault(t, 0) + 1\n",
        "    last_t = t\n",
        "\n",
        "r_time = round(type_time[1]/type_count[1]/1000, 1)\n",
        "\n",
        "if 2 in type_count and 2 in type_block:\n",
        "    f_time = round(type_time[2]/type_block[2]/1000 + r_time, 1)\n",
        "\n",
        "print(f\"average time for failed cards: {f_time}s\")\n",
        "print(f\"average time for recalled cards: {r_time}s\")\n",
        "\n",
        "def stability2index(stability):\n",
        "    return int(round(np.log(stability) / np.log(base)) + index_offset)\n",
        "\n",
        "def init_stability(d):\n",
        "    return max(((d - w[2]) / w[3] + 2) * w[1] + w[0], np.power(base, -index_offset))\n",
        "\n",
        "def cal_next_recall_stability(s, r, d, response):\n",
        "    if response == 1:\n",
        "        return s * (1 + np.exp(w[6]) * (11 - d) * np.power(s, w[7]) * (np.exp((1 - r) * w[8]) - 1))\n",
        "    else:\n",
        "        return w[9] * np.power(d, w[10]) * np.power(s, w[11]) * np.exp((1 - r) * w[12])\n",
        "\n",
        "\n",
        "stability_list = np.array([np.power(base, i - index_offset) for i in range(index_len)])\n",
        "print(f\"terminal stability: {stability_list.max(): .2f}\")\n",
        "df = pd.DataFrame(columns=[\"retention\", \"difficulty\", \"time\"])\n",
        "\n",
        "for percentage in tqdm.notebook.tqdm(range(96, 66, -2)):\n",
        "    recall = percentage / 100\n",
        "    time_list = np.zeros((d_range, index_len))\n",
        "    time_list[:,:-1] = max_time\n",
        "    for d in range(d_range, 0, -1):\n",
        "        s0 = init_stability(d)\n",
        "        s0_index = stability2index(s0)\n",
        "        diff = max_time\n",
        "        while diff > 0.1:\n",
        "            s0_time = time_list[d - 1][s0_index]\n",
        "            for s_index in range(index_len - 2, -1, -1):\n",
        "                stability = stability_list[s_index];\n",
        "                interval = max(1, round(stability * np.log(recall) / np.log(0.9)))\n",
        "                p_recall = np.power(0.9, interval / stability)\n",
        "                recall_s = cal_next_recall_stability(stability, p_recall, d, 1)\n",
        "                forget_d = min(d + d_offset, 10)\n",
        "                forget_s = cal_next_recall_stability(stability, p_recall, forget_d, 0)\n",
        "                recall_s_index = min(stability2index(recall_s), index_len - 1)\n",
        "                forget_s_index = min(max(stability2index(forget_s), 0), index_len - 1)\n",
        "                recall_time = time_list[d - 1][recall_s_index] + r_time\n",
        "                forget_time = time_list[forget_d - 1][forget_s_index] + f_time\n",
        "                exp_time = p_recall * recall_time + (1.0 - p_recall) * forget_time\n",
        "                if exp_time < time_list[d - 1][s_index]:\n",
        "                    time_list[d - 1][s_index] = exp_time\n",
        "            diff = s0_time - time_list[d - 1][s0_index]\n",
        "        df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1] = [recall, d, s0_time]\n",
        "\n",
        "df.sort_values(by=[\"difficulty\", \"retention\"], inplace=True)\n",
        "df.to_csv(\"./expected_time.csv\", index=False)\n",
        "print(\"expected_time.csv saved.\")\n",
        "\n",
        "optimal_retention_list = np.zeros(10)\n",
        "for d in range(1, d_range+1):\n",
        "    retention = df[df[\"difficulty\"] == d][\"retention\"]\n",
        "    time = df[df[\"difficulty\"] == d][\"time\"]\n",
        "    optimal_retention = retention.iat[time.argmin()]\n",
        "    optimal_retention_list[d-1] = optimal_retention\n",
        "    plt.plot(retention, time, label=f\"d={d}, r={optimal_retention}\")\n",
        "print(f\"\\n-----suggested retention (experimental): {np.inner(difficulty_distribution_padding, optimal_retention_list):.2f}-----\")\n",
        "plt.ylabel(\"expected time (second)\")\n",
        "plt.xlabel(\"retention\")\n",
        "plt.legend()\n",
        "plt.grid()\n",
        "plt.semilogy()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4 Evaluate the model\n",
        "\n",
        "Evaluate the model with the log loss. It will compare the log loss between initial model and trained model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "98f373bc73774834a3b8431e60cd89e6",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/227189 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loss before training: 0.3408\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "66c70a12313f42c58e7239f039a4bd70",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/227189 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loss after training: 0.3179\n"
          ]
        }
      ],
      "source": [
        "def log_loss(row):\n",
        "    states = my_collection.states(row['t_history'], row['r_history'])\n",
        "    row['log_loss'] = float(my_collection.model.loss(states[0], row['delta_t'], {1: 0, 2: 1, 3: 1, 4: 1}[row['r']]))\n",
        "    return row\n",
        "\n",
        "my_collection = Collection(init_w)\n",
        "dataset = dataset.progress_apply(log_loss, axis=1)\n",
        "print(f\"Loss before training: {dataset['log_loss'].mean():.4f}\")\n",
        "my_collection = Collection(w)\n",
        "dataset = dataset.progress_apply(log_loss, axis=1)\n",
        "print(f\"Loss after training: {dataset['log_loss'].mean():.4f}\")"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyMnk8/Ih2JAJZJ1PBkXQUBC",
      "collapsed_sections": [],
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "dl",
      "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.12"
    },
    "vscode": {
      "interpreter": {
        "hash": "46e27ede752268be201d36b7fbc2802b29a11b0bb095abacecc6c0428b93624a"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}