use core::fmt::Debug;
use super::Candidate;
pub trait SequenceRanker: Send + Sync + Debug {
fn rank(
&self,
candidates: &[Candidate],
) -> usize;
}
#[derive(Debug, Clone, Copy, Default, PartialEq)]
pub struct MaximumLikelihoodRanker {
pub length_penalty: Option<f64>,
}
impl MaximumLikelihoodRanker {
pub fn penalty(
&self,
length: usize,
) -> f64 {
match self.length_penalty {
None => length as f64,
Some(alpha) => ((5.0 + length as f64) / 6.0).powf(alpha),
}
}
}
impl SequenceRanker for MaximumLikelihoodRanker {
fn rank(
&self,
candidates: &[Candidate],
) -> usize {
assert!(!candidates.is_empty(), "nothing to rank");
let mut best = 0;
let mut best_score = f64::NEG_INFINITY;
for (i, candidate) in candidates.iter().enumerate() {
let score = f64::from(candidate.sum_logprob) / self.penalty(candidate.tokens.len());
if score > best_score {
best = i;
best_score = score;
}
}
best
}
}
#[cfg(test)]
mod tests {
use super::*;
fn c(
tokens: Vec<i64>,
sum_logprob: f32,
) -> Candidate {
Candidate {
tokens,
sum_logprob,
stop: None,
}
}
#[test]
fn test_plain_normalization_prefers_probability_per_token() {
let ranker = MaximumLikelihoodRanker::default();
let candidates = vec![c(vec![1, 2, 3], -3.0), c(vec![1, 2], -2.5)];
assert_eq!(ranker.rank(&candidates), 0);
assert_eq!(ranker.penalty(3), 3.0);
}
#[test]
fn test_nmt_penalty() {
let ranker = MaximumLikelihoodRanker {
length_penalty: Some(1.0),
};
assert!((ranker.penalty(1) - 1.0).abs() < 1e-12);
assert!((ranker.penalty(7) - 2.0).abs() < 1e-12);
let candidates = vec![c(vec![1, 2, 3], -3.0), c(vec![1, 2], -2.5)];
assert_eq!(ranker.rank(&candidates), 1);
}
#[test]
fn test_first_of_equals() {
let ranker = MaximumLikelihoodRanker::default();
let candidates = vec![c(vec![1], -1.0), c(vec![2], -1.0), c(vec![3], -1.0)];
assert_eq!(ranker.rank(&candidates), 0);
}
#[test]
fn test_empty_candidate() {
let ranker = MaximumLikelihoodRanker::default();
let candidates = vec![c(vec![], -0.0), c(vec![5], -1.0)];
assert_eq!(ranker.rank(&candidates), 1);
}
}