modeling_nano.py

import math
import os
import random
import warnings
from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.checkpoint
from einops import repeat
from torch import nn
from torch.cuda.amp import autocast
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from transformers.activations import ACT2FN
from transformers.modeling_outputs import (
    BaseModelOutputWithPastAndCrossAttentions,
    CausalLMOutputWithCrossAttentions, QuestionAnsweringModelOutput,
    SequenceClassifierOutputWithPast, TokenClassifierOutput)
from transformers.modeling_utils import PreTrainedModel, SequenceSummary
from transformers.utils import (ModelOutput, logging)
from transformers.utils.model_parallel_utils import (assert_device_map,
                                                     get_device_map)

from .configuration_nano import NanoConfig
from transformers.models.llama.modeling_llama import LlamaRMSNorm, LlamaDynamicNTKScalingRotaryEmbedding, LlamaRotaryEmbedding, LlamaLinearScalingRotaryEmbedding

def rotate_half(x):
    """Rotates half the hidden dims of the input."""
    x1 = x[..., : x.shape[-1] // 2]
    x2 = x[..., x.shape[-1] // 2 :]
    return torch.cat((-x2, x1), dim=-1)

def apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1):
    cos = cos[position_ids].unsqueeze(unsqueeze_dim)
    sin = sin[position_ids].unsqueeze(unsqueeze_dim)
    q_embed = (q * cos) + (rotate_half(q) * sin)
    k_embed = (k * cos) + (rotate_half(k) * sin)
    return q_embed, k_embed

class NanoAttention(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.head_dim = config.hidden_size // config.num_attention_heads
        assert (
            self.head_dim * config.num_attention_heads == config.hidden_size
        ), "d_model must be divisible by n_head"
        self.use_bias = config.use_bias

        if not config.combined_qkv or config.kv_hidden_size is not None:
            self.query = nn.Linear(
                config.hidden_size, config.hidden_size, bias=self.use_bias
            )
            self.key = nn.Linear(
                config.hidden_size
                if not config.kv_hidden_size
                else config.kv_hidden_size,
                config.hidden_size,
                bias=self.use_bias,
            )
            self.value = nn.Linear(
                config.hidden_size
                if not config.kv_hidden_size
                else config.kv_hidden_size,
                config.hidden_size,
                bias=self.use_bias,
            )
        else:
            self.qkv = nn.Linear(
                config.hidden_size, config.hidden_size * 3, bias=self.use_bias
            )
        self.out = nn.Linear(config.hidden_size, config.hidden_size, bias=self.use_bias)
        self._init_rope()

    def _init_rope(self):
        if self.config.rope_scaling is None:
            self.rotary_emb = LlamaRotaryEmbedding(
                self.head_dim,
                max_position_embeddings=self.config.max_position_embeddings,
                base=self.config.rope_theta,
            )
        else:
            scaling_type = self.config.rope_scaling["type"]
            scaling_factor = self.config.rope_scaling["factor"]
            if scaling_type == "linear":
                self.rotary_emb = LlamaLinearScalingRotaryEmbedding(
                    self.head_dim,
                    max_position_embeddings=self.config.max_position_embeddings,
                    scaling_factor=scaling_factor,
                    base=self.config.rope_theta,
                )
            elif scaling_type == "dynamic":
                self.rotary_emb = LlamaDynamicNTKScalingRotaryEmbedding(
                    self.head_dim,
                    max_position_embeddings=self.max_position_embeddings,
                    scaling_factor=scaling_factor,
                    base=self.config.rope_theta,
                )
            else:
                raise ValueError(f"Unknown RoPE scaling type {scaling_type}")

    def forward(self, x0, x1=None, causal=False, mask=None, position_ids=None, use_cache=True, layer_past=None):
        batch_size = x0.size(0)

        def split_heads(x):
            return x.view(
                batch_size, -1, self.config.num_attention_heads, self.head_dim
            ).transpose(1, 2)

        if not self.config.combined_qkv:
            q = split_heads(self.query(x0))
            k = split_heads(self.key(x1) if x1 is not None else self.key(x0))
            v = split_heads(
                self.value(x1 if x1 is not None else x0)
            )
        else:
            q, k, v = self.qkv(x0).chunk(3,-1)
            q = split_heads(q)
            k = split_heads(k)
            v = split_heads(v)

        if layer_past is not None:
            past_key, past_value = layer_past
            k = torch.cat((past_key, k), dim=-2)
            v = torch.cat((past_value, v), dim=-2)

        cos, sin = self.rotary_emb(v, seq_len=v.shape[-2])
        if self.config.experimental_full_adaption_rank is not None:
            position_ids = position_ids.repeat_interleave(x0.shape[1]//position_ids.shape[-1],dim=1)
        q, k = apply_rotary_pos_emb(q, k, cos, sin, position_ids)

        if use_cache is True:
            present = (k,v)
        else:
            present = None

        attn_output = F.scaled_dot_product_attention(
            q, k, v, attn_mask=None, dropout_p=0.0, is_causal=causal
        )
        attn_output = (
            attn_output.transpose(1, 2)
            .contiguous()
            .view(batch_size, -1, self.config.hidden_size)
        )
        return self.out(attn_output), present


class NanoGLU(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.gate_proj = nn.Linear(
            config.hidden_size, config.intermediate_size, bias=False
        )
        self.up_proj = nn.Linear(
            config.hidden_size, config.intermediate_size, bias=False
        )
        self.down_proj = nn.Linear(
            config.intermediate_size, config.hidden_size, bias=False
        )
        self.act_fn = ACT2FN[config.activation_function]

    def forward(self, x):
        return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))


class NanoBlock(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.attn = NanoAttention(config)
        self.ffn = NanoGLU(config)

        ln_class = LlamaRMSNorm if config.layernorm=="llamarmsnorm" else nn.LayerNorm
        self.ln1 = ln_class(config.hidden_size, eps=config.layer_norm_epsilon)
        self.ln2 = ln_class(config.hidden_size, eps=config.layer_norm_epsilon)

    def forward(self, x, mask=None, position_ids=None, use_cache=True, layer_past=None):

        if self.config.ffn == "llamalike":
            residual = x
            x = self.ln1(x)
            attn_out, attn_outs = self.attn(x, causal=True, mask=mask, position_ids=position_ids, use_cache=use_cache, layer_past=layer_past)
            x = residual + attn_out

            residual = x
            x = self.ln2(x)
            x = self.ffn(x)
            x = residual + x
        else: # ffn == "parallel"
            attn_in = self.ln1(x)
            ffn_in = self.ln2(x)

            attn_out, attn_outs = self.attn(attn_in, causal=True, mask=mask, position_ids=position_ids, use_cache=use_cache, layer_past=layer_past)
            ffn_out = self.ffn(ffn_in)

            x = x + attn_out + ffn_out
        
        if not use_cache: attn_outs = None
        return (x, attn_outs)



class NanoPreTrainedModel(PreTrainedModel):
    config_class = NanoConfig
    base_model_prefix = "transformer"
    is_parallelizable = False
    supports_gradient_checkpointing = True
    _no_split_modules = ["NanoBlock"]
    _skip_keys_device_placement = "past_key_values"

    def __init__(self, *inputs, **kwargs):
        super().__init__(*inputs, **kwargs)

    def _init_weights(self, module):
        """Initialize the weights."""
        if isinstance(module, (nn.Linear)):
            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
            if module.bias is not None:
                module.bias.data.zero_()
        elif isinstance(module, nn.Embedding):
            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
            if module.padding_idx is not None:
                module.weight.data[module.padding_idx].zero_()
        elif isinstance(module, nn.LayerNorm):
            module.bias.data.zero_()
            module.weight.data.fill_(1.0)

    def _set_gradient_checkpointing(self, module, value=False):
        if isinstance(module, NanoModel):
            module.gradient_checkpointing = value

class Split(nn.Module):
    def __init__(self, splits):
        super().__init__()
        self.splits=splits
    def forward(self, x):
        bs, tokens, _ = x.shape
        # print("SPLIT X0 SHAPE", x.shape)
        x = x.view(bs, tokens, self.splits, -1)
        x = x.permute(0, 1, 2, 3).reshape(bs, tokens * self.splits, -1)
        # print("SPLIT X1 SHAPE", x.shape)
        return x
    
class Recombine(nn.Module):
    def __init__(self, splits):
        super().__init__()
        self.splits = splits
    def forward(self, x):
        bs, _, _ = x.shape
        # print("RECOMBINE X SHAPE", x.shape)
        tokens = x.shape[1] // self.splits
        # print("RECOMBINE TOKENS", tokens, bs)
        x = x.view(bs, tokens, -1)
        # print("RECOMBINE X1.SHAPE", x.shape)
        return x

class Residual(nn.Module):
    def __init__(self, module, a=None):
        super().__init__()
        self.module = module
        self.a = nn.Parameter(torch.tensor(a, dtype=torch.bfloat16)) if a is not None else None
    def forward(self, x):
        return self.module(x) * (self.a if self.a is not None else 1) + x

class LoRA(nn.Module):
    def __init__(self, d, r, a=1):
        super().__init__()
        self.fn_i = nn.Linear(d, r)
        self.fn_o = nn.Linear(r, d)
        self.a = nn.Parameter(torch.tensor(a, dtype=self.fn_i.weight.dtype))
    def forward(self, x):
        return self.fn_o(self.fn_i(x)) * self.a + x
    def get_delta_w(self):
        return torch.mm(self.fn_o.weight, self.fn_i.weight) * self.a

class NanoModel(NanoPreTrainedModel):
    def __init__(self, config):
        super().__init__(config)
        ln_class = LlamaRMSNorm if config.layernorm=="llamarmsnorm" else nn.LayerNorm
        
        if config.experimental_full_adaption_rank is None:
            if config.expanded_wte_size is not None:
                self.wte = nn.Sequential(
                    nn.Embedding(config.vocab_size, config.expanded_wte_size),
                    nn.Linear(config.expanded_wte_size, config.hidden_size),
                )
            else:
                self.wte = nn.Embedding(config.vocab_size, config.hidden_size)
        else:
            assert config.expanded_wte_size is not None, "experimental full adaptation of token embeddings requires expanded_wte_size to be set"
            # self.wte = nn.Sequential(
            #     nn.Embedding(config.vocab_size, config.expanded_wte_size),
            #     LoRA(config.expanded_wte_size, config.experimental_full_adaption_rank),
            #     Split(config.expanded_wte_size//config.hidden_size)
            # )
            self.d_0 = config.expanded_wte_size if (config.full_adaptation_has_pre_proj == False) else config.pre_proj_dim
            # print("d_0", d_0)
            self.wte = nn.Sequential(
                nn.Embedding(config.vocab_size, config.expanded_wte_size),
                (
                    nn.Linear(config.expanded_wte_size, config.pre_proj_dim) if config.full_adaptation_has_pre_proj else nn.Identity()
                ),
                (
                    LoRA(self.d_0, config.experimental_full_adaption_rank)
                    if config.full_adaptation_type == "lora" else
                    nn.Linear(self.d_0, self.d_0)
                    if config.full_adaptation_type == "linear" else
                    Residual(
                        nn.Linear(self.d_0, self.d_0)
                    )
                    if config.full_adaptation_type == "linear-r" else
                    Residual(
                        nn.Linear(self.d_0, self.d_0), 1
                    )
                    if config.full_adaptation_type == "linear-ra" else
                    nn.Identity()
                ),
                Split(self.d_0//config.hidden_size)
            )
        self.h = nn.ModuleList(
            [NanoBlock(config) for i in range(config.num_hidden_layers)]
        )
        self.ln_f = ln_class(config.hidden_size, eps=config.layer_norm_epsilon)
        self.model_parallel = False
        self.device_map = None
        self.gradient_checkpointing = False
        self.post_init()

    def get_input_embeddings(self):
        return self.wte[0] if self.config.expanded_wte_size is not None else self.wte

    def set_input_embeddings(self, new_embeddings):
        if self.config.expanded_wte_size is not None:
            self.wte[0] = new_embeddings
        else:
            self.wte = new_embeddings

    def forward(
        self,
        input_ids: Optional[torch.LongTensor] = None,
        past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
        attention_mask: Optional[torch.FloatTensor] = None,
        token_type_ids: Optional[torch.LongTensor] = None,
        position_ids: Optional[torch.LongTensor] = None,
        head_mask: Optional[torch.FloatTensor] = None,
        inputs_embeds: Optional[torch.FloatTensor] = None,
        encoder_hidden_states: Optional[torch.Tensor] = None,
        encoder_attention_mask: Optional[torch.FloatTensor] = None,
        use_cache: Optional[bool] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple, BaseModelOutputWithPastAndCrossAttentions]:
        # soooo not all of the params are able to be used, since I just copied this framework from modeling_gpt2            

        output_attentions = (
            output_attentions
            if output_attentions is not None
            else self.config.output_attentions
        )
        output_hidden_states = (
            output_hidden_states
            if output_hidden_states is not None
            else self.config.output_hidden_states
        )
        use_cache = use_cache if use_cache is not None else self.config.use_cache
        return_dict = (
            return_dict if return_dict is not None else self.config.use_return_dict
        )
        if input_ids is not None and inputs_embeds is not None:
            raise ValueError(
                "You cannot specify both input_ids and inputs_embeds at the same time"
            )
        elif input_ids is not None:
            self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
            input_shape = input_ids.size()
            input_ids = input_ids.view(-1, input_shape[-1])
            batch_size = input_ids.shape[0]
        elif inputs_embeds is not None:
            input_shape = inputs_embeds.size()[:-1]
            batch_size = inputs_embeds.shape[0]
        else:
            raise ValueError("You have to specify either input_ids or inputs_embeds")

        device = input_ids.device if input_ids is not None else inputs_embeds.device

        if token_type_ids is not None:
            token_type_ids = token_type_ids.view(-1, input_shape[-1])
        if position_ids is not None:
            position_ids = position_ids.view(-1, input_shape[-1])

        if past_key_values is None:
            past_length = 0
            past_key_values = tuple([None] * len(self.h))
        else:
            past_length = past_key_values[0][0].size(-2)
        if position_ids is None:
            position_ids = torch.arange(
                past_length,
                input_shape[-1] + past_length,
                dtype=torch.long,
                device=device,
            )
            position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1])

        if attention_mask is not None:
            if batch_size <= 0:
                raise ValueError("batch_size has to be defined and > 0")
            attention_mask = attention_mask.view(batch_size, -1)
            attention_mask = attention_mask[:, None, None, :]
            attention_mask = attention_mask.to(dtype=self.dtype)  # fp16 compatibility
            attention_mask = (1.0 - attention_mask) * torch.finfo(self.dtype).min

        if self.config.add_cross_attention and encoder_hidden_states is not None:
            (
                encoder_batch_size,
                encoder_sequence_length,
                _,
            ) = encoder_hidden_states.size()
            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
            if encoder_attention_mask is None:
                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
            encoder_attention_mask = self.invert_attention_mask(encoder_attention_mask)
        else:
            encoder_attention_mask = None

        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)

        if inputs_embeds is None:
            inputs_embeds = self.wte(input_ids)
            # print("inputs embeds shape", inputs_embeds.shape)
        
        hidden_states = inputs_embeds

        if token_type_ids is not None:
            token_type_embeds = self.wte(token_type_ids)
            hidden_states = hidden_states + token_type_embeds

        # output_shape = (-1,) + input_shape[1:] + (hidden_states.size(-1),)
        output_shape = (-1,) + (hidden_states.shape[1],) + (hidden_states.size(-1),)
        # print(output_shape, "output shape")

        if self.gradient_checkpointing and self.training:
            if use_cache:
                # logger.warning_once(
                #     "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
                # )
                use_cache = False

        presents = () if use_cache else None
        all_self_attentions = () if output_attentions else None
        all_cross_attentions = (
            () if output_attentions and self.config.add_cross_attention else None
        )
        all_hidden_states = () if output_hidden_states else None
        for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
            if self.model_parallel:
                torch.cuda.set_device(hidden_states.device)
                if layer_past is not None:
                    layer_past = tuple(
                        past_state.to(hidden_states.device)
                        for past_state in layer_past
                    )
                if attention_mask is not None:
                    attention_mask = attention_mask.to(hidden_states.device)
                if isinstance(head_mask, torch.Tensor):
                    head_mask = head_mask.to(hidden_states.device)
            if output_hidden_states:
                all_hidden_states = all_hidden_states + (hidden_states,)
            outputs = block(hidden_states, mask=attention_mask, position_ids=position_ids, use_cache=use_cache, layer_past=layer_past)
            hidden_states = outputs[0]
            if use_cache == True:
                presents = presents + (outputs[1],)

        hidden_states = self.ln_f(hidden_states)
        hidden_states = hidden_states.view(output_shape)
        if output_hidden_states:
            all_hidden_states = all_hidden_states + (hidden_states,)

        if not return_dict:
            return tuple(
                v
                for v in [hidden_states, None, all_hidden_states, None, None]
                if v is not None
            )

        return BaseModelOutputWithPastAndCrossAttentions(
            last_hidden_state=hidden_states,
            past_key_values=presents,
            hidden_states=all_hidden_states,
            attentions=None,
            cross_attentions=None,
        )

class NanoModelForCausalLM(NanoPreTrainedModel):
    _tied_weights_keys = ["lm_head.weight"]
    def __init__(self, config):
        super().__init__(config)
        self.transformer = NanoModel(config)
        if config.experimental_full_adaption_rank is None or config.full_adaptation_type == "no":
            if (config.expanded_lm_head_size is not None):
                self.lm_head = nn.Sequential(
                    nn.Linear(
                        config.hidden_size, config.expanded_lm_head_size, bias=config.lm_head_projection_bias
                    ),
                    nn.Linear(
                        config.expanded_lm_head_size, config.vocab_size, bias=config.lm_head_bias
                    ),
                )
            else:
                self.lm_head = nn.Linear(config.hidden_size, config.vocab_size)
        else:
            d_0 = config.expanded_lm_head_size if (not config.full_adaptation_has_pre_proj) else config.pre_proj_dim
            self.lm_head = nn.Sequential(
                Recombine(d_0//config.hidden_size),
                nn.Identity() if not config.full_adaptation_has_pre_proj else nn.Linear(d_0, config.expanded_lm_head_size),
                (
                    LoRA(config.expanded_lm_head_size, config.experimental_full_adaption_rank)
                    if config.full_adaptation_type == "lora" else
                    nn.Linear(config.expanded_lm_head_size, config.expanded_lm_head_size)
                    if config.full_adaptation_type == "linear" else
                    Residual(
                        nn.Linear(config.expanded_lm_head_size, config.expanded_lm_head_size)
                    )
                    if config.full_adaptation_type == "linear-r" else
                    Residual(
                        nn.Linear(config.expanded_lm_head_size, config.expanded_lm_head_size), 1
                    )
                    if config.full_adaptation_type == "linear-ra" else
                    nn.Identity()
                ),
                
                nn.Linear(config.expanded_lm_head_size, config.vocab_size)
            )
        self.model_parallel = False
        self.device_map = None
        self.post_init()

    def get_output_embeddings(self):
        return self.lm_head if (self.config.experimental_full_adaption_rank is None and self.config.expanded_lm_head_size is None) else self.lm_head[-1] 

    def set_output_embeddings(self, new_embeddings):
        self.lm_head = new_embeddings

    def prepare_inputs_for_generation(
        self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs
    ):
        token_type_ids = kwargs.get("token_type_ids", None)
        # only last token for inputs_ids if past is defined in kwargs
        if past_key_values:
            input_ids = input_ids[:, -1].unsqueeze(-1)
            if token_type_ids is not None:
                token_type_ids = token_type_ids[:, -1].unsqueeze(-1)

        attention_mask = kwargs.get("attention_mask", None)
        position_ids = kwargs.get("position_ids", None)

        if attention_mask is not None and position_ids is None:
            # create position_ids on the fly for batch generation
            position_ids = attention_mask.long().cumsum(-1) - 1
            position_ids.masked_fill_(attention_mask == 0, 1)
            if past_key_values:
                position_ids = position_ids[:, -1].unsqueeze(-1)
        else:
            position_ids = None

        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
        if inputs_embeds is not None and past_key_values is None:
            model_inputs = {"inputs_embeds": inputs_embeds}
        else:
            model_inputs = {"input_ids": input_ids}

        model_inputs.update(
            {
                "past_key_values": past_key_values,
                "use_cache": kwargs.get("use_cache"),
                "position_ids": position_ids,
                "attention_mask": attention_mask,
                "token_type_ids": token_type_ids,
            }
        )
        return model_inputs

    def forward(
        self,
        input_ids: Optional[torch.LongTensor] = None,
        past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
        attention_mask: Optional[torch.FloatTensor] = None,
        token_type_ids: Optional[torch.LongTensor] = None,
        position_ids: Optional[torch.LongTensor] = None,
        head_mask: Optional[torch.FloatTensor] = None,
        inputs_embeds: Optional[torch.FloatTensor] = None,
        encoder_hidden_states: Optional[torch.Tensor] = None,
        encoder_attention_mask: Optional[torch.FloatTensor] = None,
        labels: Optional[torch.LongTensor] = None,
        use_cache: Optional[bool] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple, CausalLMOutputWithCrossAttentions]:
        r"""
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
            `labels = input_ids` Indices are selected in `[-100, 0, ..., config.vocab_size]` All labels set to `-100`
            are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]`
        """
        return_dict = (
            return_dict if return_dict is not None else self.config.use_return_dict
        )

        transformer_outputs = self.transformer(
            input_ids,
            past_key_values=past_key_values,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            encoder_hidden_states=encoder_hidden_states,
            encoder_attention_mask=encoder_attention_mask,
            use_cache=use_cache,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )
        hidden_states = transformer_outputs[0]
        # print("Hidden states shape", hidden_states.shape)
        if self.model_parallel:
            torch.cuda.set_device(self.transformer.first_device)
            hidden_states = hidden_states.to(self.lm_head.weight.device)

        lm_logits = self.lm_head(hidden_states)

        loss = None
        if labels is not None:
            # move labels to correct device to enable model parallelism
            labels = labels.to(lm_logits.device)
            # Shift so that tokens < n predict n
            shift_logits = lm_logits[..., :-1, :].contiguous()
            shift_labels = labels[..., 1:].contiguous()
            # Flatten the tokens
            loss_fct = CrossEntropyLoss()
            loss = loss_fct(
                shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)
            )

        if not return_dict:
            output = (lm_logits,) + transformer_outputs[1:]
            return ((loss,) + output) if loss is not None else output

        return CausalLMOutputWithCrossAttentions(
            loss=loss,
            logits=lm_logits,
            past_key_values=transformer_outputs.past_key_values,
            hidden_states=transformer_outputs.hidden_states,
            attentions=transformer_outputs.attentions,
            cross_attentions=transformer_outputs.cross_attentions,
        )

    @staticmethod
    def _reorder_cache(
        past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor
    ) -> Tuple[Tuple[torch.Tensor]]:
        """
        This function is used to re-order the `past_key_values` cache if [`~PreTrainedModel.beam_search`] or
        [`~PreTrainedModel.beam_sample`] is called. This is required to match `past_key_values` with the correct
        beam_idx at every generation step.
        """
        return tuple(
            tuple(
                past_state.index_select(0, beam_idx.to(past_state.device))
                for past_state in layer_past
            )
            for layer_past in past_key_values
        )


class VTMModelForCausalLM(NanoModelForCausalLM):
    _tied_weights_keys = ["lm_head.3.weight"]
    def __init__(self, config):
        super().__init__(config)

class VTMPreProjModelForCausalLM(NanoModelForCausalLM):
    _tied_weights_keys = ["lm_head.3.weight"]
    def __init__(self, config):
        super().__init__(config)

class PlusModelForCausalLM(NanoModelForCausalLM):
    _tied_weights_keys = ["lm_head.1.weight"]
    def __init__(self, config):
        super().__init__(config)