discorec 0.1.1

Recommendations for Rust using collaborative filtering
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Recommendations for Rust using collaborative filtering
//!
//! [View the docs](https://github.com/ankane/disco-rust)

mod dataset;
mod map;
mod recommender;

pub use dataset::Dataset;
pub use recommender::{FitInfo, Recommender, RecommenderBuilder};

#[cfg(test)]
mod tests {
    use crate::{Dataset, Recommender, RecommenderBuilder};

    #[test]
    fn test_rated() {
        let mut data = Dataset::new();
        data.push(1, "A", 1.0);
        data.push(1, "B", 1.0);
        data.push(1, "C", 1.0);
        data.push(1, "D", 1.0);
        data.push(2, "C", 1.0);
        data.push(2, "D", 1.0);
        data.push(2, "E", 1.0);
        data.push(2, "F", 1.0);

        let recommender = Recommender::fit_implicit(&data);

        let mut item_ids = recommender.user_recs(&1, 5).iter().map(|v| v.0).collect::<Vec<&&str>>();
        item_ids.sort();
        assert_eq!(item_ids, vec![&"E", &"F"]);

        let mut item_ids = recommender.user_recs(&2, 5).iter().map(|v| v.0).collect::<Vec<&&str>>();
        item_ids.sort();
        assert_eq!(item_ids, vec![&"A", &"B"]);
    }

    #[test]
    fn test_item_recs_same_score() {
        let mut data = Dataset::new();
        data.push(1, "A", 1.0);
        data.push(1, "B", 1.0);
        data.push(2, "C", 1.0);

        let recommender = Recommender::fit_implicit(&data);
        let item_ids = recommender.item_recs(&"A", 5).iter().map(|v| v.0).collect::<Vec<&&str>>();
        assert_eq!(item_ids, vec![&"B", &"C"]);
    }

    #[test]
    fn test_ids() {
        let mut data = Dataset::new();
        data.push(1, "A", 1.0);
        data.push(1, "B", 1.0);
        data.push(2, "B", 1.0);

        let recommender = Recommender::fit_implicit(&data);
        assert_eq!(recommender.user_ids(), &vec![1, 2]);
        assert_eq!(recommender.item_ids(), &vec!["A", "B"]);
    }

    #[test]
    fn test_factors() {
        let mut data = Dataset::new();
        data.push(1, "A", 1.0);
        data.push(1, "B", 1.0);
        data.push(2, "B", 1.0);

        let recommender = RecommenderBuilder::new().factors(20).fit_implicit(&data);

        assert_eq!(recommender.user_factors(&1).unwrap().len(), 20);
        assert_eq!(recommender.item_factors(&"A").unwrap().len(), 20);

        assert_eq!(recommender.user_factors(&3), None);
        assert_eq!(recommender.item_factors(&"C"), None);
    }

    #[test]
    fn test_callback_explicit() {
        let mut data = Dataset::new();
        data.push(1, "A", 1.0);

        RecommenderBuilder::new()
            .callback(|info| {
                assert!((1..=20).contains(&info.iteration));
                assert!(!info.train_loss.is_nan());
                assert!(info.valid_loss.is_nan());
            })
            .fit_explicit(&data);
    }

    #[test]
    fn test_callback_implicit() {
        let mut data = Dataset::new();
        data.push(1, "A", 1.0);

        RecommenderBuilder::new()
            .callback(|info| {
                assert!((1..=20).contains(&info.iteration));
                assert!(info.train_loss.is_nan());
                assert!(info.valid_loss.is_nan());
            })
            .fit_implicit(&data);
    }

    #[test]
    fn test_callback_explicit_eval() {
        let mut data = Dataset::new();
        data.push(1, "A", 1.0);

        RecommenderBuilder::new()
            .callback(|info| {
                assert!((1..=20).contains(&info.iteration));
                assert!(!info.train_loss.is_nan());
                assert!(!info.valid_loss.is_nan());
            })
            .fit_eval_explicit(&data, &data);
    }
}