Refactor/extract standalone functions from structure (#367)

* Refactor/extract standalone functions from structure

* Change visibility of several functions in dataset, parameter initialization, and training modules to `pub(crate)` for better encapsulation.

* Rename test functions for consistency across modules, prefixing with 'test_' to enhance clarity and maintainability.

* bump version

* Remove unused import of `izip` in `measure_a_by_b` function to clean up code.

* make optimal_retention standalone

* make evaluate_with_time_series_splits and compute_parameters standalone

* [autofix.ci] apply automated fixes

* Refactor FSRS initialization to remove unnecessary `Some` wrapper around parameters in multiple files, enhancing code clarity and consistency.

* Refactor FSRS initialization across multiple files to use `FSRS::default()` instead of `FSRS::new(&[])`, improving code consistency and readability.

* make benchmark standalone & remove redundant documents

* Refactor FSRS initialization in benchmarks and tests to use `FSRS::default()`, ensuring consistency and improving code readability.

* [autofix.ci] apply automated fixes

* Refactor tests to use a static `DEVICE` for `NdArrayDevice::Cpu`, improving consistency and reducing redundancy in multiple test files.

* [autofix.ci] apply automated fixes

* Refactor FSRS and Model implementations to utilize device-specific tensor creation, enhancing device management and consistency across the codebase.

* Update src/inference.rs

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* Refactor FSRSBatcher initialization to remove device parameter, enhancing code consistency across multiple files.

* Refactor BatchTensorDataset and MemoryStateTensors to eliminate device parameter, improving code consistency and simplifying tensor creation across multiple files.

* Update src/model.rs

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* Refactor device parameter handling in FSRS initialization across multiple files for improved consistency and clarity.

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: 3 people

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fsrs"
-version = "5.2.0"
+version = "6.0.0"
 authors = ["Open Spaced Repetition"]
 categories = ["algorithms", "science"]
 edition = "2024"

Cargo.toml

@@ -20,7 +20,7 @@ Read [this](https://github.com/open-spaced-repetition/fsrs4anki/wiki/The-Optimal
 // Pick whichever percentage is to your liking (see above)
 let optimal_retention = 0.75;
 // Use default parameters/weights for the scheduler
-let fsrs = FSRS::new(Some(&[]))?;
+let fsrs = FSRS::default();
 
 // Create a completely new card
 let day1_states = fsrs.next_states(None, optimal_retention, 0)?;

README.md

@@ -60,7 +60,7 @@ pub(crate) fn next_states(inf: &FSRS) -> NextStates {
 }
 
 pub fn criterion_benchmark(c: &mut Criterion) {
-    let fsrs = FSRS::new(Some(&[
+    let fsrs = FSRS::new(&[
         0.81497127,
         1.5411042,
         4.007436,
@@ -78,7 +78,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         1.3384504,
         0.22278537,
         2.6646678,
-    ]))
+    ])
     .unwrap();
 
     c.bench_function("next_states", |b| b.iter(|| black_box(next_states(&fsrs))));

benches/benchmark.rs

@@ -1,12 +1,7 @@
 use criterion::{Criterion, criterion_group, criterion_main};
 use fsrs::{
-    // dataset::prepare_training_data, // Will be inlined
-    // convertor_tests::anki21_sample_file_converted_to_fsrs, // Will be inlined
-    ComputeParametersInput,
-    DEFAULT_PARAMETERS,
-    FSRS,
-    FSRSItem,
-    FSRSReview,
+    ComputeParametersInput, FSRS, FSRSItem, FSRSReview, compute_parameters,
+    evaluate_with_time_series_splits,
 };
 // Add necessary imports for inlined code
 use chrono::prelude::*;
@@ -212,7 +207,7 @@ fn load_and_prepare_data() -> Vec<FSRSItem> {
 fn benchmark_evaluate(c: &mut Criterion) {
     let items = load_and_prepare_data();
     // Evaluate uses the FSRS instance's existing parameters.
-    let fsrs = FSRS::new(Some(&DEFAULT_PARAMETERS)).unwrap();
+    let fsrs = FSRS::default();
 
     let mut group = c.benchmark_group("parameters");
     group.sample_size(10); // Reduce sample size if benchmarks are too long
@@ -229,7 +224,6 @@ fn benchmark_evaluate(c: &mut Criterion) {
 fn benchmark_evaluate_with_time_series_splits(c: &mut Criterion) {
     let items = load_and_prepare_data();
     // evaluate_with_time_series_splits computes parameters internally for each split.
-    let fsrs = FSRS::new(None).unwrap();
     let input = ComputeParametersInput {
         train_set: items.clone(),
         progress: None,
@@ -242,17 +236,14 @@ fn benchmark_evaluate_with_time_series_splits(c: &mut Criterion) {
 
     group.bench_function("evaluate_with_time_series_splits", |b| {
         b.iter(|| {
-            fsrs.evaluate_with_time_series_splits(black_box(input.clone()), |_| true)
-                .unwrap();
+            evaluate_with_time_series_splits(black_box(input.clone()), |_| true).unwrap();
         })
     });
     group.finish();
 }
 
 fn benchmark_compute_parameters(c: &mut Criterion) {
     let items = load_and_prepare_data();
-    // compute_parameters computes new parameters, so initial FSRS parameters don't matter.
-    let fsrs = FSRS::new(None).unwrap();
     let input = ComputeParametersInput {
         train_set: items.clone(), // Using the full prepared dataset
         progress: None,
@@ -265,7 +256,7 @@ fn benchmark_compute_parameters(c: &mut Criterion) {
 
     group.bench_function("compute_parameters", |b| {
         b.iter(|| {
-            fsrs.compute_parameters(black_box(input.clone())).unwrap();
+            compute_parameters(black_box(input.clone())).unwrap();
         })
     });
 

benches/parameters.rs

@@ -1,6 +1,6 @@
 use criterion::{Criterion, criterion_group, criterion_main};
 use fsrs::{Card, expected_workload, expected_workload_with_existing_cards};
-use fsrs::{DEFAULT_PARAMETERS, SimulationResult, SimulatorConfig, simulate};
+use fsrs::{DEFAULT_PARAMETERS, SimulationResult, SimulatorConfig, optimal_retention, simulate};
 use fsrs::{FSRS, FSRSError};
 use rayon::iter::IntoParallelIterator;
 use rayon::iter::ParallelIterator;
@@ -28,9 +28,8 @@ pub(crate) fn parallel_simulate(config: &SimulatorConfig) -> Result<Vec<f32>, FS
         .collect()
 }
 
-pub(crate) fn optimal_retention(inf: &FSRS, config: &SimulatorConfig) -> f32 {
-    inf.optimal_retention(config, &[], |_v| true, None, None)
-        .unwrap()
+pub(crate) fn bench_optimal_retention(_inf: &FSRS, config: &SimulatorConfig) -> f32 {
+    optimal_retention(config, &[], |_v| true, None, None).unwrap()
 }
 
 pub(crate) fn run_expected_workload_for_30_retentions() {
@@ -66,7 +65,7 @@ pub(crate) fn run_expected_workload_with_10000_existing_cards() {
 }
 
 pub fn criterion_benchmark(c: &mut Criterion) {
-    let fsrs = FSRS::new(Some(&DEFAULT_PARAMETERS)).unwrap();
+    let fsrs = FSRS::default();
     let config = SimulatorConfig {
         deck_size: 36500,
         learn_span: 90,
@@ -79,7 +78,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         b.iter(|| black_box(parallel_simulate(&config)))
     });
     c.bench_function("optimal_retention", |b| {
-        b.iter(|| black_box(optimal_retention(&fsrs, &config)))
+        b.iter(|| black_box(bench_optimal_retention(&fsrs, &config)))
     });
     c.bench_function("expected_workload_30_retentions", |b| {
         b.iter(run_expected_workload_for_30_retentions)

benches/simulation.rs

@@ -2,7 +2,7 @@ use fsrs::{FSRS, FSRSItem, FSRSReview};
 
 fn migrate_with_full_history() -> Result<(), Box<dyn std::error::Error>> {
     // Create a new FSRS model
-    let fsrs = FSRS::new(Some(&[]))?;
+    let fsrs = FSRS::default();
 
     // Simulate a full review history for a card
     let reviews = vec![
@@ -35,7 +35,7 @@ fn migrate_with_full_history() -> Result<(), Box<dyn std::error::Error>> {
 
 fn migrate_with_partial_history() -> Result<(), Box<dyn std::error::Error>> {
     // Create a new FSRS model
-    let fsrs = FSRS::new(Some(&[]))?;
+    let fsrs = FSRS::default();
 
     // Set the true retention of the original algorithm
     let sm2_retention = 0.9;
@@ -76,7 +76,7 @@ fn migrate_with_partial_history() -> Result<(), Box<dyn std::error::Error>> {
 
 fn migrate_with_latest_state() -> Result<(), Box<dyn std::error::Error>> {
     // Create a new FSRS model
-    let fsrs = FSRS::new(Some(&[]))?;
+    let fsrs = FSRS::default();
 
     // Set the true retention of the original algorithm
     let sm2_retention = 0.9;

examples/migrate.rs

@@ -1,5 +1,5 @@
 use chrono::NaiveDate;
-use fsrs::{ComputeParametersInput, DEFAULT_PARAMETERS, FSRS, FSRSItem, FSRSReview};
+use fsrs::{ComputeParametersInput, FSRSItem, FSRSReview, compute_parameters};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Create review histories for cards
@@ -13,12 +13,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     println!("Size of FSRSItems: {}", fsrs_items.len());
 
-    // Create an FSRS instance with default parameters
-    let fsrs = FSRS::new(Some(&[]))?;
-    println!("Default parameters: {:?}", DEFAULT_PARAMETERS);
-
     // Optimize the FSRS model using the created items
-    let optimized_parameters = fsrs.compute_parameters(ComputeParametersInput {
+    let optimized_parameters = compute_parameters(ComputeParametersInput {
         train_set: fsrs_items,
         ..Default::default()
     })?;

examples/optimize.rs

@@ -27,7 +27,7 @@ fn schedule_new_card() -> Result<(), Box<dyn std::error::Error>> {
     let desired_retention = 0.9;
 
     // Create a new FSRS model
-    let fsrs = FSRS::new(Some(&[]))?;
+    let fsrs = FSRS::default();
 
     // Get next states for a new card
     let next_states = fsrs.next_states(card.memory_state, desired_retention, 0)?;
@@ -81,7 +81,7 @@ fn schedule_existing_card() -> Result<(), Box<dyn std::error::Error>> {
     let desired_retention = 0.9;
 
     // Create a new FSRS model
-    let fsrs = FSRS::new(Some(&[]))?;
+    let fsrs = FSRS::default();
 
     // Calculate the elapsed time since the last review
     let elapsed_days = (Utc::now() - card.last_review.unwrap()).num_days() as u32;

examples/schedule.rs

@@ -16,8 +16,9 @@ pub(crate) struct BatchTensorDataset<B: Backend> {
 
 impl<B: Backend> BatchTensorDataset<B> {
     /// Creates a new shuffled dataset.
-    pub fn new(dataset: FSRSDataset, batch_size: usize, device: B::Device) -> Self {
-        let batcher = FSRSBatcher::<B>::new(device.clone());
+    pub fn new(dataset: FSRSDataset, batch_size: usize) -> Self {
+        let device = B::Device::default();
+        let batcher = FSRSBatcher::<B>::new();
         let dataset = dataset
             .items
             .chunks(batch_size)
@@ -102,10 +103,7 @@ impl<B: Backend> ShuffleDataLoader<B> {
 
 #[cfg(test)]
 mod tests {
-    use burn::{
-        backend::{NdArray, ndarray::NdArrayDevice},
-        tensor::Shape,
-    };
+    use burn::{backend::NdArray, tensor::Shape};
     use itertools::Itertools;
 
     use super::*;
@@ -124,10 +122,9 @@ mod tests {
         let dataset = FSRSDataset::from(constant_weighted_fsrs_items(train_set));
         let batch_size = 512;
         let seed = 114514;
-        let device = NdArrayDevice::Cpu;
         type Backend = NdArray<f32>;
 
-        let dataset = BatchTensorDataset::<Backend>::new(dataset, batch_size, device);
+        let dataset = BatchTensorDataset::<Backend>::new(dataset, batch_size);
         let dataloader = ShuffleDataLoader::new(dataset, seed);
         let mut iterator = dataloader.iter();
         // dbg!(&iterator.indices);