alith-models 0.4.3

Load and Download LLM Models, Metadata, and Tokenizers
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

use super::ApiLLMModel;
use crate::{LLMModelBase, tokenizer::Tokenizer};
use std::sync::Arc;

impl ApiLLMModel {
    pub fn perplexity_model_from_model_id(model_id: &str) -> ApiLLMModel {
        if model_id.starts_with("llama-3.1-sonar-small") {
            Self::sonar_small()
        } else if model_id.starts_with("llama-3.1-sonar-large") {
            Self::sonar_large()
        } else if model_id.starts_with("llama-3.1-sonar-huge") {
            Self::sonar_huge()
        } else if model_id.contains("sonar-small") {
            Self::sonar_small()
        } else if model_id.contains("sonar-large") {
            Self::sonar_large()
        } else if model_id.contains("sonar-huge") {
            Self::sonar_huge()
        } else {
            panic!("Model ID ({model_id}) not found for ApiLLMModel")
        }
    }

    pub fn sonar_small() -> ApiLLMModel {
        let model_id = "llama-3.1-sonar-small-128k-online".to_string();
        let tokenizer = model_tokenizer(&model_id);
        ApiLLMModel {
            model_base: LLMModelBase {
                model_id,
                model_ctx_size: 127072,
                inference_ctx_size: 8192,
                tokenizer,
            },
            cost_per_m_in_tokens: 0.1,
            cost_per_m_out_tokens: 0.1,
            tokens_per_message: 3,
            tokens_per_name: None,
        }
    }

    pub fn sonar_large() -> ApiLLMModel {
        let model_id = "llama-3.1-sonar-large-128k-online".to_string();
        let tokenizer = model_tokenizer(&model_id);
        ApiLLMModel {
            model_base: LLMModelBase {
                model_id,
                model_ctx_size: 127072,
                inference_ctx_size: 8192,
                tokenizer,
            },
            cost_per_m_in_tokens: 0.5,
            cost_per_m_out_tokens: 0.5,
            tokens_per_message: 3,
            tokens_per_name: None,
        }
    }

    pub fn sonar_huge() -> ApiLLMModel {
        let model_id = "llama-3.1-sonar-huge-128k-online".to_string();
        let tokenizer = model_tokenizer(&model_id);
        ApiLLMModel {
            model_base: LLMModelBase {
                model_id,
                model_ctx_size: 127072,
                inference_ctx_size: 8192,
                tokenizer,
            },
            cost_per_m_in_tokens: 2.5,
            cost_per_m_out_tokens: 2.5,
            tokens_per_message: 3,
            tokens_per_name: None,
        }
    }
}

pub fn model_tokenizer(_model_id: &str) -> Arc<Tokenizer> {
    Arc::new(
        Tokenizer::new_tiktoken("gpt-4")
            .unwrap_or_else(|_| panic!("Failed to load tokenizer for gpt-4")),
    )
}

pub trait PerplexityModelTrait: Sized {
    fn model(&mut self) -> &mut ApiLLMModel;

    /// Set the model using the model_id string.
    fn model_id_str(mut self, model_id: &str) -> Self
    where
        Self: Sized,
    {
        *self.model() = ApiLLMModel::perplexity_model_from_model_id(model_id);
        self
    }

    fn sonar_small(mut self) -> Self
    where
        Self: Sized,
    {
        *self.model() = ApiLLMModel::sonar_small();
        self
    }

    fn sonar_large(mut self) -> Self
    where
        Self: Sized,
    {
        *self.model() = ApiLLMModel::sonar_large();
        self
    }

    fn sonar_huge(mut self) -> Self
    where
        Self: Sized,
    {
        *self.model() = ApiLLMModel::sonar_huge();
        self
    }
}