fsrs4anki_optimizer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# FSRS4Anki v3.7.0 Optimizer"
      ]
    },
    {
      "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.7.0/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."
      ]
    },
    {
      "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 **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."
      ]
    },
    {
      "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",
        "timezone = 'Asia/Shanghai'\n",
        "\n",
        "# Replace it with your Anki's setting in Prefernces -> 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": "98352f3f3f8e45658a23035a36c09f11",
              "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": "2a79ceefccd745e0a15b8334c8e46651",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/96660 [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": "6c3960480caa46419e376b3c961180b9",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/1312 [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": "d65e7a8758804603a13855f93542f2af",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/1312 [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       7978\n",
            "        1,3           3.9          0.876        4.3    4.30       4155\n",
            "      1,3,3           8.6          0.883        9.2    2.14       2684\n",
            "    1,3,3,3          17.8          0.857       13.8    1.50       1483\n",
            "  1,3,3,3,3          37.0          0.812       19.4    1.41        606\n",
            "1,3,3,3,3,3          77.1          0.708       23.1    1.19        128\n",
            "          2           1.0          0.901        1.1     inf        234\n",
            "        2,3           3.2          0.943        6.3    5.73        154\n",
            "          3           1.5          0.962        5.4     inf       9070\n",
            "        3,3           3.9          0.966       15.2    2.81       6527\n",
            "      3,3,3           9.0          0.960       23.5    1.55       5036\n",
            "    3,3,3,3          18.6          0.941       35.2    1.50       3052\n",
            "  3,3,3,3,3          39.5          0.914       46.9    1.33       1423\n",
            "3,3,3,3,3,3          74.3          0.853       55.6    1.19        411\n",
            "          4           3.8          0.966       12.1     inf      11436\n",
            "        4,3           8.1          0.975       38.9    3.21       7367\n",
            "      4,3,3          18.0          0.963       57.7    1.48       5147\n",
            "    4,3,3,3          34.0          0.947       77.2    1.34       2525\n",
            "  4,3,3,3,3          46.3          0.906       50.1    0.65        452\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) &\n",
        "        (df['id'] >= time.mktime(datetime.strptime(revlog_start_date, \"%Y-%m-%d\").timetuple()) * 1000)].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",
        "df.to_csv(\"revlog.csv\", index=False)\n",
        "print(\"revlog.csv saved.\")\n",
        "df = df[(df['type'] == 0) | (df['type'] == 1)].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')).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).progress_apply(get_feature)\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']).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 = df[(df['retention'] < 1) & (df['retention'] > 0)]\n",
        "\n",
        "def cal_stability(group: pd.DataFrame) -> pd.DataFrame:\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['group_cnt'] = sum(group['total_cnt'])\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']).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",
        "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_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.02, 0.8, 2, -0.2, 0.5, 1]\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)  # initStability\n",
        "            w[1] = w[1].clamp(0.1, 5)  # initStabilityRatingFactor\n",
        "            w[2] = w[2].clamp(1, 10)  # initDifficulty\n",
        "            w[3] = w[3].clamp(-5, -0.1)  # initDifficultyRatingFactor\n",
        "            w[4] = w[4].clamp(-5, -0.1)  # updateDifficultyRatingFactor\n",
        "            w[5] = w[5].clamp(0, 0.5)  # difficultyMeanReversionFactor\n",
        "            w[6] = w[6].clamp(0, 5)  # recallFactor\n",
        "            w[7] = w[7].clamp(-0.2, -0.01)  # recallStabilityDecay\n",
        "            w[8] = w[8].clamp(0.01, 2)  # recallRetrievabilityFactor\n",
        "            w[9] = w[9].clamp(0.5, 5)  # forgetFactor\n",
        "            w[10] = w[10].clamp(-2, -0.01)  # forgetDifficultyDecay\n",
        "            w[11] = w[11].clamp(0.01, 1)  # forgetStabilityDecay\n",
        "            w[12] = w[12].clamp(0.01, 2)  # forgetRetrievabilityFactor\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": "226ce66d5c214792b39987b8cc0f355f",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/225934 [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": "c04557a2e31a42b3ab6dadfc36235a28",
              "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.02, 0.8, 2.0, -0.2, 0.5, 1.0]\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "e08159cc3d474cc4a18ef8d0a4894a6c",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "train:   0%|          | 0/196962 [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.4984, -0.4984, 0.2016, 1.4016, -0.0184, 0.8016, 2.0016, -0.1984, 0.5016, 1.0016]\n",
            "iteration: 19697\n",
            "w: [1.014, 2.2933, 5.1859, -0.8665, -0.753, 0.0278, 1.3077, -0.0323, 0.6998, 1.783, -0.4174, 0.4751, 0.7849]\n",
            "iteration: 39393\n",
            "w: [1.014, 2.2933, 5.1883, -1.0109, -0.8103, 0.0189, 1.3359, -0.0402, 0.722, 1.7791, -0.4218, 0.5329, 0.7656]\n",
            "iteration: 59089\n",
            "w: [1.014, 2.2933, 5.1806, -1.0338, -0.9271, 0.009, 1.3561, -0.0459, 0.734, 1.7582, -0.4392, 0.596, 0.8001]\n",
            "iteration: 78785\n",
            "w: [1.014, 2.2933, 5.231, -1.0983, -1.0567, 0.022, 1.4053, -0.0366, 0.7799, 1.7125, -0.4748, 0.6083, 0.7739]\n",
            "iteration: 98481\n",
            "w: [1.014, 2.2933, 5.1966, -1.0786, -1.1153, 0.005, 1.4282, -0.0441, 0.7988, 1.7388, -0.4457, 0.6353, 0.8087]\n",
            "iteration: 118177\n",
            "w: [1.014, 2.2933, 5.1881, -1.1304, -1.1087, 0.0283, 1.4025, -0.0234, 0.7683, 1.7037, -0.4725, 0.5728, 0.8558]\n",
            "iteration: 137873\n",
            "w: [1.014, 2.2933, 5.146, -1.1969, -1.0858, 0.0077, 1.388, -0.026, 0.746, 1.7052, -0.4699, 0.6312, 0.9203]\n",
            "iteration: 157569\n",
            "w: [1.014, 2.2933, 5.1197, -1.1527, -1.0874, 0.0259, 1.368, -0.0762, 0.7209, 1.7295, -0.4381, 0.6247, 0.9711]\n",
            "iteration: 177265\n",
            "w: [1.014, 2.2933, 5.0225, -1.1358, -1.0742, 0.0118, 1.4074, -0.0451, 0.7556, 1.7049, -0.461, 0.5968, 0.994]\n",
            "iteration: 196961\n",
            "w: [1.014, 2.2933, 4.9588, -1.1608, -0.9955, 0.0235, 1.3923, -0.0485, 0.7363, 1.6938, -0.4707, 0.6032, 0.9763]\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)\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": [
        "## 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": [
            "var w = [1.014, 2.2933, 4.9588, -1.1608, -0.9954, 0.0234, 1.3923, -0.0484, 0.7363, 1.6937, -0.4708, 0.6032, 0.9762];\n"
          ]
        }
      ],
      "source": [
        "print(f\"var w = {w};\")"
      ]
    },
    {
      "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,4,9,19,39,79,159,317,624\n",
            "difficulty history: 0,7.3,7.2,7.2,7.1,7.1,7.0,7.0,6.9,6.9,6.8\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,19,44,100,223,489,1052,2226,4631\n",
            "difficulty history: 0,6.1,6.1,6.1,6.0,6.0,6.0,6.0,5.9,5.9,5.9\n",
            "\n",
            "first rating: 3\n",
            "rating history: 3,3,3,3,3,3,3,3,3,3,3\n",
            "interval history: 0,6,16,42,107,265,641,1512,3483,7842,17280\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,24,69,192,517,1348,3409,8376,20022,46625\n",
            "difficulty history: 0,3.8,3.8,3.9,3.9,3.9,3.9,4.0,4.0,4.0,4.0\n",
            "\n"
          ]
        }
      ],
      "source": [
        "requestRetention = 0.9  # recommended setting: 0.8 ~ 0.9\n",
        "\n",
        "\n",
        "class Collection:\n",
        "    def __init__(self):\n",
        "        self.model = model\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()\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(4.9588))\n",
            "(tensor(15.8415), tensor(4.9588))\n",
            "(tensor(41.8368), tensor(4.9588))\n",
            "(tensor(106.9482), tensor(4.9588))\n",
            "(tensor(265.4701), tensor(4.9588))\n",
            "(tensor(21.7953), tensor(6.9029))\n",
            "(tensor(4.3077), tensor(8.8015))\n",
            "(tensor(6.9330), tensor(8.7116))\n",
            "(tensor(11.5889), tensor(8.6238))\n",
            "(tensor(19.6520), tensor(8.5380))\n",
            "(tensor(33.2010), tensor(8.4543))\n",
            "(tensor(55.7056), tensor(8.3725))\n",
            "rating history: 3,3,3,3,3,1,1,3,3,3,3,3\n",
            "interval history: 0,6,16,42,107,265,22,4,7,12,20,33,56\n",
            "difficulty history: 0,5.0,5.0,5.0,5.0,5.0,6.9,8.8,8.7,8.6,8.5,8.5,8.4\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": [
        "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": "e3dc6ddcb6f649c0a99791e9fae215e3",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/119670 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "prediction.tsv saved.\n",
            "difficulty\n",
            "1     0.001868\n",
            "2     0.011008\n",
            "3     0.039538\n",
            "4     0.154465\n",
            "5     0.160835\n",
            "6     0.067444\n",
            "7     0.135070\n",
            "8     0.068701\n",
            "9     0.107399\n",
            "10    0.253671\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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Calculate the optimal retention to minimize the repetitions for long-term memory consolidation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "terminal stability:  637.63\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "027a86ff7d3d40eab53d09dce686b657",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/10 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "expected_repetitions.csv saved.\n",
            "\n",
            "-----suggested retention: 0.87-----\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 = 800\n",
        "index_offset = 150\n",
        "d_range = 10\n",
        "d_offset = 1\n",
        "r_repetitions = 1\n",
        "f_repetitions = 2.3\n",
        "max_repetitions = 200000\n",
        "\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\", \"repetitions\"])\n",
        "\n",
        "for percentage in tqdm.notebook.tqdm(range(96, 76, -2)):\n",
        "    recall = percentage / 100\n",
        "    repetitions_list = np.zeros((d_range, index_len))\n",
        "    repetitions_list[:,:-1] = max_repetitions\n",
        "    for d in range(d_range, 0, -1):\n",
        "        s0 = init_stability(d)\n",
        "        s0_index = stability2index(s0)\n",
        "        diff = max_repetitions\n",
        "        while diff > 0.1:\n",
        "            s0_repetitions = repetitions_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 = max(stability2index(forget_s), 0)\n",
        "                recall_repetitions = repetitions_list[d - 1][recall_s_index] + r_repetitions\n",
        "                forget_repetitions = repetitions_list[forget_d - 1][forget_s_index] + f_repetitions\n",
        "                exp_repetitions = p_recall * recall_repetitions + (1.0 - p_recall) * forget_repetitions\n",
        "                if exp_repetitions < repetitions_list[d - 1][s_index]:\n",
        "                    repetitions_list[d - 1][s_index] = exp_repetitions\n",
        "            diff = s0_repetitions - repetitions_list[d - 1][s0_index]\n",
        "        df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1] = [recall, d, s0_repetitions]\n",
        "\n",
        "df.sort_values(by=[\"difficulty\", \"retention\"], inplace=True)\n",
        "df.to_csv(\"./expected_repetitions.csv\", index=False)\n",
        "print(\"expected_repetitions.csv saved.\")\n",
        "\n",
        "optimal_retention_list = []\n",
        "for d in range(d_range, 0, -1):\n",
        "    retention = df[df[\"difficulty\"] == d][\"retention\"]\n",
        "    repetitions = df[df[\"difficulty\"] == d][\"repetitions\"]\n",
        "    optimal_retention = retention.iat[repetitions.argmin()]\n",
        "    optimal_retention_list.append(optimal_retention)\n",
        "    plt.plot(retention, repetitions, label=f\"d={d}, r={optimal_retention}\")\n",
        "print(f\"\\n-----suggested retention: {np.inner(np.array(difficulty_distribution), np.array(optimal_retention_list)):.2f}-----\")\n",
        "plt.ylabel(\"expected repetitions\")\n",
        "plt.xlabel(\"retention\")\n",
        "plt.legend()\n",
        "plt.grid()\n",
        "plt.semilogy()\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyMnk8/Ih2JAJZJ1PBkXQUBC",
      "collapsed_sections": [],
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3.8.13 ('fsrs4anki')",
      "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.13"
    },
    "vscode": {
      "interpreter": {
        "hash": "8dd9a290ffd10997e0b0d411ff1325a47862ea932e0fd309ade800e0e51d2b4b"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}