Add application file

.gitignore

@@ -0,0 +1,4 @@
+.idea/
+__pycache__
+projects
+.DS_Store

app.py

@@ -0,0 +1,187 @@
+import gradio as gr
+from gradio.components import Textbox, Slider, Plot
+import numpy as np
+import matplotlib.pyplot as plt
+from tqdm.auto import tqdm
+
+plt.style.use('seaborn-v0_8-whitegrid')
+
+columns = ["difficulty", "stability", "retrievability", "delta_t",
+           "reps", "lapses", "last_date", "due", "ivl", "cost", "rand"]
+col = {key: i for i, key in enumerate(columns)}
+
+
+def simulate(w, request_retention=0.9, deck_size=10000, learn_span=100, max_cost_perday=200, max_ivl=36500, recall_cost=10, forget_cost=30, learn_cost=10):
+    card_table = np.zeros((len(columns), deck_size))
+    card_table[col["due"]] = learn_span
+    card_table[col["difficulty"]] = 1e-10
+    card_table[col["stability"]] = 1e-10
+
+    review_cnt_per_day = np.zeros(learn_span)
+    learn_cnt_per_day = np.zeros(learn_span)
+    memorized_cnt_per_day = np.zeros(learn_span)
+
+    def cal_next_recall_stability(s, r, d, response):
+        if response == 1:
+            return s * (1 + np.exp(w[8]) * (11 - d) * np.power(s, -w[9]) * (np.exp((1 - r) * w[10]) - 1))
+        else:
+            return np.minimum(w[11] * np.power(d, -w[12]) * (np.power(s + 1, w[13]) - 1) * np.exp((1 - r) * w[14]), s)
+
+    for today in tqdm(range(learn_span)):
+        has_learned = card_table[col["stability"]] > 1e-10
+        card_table[col["delta_t"]][has_learned] = today - \
+            card_table[col["last_date"]][has_learned]
+        card_table[col["retrievability"]][has_learned] = np.power(
+            1 + card_table[col["delta_t"]][has_learned] / (9 * card_table[col["stability"]][has_learned]), -1)
+
+        card_table[col["cost"]] = 0
+        need_review = card_table[col["due"]] <= today
+        card_table[col["rand"]][need_review] = np.random.rand(
+            np.sum(need_review))
+        forget = card_table[col["rand"]] > card_table[col["retrievability"]]
+        card_table[col["cost"]][need_review & forget] = forget_cost
+        card_table[col["cost"]][need_review & ~forget] = recall_cost
+        true_review = need_review & (
+            np.cumsum(card_table[col["cost"]]) <= max_cost_perday)
+        card_table[col["last_date"]][true_review] = today
+
+        card_table[col["lapses"]][true_review & forget] += 1
+        card_table[col["reps"]][true_review & ~forget] += 1
+
+        card_table[col["stability"]][true_review & forget] = cal_next_recall_stability(
+            card_table[col["stability"]][true_review & forget], card_table[col["retrievability"]][true_review & forget], card_table[col["difficulty"]][true_review & forget], 0)
+
+        card_table[col["stability"]][true_review & ~forget] = cal_next_recall_stability(
+            card_table[col["stability"]][true_review & ~forget], card_table[col["retrievability"]][true_review & ~forget], card_table[col["difficulty"]][true_review & ~forget], 1)
+
+        card_table[col["difficulty"]][true_review & forget] = np.clip(
+            card_table[col["difficulty"]][true_review & forget] + 2 * w[6], 1, 10)
+
+        need_learn = card_table[col["due"]] == learn_span
+        card_table[col["cost"]][need_learn] = learn_cost
+        true_learn = need_learn & (
+            np.cumsum(card_table[col["cost"]]) <= max_cost_perday)
+        card_table[col["last_date"]][true_learn] = today
+        first_ratings = np.random.randint(0, 4, np.sum(true_learn))
+        card_table[col["stability"]][true_learn] = np.choose(
+            first_ratings, w[:4])
+        card_table[col["difficulty"]][true_learn] = w[4] - \
+            w[5] * (first_ratings - 3)
+
+        card_table[col["ivl"]][true_review | true_learn] = np.clip(np.round(
+            9 * card_table[col["stability"]][true_review | true_learn] * (1 / request_retention - 1), 0), 1, max_ivl)
+        card_table[col["due"]][true_review | true_learn] = today + \
+            card_table[col["ivl"]][true_review | true_learn]
+
+        review_cnt_per_day[today] = np.sum(true_review)
+        learn_cnt_per_day[today] = np.sum(true_learn)
+        memorized_cnt_per_day[today] = card_table[col["retrievability"]].sum()
+    return card_table, review_cnt_per_day, learn_cnt_per_day, memorized_cnt_per_day
+
+
+def interface_func(weights: str, learning_time: int, learn_span: int, deck_size: int, max_ivl: int, recall_cost: int, forget_cost: int, learn_cost: int,
+                   progress=gr.Progress(track_tqdm=True)):
+    np.random.seed(42)
+    w = list(map(lambda x: float(x.strip()), weights.split(',')))
+    max_cost_perday = learning_time * 60
+
+    def moving_average(data, window_size=learn_span//20):
+        weights = np.ones(window_size) / window_size
+        return np.convolve(data, weights, mode='valid')
+
+    for request_retention in [0.95, 0.9, 0.85, 0.8, 0.75]:
+        (_,
+         review_cnt_per_day,
+         learn_cnt_per_day,
+         memorized_cnt_per_day) = simulate(w,
+                                           request_retention=request_retention,
+                                           deck_size=deck_size,
+                                           learn_span=learn_span,
+                                           max_cost_perday=max_cost_perday,
+                                           max_ivl=max_ivl,
+                                           recall_cost=recall_cost,
+                                           forget_cost=forget_cost,
+                                           learn_cost=learn_cost)
+
+        plt.figure(1)
+        plt.plot(moving_average(review_cnt_per_day),
+                 label=f"R={request_retention*100:.0f}%")
+        plt.title("Review Count per Day")
+        plt.legend()
+        plt.figure(2)
+        plt.plot(moving_average(learn_cnt_per_day),
+                 label=f"R={request_retention*100:.0f}%")
+        plt.title("Learn Count per Day")
+        plt.legend()
+        plt.figure(3)
+        plt.plot(np.cumsum(learn_cnt_per_day),
+                 label=f"R={request_retention*100:.0f}%")
+        plt.title("Cumulative Learn Count")
+        plt.legend()
+        plt.figure(4)
+        plt.plot(memorized_cnt_per_day,
+                 label=f"R={request_retention*100:.0f}%")
+        plt.title("Memorized Count per Day")
+        plt.legend()
+
+    return plt.figure(1), plt.figure(2), plt.figure(3), plt.figure(4)
+
+description = f"""
+# FSRS4Anki Simulator
+
+Here is a simulator for FSRS4Anki. It can simulate the learning process of a deck with given weights and parameters. 
+
+It will help you to find the expected requestRetention for FSRS4Anki.
+
+The simulator assumes that you spend the same amount of time on Anki every day.
+"""
+
+with gr.Blocks() as demo:
+    with gr.Box():
+        gr.Markdown(description)
+    with gr.Box():
+        with gr.Row():
+            with gr.Column():
+                weights = Textbox(label="Weights", lines=1,
+                                  value="0.4, 0.6, 2.4, 5.8, 4.93, 0.94, 0.86, 0.01, 1.49, 0.14, 0.94, 2.18, 0.05, 0.34, 1.26, 0.29, 2.61")
+                learning_time = Slider(label="Learning Time perday (minutes)",
+                                       minimum=5, maximum=1440, step=5, value=30)
+                learn_span = Slider(label="Learning Period (days)", minimum=30,
+                                    maximum=3650, step=10, value=365)
+                deck_size = Slider(label="Deck Size (cards)", minimum=100,
+                                   maximum=100000, step=100, value=10000)
+            with gr.Column():
+                max_ivl = Slider(label="Maximum Interval (days)", minimum=30,
+                                 maximum=36500, step=10, value=36500)
+                recall_cost = Slider(label="Review Cost (seconds)", minimum=1,
+                                     maximum=600, step=1, value=10)
+                forget_cost = Slider(label="Relearn Cost (seconds)",
+                                     minimum=1, maximum=600, step=1, value=30)
+                learn_cost = Slider(label="Learn Cost (seconds)", minimum=1,
+                                    maximum=600, step=1, value=10)
+        with gr.Row():
+            btn_plot = gr.Button("Simulate")
+        with gr.Row():
+            with gr.Column():
+                review_count = Plot(label="Review Count per Day")
+                learn_count = Plot(label="Learn Count per Day")
+            with gr.Column():
+                cumulative_learn_count = Plot(label="Cumulative Learn Count")
+                memorized_count = Plot(label="Memorized Count per Day")
+
+    btn_plot.click(
+        fn=interface_func,
+        inputs=[weights,
+                learning_time,
+                learn_span,
+                deck_size,
+                max_ivl,
+                recall_cost,
+                forget_cost,
+                learn_cost,
+                ],
+        outputs=[review_count, learn_count,
+                cumulative_learn_count, memorized_count],
+    )
+
+demo.queue().launch(show_error=True)

requirements.txt

@@ -0,0 +1,3 @@
+matplotlib>=3.7.0
+numpy>=1.22.4
+tqdm>=4.64.1