Update modeling_rwkv5.py

modeling_rwkv5.py

@@ -1,5 +1,6 @@
 # coding=utf-8
-# Copyright 2024 The RWKV team and HuggingFace Inc. team.
+# Copyright 2023 Bo Peng and HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,7 +16,6 @@
 """PyTorch RWKV5 World model."""
 
 from dataclasses import dataclass
-from pathlib import Path
 from typing import List, Optional, Tuple, Union
 
 import torch
@@ -30,7 +30,6 @@ from transformers.utils import (
     add_code_sample_docstrings,
     add_start_docstrings,
     add_start_docstrings_to_model_forward,
-    is_bitsandbytes_available,
     is_ninja_available,
     is_torch_cuda_available,
     logging,
@@ -44,23 +43,28 @@ logger = logging.get_logger(__name__)
 _CHECKPOINT_FOR_DOC = "RWKV/rwkv-5-world-1b5"
 _CONFIG_FOR_DOC = "Rwkv5Config"
 
+RWKV5_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "RWKV/rwkv-5-world-1b5",
+    "RWKV/rwkv-5-world-3b",
+    # See all RWKV models at https://huggingface.co/models?filter=rwkv
+]
+
 rwkv5_cuda_kernel = None
 
 
-# Copied from https://github.com/huggingface/transformers/blob/18cbaf13dcaca7145f5652aefb9b19734c56c3cd/src/transformers/models/rwkv/modeling_rwkv.py#L65
 def load_wkv5_cuda_kernel(head_size):
     from torch.utils.cpp_extension import load as load_kernel
 
     global rwkv5_cuda_kernel
 
-    kernel_folder = Path(__file__).parent.resolve()
+    kernel_folder = Path(__file__).resolve().parent.parent.parent / "kernels" / "rwkv5"
     cuda_kernel_files = [kernel_folder / f for f in ["wkv5_op.cpp", "wkv5_cuda.cu"]]
 
     # Only load the kernel if it's not been loaded yet or if we changed the context length
     if rwkv5_cuda_kernel is not None and rwkv5_cuda_kernel.head_size == head_size:
         return
 
-    logger.info(f"Loading CUDA kernel for RWKV5 at head size of {head_size}.")
+    logger.info(f"Loading CUDA kernel for RWKV at head size of {head_size}.")
 
     flags = [
         "-res-usage",
@@ -80,177 +84,200 @@ def load_wkv5_cuda_kernel(head_size):
     rwkv5_cuda_kernel.head_size = head_size
 
 
-class Rwkv5LinearAttention(torch.autograd.Function):
+class WKV_5(torch.autograd.Function):
     @staticmethod
-    def forward(ctx, receptance, key, value, time_decay, time_first, state):
+    def forward(ctx, B, T, C, H, r, k, v, w, u, s):
         with torch.no_grad():
-            assert receptance.dtype == torch.bfloat16
-            assert key.dtype == torch.bfloat16
-            assert value.dtype == torch.bfloat16
-            assert time_decay.dtype == torch.bfloat16
-            assert time_first.dtype == torch.bfloat16
-            assert state.dtype == torch.float32
-            batch, seq_length, hidden_size = key.shape
-            num_heads = time_decay.shape[0]
-            ctx.batch = batch
-            ctx.seq_length = seq_length
-            ctx.hidden_size = hidden_size
-            ctx.num_heads = num_heads
-            e_time_decay = (-torch.exp(time_decay.float())).contiguous()
-            ee_time_decay = (torch.exp(e_time_decay)).contiguous()
-            assert ee_time_decay.dtype == torch.float32
-            ctx.save_for_backward(receptance, key, value, ee_time_decay, e_time_decay, time_first)
-            out = torch.empty(
-                (batch, seq_length, hidden_size),
-                device=receptance.device,
-                dtype=torch.bfloat16,
-                memory_format=torch.contiguous_format,
-            )
-            state = state.clone()
-            rwkv5_cuda_kernel.forward_bf16(
-                batch,
-                seq_length,
-                hidden_size,
-                num_heads,
-                state,
-                receptance,
-                key,
-                value,
-                ee_time_decay,
-                time_first,
-                out,
-            )
-            return out, state
+            assert r.dtype == torch.bfloat16
+            assert k.dtype == torch.bfloat16
+            assert v.dtype == torch.bfloat16
+            assert w.dtype == torch.bfloat16
+            assert u.dtype == torch.bfloat16
+            assert s.dtype == torch.float32
+            ctx.B = B
+            ctx.T = T
+            ctx.C = C
+            ctx.H = H
+            assert r.is_contiguous()
+            assert k.is_contiguous()
+            assert v.is_contiguous()
+            assert w.is_contiguous()
+            assert u.is_contiguous()
+            ew = (-torch.exp(w.float())).contiguous()
+            eew = (torch.exp(ew)).contiguous()
+            ctx.save_for_backward(r, k, v, eew, ew, u)
+            y = torch.empty(
+                (B, T, C), device=r.device, dtype=torch.bfloat16, memory_format=torch.contiguous_format
+            )  # .uniform_(-1, 1)
+            rwkv5_cuda_kernel.forward(B, T, C, H, r, k, v, eew, u, y, s)
+            return y, s
 
     @staticmethod
-    def backward(ctx, gout):
+    def backward(ctx, gy):
         with torch.no_grad():
-            assert gout.dtype == torch.bfloat16
-            batch = ctx.batch
-            seq_length = ctx.seq_length
-            hidden_size = ctx.hidden_size
-            num_heads = ctx.num_heads
-            receptance, key, value, ee_time_decay, e_time_decay, time_first = ctx.saved_tensors
-
-            global_shape = (batch, seq_length, hidden_size)
-
-            # TODO dtype should not be forced here IMO
-            greceptance = torch.empty(
-                global_shape,
-                device=gout.device,
+            assert gy.dtype == torch.bfloat16
+            B = ctx.B
+            T = ctx.T
+            C = ctx.C
+            H = ctx.H
+            assert gy.is_contiguous()
+            r, k, v, eew, ew, u = ctx.saved_tensors
+            gr = torch.empty(
+                (B, T, C),
+                device=gy.device,
                 requires_grad=False,
                 dtype=torch.bfloat16,
                 memory_format=torch.contiguous_format,
-            )
-            g_key = torch.empty(
-                global_shape,
-                device=gout.device,
+            )  # .uniform_(-1, 1)
+            gk = torch.empty(
+                (B, T, C),
+                device=gy.device,
                 requires_grad=False,
                 dtype=torch.bfloat16,
                 memory_format=torch.contiguous_format,
-            )
-            g_value = torch.empty(
-                global_shape,
-                device=gout.device,
+            )  # .uniform_(-1, 1)
+            gv = torch.empty(
+                (B, T, C),
+                device=gy.device,
                 requires_grad=False,
                 dtype=torch.bfloat16,
                 memory_format=torch.contiguous_format,
-            )
-            g_time_decay = torch.empty(
-                (batch, hidden_size),
-                device=gout.device,
+            )  # .uniform_(-1, 1)
+            gw = torch.empty(
+                (B, C),
+                device=gy.device,
                 requires_grad=False,
                 dtype=torch.bfloat16,
                 memory_format=torch.contiguous_format,
-            )
-            g_time_first = torch.empty(
-                (batch, hidden_size),
-                device=gout.device,
+            )  # .uniform_(-1, 1)
+            gu = torch.empty(
+                (B, C),
+                device=gy.device,
                 requires_grad=False,
                 dtype=torch.bfloat16,
                 memory_format=torch.contiguous_format,
-            )
-            rwkv5_cuda_kernel.backward_bf16(
-                batch,
-                seq_length,
-                hidden_size,
-                num_heads,
-                receptance,
-                key,
-                value,
-                ee_time_decay,
-                e_time_decay,
-                time_first,
-                gout,
-                greceptance,
-                g_key,
-                g_value,
-                g_time_decay,
-                g_time_first,
-            )
-            head_size = hidden_size // num_heads
-            g_time_decay = torch.sum(g_time_decay, 0).view(num_heads, head_size)
-            g_time_first = torch.sum(g_time_first, 0).view(num_heads, head_size)
-            return (None, None, None, None, greceptance, g_key, g_value, g_time_decay, g_time_first)
-
-
-def rwkv5_linear_attention_cpu(receptance, key, value, time_decay, time_first, state):
-    input_dtype = receptance.dtype
-    # For CPU fallback. Will be slower and probably take more memory than the custom CUDA kernel if not executed
-    # within a torch.no_grad.
-    batch, seq_length, hidden_size = receptance.shape
-    num_heads, head_size = time_first.shape
-    key = key.float().view(batch, seq_length, num_heads, head_size).transpose(1, 2).transpose(-2, -1)
-    value = value.float().view(batch, seq_length, num_heads, head_size).transpose(1, 2)
-    receptance = receptance.float().view(batch, seq_length, num_heads, head_size).transpose(1, 2)
-    time_decay = torch.exp(-torch.exp(time_decay.float())).reshape(-1, 1, 1).reshape(num_heads, -1, 1)
-    time_first = time_first.float().reshape(-1, 1, 1).reshape(num_heads, -1, 1)
-    out = torch.zeros_like(key).reshape(batch, seq_length, num_heads, head_size)
-
-    for current_index in range(seq_length):
-        current_receptance = receptance[:, :, current_index:current_index+1, :]
-        current_key = key[:, :, :, current_index:current_index+1]
-        current_value = value[:, :, current_index:current_index+1, :]
-        attention_output = current_key @ current_value
-        out[:, current_index] = (current_receptance @ (time_first * attention_output + state)).squeeze(2)
+            )  # .uniform_(-1, 1)
+            rwkv5_cuda_kernel.backward(B, T, C, H, r, k, v, eew, ew, u, gy, gr, gk, gv, gw, gu)
+            gw = torch.sum(gw, 0).view(H, C // H)
+            gu = torch.sum(gu, 0).view(H, C // H)
+            return (None, None, None, None, gr, gk, gv, gw, gu)
+
+
+def rwkv_linear_attention_v5_cpu(
+    B,
+    H,
+    S,
+    T,
+    n_head,
+    hidden,
+    time_decay,
+    time_first,
+    receptance,
+    key,
+    value,
+    gate,
+    lxw,
+    lxb,
+    ow,
+    state,
+):
+    key = key.to(torch.float32).view(B, T, H, S).transpose(1, 2).transpose(-2, -1)
+    value = value.to(torch.float32).view(B, T, H, S).transpose(1, 2)
+    receptance = receptance.to(torch.float32).view(B, T, H, S).transpose(1, 2)
+    time_decay = torch.exp(-torch.exp(time_decay.float())).reshape(-1, 1, 1).reshape(n_head, -1, 1)
+    time_first = time_first.float().reshape(-1, 1, 1).reshape(n_head, -1, 1)
+    lxw = lxw.float()
+    lxb = lxb.float()
+    out = torch.zeros_like(key).reshape(B, T, H, S)
+    for t in range(T):
+        rt = receptance[:, :, t : t + 1, :]
+        kt = key[:, :, :, t : t + 1]
+        vt = value[:, :, t : t + 1, :]
+        at = kt @ vt
+        out[:, t] = (rt @ (time_first * at + state)).squeeze(2)
         with torch.no_grad():
-            state = attention_output + time_decay * state
+            state = at + time_decay * state
+
+    out = out.reshape(B * T, H * S)
+    out = F.group_norm(out, num_groups=H, weight=lxw, bias=lxb).reshape(B, T, H * S)
+    out = out.to(dtype=hidden.dtype) * gate
+    out = out @ ow
 
     return out, state
 
-# copied from RWKV but with receptance
-def RWKV5_linear_attention(training, receptance, key, value, time_decay, time_first, state):
-    no_cuda = any(t.device.type != "cuda" for t in [time_decay, time_first, key, value])
+
+def rwkv_linear_attention(
+    B,
+    H,
+    S,
+    T,
+    n_head,
+    hidden,
+    time_decay,
+    time_first,
+    receptance,
+    key,
+    value,
+    gate,
+    lxw,
+    lxb,
+    ow,
+    state,
+):
+    no_cuda = any(t.device.type != "cuda" for t in [time_decay, time_first, receptance, key, value])
     # Launching the CUDA kernel for just one token will actually be slower (there is no for loop in the CPU version
     # in this case).
     one_token = key.size(1) == 1
-    if not training or rwkv5_cuda_kernel is None or no_cuda or one_token:
-        return rwkv5_linear_attention_cpu(
-            receptance, key, value, time_decay, time_first, state
+    if rwkv5_cuda_kernel is None or no_cuda or one_token:
+        return rwkv_linear_attention_v5_cpu(
+            B,
+            H,
+            S,
+            T,
+            n_head,
+            hidden,
+            time_decay,
+            time_first,
+            receptance,
+            key,
+            value,
+            gate,
+            lxw,
+            lxb,
+            ow,
+            state,
         )
     else:
-        return Rwkv5LinearAttention.apply(receptance, key, value, time_decay, time_first, state)
+        out, state = WKV_5.apply(B, T, H * S, H, receptance, key, value, time_decay, time_first, state)
+        out = out.reshape(B * T, H * S)
+        out = F.group_norm(out, num_groups=H, weight=lxw, bias=lxb).reshape(B, T, H * S)
+        out = out.to(dtype=hidden.dtype) * gate
+        out = out @ ow
+        return out, state
 
 
-class Rwkv5SelfAttention(nn.Module):
+class RwkvSelfAttention(nn.Module):
     def __init__(self, config, layer_id=0):
         super().__init__()
         self.config = config
         kernel_loaded = rwkv5_cuda_kernel is not None and rwkv5_cuda_kernel.head_size == config.head_size
         if is_ninja_available() and is_torch_cuda_available() and not kernel_loaded:
             try:
-                load_wkv5_cuda_kernel(config.head_size)
+                load_wkv5_cuda_kernel(config.context_length)
             except Exception:
                 logger.info("Could not load the custom CUDA kernel for RWKV5 attention.")
         self.layer_id = layer_id
         hidden_size = config.hidden_size
-        attention_hidden_size = config.attention_hidden_size
+        # https://github.com/BlinkDL/RWKV-LM/blob/main/RWKV-v4neo/src/model.py#L146
+        num_attention_heads = hidden_size // config.head_size
+        self.num_attention_heads = num_attention_heads
+        attention_hidden_size = (
+            config.attention_hidden_size if config.attention_hidden_size is not None else hidden_size
+        )
         self.attention_hidden_size = attention_hidden_size
-        head_size = config.head_size
-        num_heads = attention_hidden_size // head_size
 
-        self.time_decay = nn.Parameter(torch.empty(num_heads, head_size))
-        self.time_faaaa = nn.Parameter(torch.empty(num_heads, head_size))
+        self.time_decay = nn.Parameter(torch.empty(num_attention_heads, config.head_size))
+        self.time_faaaa = nn.Parameter(torch.empty(num_attention_heads, config.head_size))
         self.time_mix_gate = nn.Parameter(torch.empty(1, 1, hidden_size))
 
         self.time_mix_key = nn.Parameter(torch.empty(1, 1, hidden_size))
@@ -263,9 +290,11 @@ class Rwkv5SelfAttention(nn.Module):
         self.receptance = nn.Linear(hidden_size, attention_hidden_size, bias=False)
         self.gate = nn.Linear(hidden_size, attention_hidden_size, bias=False)
         self.output = nn.Linear(attention_hidden_size, hidden_size, bias=False)
-        self.ln_x = nn.GroupNorm(num_heads, hidden_size)
+        # https://github.com/BlinkDL/RWKV-LM/blob/3db37a72356b736966ddd377268f02b80963af3f/RWKV-v4neo/src/model.py#L190C1-L190C1
+        self.ln_x = nn.GroupNorm(hidden_size // config.head_size, hidden_size)
 
-    def extract_key_value(self, hidden, state=None):
+    # TODO: maybe jit, otherwise move inside forward
+    def extract_key_value(self, B, H, S, T, hidden, state=None):
         # Mix hidden with the previous timestep to produce key, value, receptance
         if hidden.size(1) == 1 and state is not None:
             shifted = state[0][:, :, self.layer_id]
@@ -275,12 +304,12 @@ class Rwkv5SelfAttention(nn.Module):
                 shifted[:, 0] = state[0][:, :, self.layer_id]
         if len(shifted.size()) == 2:
             shifted = shifted.unsqueeze(1)
-        
         key = hidden * self.time_mix_key + shifted * (1 - self.time_mix_key)
         value = hidden * self.time_mix_value + shifted * (1 - self.time_mix_value)
         receptance = hidden * self.time_mix_receptance + shifted * (1 - self.time_mix_receptance)
         gate = hidden * self.time_mix_gate + shifted * (1 - self.time_mix_gate)
 
+        # https://github.com/BlinkDL/ChatRWKV/blob/main/rwkv_pip_package/src/rwkv/model.py#L693
         key = self.key(key)
         value = self.value(value)
         receptance = self.receptance(receptance)
@@ -292,32 +321,45 @@ class Rwkv5SelfAttention(nn.Module):
         return receptance, key, value, gate, state
 
     def forward(self, hidden, state=None, use_cache=False, seq_mode=True):
-        receptance, key, value, gate, state = self.extract_key_value(hidden, state=state)
-
-        B,T,C = receptance.shape
-        H, S = self.time_faaaa.shape
+        B = hidden.shape[0]
+        H = self.time_decay.shape[0]
+        S = hidden.shape[-1] // H
+        T = hidden.shape[1]
 
+        receptance, key, value, gate, state = self.extract_key_value(B, H, S, T, hidden, state=state)
         layer_state = state[1][:, :, :, :, self.layer_id] if state is not None else None
-        out, layer_state = RWKV5_linear_attention(
-            self.training, receptance, key, value, self.time_decay, self.time_faaaa, layer_state
+        rwkv, layer_state = rwkv_linear_attention(
+            B,
+            H,
+            S,
+            T,
+            self.num_attention_heads,
+            hidden,
+            self.time_decay,
+            self.time_faaaa,
+            receptance,
+            key,
+            value,
+            gate,
+            self.ln_x.weight,
+            self.ln_x.bias,
+            self.output.weight.t(),
+            state=layer_state,
         )
 
         if layer_state is not None:
             state[1][:, :, :, :, self.layer_id] = layer_state
 
-        out = out.reshape(B * T, H * S)
-        out = F.group_norm(out / self.config.head_size_divisor, num_groups=H, weight=self.ln_x.weight.to(out.dtype), bias=self.ln_x.bias.to(out.dtype), eps=self.ln_x.eps).reshape(B, T, H * S)
-        out = out.to(dtype=hidden.dtype) * gate
-        out = self.output(out)
-        return out, state
+        return rwkv, state
+
 
-# Copied from rwkv exceot for the intermediate size
-class Rwkv5FeedForward(nn.Module):
+class RwkvFeedForward(nn.Module):
     def __init__(self, config, layer_id=0):
         super().__init__()
         self.config = config
         self.layer_id = layer_id
         hidden_size = config.hidden_size
+        # https://github.com/BlinkDL/RWKV-LM/blob/3db37a72356b736966ddd377268f02b80963af3f/RWKV-v4neo/train.py#L168
         intermediate_size = (
             config.intermediate_size
             if config.intermediate_size is not None
@@ -354,8 +396,7 @@ class Rwkv5FeedForward(nn.Module):
         return receptance * value, state
 
 
-# Copied from transformers.models.rwkv.modeling_rwkv.RwkvBlock with Rwkv->Rwkv5
-class Rwkv5Block(nn.Module):
+class RwkvBlock(nn.Module):
     def __init__(self, config, layer_id):
         super().__init__()
         self.config = config
@@ -367,8 +408,8 @@ class Rwkv5Block(nn.Module):
         self.ln1 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_epsilon)
         self.ln2 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_epsilon)
 
-        self.attention = Rwkv5SelfAttention(config, layer_id)
-        self.feed_forward = Rwkv5FeedForward(config, layer_id)
+        self.attention = RwkvSelfAttention(config, layer_id)
+        self.feed_forward = RwkvFeedForward(config, layer_id)
 
     def forward(self, hidden, state=None, use_cache=False, output_attentions=False, seq_mode=True):
         if self.layer_id == 0:
@@ -388,7 +429,6 @@ class Rwkv5Block(nn.Module):
         return outputs
 
 
-# Copied from transformers.models.rwkv.modeling_rwkv.RwkvPreTrainedModel with Rwkv->Rwkv5
 class Rwkv5PreTrainedModel(PreTrainedModel):
     """
     An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
@@ -396,20 +436,19 @@ class Rwkv5PreTrainedModel(PreTrainedModel):
     """
 
     config_class = Rwkv5Config
-    base_model_prefix = "rwkv5"
-    _no_split_modules = ["Rwkv5Block"]
+    base_model_prefix = "rwkv"
+    _no_split_modules = ["RwkvBlock"]
     _keep_in_fp32_modules = ["time_decay", "time_first"]
     supports_gradient_checkpointing = True
 
     def _init_weights(self, module):
         """Initialize the weights."""
-        if isinstance(module, Rwkv5SelfAttention):
+        if isinstance(module, RwkvSelfAttention):
             layer_id = module.layer_id
             num_hidden_layers = module.config.num_hidden_layers
             hidden_size = module.config.hidden_size
             attention_hidden_size = module.attention_hidden_size
-            head_size = module.config.head_size
-            num_heads = attention_hidden_size // head_size
+            num_attention_heads = hidden_size // module.config.num_attention_heads
 
             ratio_0_to_1 = layer_id / (num_hidden_layers - 1)  # 0 to 1
             ratio_1_to_almost0 = 1.0 - (layer_id / num_hidden_layers)  # 1 to ~0
@@ -421,6 +460,7 @@ class Rwkv5PreTrainedModel(PreTrainedModel):
             )
             time_weight = time_weight[None, None, :]
 
+            # https://github.com/BlinkDL/RWKV-LM/blob/main/RWKV-v4neo/src/model.py#L398
             decay_speed = [
                 -6.0 + 5.0 * (h / (attention_hidden_size - 1)) ** (0.7 + 1.3 * ratio_0_to_1)
                 for h in range(attention_hidden_size)
@@ -436,15 +476,15 @@ class Rwkv5PreTrainedModel(PreTrainedModel):
             )
 
             with torch.no_grad():
-                module.time_decay.data = decay_speed.reshape(num_heads, head_size)
-                module.time_faaaa.data = tmp.reshape(num_heads, head_size)
+                module.time_decay.data = decay_speed.reshape(num_attention_heads, module.config.num_attention_heads)
+                module.time_faaaa.data = tmp.reshape(num_attention_heads, module.config.num_attention_heads)
                 module.time_mix_key.data = torch.pow(time_weight, ratio_1_to_almost0)
 
                 module.time_mix_value.data = torch.pow(time_weight, ratio_1_to_almost0) + 0.3 * ratio_0_to_1
                 module.time_mix_receptance.data = torch.pow(time_weight, 0.5 * ratio_1_to_almost0)
                 module.time_mix_gate.data = torch.pow(time_weight, 0.5 * ratio_1_to_almost0)
 
-        elif isinstance(module, Rwkv5FeedForward):
+        elif isinstance(module, RwkvFeedForward):
             layer_id = module.layer_id
             num_hidden_layers = module.config.num_hidden_layers
             hidden_size = module.config.hidden_size
@@ -463,12 +503,10 @@ class Rwkv5PreTrainedModel(PreTrainedModel):
                 module.time_mix_receptance.data = torch.pow(time_weight, ratio_1_to_almost0)
 
 
-# Copied from transformers.models.rwkv.modeling_rwkv.RwkvOutput with Rwkv->Rwkv5
 @dataclass
 class Rwkv5Output(ModelOutput):
     """
-    Class for the RWKV5 model outputs.
-
+    Class for the RWKV model outputs.
     Args:
         last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
             Sequence of hidden-states at the output of the last layer of the model.
@@ -491,12 +529,10 @@ class Rwkv5Output(ModelOutput):
     attentions: Optional[Tuple[torch.FloatTensor]] = None
 
 
-# Copied from transformers.models.rwkv.modeling_rwkv.RwkvCausalLMOutput with Rwkv->Rwkv5
 @dataclass
 class Rwkv5CausalLMOutput(ModelOutput):
     """
     Base class for causal language model (or autoregressive) outputs.
-
     Args:
         loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
             Language modeling loss (for next-token prediction).
@@ -522,20 +558,19 @@ class Rwkv5CausalLMOutput(ModelOutput):
     attentions: Optional[Tuple[torch.FloatTensor]] = None
 
 
-RWKV5_START_DOCSTRING = r"""
+RWKV_START_DOCSTRING = r"""
     This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
     library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
     etc.) This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)
     subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to
     general usage and behavior.
-
     Parameters:
         config ([`Rwkv5Config`]): Model configuration class with all the parameters of the model.
             Initializing with a config file does not load the weights associated with the model, only the
             configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
 """
 
-RWKV5_INPUTS_DOCSTRING = r"""
+RWKV_INPUTS_DOCSTRING = r"""
     Args:
         input_ids (`torch.LongTensor` of shape `(batch_size, input_ids_length)`):
             `input_ids_length` = `sequence_length` if `past_key_values` is `None` else
@@ -565,15 +600,15 @@ RWKV5_INPUTS_DOCSTRING = r"""
 
 
 @add_start_docstrings(
-    "The bare RWKV5 Model transformer outputting raw hidden-states without any specific head on top.",
-    RWKV5_START_DOCSTRING,
+    "The bare RWKV Model transformer outputting raw hidden-states without any specific head on top.",
+    RWKV_START_DOCSTRING,
 )
 class Rwkv5Model(Rwkv5PreTrainedModel):
     def __init__(self, config):
         super().__init__(config)
 
         self.embeddings = nn.Embedding(config.vocab_size, config.hidden_size)
-        self.blocks = nn.ModuleList([Rwkv5Block(config, layer_id=idx) for idx in range(config.num_hidden_layers)])
+        self.blocks = nn.ModuleList([RwkvBlock(config, layer_id=idx) for idx in range(config.num_hidden_layers)])
         self.ln_out = nn.LayerNorm(config.hidden_size)
 
         self.layers_are_rescaled = False
@@ -588,7 +623,7 @@ class Rwkv5Model(Rwkv5PreTrainedModel):
     def set_input_embeddings(self, new_embeddings):
         self.embeddings = new_embeddings
 
-    @add_start_docstrings_to_model_forward(RWKV5_INPUTS_DOCSTRING)
+    @add_start_docstrings_to_model_forward(RWKV_INPUTS_DOCSTRING)
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC,
         output_type=Rwkv5Output,
@@ -609,7 +644,6 @@ class Rwkv5Model(Rwkv5PreTrainedModel):
         output_hidden_states = (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
-        # FIXME - training is supportable with the CUDA code
         # rwkv5 only support inference in huggingface.
         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
@@ -627,37 +661,40 @@ class Rwkv5Model(Rwkv5PreTrainedModel):
         if inputs_embeds is None:
             inputs_embeds = self.embeddings(input_ids)
 
-        if state is None:
+        if use_cache and state is None:
+            # https://github.com/BlinkDL/ChatRWKV/blob/main/rwkv_pip_package/src/rwkv/model.py#L904-L906
             state = []
-            head_size = self.config.head_size
-            num_heads = self.config.attention_hidden_size // head_size
-            state_attn_x = torch.zeros(
-                (inputs_embeds.size(0), self.config.hidden_size, self.config.num_hidden_layers),
-                dtype=inputs_embeds.dtype,
-                requires_grad=False,
-                device=inputs_embeds.device,
-            ).contiguous()
-            state_attn_kv = torch.zeros(
-                (
-                    inputs_embeds.size(0),
-                    num_heads,
-                    head_size,
-                    head_size,
-                    self.config.num_hidden_layers,
-                ),
-                dtype=torch.float32,
-                requires_grad=False,
-                device=inputs_embeds.device,
-            ).contiguous()
-            state_ffn_x = torch.zeros(
-                (inputs_embeds.size(0), self.config.hidden_size, self.config.num_hidden_layers),
-                dtype=inputs_embeds.dtype,
-                requires_grad=False,
-                device=inputs_embeds.device,
-            ).contiguous()
-            state.append(state_attn_x)
-            state.append(state_attn_kv)
-            state.append(state_ffn_x)
+            num_attention_heads = self.config.hidden_size // self.config.num_attention_heads
+            state.append(
+                torch.zeros(
+                    (inputs_embeds.size(0), self.config.hidden_size, self.config.num_hidden_layers),
+                    dtype=inputs_embeds.dtype,
+                    requires_grad=False,
+                    device=inputs_embeds.device,
+                ).contiguous()
+            )
+            state.append(
+                torch.zeros(
+                    (
+                        inputs_embeds.size(0),
+                        num_attention_heads,
+                        self.config.hidden_size // num_attention_heads,
+                        self.config.hidden_size // num_attention_heads,
+                        self.config.num_hidden_layers,
+                    ),
+                    dtype=torch.float32,
+                    requires_grad=False,
+                    device=inputs_embeds.device,
+                ).contiguous()
+            )
+            state.append(
+                torch.zeros(
+                    (inputs_embeds.size(0), self.config.hidden_size, self.config.num_hidden_layers),
+                    dtype=inputs_embeds.dtype,
+                    requires_grad=False,
+                    device=inputs_embeds.device,
+                ).contiguous()
+            )
 
         seq_mode = inputs_embeds.shape[1] > 1
         hidden_states = inputs_embeds
@@ -720,37 +757,14 @@ class Rwkv5Model(Rwkv5PreTrainedModel):
 
         self.layers_are_rescaled = not self.training
 
-    def _bnb_4bit_dequantize_and_rescale(self, target_layer, block_id):
-        r"""
-        Perform the dequantization and rescaling of the weights of a given layer. After that operation the layer will
-        be quantized again.
-        """
-        if not is_bitsandbytes_available():
-            raise ImportError("Please install bitsandbytes to use this method.")
-        import bitsandbytes as bnb
-
-        dequant_weights = bnb.functional.dequantize_4bit(target_layer.weight.data, target_layer.weight.quant_state)
-
-        dequant_weights.div_(2 ** int(block_id // self.config.rescale_every))
 
-        # re-quantize the model:
-        # we need to put it first on CPU then back to the device
-        # this will create an overhead :/
-        # We set requires_grad=False as we cannot compute gradients on top of 4bit parameters anyway and to avoid
-        # bugs with bnb
-        quant_weight = bnb.nn.Params4bit(dequant_weights.to("cpu"), requires_grad=False).to(dequant_weights.device)
-        setattr(target_layer, "weight", quant_weight)
-
-
-# copied from HuggingFace https://github.com/huggingface/transformers/blob/main/src/transformers/models/rwkv/modeling_rwkv.py
 @add_start_docstrings(
     """
-    The RWKV5 Model transformer with a language modeling head on top (linear layer with weights tied to the input
+    The RWKV Model transformer with a language modeling head on top (linear layer with weights tied to the input
     embeddings).
     """,
-    RWKV5_START_DOCSTRING,
+    RWKV_START_DOCSTRING,
 )
-# Copied from transformers.models.rwkv.modeling_rwkv.RwkvForCausalLM with Rwkv->Rwkv5
 class Rwkv5ForCausalLM(Rwkv5PreTrainedModel):
     _tied_weights_keys = ["head.weight"]
 
@@ -772,6 +786,9 @@ class Rwkv5ForCausalLM(Rwkv5PreTrainedModel):
         # only last token for inputs_ids if the state is passed along.
         if state is not None:
             input_ids = input_ids[:, -1].unsqueeze(-1)
+        else:
+            # add in \n at the beginning
+            input_ids = torch.cat([torch.full([1,1],11,device=input_ids.device,dtype=input_ids.dtype), input_ids])
 
         # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
         if inputs_embeds is not None and state is None:
@@ -782,7 +799,7 @@ class Rwkv5ForCausalLM(Rwkv5PreTrainedModel):
         model_inputs["state"] = state
         return model_inputs
 
-    @add_start_docstrings_to_model_forward(RWKV5_INPUTS_DOCSTRING)
+    @add_start_docstrings_to_model_forward(RWKV_INPUTS_DOCSTRING)
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC,
         output_type=Rwkv5CausalLMOutput,
@@ -808,7 +825,7 @@ class Rwkv5ForCausalLM(Rwkv5PreTrainedModel):
         """
         return_dict = return_dict if return_dict is not None else self.config.use_return_dict
 
-        outputs = self.rwkv(
+        rwkv_outputs = self.rwkv(
             input_ids,
             inputs_embeds=inputs_embeds,
             state=state,
@@ -817,7 +834,7 @@ class Rwkv5ForCausalLM(Rwkv5PreTrainedModel):
             output_hidden_states=output_hidden_states,
             return_dict=return_dict,
         )
-        hidden_states = outputs[0]
+        hidden_states = rwkv_outputs[0]
 
         logits = self.head(hidden_states)
 
@@ -833,13 +850,13 @@ class Rwkv5ForCausalLM(Rwkv5PreTrainedModel):
             loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
 
         if not return_dict:
-            output = (logits,) + outputs[1:]
+            output = (logits,) + rwkv_outputs[1:]
             return ((loss,) + output) if loss is not None else output
 
         return Rwkv5CausalLMOutput(
             loss=loss,
             logits=logits,
-            state=outputs.state,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
+            state=rwkv_outputs.state,
+            hidden_states=rwkv_outputs.hidden_states,
+            attentions=rwkv_outputs.attentions,
+        )