Modifying old revlog ease factor values into FSRS difficulty

jhhr · February 27, 2025, 11:34am

The old Auto Ease Factor addon had a function for rewriting the revlog ease factors as if they had been reviewed using the config enabled at that time. This was a dangerous operation that was only kind of undoable in that you could set your config back to what it was before and rewrite the revlog again.

The SM2 revlog rewrite code from Auto Ease Factor is like this:

github.com/jhhr/custom-schedule-helper

ease/auto_ease_factor.py

main


      
              card_settings["factor_list"] = [deck_starting_ease]
              for i in range(len(all_reps)):
                  rep_id = all_reps[i][0]
                  card_settings["review_list"] = (
                      get_reviews_only(card, rids=[r[0] for r in all_reps[0:i]])
                      if config.reviews_only
                      else [r[1] for r in all_reps[0:i]]
                  )
                  new_factor, _ = calculate_ease(config, deck_starting_ease, card_settings, leashed)
                  # This breaks undo history, so no undoing is possible when doing deck adjustment
                  mw.col.db.execute("update revlog set factor = ? where id = ?", new_factor, rep_id)
                  card_settings["factor_list"].append(new_factor)
          if config.reviews_only:
              card_settings["review_list"] = get_reviews_only(card)
          else:
              card_settings["review_list"] = get_all_reps(card)
          if new_answer is not None:
              append_answer = new_answer
              card_settings["review_list"].append(append_answer)
          factor_list = get_ease_factors(card)
          if factor_list is not None and len(factor_list) > 0 and prev_card_factor is not None:

Now that I’ve switched to using FSRS instead of my heavily customized SM2 scheduling, I’d like to make a similar function that would overwrite the factor values using the current FSRS settings as if those reviews had been done with my current FSRS settings.

Is this even possible? If so, what Anki backend functions will I need to use?

L.M.Sherlock · February 28, 2025, 10:44am

Here is the code employed in Anki Rust backend:

github.com/ankitects/anki

rslib/src/revlog/mod.rs

a6426bebe


      
          let ease_factor = u32::from(
              card.memory_state
                  .map(|s| ((s.difficulty_shifted() * 1000.) as u16))
                  .unwrap_or(card.ease_factor),
          );

github.com/ankitects/anki

rslib/src/card/mod.rs

a6426bebe


      
          impl FsrsMemoryState {
              /// Returns the difficulty normalized to a 0.0-1.0 range.
              pub(crate) fn difficulty(&self) -> f32 {
                  (self.difficulty - 1.0) / 9.0
              }
          
              /// Returns the difficulty normalized to a 0.1-1.1 range,
              /// which is used in revlog entries.
              pub(crate) fn difficulty_shifted(&self) -> f32 {
                  self.difficulty() + 0.1
              }
          }

vaibhav · February 28, 2025, 10:57am

Why do you want to overwrite the D values in the old revlogs? The values don’t affect scheduling. Scheduling depends on the value of memory states in the cards table. These values in the cards table are automatically updated whenever you update the parameters as if you did all the reviews with the latest parameters.

jhhr · February 28, 2025, 12:56pm

I know. The reason is curiosity and vanity:

I’m curious as to what difficulty values different FSRS configs would give to my historical reviews
And because I’ve made a cool little graph to show the revlog in my card templates. It bugs me that the graph contains mixed values.

tiny_revlog_graph

jhhr · February 28, 2025, 1:46pm

anki/rslib/src/revlog/mod.rs at a6426bebe21ea1fe85f5cf31a711134b06447788 · ankitects/anki · GitHub

I think this isn’t what I need. The rust backend part where it sets the card.memory_state and then passes that card to log_scheduled_review, is what I’m looking for, I think.

If I understand the gist of the FSRS algorithm correctly, I need to calculate S, R and D for a historical review and then calculate the next S, R, D using the previous ones as input, right? I imagine the code I need is something like this:

def get_next_memory_state(
  stability,
  difficulty,
  elapsed_days,
  answer,
  fsrs_params,
):
  retrievability = calc_retrievability(stability, difficulty, fsrs_params, elapsed_days)
  new_stability, new_difficulty = calc_memory_state(stability, difficulty, retrievability, answer)
  return new_stability, new_difficulty

def calc_first_memory_state(answer, fsrs_params):
  ...
  return stability, difficulty


...


fsrs_params = col.decks.get...
sd_list = [calc_first_memory_state(all_card_revs[0].ease, fsrs_params)]

for i in len(all_card_revs):
  last_rev = all_card_revs[i]
  rev = all_card_revs[i + 1]
  stability, difficulty = sd_list[i]
  elapsed_days = calc_elapsed_days(last_rev, rev)
  new_stability, new_difficulty = get_next_memory_state(
    stability,
    difficulty,
    rev.ease,
    fsrs_params,
  )
  sd_list.append((new_stability, new_difficulty))

Topic		Replies	Views
Understanding the revlog table Help	7	151	November 26, 2024
Edit card history in DB editor Help	2	341	January 7, 2024
What is the revlog ease value in FSRS Development	4	48	February 23, 2025
Does FSRS solve "ease hell"? Help	3	1149	January 11, 2024
[23.10 Desktop] Add a feature to automatically periodically re-optimize FSRS parameters Suggestions	85	1420	January 24, 2025

Modifying old revlog ease factor values into FSRS difficulty

Related topics