adarank 0.1.0

AdaRank: a boosting algorithm for information retrieval
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

use crate::datapoint::DataPoint;
use crate::error::LtrError;
use crate::ranklist::RankList;
use crate::DataSet;

use super::LtrFormat;

/// The default implementation of SVMLight parsing
/// is based on the SVM-light format.
///
/// The format is as follows:
/// <label> qid:<qid> <index1>:<value1> <index2>:<value2> ... # <info>
pub struct SVMLight;

impl SVMLight {
    /// Load a single `DataPoint` from a line of the SVMLight format.
    ///
    /// The format is as follows:
    /// <label> qid:<qid> <index1>:<value1> <index2>:<value2> ... # <info>
    ///
    /// # Arguments
    /// * `buffer` - The buffer containing the SVMLight formatted data point.
    ///
    /// # Returns
    /// A `DataPoint` with the data loaded from the buffer.
    ///
    /// # Errors
    /// If the buffer is not in the correct format, an error is returned.
    pub fn load_datapoint(buffer: &str) -> Result<DataPoint, LtrError> {
        // Convert the buffer into a string
        let mut data_point = DataPoint::empty();

        // Find # to extract the  optional description.
        let mut buffer_iter = buffer.split('#');
        let buffer_str = buffer_iter.next().ok_or(LtrError::ParseError(
            "Error in SVMLight::load_datapoint: Description processing failure.",
        ))?;
        if let Some(info) = buffer_iter.next() {
            data_point.set_description(info.trim());
        }

        let mut iter = buffer_str.trim().split(' '); // Split on spaces

        // Get the label
        let label = iter
            .next()
            .ok_or(LtrError::InvalidDataPoint("Missing the label parameter."))?;
        data_point.set_label(
            label
                .parse::<u8>()
                .map_err(|_| LtrError::InvalidDataPoint("Invalid label parameter."))?,
        );

        // Get the qid:<qid>
        let qid = iter
            .next()
            .ok_or(LtrError::InvalidDataPoint("Missing the qid parameter."))?;

        let mut qid_iter = qid.split(':');
        qid_iter.next().ok_or(LtrError::ParseError(
            "Error in SVMLight::load_datapoint: Query ID processing failure.",
        ))?; // Skip the qid:
        let qid_str = qid_iter.next().ok_or(LtrError::ParseError(
            "Error in SVMLight::load_datapoint: Query ID processing failure",
        ))?;
        let qid = qid_str
            .parse::<u32>()
            .map_err(|_| LtrError::InvalidDataPoint("Invalid qid parameter."))?;

        data_point.set_query_id(qid);

        // Get the features
        let mut feature_values = Vec::new();
        for feature in iter {
            let mut feature_iter = feature.split(':');

            let index = feature_iter
                .next()
                .ok_or(LtrError::InvalidDataPoint("Missing feature index."))?
                .parse::<usize>()
                .map_err(|_| LtrError::InvalidDataPoint("Invalid feature index."))?;

            let value = feature_iter
                .next()
                .ok_or(LtrError::InvalidDataPoint("Missing feature value."))?
                .parse::<f32>()
                .map_err(|_| LtrError::InvalidDataPoint("Invalid feature value."))?;

            if index > feature_values.len() {
                feature_values.resize(index as usize, 0.0);
            }

            feature_values[index - 1] = value;
        }

        data_point.set_features(feature_values)?;

        Ok(data_point)
    }

    /// Load a RankList from a SVM-Light buffer.
    /// Notice that this method DOES NOT check whether the RankList has
    /// different query ids. If you're not sure, use the `load_dataset` method.
    ///
    /// The format is as follows:
    /// <datapoint1>\n
    /// <datapoint2>\n
    /// ...
    /// <datapointN>\n
    ///
    /// # Arguments
    /// * `buffer` - The buffer containing the SVMLight formatted rank list.
    ///
    /// # Returns
    /// A `RankList` with the data loaded from the buffer.
    ///
    /// # Errors
    /// If the buffer is not in the correct format, an error is returned.
    pub fn load_ranklist(buffer: &str) -> Result<RankList, LtrError> {
        let mut data_points = Vec::new();
        let mut buffer_iter = buffer.split('\n');
        while let Some(line) = buffer_iter.next() {
            if line.is_empty() {
                continue;
            }

            let data_point = SVMLight::load_datapoint(line)?;
            data_points.push(data_point);
        }

        Ok(RankList::new(data_points))
    }

    /// Load a DataSet from a SVM-Light buffer.
    ///
    /// # Arguments
    /// * `buffer` - The buffer containing the SVMLight formatted dataset.
    ///
    /// # Returns
    /// A `DataSet` with the data loaded from the buffer.
    pub fn load_dataset(buffer: &str) -> Result<DataSet, LtrError> {
        let mut buffer_iter = buffer.split('\n');
        let mut dataset: DataSet = DataSet::new();

        let mut current_query_id = 0;
        let mut current_rank_list = Vec::new();

        while let Some(line) = buffer_iter.next() {
            if line.is_empty() {
                continue;
            }
            let dp = SVMLight::load_datapoint(line)?;
            if dp.get_query_id() == current_query_id || current_query_id == 0 {
                current_query_id = dp.get_query_id();
                current_rank_list.push(dp);
            } else {
                // Different query id, so we need to add the current rank list to the dataset
                let ranklist = RankList::new(current_rank_list.clone());
                dataset.push(ranklist);
                current_rank_list.clear();

                current_query_id = dp.get_query_id();
                current_rank_list.push(dp);
            }
        }
        // Add the last rank list
        let ranklist = RankList::new(current_rank_list);
        dataset.push(ranklist);

        Ok(dataset)
    }
}

impl LtrFormat for SVMLight {
    fn load(path: &str) -> Result<DataSet, LtrError> {
        let buffer = match std::fs::read_to_string(path) {
            Ok(buffer) => buffer,
            Err(e) => return Err(LtrError::IOError(e.to_string())),
        };

        SVMLight::load_dataset(&buffer)
    }

    fn save(_path: &str, _dataset: &DataSet) -> Result<(), LtrError> {
        unimplemented!()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_svm_light_parser() {
        let buffer = "1 qid:10 1:21.00 2:2.30 3:4.50 # desc";
        let data_point = SVMLight::load_datapoint(buffer).unwrap();

        assert_eq!(data_point.get_label(), 1);
        assert_eq!(data_point.get_query_id(), 10);
        assert_eq!(data_point.get_description(), Some(&"desc".to_string()));
        assert_eq!(data_point.get_features().len(), 3);
        assert_eq!(*data_point.get_feature(1).unwrap(), 21.0f32);
        assert_eq!(*data_point.get_feature(2).unwrap(), 2.3f32);
        assert_eq!(*data_point.get_feature(3).unwrap(), 4.5f32);

        let buffer_without_description: &str = "20 qid:9 1:1.00 2:222.30 3:444.50";
        let data_point = SVMLight::load_datapoint(buffer_without_description).unwrap();
        assert_eq!(data_point.get_description(), None);
        assert_eq!(data_point.get_label(), 20);
        assert_eq!(data_point.get_query_id(), 9);
        assert_eq!(data_point.get_features().len(), 3);
        assert_eq!(*data_point.get_feature(1).unwrap(), 1.0f32);
        assert_eq!(*data_point.get_feature(2).unwrap(), 222.3f32);
        assert_eq!(*data_point.get_feature(3).unwrap(), 444.5f32)
    }
}