candle_transformers/models/
gemma.rs

1//! Gemma inference implementation.
2//!
3//! See ["Gemma: Open Models Based on Gemini Technology"](https://blog.google/technology/developers/gemma-open-ai-model/)
4//!
5//! Based on implementation from Google and PyTorch
6
7use std::sync::Arc;
8
9use candle::{DType, Device, Module, Result, Tensor, D};
10use candle_nn::{linear_b as linear, Activation, Linear, VarBuilder};
11
12fn default_max_position_embeddings() -> usize {
13    4096
14}
15
16#[derive(serde::Deserialize, Debug, Clone)]
17pub struct Config {
18    pub attention_bias: bool,
19    pub head_dim: usize,
20    // The code gemma configs include both hidden_act and hidden_activation.
21    pub hidden_act: Option<Activation>,
22    pub hidden_activation: Option<Activation>,
23    pub hidden_size: usize,
24    pub intermediate_size: usize,
25    pub num_attention_heads: usize,
26    pub num_hidden_layers: usize,
27    pub num_key_value_heads: usize,
28    pub rms_norm_eps: f64,
29    pub rope_theta: f64,
30    pub vocab_size: usize,
31
32    #[serde(default = "default_max_position_embeddings")]
33    pub max_position_embeddings: usize,
34}
35
36impl Config {
37    fn hidden_act(&self) -> Result<Activation> {
38        match (self.hidden_act, self.hidden_activation) {
39            (None, Some(act)) | (Some(act), None) => Ok(act),
40            (Some(_), Some(_)) => candle::bail!("both hidden_act and hidden_activation are set"),
41            (None, None) => candle::bail!("none of hidden_act and hidden_activation are set"),
42        }
43    }
44}
45
46#[derive(Debug, Clone)]
47struct RmsNorm {
48    weight: Tensor,
49    eps: f64,
50}
51
52impl RmsNorm {
53    fn new(dim: usize, eps: f64, vb: VarBuilder) -> Result<Self> {
54        let weight = vb.get(dim, "weight")?;
55        Ok(Self { weight, eps })
56    }
57}
58
59impl Module for RmsNorm {
60    fn forward(&self, x: &Tensor) -> Result<Tensor> {
61        let x_dtype = x.dtype();
62        let internal_dtype = match x_dtype {
63            DType::F16 | DType::BF16 => DType::F32,
64            d => d,
65        };
66        let hidden_size = x.dim(D::Minus1)?;
67        let x = x.to_dtype(internal_dtype)?;
68        let norm_x = (x.sqr()?.sum_keepdim(D::Minus1)? / hidden_size as f64)?;
69        let x_normed = x.broadcast_div(&(norm_x + self.eps)?.sqrt()?)?;
70        x_normed
71            .to_dtype(x_dtype)?
72            .broadcast_mul(&(&self.weight + 1.0)?)
73    }
74}
75
76#[derive(Debug, Clone)]
77struct RotaryEmbedding {
78    sin: Tensor,
79    cos: Tensor,
80}
81
82impl RotaryEmbedding {
83    fn new(dtype: DType, cfg: &Config, dev: &Device) -> Result<Self> {
84        let dim = cfg.head_dim;
85        let max_seq_len = cfg.max_position_embeddings;
86        let inv_freq: Vec<_> = (0..dim)
87            .step_by(2)
88            .map(|i| 1f32 / cfg.rope_theta.powf(i as f64 / dim as f64) as f32)
89            .collect();
90        let inv_freq_len = inv_freq.len();
91        let inv_freq = Tensor::from_vec(inv_freq, (1, inv_freq_len), dev)?.to_dtype(dtype)?;
92        let t = Tensor::arange(0u32, max_seq_len as u32, dev)?
93            .to_dtype(dtype)?
94            .reshape((max_seq_len, 1))?;
95        let freqs = t.matmul(&inv_freq)?;
96        Ok(Self {
97            sin: freqs.sin()?,
98            cos: freqs.cos()?,
99        })
100    }
101
102    fn apply_rotary_emb_qkv(
103        &self,
104        q: &Tensor,
105        k: &Tensor,
106        seqlen_offset: usize,
107    ) -> Result<(Tensor, Tensor)> {
108        let (_b_sz, _h, seq_len, _n_embd) = q.dims4()?;
109        let cos = self.cos.narrow(0, seqlen_offset, seq_len)?;
110        let sin = self.sin.narrow(0, seqlen_offset, seq_len)?;
111        let q_embed = candle_nn::rotary_emb::rope(&q.contiguous()?, &cos, &sin)?;
112        let k_embed = candle_nn::rotary_emb::rope(&k.contiguous()?, &cos, &sin)?;
113        Ok((q_embed, k_embed))
114    }
115}
116
117#[derive(Debug, Clone)]
118#[allow(clippy::upper_case_acronyms)]
119struct MLP {
120    gate_proj: Linear,
121    up_proj: Linear,
122    down_proj: Linear,
123    act_fn: candle_nn::Activation,
124}
125
126impl MLP {
127    fn new(cfg: &Config, vb: VarBuilder) -> Result<Self> {
128        let hidden_sz = cfg.hidden_size;
129        let intermediate_sz = cfg.intermediate_size;
130        let gate_proj = linear(hidden_sz, intermediate_sz, false, vb.pp("gate_proj"))?;
131        let up_proj = linear(hidden_sz, intermediate_sz, false, vb.pp("up_proj"))?;
132        let down_proj = linear(intermediate_sz, hidden_sz, false, vb.pp("down_proj"))?;
133        Ok(Self {
134            gate_proj,
135            up_proj,
136            down_proj,
137            act_fn: cfg.hidden_act()?,
138        })
139    }
140}
141
142impl Module for MLP {
143    fn forward(&self, xs: &Tensor) -> Result<Tensor> {
144        let lhs = xs.apply(&self.gate_proj)?.apply(&self.act_fn)?;
145        let rhs = xs.apply(&self.up_proj)?;
146        (lhs * rhs)?.apply(&self.down_proj)
147    }
148}
149
150#[derive(Debug, Clone)]
151struct Attention {
152    q_proj: Linear,
153    k_proj: Linear,
154    v_proj: Linear,
155    o_proj: Linear,
156    num_heads: usize,
157    num_kv_heads: usize,
158    num_kv_groups: usize,
159    head_dim: usize,
160    rotary_emb: Arc<RotaryEmbedding>,
161    kv_cache: Option<(Tensor, Tensor)>,
162    use_flash_attn: bool,
163}
164
165impl Attention {
166    fn new(
167        rotary_emb: Arc<RotaryEmbedding>,
168        use_flash_attn: bool,
169        cfg: &Config,
170        vb: VarBuilder,
171    ) -> Result<Self> {
172        let hidden_sz = cfg.hidden_size;
173        let num_heads = cfg.num_attention_heads;
174        let num_kv_heads = cfg.num_key_value_heads;
175        let num_kv_groups = num_heads / num_kv_heads;
176        let head_dim = cfg.head_dim;
177        let bias = cfg.attention_bias;
178        let q_proj = linear(hidden_sz, num_heads * head_dim, bias, vb.pp("q_proj"))?;
179        let k_proj = linear(hidden_sz, num_kv_heads * head_dim, bias, vb.pp("k_proj"))?;
180        let v_proj = linear(hidden_sz, num_kv_heads * head_dim, bias, vb.pp("v_proj"))?;
181        let o_proj = linear(num_heads * head_dim, hidden_sz, bias, vb.pp("o_proj"))?;
182        Ok(Self {
183            q_proj,
184            k_proj,
185            v_proj,
186            o_proj,
187            num_heads,
188            num_kv_heads,
189            num_kv_groups,
190            head_dim,
191            rotary_emb,
192            kv_cache: None,
193            use_flash_attn,
194        })
195    }
196
197    fn forward(
198        &mut self,
199        xs: &Tensor,
200        attention_mask: Option<&Tensor>,
201        seqlen_offset: usize,
202    ) -> Result<Tensor> {
203        let (b_sz, q_len, _) = xs.dims3()?;
204
205        let query_states = self.q_proj.forward(xs)?;
206        let key_states = self.k_proj.forward(xs)?;
207        let value_states = self.v_proj.forward(xs)?;
208
209        let query_states = query_states
210            .reshape((b_sz, q_len, self.num_heads, self.head_dim))?
211            .transpose(1, 2)?;
212        let key_states = key_states
213            .reshape((b_sz, q_len, self.num_kv_heads, self.head_dim))?
214            .transpose(1, 2)?;
215        let value_states = value_states
216            .reshape((b_sz, q_len, self.num_kv_heads, self.head_dim))?
217            .transpose(1, 2)?;
218
219        let (query_states, key_states) =
220            self.rotary_emb
221                .apply_rotary_emb_qkv(&query_states, &key_states, seqlen_offset)?;
222
223        let (key_states, value_states) = match &self.kv_cache {
224            None => (key_states, value_states),
225            Some((prev_k, prev_v)) => {
226                let key_states = Tensor::cat(&[prev_k, &key_states], 2)?;
227                let value_states = Tensor::cat(&[prev_v, &value_states], 2)?;
228                (key_states, value_states)
229            }
230        };
231        self.kv_cache = Some((key_states.clone(), value_states.clone()));
232
233        let key_states = crate::utils::repeat_kv(key_states, self.num_kv_groups)?.contiguous()?;
234        let value_states =
235            crate::utils::repeat_kv(value_states, self.num_kv_groups)?.contiguous()?;
236
237        let attn_output = if self.use_flash_attn {
238            // flash-attn expects (b_sz, seq_len, nheads, head_dim)
239            let q = query_states.transpose(1, 2)?;
240            let k = key_states.transpose(1, 2)?;
241            let v = value_states.transpose(1, 2)?;
242            let scale = 1f32 / (self.head_dim as f32).sqrt();
243            flash_attn(&q, &k, &v, scale, attention_mask.is_some())?.transpose(1, 2)?
244        } else {
245            let scale = 1f64 / f64::sqrt(self.head_dim as f64);
246            let attn_weights = (query_states.matmul(&key_states.transpose(2, 3)?)? * scale)?;
247
248            let attn_weights = match attention_mask {
249                None => attn_weights,
250                Some(mask) => attn_weights.broadcast_add(mask)?,
251            };
252            let attn_weights = candle_nn::ops::softmax_last_dim(&attn_weights)?;
253            attn_weights.matmul(&value_states)?
254        };
255        attn_output
256            .transpose(1, 2)?
257            .reshape((b_sz, q_len, ()))?
258            .apply(&self.o_proj)
259    }
260
261    fn clear_kv_cache(&mut self) {
262        self.kv_cache = None
263    }
264}
265
266#[cfg(feature = "flash-attn")]
267fn flash_attn(
268    q: &Tensor,
269    k: &Tensor,
270    v: &Tensor,
271    softmax_scale: f32,
272    causal: bool,
273) -> Result<Tensor> {
274    candle_flash_attn::flash_attn(q, k, v, softmax_scale, causal)
275}
276
277#[cfg(not(feature = "flash-attn"))]
278fn flash_attn(_: &Tensor, _: &Tensor, _: &Tensor, _: f32, _: bool) -> Result<Tensor> {
279    unimplemented!("compile with '--features flash-attn'")
280}
281
282#[derive(Debug, Clone)]
283struct DecoderLayer {
284    self_attn: Attention,
285    mlp: MLP,
286    input_layernorm: RmsNorm,
287    post_attention_layernorm: RmsNorm,
288}
289
290impl DecoderLayer {
291    fn new(
292        rotary_emb: Arc<RotaryEmbedding>,
293        use_flash_attn: bool,
294        cfg: &Config,
295        vb: VarBuilder,
296    ) -> Result<Self> {
297        let self_attn = Attention::new(rotary_emb, use_flash_attn, cfg, vb.pp("self_attn"))?;
298        let mlp = MLP::new(cfg, vb.pp("mlp"))?;
299        let input_layernorm =
300            RmsNorm::new(cfg.hidden_size, cfg.rms_norm_eps, vb.pp("input_layernorm"))?;
301        let post_attention_layernorm = RmsNorm::new(
302            cfg.hidden_size,
303            cfg.rms_norm_eps,
304            vb.pp("post_attention_layernorm"),
305        )?;
306        Ok(Self {
307            self_attn,
308            mlp,
309            input_layernorm,
310            post_attention_layernorm,
311        })
312    }
313
314    fn forward(
315        &mut self,
316        xs: &Tensor,
317        attention_mask: Option<&Tensor>,
318        seqlen_offset: usize,
319    ) -> Result<Tensor> {
320        let residual = xs;
321        let xs = self.input_layernorm.forward(xs)?;
322        let xs = self.self_attn.forward(&xs, attention_mask, seqlen_offset)?;
323        let xs = (xs + residual)?;
324        let residual = &xs;
325        let xs = xs.apply(&self.post_attention_layernorm)?.apply(&self.mlp)?;
326        residual + xs
327    }
328
329    fn clear_kv_cache(&mut self) {
330        self.self_attn.clear_kv_cache()
331    }
332}
333
334#[derive(Debug, Clone)]
335pub struct Model {
336    embed_tokens: candle_nn::Embedding,
337    layers: Vec<DecoderLayer>,
338    norm: RmsNorm,
339    lm_head: Linear,
340    device: Device,
341    dtype: DType,
342    hidden_size: usize,
343}
344
345impl Model {
346    pub fn new(use_flash_attn: bool, cfg: &Config, vb: VarBuilder) -> Result<Self> {
347        let vb_m = vb.pp("model");
348        let embed_tokens =
349            candle_nn::embedding(cfg.vocab_size, cfg.hidden_size, vb_m.pp("embed_tokens"))?;
350        let rotary_emb = Arc::new(RotaryEmbedding::new(vb.dtype(), cfg, vb_m.device())?);
351        let mut layers = Vec::with_capacity(cfg.num_hidden_layers);
352        let vb_l = vb_m.pp("layers");
353        for layer_idx in 0..cfg.num_hidden_layers {
354            let layer =
355                DecoderLayer::new(rotary_emb.clone(), use_flash_attn, cfg, vb_l.pp(layer_idx))?;
356            layers.push(layer)
357        }
358        let norm = RmsNorm::new(cfg.hidden_size, cfg.rms_norm_eps, vb_m.pp("norm"))?;
359        let lm_head = Linear::new(embed_tokens.embeddings().clone(), None);
360        Ok(Self {
361            embed_tokens,
362            layers,
363            norm,
364            lm_head,
365            device: vb.device().clone(),
366            dtype: vb.dtype(),
367            hidden_size: cfg.hidden_size,
368        })
369    }
370
371    pub fn embed_tokens(&self) -> &candle_nn::Embedding {
372        &self.embed_tokens
373    }
374
375    fn prepare_decoder_attention_mask(
376        &self,
377        b_size: usize,
378        tgt_len: usize,
379        seqlen_offset: usize,
380    ) -> Result<Tensor> {
381        let mask: Vec<_> = (0..tgt_len)
382            .flat_map(|i| (0..tgt_len).map(move |j| if i < j { f32::NEG_INFINITY } else { 0. }))
383            .collect();
384        let mask = Tensor::from_slice(&mask, (tgt_len, tgt_len), &self.device)?;
385        let mask = if seqlen_offset > 0 {
386            let mask0 = Tensor::zeros((tgt_len, seqlen_offset), DType::F32, &self.device)?;
387            Tensor::cat(&[&mask0, &mask], D::Minus1)?
388        } else {
389            mask
390        };
391        mask.expand((b_size, 1, tgt_len, tgt_len + seqlen_offset))?
392            .to_dtype(self.dtype)
393    }
394
395    pub fn forward(&mut self, input_ids: &Tensor, seqlen_offset: usize) -> Result<Tensor> {
396        let (b_size, seq_len) = input_ids.dims2()?;
397        let attention_mask = if seq_len <= 1 {
398            None
399        } else {
400            let mask = self.prepare_decoder_attention_mask(b_size, seq_len, seqlen_offset)?;
401            Some(mask)
402        };
403        let xs = self.embed_tokens.forward(input_ids)?;
404        let mut xs = (xs * (self.hidden_size as f64).sqrt())?;
405        for layer in self.layers.iter_mut() {
406            xs = layer.forward(&xs, attention_mask.as_ref(), seqlen_offset)?
407        }
408        xs.narrow(1, seq_len - 1, 1)?
409            .apply(&self.norm)?
410            .apply(&self.lm_head)
411    }
412    pub fn forward_embeds(
413        &mut self,
414        xs: &Tensor,
415        attn_mask: Option<&Tensor>,
416        seqlen_offset: usize,
417    ) -> Result<Tensor> {
418        let (_, seq_len, _) = xs.dims3()?;
419        let mut xs = (xs * (self.hidden_size as f64).sqrt())?;
420        for layer in self.layers.iter_mut() {
421            xs = layer.forward(&xs, attn_mask, seqlen_offset)?
422        }
423        xs.narrow(1, seq_len - 1, 1)?
424            .apply(&self.norm)?
425            .apply(&self.lm_head)
426    }
427
428    // Forward the model and return the hidden states without the lm_head
429    pub fn forward_embeds_without_projection(
430        &mut self,
431        xs: &Tensor,
432        attn_mask: Option<&Tensor>,
433        seqlen_offset: usize,
434    ) -> Result<Tensor> {
435        let (_, _, _) = xs.dims3()?;
436        let mut xs = (xs * (self.hidden_size as f64).sqrt())?;
437        for layer in self.layers.iter_mut() {
438            xs = layer.forward(&xs, attn_mask, seqlen_offset)?
439        }
440        Ok(xs)
441    }
442
443    pub fn clear_kv_cache(&mut self) {
444        for layer in self.layers.iter_mut() {
445            layer.clear_kv_cache()
446        }
447    }
448}
candle_transformers/models/gemma.rs

candle_transformers/models/
gemma.rs
