diff --git a/llm-awq/awq.egg-info/SOURCES.txt b/llm-awq/awq.egg-info/SOURCES.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aaa11c8b1f86583681450ca4595041df5b2697fe
--- /dev/null
+++ b/llm-awq/awq.egg-info/SOURCES.txt
@@ -0,0 +1,81 @@
+LICENSE
+README.md
+pyproject.toml
+awq/entry.py
+awq.egg-info/PKG-INFO
+awq.egg-info/SOURCES.txt
+awq.egg-info/dependency_links.txt
+awq.egg-info/requires.txt
+awq.egg-info/top_level.txt
+awq/kernels/setup.py
+awq/kernels/csrc/attention/setup.py
+awq/quantize/__init__.py
+awq/quantize/auto_clip.py
+awq/quantize/auto_scale.py
+awq/quantize/pre_quant.py
+awq/quantize/qmodule.py
+awq/quantize/quantizer.py
+awq/quantize/smooth.py
+awq/quantize/w8a8_linear.py
+awq/utils/__init__.py
+awq/utils/calib_data.py
+awq/utils/lm_eval_adaptor.py
+awq/utils/module.py
+awq/utils/parallel.py
+awq/utils/utils.py
+tinychat/benchmark.py
+tinychat/demo.py
+tinychat/internvl_benchmark.py
+tinychat/internvl_demo.py
+tinychat/nvila_benchmark.py
+tinychat/nvila_demo.py
+tinychat/offline-weight-repacker.py
+tinychat/split_ckpt.py
+tinychat/vila10_demo.py
+tinychat/vila15_demo.py
+tinychat/models/__init__.py
+tinychat/models/falcon.py
+tinychat/models/internvl3.py
+tinychat/models/llama.py
+tinychat/models/llava_llama.py
+tinychat/models/mpt.py
+tinychat/models/nvila_qwen2.py
+tinychat/models/qwen2.py
+tinychat/models/vila_llama.py
+tinychat/models/internvl/configuration_internvl.py
+tinychat/models/internvl/conversation.py
+tinychat/models/internvl/internvit.py
+tinychat/models/internvl/media.py
+tinychat/models/llava_base/llava_arch.py
+tinychat/models/llava_base/multimodal_encoder/builder.py
+tinychat/models/llava_base/multimodal_encoder/clip_encoder.py
+tinychat/models/llava_base/multimodal_projector/builder.py
+tinychat/models/nvila/builder.py
+tinychat/models/nvila/configuration_llava.py
+tinychat/models/nvila/llava_arch.py
+tinychat/modules/__init__.py
+tinychat/modules/fused_attn.py
+tinychat/modules/fused_internencoder.py
+tinychat/modules/fused_mlp.py
+tinychat/modules/fused_norm.py
+tinychat/modules/fused_siglipdecoder.py
+tinychat/modules/fused_vision_attn.py
+tinychat/serve/controller.py
+tinychat/serve/gradio_web_server.py
+tinychat/serve/llava_conv.py
+tinychat/serve/model_worker.py
+tinychat/serve/model_worker_new.py
+tinychat/stream_generators/NVILA_stream_gen.py
+tinychat/stream_generators/__init__.py
+tinychat/stream_generators/internvl_stream_gen.py
+tinychat/stream_generators/llava_stream_gen.py
+tinychat/stream_generators/stream_gen.py
+tinychat/utils/__init__.py
+tinychat/utils/constants.py
+tinychat/utils/conversation_utils.py
+tinychat/utils/input_metadata.py
+tinychat/utils/llava_image_processing.py
+tinychat/utils/load_quant.py
+tinychat/utils/log_utils.py
+tinychat/utils/prompt_templates.py
+tinychat/utils/tune.py
\ No newline at end of file
diff --git a/llm-awq/awq.egg-info/dependency_links.txt b/llm-awq/awq.egg-info/dependency_links.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/llm-awq/awq.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/llm-awq/awq.egg-info/requires.txt b/llm-awq/awq.egg-info/requires.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bc13f00bfadf8ce78808e2bd3c3b607f06ccdf7e
--- /dev/null
+++ b/llm-awq/awq.egg-info/requires.txt
@@ -0,0 +1,16 @@
+accelerate==0.34.2
+sentencepiece
+tokenizers>=0.12.1
+torch==2.3.0
+torchvision==0.18.0
+transformers==4.46.0
+lm_eval==0.3.0
+texttable
+toml
+attributedict
+protobuf
+gradio==3.35.2
+gradio_client==0.2.9
+fastapi
+uvicorn
+pydantic==1.10.19
diff --git a/llm-awq/awq.egg-info/top_level.txt b/llm-awq/awq.egg-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7928383645d42ce1f3209d78cf2e3d8345ed8273
--- /dev/null
+++ b/llm-awq/awq.egg-info/top_level.txt
@@ -0,0 +1,3 @@
+awq
+figures
+tinychat
diff --git a/llm-awq/awq/quantize/qmodule.py b/llm-awq/awq/quantize/qmodule.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7b477c3b07bf66cfbe63752bb09f18374ac830e
--- /dev/null
+++ b/llm-awq/awq/quantize/qmodule.py
@@ -0,0 +1,235 @@
+import math
+import torch
+import torch.nn as nn
+import awq_inference_engine  # with CUDA kernels
+
+
+def make_divisible(c, divisor):
+    return (c + divisor - 1) // divisor
+
+
+def calculate_zeros_width(in_features, group_size=128, pack_num=8):
+    if group_size >= 128:
+        size_multiplier = 1
+    elif group_size == 64:
+        size_multiplier = 2
+    elif group_size == 32:
+        size_multiplier = 4
+    else:
+        raise NotImplementedError
+
+    base_width = make_divisible(in_features // group_size, pack_num)
+    base_width = make_divisible(base_width, size_multiplier) * size_multiplier
+    return base_width
+
+
+def pack_intweight(unpacked_qweight, interleave, kstride):
+    # unpacked_qweight: [N, K]
+    N = unpacked_qweight.shape[0]
+    K = unpacked_qweight.shape[1]
+
+    Packed_Kernel = unpacked_qweight.cpu().numpy().reshape(N, K // 32, 32)
+    # np.arange(32).reshape(4, 4, 2).transpose(1, 0, 2) => [0, 1, 8, 9, 16, 17, 24, 25, ...]
+    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 4, 4, 2).transpose(0, 1, 3, 2, 4)
+    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 32)
+
+    # reorder each 8 weights for fast dequantization
+    # [0, 1, 2, 3, 4, 5, 6, 7] => [0, 2, 4, 6, 1, 3, 5, 7]
+    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 4, 8)
+    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 4, 4, 2).transpose(0, 1, 2, 4, 3)
+    Packed_Kernel = Packed_Kernel.reshape(N, K)
+
+    # interleaving every four rows
+    Packed_Kernel = Packed_Kernel.reshape(
+        N // interleave, interleave, K // kstride, kstride
+    )
+    # N // 4, K // 64, 4, 64
+    Packed_Kernel = Packed_Kernel.transpose(0, 2, 1, 3)
+    Packed_Kernel = Packed_Kernel.reshape(
+        N // interleave, K // kstride, kstride, interleave
+    )
+    # Packing -> (N // 4, K // 64, 64)
+    Packed_Kernel = (
+        Packed_Kernel[..., 0]
+        | (Packed_Kernel[..., 1] << 4)
+        | (Packed_Kernel[..., 2] << 8)
+        | (Packed_Kernel[..., 3] << 12)
+    )
+    # reshape to (N // 4, K), FP16 format
+    Packed_Kernel = Packed_Kernel.reshape(N // interleave, K)
+    qweight = (
+        torch.tensor(Packed_Kernel.astype("int16"))
+        .to(unpacked_qweight.device)
+        .contiguous()
+    )
+    return qweight
+
+
+class ScaledActivation(nn.Module):
+    def __init__(self, module, scales):
+        super().__init__()
+        self.act = module
+        self.scales = nn.Parameter(scales.data)
+
+    def forward(self, x):
+        return self.act(x) / self.scales.view(1, 1, -1).to(x.device)
+
+
+class WQLinear(nn.Module):
+    def __init__(self, w_bit, group_size, in_features, out_features, bias, dev, dtype=torch.float16):
+        super().__init__()
+
+        if w_bit not in [4]:
+            raise NotImplementedError("Only 4-bit are supported for now.")
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.w_bit = w_bit
+        self.group_size = group_size if group_size != -1 else in_features
+        self.split_k_iters = 8
+        self.interleave = 4
+        # quick sanity check (make sure aligment)
+        assert self.in_features % self.group_size == 0
+        assert out_features % (32 // self.w_bit) == 0
+        pack_num = 32 // self.w_bit
+        int16_pack_num = 16 // self.w_bit
+
+        assert out_features % (self.interleave) == 0
+        self.register_buffer(
+            "qweight",
+            torch.zeros(
+                (
+                    out_features // self.interleave,
+                    in_features // int16_pack_num * self.interleave,
+                ),
+                dtype=torch.int16,
+                device=dev,
+            ),
+        )
+        self.register_buffer(
+            "scales",
+            torch.zeros(
+                (
+                    calculate_zeros_width(in_features, self.group_size) * pack_num,
+                    out_features,
+                ),
+                dtype=dtype,
+                device=dev,
+            ),
+        )
+        self.register_buffer(
+            "scaled_zeros",
+            torch.zeros(
+                (
+                    calculate_zeros_width(in_features, self.group_size) * pack_num,
+                    out_features,
+                ),
+                dtype=dtype,
+                device=dev,
+            ),
+        )
+
+        if bias:
+            self.register_buffer(
+                "bias", torch.zeros((out_features), dtype=dtype, device=dev)
+            )
+        else:
+            self.bias = None
+
+    @classmethod
+    def from_linear(
+        cls, linear, w_bit, group_size, init_only=False, scales=None, zeros=None
+    ):
+        awq_linear = cls(
+            w_bit,
+            group_size,
+            linear.in_features,
+            linear.out_features,
+            linear.bias is not None,
+            linear.weight.device,
+            dtype=linear.weight.data.dtype
+        )
+        if init_only:  # just prepare for loading sd
+            return awq_linear
+
+        # need scales and zeros info for real quantization
+        assert scales is not None and zeros is not None
+        scale_zeros = zeros * scales
+
+        dtype = scales.dtype
+
+        pack_num = 32 // awq_linear.w_bit
+        qscales = torch.zeros(
+            (
+                scales.shape[0],
+                calculate_zeros_width(linear.in_features, group_size) * pack_num,
+            ),
+            dtype=dtype,
+            device=scales.device,
+        )
+        qscales[:, : scales.shape[1]] = scales
+        # awq_linear.scales = scales.clone().half()
+        awq_linear.scales = qscales.transpose(1, 0).contiguous()
+        if linear.bias is not None:
+            awq_linear.bias = linear.bias.clone().to(dtype)
+
+        intweight = []
+        for idx in range(awq_linear.in_features):
+            intweight.append(
+                torch.round(
+                    (linear.weight.data[:, idx] + scale_zeros[:, idx // group_size])
+                    / qscales[:, idx // group_size]
+                ).to(torch.int)[:, None]
+            )
+        intweight = torch.cat(intweight, dim=1)
+        # intweight = intweight.t().contiguous()
+        intweight = intweight.to(dtype=torch.int32)
+        awq_linear.qweight = pack_intweight(
+            intweight.contiguous(), interleave=4, kstride=64
+        )
+
+        zeros = zeros.to(dtype=torch.int32)
+        scaled_zeros = torch.zeros_like(qscales)
+        # scaled_zeros[:, :scales.shape[1]] = -(qscales[:, :scales.shape[1]] * (zeros.to(torch.float32) - 8.0)).to(torch.float16)
+        scaled_zeros[:, : scales.shape[1]] = -(
+            qscales[:, : scales.shape[1]] * (zeros.to(torch.float32))
+        ).to(dtype)
+        awq_linear.scaled_zeros = scaled_zeros.transpose(1, 0).contiguous()
+
+        return awq_linear
+
+    @torch.no_grad()
+    def forward(self, x):
+        # out_shape = x.shape[:-1] + (self.out_features,)
+        # inputs = x.reshape(-1, x.shape[-1])
+        inputs = x
+        if inputs.numel() / inputs.shape[-1] < 8:
+            out = awq_inference_engine.gemv_forward_cuda_new(
+                inputs,
+                self.qweight,
+                self.scales,
+                self.scaled_zeros,
+                inputs.numel() // inputs.shape[-1],
+                self.out_features,
+                self.in_features,
+                self.group_size,
+            )
+        else:
+            out = awq_inference_engine.gemm_forward_cuda_new(
+                inputs, self.qweight, self.scales, self.scaled_zeros
+            )  # - 8.0 * self.scales)
+        out = out + self.bias if self.bias is not None else out
+        # print(out)
+        # assert 0
+        return out
+
+    def extra_repr(self) -> str:
+        return (
+            "in_features={}, out_features={}, bias={}, w_bit={}, group_size={}".format(
+                self.in_features,
+                self.out_features,
+                self.bias is not None,
+                self.w_bit,
+                self.group_size,
+            )
+        )
diff --git a/llm-awq/awq/quantize/w8a8_linear.py b/llm-awq/awq/quantize/w8a8_linear.py
new file mode 100644
index 0000000000000000000000000000000000000000..b733a1d5974ef2b3c2f3650f32d4d5dd95d32e1e
--- /dev/null
+++ b/llm-awq/awq/quantize/w8a8_linear.py
@@ -0,0 +1,276 @@
+# Adapted from qserve (https://github.com/mit-han-lab/qserve/tree/main) and modified by Yuming Lou
+
+
+from typing import Optional, Union
+from torch.nn import Parameter
+import awq_inference_engine
+import torch
+import gc
+from awq.utils.module import set_op_by_name
+from tqdm import tqdm
+
+
+class W8A8OF16LinearStaticScale(torch.nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        bias: bool = True,
+        scale: Union[torch.tensor, float] = 1.0,
+        params_dtype: Optional[torch.dtype] = None,
+    ):
+        super().__init__()
+
+        # Keep input parameters
+        self.in_features = in_features
+        self.out_features = out_features
+        # size [1] or size [oc]
+        self.register_buffer(
+            "dequant_scale", torch.ones(out_features, dtype=torch.half)
+        )
+        # Parameters.
+        # NOTE: torch.nn.functional.linear performs XA^T + b and as a result
+        # we allocate the transpose.
+        self.create_weights()
+
+        if bias:
+            self.bias = torch.empty(
+                self.out_features,
+                device=torch.cuda.current_device(),
+                dtype=torch.float16,
+            )
+        else:
+            self.register_parameter("bias", None)
+
+    def create_weights(self) -> None:
+        self.register_buffer(
+            "weight",
+            torch.empty(
+                self.out_features,
+                self.in_features,
+                dtype=torch.int8,
+                requires_grad=False,
+            ),
+        )
+
+    def apply_weights(
+        self,
+        x: torch.Tensor,
+        bias: Optional[torch.Tensor],
+    ) -> torch.Tensor:
+        raise NotImplementedError
+
+    def forward(self, input_):
+        # Matrix multiply.
+        output = self.apply_weights(input_, self.bias)
+        output_bias = self.bias
+        return output, output_bias
+
+
+class W8A8OF16LinearDynamicInputScale(W8A8OF16LinearStaticScale):
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        bias: bool = True,
+        scale: Union[torch.tensor, float] = 1.0,
+        params_dtype: Optional[torch.dtype] = None,
+    ):            
+        super().__init__(
+            in_features=in_features,
+            out_features=out_features,
+            bias=bias,
+            scale=scale,
+            params_dtype=params_dtype,
+        )
+        if bias:
+            self.apply_weights = self.apply_weights_bias
+        else:
+            self.apply_weights = self.apply_weights_no_bias
+    
+    #W bias. Fused bias and W8A8 GEMM
+    def apply_weights_bias(
+        self,
+        # [batch, tokens, channels]
+        x: torch.Tensor,
+        # [batch * tokens]
+        input_scale: torch.Tensor,
+        output_buffer: torch.Tensor,
+        bias: torch.Tensor = None,
+    ):
+        x_shape = x.shape
+        if len(x.shape) > 2:
+            assert 0, "Not implemented"
+            x = x.view(-1, x_shape[-1])
+        # If use awq_inference_engine.w8a8_gemm_fuse_bias_forward_cuda
+        awq_inference_engine.w8a8_gemm_fuse_bias_forward_cuda(
+        x, self.weight, self.dequant_scale, input_scale, output_buffer, bias
+        )                    
+        if len(x.shape) > 2:
+            assert 0, "Not implemented 2"
+            output_buffer = output_buffer.view(*x_shape[:-1], -1)
+    
+    #W/H bias. W8A8 GEMM
+    def apply_weights_no_bias(
+            self,
+            # [batch, tokens, channels]
+            x: torch.Tensor,
+            # [batch * tokens]
+            input_scale: torch.Tensor,
+            output_buffer: torch.Tensor,
+            bias: torch.Tensor = None,
+        ):
+            x_shape = x.shape
+            if len(x.shape) > 2:
+                assert 0, "Not implemented"
+                x = x.view(-1, x_shape[-1])
+            # If use awq_inference_engine.w8a8_gemm_forward_cuda
+            awq_inference_engine.w8a8_gemm_forward_cuda(
+                x, self.weight, self.dequant_scale, input_scale, output_buffer
+            )
+            if len(x.shape) > 2:
+                assert 0, "Not implemented 2"
+                output_buffer = output_buffer.view(*x_shape[:-1], -1)
+
+    def forward(self, input_, input_scale, output_buffer):
+        # Matrix multiply.
+        self.apply_weights(input_, input_scale, output_buffer, self.bias)
+
+    @classmethod
+    def from_linear(
+        cls,
+        linear,
+        init_only=False,
+        s1_scale=None,
+        fc1=False,
+    ):
+        q_linear = cls(
+            linear.in_features,
+            linear.out_features,
+            linear.bias is not None,
+        )
+        if init_only:  # just prepare for loading sd
+            return q_linear
+        if s1_scale is None:
+            s1_scale, _ = torch.max(abs(linear.weight.data), dim=-1, keepdim=True)
+            s1_scale = s1_scale.clamp_(min=1e-5).div_(127)
+
+        if linear.bias is not None:
+            q_linear.bias = linear.bias.clone().half().contiguous().cuda()
+        ## Quantize the weights
+        # ---- Quantize the weights to int8 ---- #
+        linear_weight = linear.weight.data  # OC, IC
+        linear_weight = linear_weight.div_(s1_scale.to(linear_weight.device))
+        linear_weight = linear_weight.round_().to(torch.int8)
+            
+        q_linear.weight.data[:, :] = linear_weight.half().contiguous().cuda()
+
+        # ---- Pack the scales ---- #
+        q_linear.dequant_scale.data[:] = (
+            s1_scale.reshape(-1).half().contiguous().cuda()
+        )
+        return q_linear.cuda()
+
+    @classmethod
+    def from_qkv(
+        cls,
+        q,
+        k,
+        v,
+        init_only=False,
+        s1_scale=None,
+    ):
+        q_linear = cls(
+            q.in_features,
+            q.out_features + k.out_features + v.out_features,
+            q.bias is not None,
+        )
+        if init_only:  # just prepare for loading sd
+            return q_linear
+        weight = torch.cat([q.weight.data, k.weight.data, v.weight.data], dim=0)
+
+        if s1_scale is None:
+            s1_scale, _ = torch.max(abs(weight), dim=-1, keepdim=True)
+            s1_scale = s1_scale.clamp_(min=1e-5).div_(127)
+
+        if q.bias is not None:
+            bias = torch.cat([q.bias, k.bias, v.bias], dim=0)
+            q_linear.bias = bias.clone().half().contiguous().cuda()
+        # ---- Quantize the weights to int8 ---- #
+        weight = weight.div_(s1_scale.to(weight.device))
+        weight = weight.round_().to(torch.int8)
+
+        q_linear.weight.data[:, :] = weight.contiguous().cuda()
+
+        # ---- Pack the scales ---- #
+        q_linear.dequant_scale.data[:] = (
+            s1_scale.reshape(q.out_features + k.out_features + v.out_features)
+            .half()
+            .contiguous().cuda()
+        )
+        return q_linear.cuda()
+
+
+class FakeW8A8Linear(torch.nn.Module):
+    def __init__(
+        self, in_features: int, out_features: int, bias: bool = True, wbit: int = 8
+    ):
+        super().__init__()
+        self.weight = torch.nn.Parameter(
+            torch.empty(out_features, in_features, dtype=torch.half)
+        )
+        if bias:
+            self.bias = torch.nn.Parameter(
+                torch.empty(1, out_features, dtype=torch.half)
+            )
+        else:
+            self.bias = None
+        self.wbit = wbit
+        self.maxv = 2 ** (wbit - 1) - 1
+
+    def forward(self, input):
+        t_shape = input.shape
+        input.view(-1, t_shape[-1])
+        scales = input.abs().max(dim=-1, keepdim=True)[0]
+        scales.clamp_(min=1e-5).div_(self.maxv)
+        input.div_(scales).round_().mul_(scales)
+        output = torch.functional.F.linear(input, self.weight, self.bias)
+        return output
+
+    @classmethod
+    def from_linear(cls, linear: torch.nn.Linear, wbit=8):
+        fake_linear = cls(
+            linear.in_features, linear.out_features, linear.bias is not None, wbit
+        )
+        maxv = 2 ** (wbit - 1) - 1
+        scale = (
+            torch.max(abs(linear.weight.data.detach()), -1, keepdim=True)[0]
+            .clamp_(min=1e-5)
+            .div_(maxv)
+        )
+        weight = linear.weight.data / scale
+        weight = weight.round_()
+        weight = weight * scale
+        fake_linear.weight.copy_(weight.contiguous())
+        if linear.bias is not None:
+            fake_linear.bias.copy_(
+                linear.bias.detach().half().reshape(1, linear.out_features).contiguous()
+            )
+        else:
+            linear.bias = None
+        del linear, scale, weight
+        torch.cuda.empty_cache()
+        return fake_linear
+
+
+def fake_quant(model, wbit=8):
+    for name, m in tqdm(
+        model.named_modules(),
+        desc="Fake quantizing",
+        total=len(list(model.named_modules())),
+    ):
+        if isinstance(m, torch.nn.Linear):
+            FQlinear = FakeW8A8Linear.from_linear(m, wbit)
+            del m
+            torch.cuda.empty_cache()
+            set_op_by_name(model, name, FQlinear)
diff --git a/llm-awq/awq/utils/lm_eval_adaptor.py b/llm-awq/awq/utils/lm_eval_adaptor.py
new file mode 100644
index 0000000000000000000000000000000000000000..8115702971b44876dcf237b92b6a34d8cd93a5f4
--- /dev/null
+++ b/llm-awq/awq/utils/lm_eval_adaptor.py
@@ -0,0 +1,116 @@
+import transformers
+import torch
+from lm_eval.base import BaseLM
+import fnmatch
+
+
+class LMEvalAdaptor(BaseLM):
+    def __init__(self, model_name, model, tokenizer, batch_size=1, max_length=-1):
+        super().__init__()
+
+        assert isinstance(batch_size, int)
+
+        self.model_name = model_name
+        self.model = model
+        self.model.eval()
+
+        self.tokenizer = tokenizer
+
+        # assert isinstance(self.tokenizer, (
+        #     transformers.GPT2Tokenizer, transformers.GPT2TokenizerFast,
+        #     transformers.T5Tokenizer, transformers.T5TokenizerFast,
+        # )), "this tokenizer has not been checked for compatibility yet!"
+
+        self.vocab_size = self.tokenizer.vocab_size
+
+        self._batch_size = batch_size
+
+        self._max_length = max_length
+
+    @property
+    def eot_token_id(self):
+        # we use EOT because end of *text* is more accurate for what we're doing than end of *sentence*
+        return self.tokenizer.eos_token_id
+
+    @property
+    def max_length(self):
+        if self._max_length != -1:
+            return self._max_length
+        if hasattr(self.model.config, "n_ctx"):
+            return self.model.config.n_ctx
+        elif hasattr(self.model.config, "max_position_embeddings"):
+            return self.model.config.max_position_embeddings
+        elif hasattr(self.model.config, "n_positions"):
+            return self.model.config.n_positions
+        elif "bloom" in self.model_name:
+            return 2048
+        elif "llama" in self.model_name:
+            return 2048  # TODO: did not check this
+        elif "mpt" in self.model_name:
+            return 2048
+        elif "falcon" in self.model_name:
+            return 2048
+        else:
+            print(self.model.config)
+            raise NotImplementedError
+
+    @property
+    def max_gen_toks(self):
+        return 256
+
+    @property
+    def batch_size(self):
+        return self._batch_size
+
+    @property
+    def device(self):
+        return "cuda"
+
+    def tok_encode(self, string: str):
+        return self.tokenizer.encode(string, add_special_tokens=False)
+
+    def tok_decode(self, tokens):
+        return self.tokenizer.decode(tokens)
+
+    def _model_call(self, inps):
+        """
+        inps: a torch tensor of shape [batch, sequence]
+        the size of sequence may vary from call to call
+
+        returns: a torch tensor of shape [batch, sequence, vocab] with the
+        logits returned from the model
+        """
+        with torch.no_grad():
+            if isinstance(
+                self.model,
+                transformers.models.t5.modeling_t5.T5ForConditionalGeneration,
+            ):
+                dec_inps = torch.cat(
+                    [
+                        torch.tensor(
+                            self.model.generation_config.decoder_start_token_id,
+                        )
+                        .tile(len(inps), 1)
+                        .to(inps),
+                        inps,
+                    ],
+                    dim=1,
+                )
+
+                kwargs = {
+                    "decoder_input_ids": dec_inps,
+                }
+            else:
+                kwargs = {}
+            out = self.model(inps, **kwargs)[0]
+            if (
+                "opt" in self.model_name
+            ):  # there are a few extra tokens in opt, which we should omit
+                return out[:, :, :50257]
+            else:
+                return out  # [:, :, :self.tokenizer.vocab_size]
+
+    def _model_generate(self, context, max_length, eos_token_id):
+        return self.model.generate(
+            context, max_length=max_length, eos_token_id=eos_token_id, do_sample=False
+        )
diff --git a/llm-awq/awq/utils/utils.py b/llm-awq/awq/utils/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..708e62edd897c7f8264c8fdc0abe883528aea4a9
--- /dev/null
+++ b/llm-awq/awq/utils/utils.py
@@ -0,0 +1,51 @@
+import torch
+import accelerate
+
+
+def get_module_by_name_suffix(model, module_name: str):
+    for name, module in model.named_modules():
+        if name.endswith(module_name):
+            return module
+
+
+def simple_dispatch_model(model, device_map):
+    from accelerate.hooks import add_hook_to_module, AlignDevicesHook
+
+    if "" in device_map:
+        d = device_map[""]
+        model = model.to(torch.device(d))
+        model.hf_device_map = device_map
+        return model
+
+    tied_params = accelerate.utils.modeling.find_tied_parameters(model)
+    if set(device_map.values()) == {"cpu"} or set(device_map.values()) == {
+        "cpu",
+        "disk",
+    }:
+        main_device = "cpu"
+    else:
+        main_device = [d for d in device_map.values() if d not in ["cpu", "disk"]][0]
+
+    cpu_offload_group = [(n, d) for n, d in device_map.items() if d == "cpu"]
+    prev_hook = None
+    for idx, (n, d) in enumerate(cpu_offload_group):
+        m = get_module_by_name_suffix(model, n)
+        _, prev_hook = accelerate.cpu_offload_with_hook(
+            m, execution_device=main_device, prev_module_hook=prev_hook
+        )
+    # set first cpu offload module's prev_module_hook to the last cpu offload module's hook
+    if len(cpu_offload_group) > 1:
+        get_module_by_name_suffix(
+            model, cpu_offload_group[0][0]
+        )._hf_hook.prev_module_hook = prev_hook
+
+    for n, d in device_map.items():
+        m = get_module_by_name_suffix(model, n)
+        if d != "cpu":
+            d = torch.device(d)
+            hook = AlignDevicesHook(d, io_same_device=True, place_submodules=True)
+            add_hook_to_module(m, hook)
+    accelerate.utils.modeling.retie_parameters(model, tied_params)
+    model.hf_device_map = device_map
+
+    return model
diff --git a/llm-awq/examples/convert_to_hf.py b/llm-awq/examples/convert_to_hf.py
new file mode 100644
index 0000000000000000000000000000000000000000..64f8335cb1b8990830c4583c237226e8e366f404
--- /dev/null
+++ b/llm-awq/examples/convert_to_hf.py
@@ -0,0 +1,69 @@
+# This script demonstrates how you can convert your model into HF format
+# easily and push the quantized weights on the Hub using simple tools.
+# Make sure to have transformers > 4.34 and that you have ran
+# `huggingface-cli login` on your terminal before running this
+# script
+import os
+import argparse
+
+# This demo only support single GPU for now
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
+from transformers import AutoConfig, AwqConfig, AutoTokenizer
+from huggingface_hub import HfApi
+
+api = HfApi()
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--model_path", type=str, help="path of the original hf model", required=True
+)
+parser.add_argument(
+    "--quantized_model_path",
+    type=str,
+    help="path of the quantized AWQ model",
+    required=True,
+)
+parser.add_argument(
+    "--quantized_model_hub_path",
+    type=str,
+    help="path of the quantized AWQ model to push on the Hub",
+    required=True,
+)
+parser.add_argument("--w_bit", type=int, default=4, help="")
+parser.add_argument("--q_group_size", default=128, type=int)
+parser.add_argument("--no_zero_point", action="store_true")
+
+args = parser.parse_args()
+
+original_model_path = args.model_path
+quantized_model_path = args.quantized_model_path
+quantized_model_hub_path = args.quantized_model_hub_path
+
+# Load the corresponding AWQConfig
+quantization_config = AwqConfig(
+    bits=args.w_bit,
+    group_size=args.q_group_size,
+    zero_point=not args.no_zero_point,
+    backend="llm-awq",
+    version="gemv",
+)
+
+# Set the attribute `quantization_config` in model's config
+config = AutoConfig.from_pretrained(original_model_path)
+config.quantization_config = quantization_config
+
+# Load tokenizer
+tok = AutoTokenizer.from_pretrained(original_model_path)
+
+# Push config and tokenizer
+config.push_to_hub(quantized_model_hub_path)
+tok.push_to_hub(quantized_model_hub_path)
+
+# Upload model weights
+api.upload_file(
+    path_or_fileobj=quantized_model_path,
+    path_in_repo="pytorch_model.bin",
+    repo_id=quantized_model_hub_path,
+    repo_type="model",
+)
diff --git a/llm-awq/examples/llava_demo.ipynb b/llm-awq/examples/llava_demo.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3302ae3f0bdb77546cb454ad1703f06461a1e365
--- /dev/null
+++ b/llm-awq/examples/llava_demo.ipynb
@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AWQ on LLaVA"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this notebook, we use LLaVA model to demonstrate the performance of AWQ on multi-modal models. We implement AWQ real-INT4 inference kernels, which are wrapped as Pytorch modules and can be easily used by existing models. We also provide a simple example to show how to use AWQ to quantize a model and save/load the quantized model checkpoint."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In order to run this notebook, you need to install the following packages:\n",
+    "- [AWQ](https://github.com/mit-han-lab/llm-awq)\n",
+    "- [Pytorch](https://pytorch.org/)\n",
+    "- [Accelerate](https://github.com/huggingface/accelerate)\n",
+    "- [LLaVA](https://github.com/haotian-liu/LLaVA)\n",
+    "- [Transformers](https://github.com/huggingface/transformers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import numpy as np\n",
+    "\n",
+    "from PIL import Image\n",
+    "import gc\n",
+    "import requests\n",
+    "from io import BytesIO\n",
+    "\n",
+    "from transformers import AutoConfig, AutoTokenizer\n",
+    "from accelerate import load_checkpoint_and_dispatch\n",
+    "\n",
+    "from awq.quantize.pre_quant import run_awq, apply_awq\n",
+    "from awq.quantize.quantizer import real_quantize_model_weight\n",
+    "\n",
+    "from tinychat.utils.load_quant import load_awq_model\n",
+    "from tinychat.utils.tune import device_warmup, tune_all_wqlinears\n",
+    "from tinychat.utils.prompt_templates import get_prompter, get_stop_token_ids\n",
+    "from tinychat.utils.llava_image_processing import process_images, load_image\n",
+    "from tinychat.models.llava_llama import LlavaLlamaForCausalLM\n",
+    "from tinychat.stream_generators.llava_stream_gen import LlavaStreamGenerator\n",
+    "from tinychat.modules import make_quant_norm, make_quant_attn, make_fused_mlp, make_fused_vision_attn\n",
+    "\n",
+    "import os\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
+    "# This demo only support single GPU for now\n",
+    "\n",
+    "model_path = \"/dataset/llava/llava-v1.5-7b\"  # Please change here \n",
+    "quant_path = \"../quant_cache/llava-v1.5-7b-w4-g128-awq.pt\"  # place to dump quant weights\n",
+    "\n",
+    "device = \"cuda\""
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Please get the LLaVA model from [LLaVA](https://github.com/haotian-liu/LLaVA) and run the following cell to generate a quantized model checkpoint first (note that we only quantize the language decoder, which dominates the model parameter as well as **the generation speed**). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:04<00:00,  2.48s/it]\n",
+      "real weight quantization...: 100%|██████████| 32/32 [02:41<00:00,  5.05s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Skip this part if the quantized checkpoints are ready.\n",
+    "\n",
+    "from llava.model import LlavaLlamaForCausalLM as LlavaLlamaForCausalLMFP16\n",
+    "model = LlavaLlamaForCausalLMFP16.from_pretrained(model_path, low_cpu_mem_usage=True, torch_dtype=torch.float16, use_cache=True).cuda()\n",
+    "\n",
+    "awq_results = torch.load(\"../awq_cache/llava-v1.5-7b-w4-g128.pt\", map_location=\"cpu\")  # Please change here \n",
+    "apply_awq(model, awq_results)\n",
+    "\n",
+    "real_quantize_model_weight(model, w_bit=4, q_config={\"zero_point\": True, \"q_group_size\": 128})\n",
+    "torch.save(model.cpu().state_dict(), quant_path)\n",
+    "\n",
+    "del model\n",
+    "gc.collect()\n",
+    "torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then load the quantized llava model. We first initialize an empty model and replace all the linear layers with WQLinear layers. After that, we load the quantized weights from the checkpoint. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "real weight quantization...(init only): 100%|██████████| 32/32 [00:00<00:00, 79.31it/s] \n",
+      "Loading checkpoint: 100%|██████████| 1/1 [00:01<00:00,  1.78s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def skip(*args, **kwargs):\n",
+    "    pass\n",
+    "    \n",
+    "# Accelerate model initialization\n",
+    "setattr(torch.nn.Linear, \"reset_parameters\", lambda self: None)\n",
+    "setattr(torch.nn.LayerNorm, \"reset_parameters\", lambda self: None)\n",
+    "torch.nn.init.kaiming_uniform_ = skip\n",
+    "torch.nn.init.kaiming_normal_ = skip\n",
+    "torch.nn.init.uniform_ = skip\n",
+    "torch.nn.init.normal_ = skip\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False)\n",
+    "config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)\n",
+    "model = LlavaLlamaForCausalLM(config, device).half() \n",
+    "\n",
+    "# load the vision_tower\n",
+    "vision_tower = model.get_model().vision_tower\n",
+    "if not vision_tower.is_loaded:\n",
+    "    vision_tower.load_model()\n",
+    "image_processor = vision_tower.image_processor\n",
+    "\n",
+    "# load quantized model\n",
+    "model = load_awq_model(model, quant_path, 4, 128, device)\n",
+    "\n",
+    "# optimize for inference speed\n",
+    "make_quant_attn(model, device)\n",
+    "make_quant_norm(model)\n",
+    "make_fused_mlp(model)\n",
+    "model = model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, let's define the configurations for the conversation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Conversation parameters\n",
+    "from attributedict.collections import AttributeDict\n",
+    "gen_params = AttributeDict(\n",
+    "    [\n",
+    "        (\"seed\", -1),  # RNG seed\n",
+    "        (\"n_threads\", 1),  # TODO: fix this\n",
+    "        (\"n_predict\", 512),  # new tokens to predict\n",
+    "        (\"n_parts\", -1),  # amount of model parts (-1: determine from model dimensions)\n",
+    "        (\"n_ctx\", 512),  # context size\n",
+    "        (\"n_batch\", 512),  # batch size for prompt processing (must be >=32 to use BLAS)\n",
+    "        (\"n_keep\", 0),  # number of tokens to keep from initial prompt\n",
+    "        (\"n_vocab\", 50272),  # vocabulary size\n",
+    "        # sampling parameters\n",
+    "        (\"logit_bias\", dict()),  # logit bias for specific tokens: <int, float>\n",
+    "        (\"top_k\", 40),  # <= 0 to use vocab size\n",
+    "        (\"top_p\", 0.95),  # 1.0 = disabled\n",
+    "        (\"tfs_z\", 1.00),  # 1.0 = disabled\n",
+    "        (\"typical_p\", 1.00),  # 1.0 = disabled\n",
+    "        (\"temp\", 0.20),  # 1.0 = disabled\n",
+    "        (\"repeat_penalty\", 1.10),  # 1.0 = disabled\n",
+    "        (\n",
+    "            \"repeat_last_n\",\n",
+    "            64,\n",
+    "        ),  # last n tokens to penalize (0 = disable penalty, -1 = context size)\n",
+    "        (\"frequency_penalty\", 0.00),  # 0.0 = disabled\n",
+    "        (\"presence_penalty\", 0.00),  # 0.0 = disabled\n",
+    "        (\"mirostat\", 0),  # 0 = disabled, 1 = mirostat, 2 = mirostat 2.0\n",
+    "        (\"mirostat_tau\", 5.00),  # target entropy\n",
+    "        (\"mirostat_eta\", 0.10),  # learning rate\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We add the output streamer to manage the generation process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stream_output(output_stream):\n",
+    "    print(f\"ASSISTANT: \", end=\"\", flush=True)\n",
+    "    pre = 0\n",
+    "    for outputs in output_stream:\n",
+    "        output_text = outputs[\"text\"]\n",
+    "        output_text = output_text.strip().split(\" \")\n",
+    "        now = len(output_text) - 1\n",
+    "        if now > pre:\n",
+    "            print(\" \".join(output_text[pre:now]), end=\" \", flush=True)\n",
+    "            pre = now\n",
+    "    print(\" \".join(output_text[pre:]), flush=True)\n",
+    "    if \"timing\" in outputs and outputs[\"timing\"] is not None:\n",
+    "        timing = outputs[\"timing\"]\n",
+    "        context_tokens = timing[\"context_tokens\"]\n",
+    "        context_time = timing[\"context_time\"]\n",
+    "        total_tokens = timing[\"total_tokens\"]\n",
+    "        generation_time_list = timing[\"generation_time_list\"]\n",
+    "        generation_tokens = len(generation_time_list)\n",
+    "        average_speed = (context_time + np.sum(generation_time_list)) / (\n",
+    "            context_tokens + generation_tokens\n",
+    "        )\n",
+    "        print(\"=\" * 50)\n",
+    "        print(\"Speed of Inference\")\n",
+    "        print(\"-\" * 50)\n",
+    "        print(\n",
+    "            f\"Generation Stage : {np.average(generation_time_list) * 1000:.2f} ms/token\"\n",
+    "        )\n",
+    "        print(\"=\" * 50)\n",
+    "    return \" \".join(output_text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then input a image link and a question below.\n",
+    "\n",
+    "## Q: What is unusual about this image?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "query = \"What is unusual about this image?\"\n",
+    "image_file = \"https://llava.hliu.cc/file=/nobackup/haotian/code/LLaVA/llava/serve/examples/extreme_ironing.jpg\" \n",
+    "\n",
+    "def load_image(image_file):\n",
+    "    if image_file.startswith('http') or image_file.startswith('https'):\n",
+    "        response = requests.get(image_file)\n",
+    "        image = Image.open(BytesIO(response.content)).convert('RGB')\n",
+    "    else:\n",
+    "        image = Image.open(image_file).convert('RGB')\n",
+    "    return image\n",
+    "\n",
+    "# show the image\n",
+    "import matplotlib.pyplot as plt\n",
+    "image = load_image(image_file)\n",
+    "plt.imshow(image)\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "# preprocess the image tensor\n",
+    "image_tensor = process_images([image], image_processor, model.config)\n",
+    "if type(image_tensor) is list:\n",
+    "    image_tensor = [image.to(device, dtype=torch.float16) for image in image_tensor]\n",
+    "else:\n",
+    "    image_tensor = image_tensor.to(device, dtype=torch.float16)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we can use the model for generation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "USER: What is unusual about this image?\n",
+      "ASSISTANT: In this image, what is unusual is that a man is sitting on top of a clothes drying rack attached to the back of a yellow SUV taxi. This is not a typical sight on city streets, as people usually do not use their vehicles as makeshift clothes drying racks or transportation for such purposes. It appears that the man has chosen to dry his clothes in public while traveling in his taxi, which adds an unconventional element to the scene.\n",
+      "==================================================\n",
+      "Speed of Inference\n",
+      "--------------------------------------------------\n",
+      "Generation Stage : 7.56 ms/token\n",
+      "==================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "stream_generator = LlavaStreamGenerator\n",
+    "\n",
+    "model_prompter = get_prompter('llama', model_path, short_prompt=False)\n",
+    "stop_token_ids = get_stop_token_ids('llama', model_path)\n",
+    "\n",
+    "print(f\"USER: {query}\")\n",
+    "# Insert image token\n",
+    "model_prompter.insert_prompt(\"<image>\\n\" + query)\n",
+    "output_stream = stream_generator(\n",
+    "    model,\n",
+    "    tokenizer,\n",
+    "    model_prompter.model_input,\n",
+    "    gen_params,\n",
+    "    device=device,\n",
+    "    stop_token_ids=stop_token_ids,\n",
+    "    image_tensor=image_tensor,\n",
+    ")\n",
+    "outputs = stream_output(output_stream)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.17"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/llm-awq/figures/vila-logo.jpg b/llm-awq/figures/vila-logo.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..18a79eab327acdd98bf19d0b254c036381f5fc97
Binary files /dev/null and b/llm-awq/figures/vila-logo.jpg differ
diff --git a/llm-awq/scripts/codellama_example.sh b/llm-awq/scripts/codellama_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..6c5375f2553894095b40a2292a0f1f63657333b3
--- /dev/null
+++ b/llm-awq/scripts/codellama_example.sh
@@ -0,0 +1,25 @@
+MODEL=CodeLlama-13b-Instruct
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/codellama-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/codellama-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/codellama-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/codellama-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
\ No newline at end of file
diff --git a/llm-awq/scripts/llama2_example.sh b/llm-awq/scripts/llama2_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..dff0a71f9ca3c733b1543dffbed12089b078d50f
--- /dev/null
+++ b/llm-awq/scripts/llama2_example.sh
@@ -0,0 +1,25 @@
+MODEL=llama-2-7b
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/llama2-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/llama2-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/llama2-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/llama2-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
\ No newline at end of file
diff --git a/llm-awq/scripts/llama3_example.sh b/llm-awq/scripts/llama3_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9ee886c7daf887db80ae96746d743d4fd77f1663
--- /dev/null
+++ b/llm-awq/scripts/llama3_example.sh
@@ -0,0 +1,25 @@
+MODEL=llama3-8b
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/models/llama3/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/models/llama3/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/models/llama3/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/models/llama3/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
\ No newline at end of file
diff --git a/llm-awq/scripts/llama_example.sh b/llm-awq/scripts/llama_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..3cec08cdada964a193399d0a00f82cf51ebbb613
--- /dev/null
+++ b/llm-awq/scripts/llama_example.sh
@@ -0,0 +1,25 @@
+MODEL=llama-7b
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/llama-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/llama-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/llama-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/llama-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
\ No newline at end of file
diff --git a/llm-awq/scripts/opt_example.sh b/llm-awq/scripts/opt_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..76c8d77fbfd487d670447bb4479f3fd40d155b2e
--- /dev/null
+++ b/llm-awq/scripts/opt_example.sh
@@ -0,0 +1,25 @@
+MODEL=opt-6.7b
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/opt/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/opt/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/opt/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/opt/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
\ No newline at end of file
diff --git a/llm-awq/scripts/qwen_example.sh b/llm-awq/scripts/qwen_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..3178b30d20df281590b88a8d07ce5c7f59d25790
--- /dev/null
+++ b/llm-awq/scripts/qwen_example.sh
@@ -0,0 +1,25 @@
+MODEL=qwen2.5-7b
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/models/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/models/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/models/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/models/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
diff --git a/llm-awq/scripts/starcoder_example.sh b/llm-awq/scripts/starcoder_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b176cd0723b6587bf497e492de05a8ee58b4aed5
--- /dev/null
+++ b/llm-awq/scripts/starcoder_example.sh
@@ -0,0 +1,25 @@
+MODEL=starcoder
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/starcoder-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/starcoder-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/starcoder-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/starcoder-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
\ No newline at end of file
diff --git a/llm-awq/scripts/vicuna_example.sh b/llm-awq/scripts/vicuna_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b70d4e78453b5f626a80aef748adb41e53942de3
--- /dev/null
+++ b/llm-awq/scripts/vicuna_example.sh
@@ -0,0 +1,25 @@
+MODEL=vicuna-7b
+
+# run AWQ search (optional; we provided the pre-computed results)
+python -m awq.entry --model_path /dataset/vicuna-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --run_awq --dump_awq awq_cache/$MODEL-w4-g128.pt
+
+# evaluate the AWQ quantize model (simulated pseudo quantization)
+python -m awq.entry --model_path /dataset/vicuna-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend fake
+
+# generate real quantized weights (w4)
+python -m awq.entry --model_path /dataset/vicuna-hf/$MODEL \
+    --w_bit 4 --q_group_size 128 \
+    --load_awq awq_cache/$MODEL-w4-g128.pt \
+    --q_backend real --dump_quant quant_cache/$MODEL-w4-g128-awq.pt
+
+# load and evaluate the real quantized model (smaller gpu memory usage)
+python -m awq.entry --model_path /dataset/vicuna-hf/$MODEL \
+    --tasks wikitext \
+    --w_bit 4 --q_group_size 128 \
+    --load_quant quant_cache/$MODEL-w4-g128-awq.pt
\ No newline at end of file
diff --git a/llm-awq/tinychat/benchmark.py b/llm-awq/tinychat/benchmark.py
new file mode 100644
index 0000000000000000000000000000000000000000..e397f10c09be377d9b02d1cf115d60f18ebe5987
--- /dev/null
+++ b/llm-awq/tinychat/benchmark.py
@@ -0,0 +1,379 @@
+# Usage:
+# Please first install awq/kernels
+# then directly run CUDA_VISIBLE_DEVICES=0 python benchmark.py
+import argparse
+import torch
+import time
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig, modeling_utils
+import tinychat.utils.constants
+from tinychat.utils.load_quant import load_awq_model
+from awq.quantize.quantizer import real_quantize_model_weight
+from tinychat.utils.tune import (
+    tune_all_wqlinears,
+    device_warmup,
+    tune_llava_patch_embedding,
+)
+from tinychat.modules import make_quant_norm, make_quant_attn, make_fused_mlp
+
+
+def skip(*args, **kwargs):
+    pass
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_type", type=str, default="LLaMa", help="type of the model"
+    )
+    parser.add_argument(
+        "--model_path",
+        type=str,
+        default="/data/llm/checkpoints/vicuna-hf/vicuna-7b",
+        help="path to the model",
+    )
+    parser.add_argument("--q_group_size", type=int, default=128)
+    parser.add_argument(
+        "--verbose",
+        default=False,
+        action="store_true",
+        help="Wheter to print more information.",
+    )
+    parser.add_argument(
+        "--max_seq_len",
+        type=int,
+        default=8192,
+        help="maximum sequence length for kv cache",
+    )
+    parser.add_argument(
+        "--max_batch_size", type=int, default=1, help="maximum batch size for kv cache"
+    )
+    parser.add_argument(
+        "--flash_attn",
+        action="store_true",
+        help="whether to use flash attention",
+    )
+    parser.add_argument(
+        "--chunk_prefilling",
+        action="store_true",
+        help="If used, in context stage, the history tokens will not be recalculated, greatly speeding up the calculation",
+    )
+    parser.add_argument(
+        "--context_length",
+        type=list,
+        nargs="+",
+        help="The length of input. And if chunk_prefilling used, this serves as the length of tokens from history rounds.",
+    )
+    parser.add_argument(
+        "--question_length",
+        type=list,
+        nargs="+",
+        help="The length of new input. Only useful and necessary when benchmarking chunk_prefilling method",
+    )
+    parser.add_argument(
+        "--precision", type=str, default="W4A16", help="compute precision"
+    )
+    args = parser.parse_args()
+    # some checks
+    assert (args.question_length is not None and args.chunk_prefilling) or (
+        not args.chunk_prefilling
+    ), "If you want to benchmark chunk prefilling, you need specify the question length and context length"
+    assert args.precision in ["W4A16", "W16A16"], "We only support W4A16/W16A16 now"
+    token_num = 256
+    # We support fixing a certain kind of length
+    if args.chunk_prefilling:
+        if len(args.context_length) == 1 and len(args.question_length) > 1:
+            args.context_length = [
+                args.context_length[0] for _ in range(len(args.question_length))
+            ]
+        elif len(args.question_length) == 1 and len(args.context_length) > 1:
+            args.question_length = [
+                args.question_length[0] for _ in range(len(args.context_length))
+            ]
+        elif len(args.question_length) != len(args.context_length):
+            raise ValueError(
+                "The number of items in the question_length and context_length is expected to be either one or equal!"
+            )
+    tinychat.utils.constants.max_batch_size = args.max_batch_size
+    tinychat.utils.constants.max_seq_len = args.max_seq_len
+    from tinychat.models import FalconForCausalLM, LlamaForCausalLM, MPTForCausalLM
+    from tinychat.models.vila_llama import VilaLlamaForCausalLM
+
+    modeling_utils._init_weights = False
+    torch.nn.init.kaiming_uniform_ = skip
+    torch.nn.init.kaiming_normal_ = skip
+    torch.nn.init.uniform_ = skip
+    torch.nn.init.normal_ = skip
+
+    device = "cuda:0"
+    model_type_dict = {
+        "llama": LlamaForCausalLM,
+        "falcon": FalconForCausalLM,
+        "mpt": MPTForCausalLM,
+    }
+
+    config = AutoConfig.from_pretrained(args.model_path, trust_remote_code=True)
+    assert args.model_type.lower() in [
+        "llama",
+        "falcon",
+        "mpt",
+        "vila",
+    ], "We only support llama & falcon & mpt & vila now"
+    if "vila" in args.model_type.lower():
+        model = VilaLlamaForCausalLM(config).half()
+        print(model)
+        if args.precision in ["W4A16"]:
+            real_quantize_model_weight(
+                model.llm,
+                w_bit=4,
+                q_config=dict(q_group_size=args.q_group_size, zero_point=True),
+                init_only=True,
+            )
+            make_quant_attn(model.llm, device, args.flash_attn)
+            make_quant_norm(model.llm)
+            make_fused_mlp(model.llm)
+        model = model.to(device)
+        device_warmup(device)
+        tune_llava_patch_embedding(model.get_vision_tower(), device=device)
+        if not args.chunk_prefilling:
+            image_num = [
+                int(int("".join(i)) * 1 / 196) for i in args.context_length
+            ]  # consider about three thirds of the history tokens are images
+            if sum(image_num) > 0:
+                image_tensor = 2 * torch.rand((max(image_num), 3, 384, 384)) - 1
+                image_tensor = image_tensor.half().to(device)
+            else:
+                image_tensor = None
+
+        print("huggingface ckpt loaded")
+
+        # warming up
+        input_ids = [1 for _ in range(2048)]
+        inputs = torch.as_tensor([input_ids], device=device)
+        out = model(
+            inputs, start_pos=0, chunk_prefilling=args.chunk_prefilling
+        )  # warmup
+
+        if not args.chunk_prefilling:
+            for i, context_length in enumerate(args.context_length):
+                context_length = int("".join(context_length))
+                time_lis = []
+                if image_num[i]:
+                    images = image_tensor[0 : image_num[i], :, :, :]
+                    input_ids = [-200 for _ in range(image_num[i])] + [
+                        1 for _ in range(context_length - 196 * image_num[i])
+                    ]
+                else:
+                    images = None
+                    input_ids = [1 for _ in range(context_length)]
+                print("-" * 80)
+                print(
+                    "Context length: {} with {} pictures".format(
+                        context_length, image_num[i]
+                    )
+                )
+                with torch.inference_mode():
+                    for i in range(10):  # Run ten times and get the average value
+                        start_pos = 0
+                        torch.cuda.synchronize()
+                        t_st = time.time()
+                        inputs = torch.as_tensor([input_ids], device=device)
+                        out = model(
+                            inputs,
+                            start_pos=start_pos,
+                            chunk_prefilling=args.chunk_prefilling,
+                            images=images,
+                        )
+                        start_pos += inputs.shape[1]
+                        torch.cuda.synchronize()
+                        t_ed = time.time()
+                        token = out[:, -1].max(1)[1].unsqueeze(1)
+                        time_lis.append(t_ed - t_st)
+                        if args.verbose:
+                            print(i, t_ed - t_st)
+                    print(f"Time To First Token: {np.mean(time_lis):.5f} s.")
+                    print("-" * 80)
+        else:
+            for i, (context_length, question_length) in enumerate(
+                zip(args.context_length, args.question_length)
+            ):
+                context_length = int("".join(context_length))
+                question_length = int("".join(question_length))
+                input_ids_old = [1 for _ in range(context_length)]
+                images = None
+                input_ids_new = [1 for _ in range(question_length)]
+                time_lis = []
+                print("-" * 80)
+                print(
+                    "History length: {} ; Question length: {}".format(
+                        context_length, question_length
+                    )
+                )
+                with torch.inference_mode():
+                    for i in range(10):  # Run ten times and get the average value
+                        # history rounds
+                        start_pos = 0
+                        if context_length > question_length:
+                            inputs = torch.as_tensor([input_ids_old], device=device)
+                            out = model(
+                                inputs,
+                                start_pos=start_pos,
+                                chunk_prefilling=args.chunk_prefilling,
+                                images=None,
+                            )
+                            start_pos += context_length
+
+                        # the present round
+                        torch.cuda.synchronize()
+                        t_st = time.time()
+                        inputs = torch.as_tensor([input_ids_new], device=device)
+                        out = model(
+                            inputs,
+                            start_pos=start_pos,
+                            chunk_prefilling=args.chunk_prefilling,
+                        )
+                        start_pos += inputs.shape[1]
+                        torch.cuda.synchronize()
+                        t_ed = time.time()
+
+                        token = out[:, -1].max(1)[1].unsqueeze(1)
+                        time_lis.append(t_ed - t_st)
+                        if args.verbose:
+                            print(i, t_ed - t_st)
+                    print(
+                        f"Time To First Token of this round: {np.mean(time_lis):.5f} s."
+                    )
+                    print("-" * 80)
+    else:
+        model = model_type_dict[args.model_type.lower()](config).half()
+        if args.precision in ["W4A16"]:
+            real_quantize_model_weight(
+                model,
+                w_bit=4,
+                q_config=dict(q_group_size=args.q_group_size, zero_point=True),
+                init_only=True,
+            )
+        model = model.to(device)
+
+        if args.precision in ["W4A16"]:
+            # tune_all_wqlinears(model)
+            make_quant_attn(model, device, args.flash_attn)
+            make_quant_norm(model)
+            make_fused_mlp(model)
+        device_warmup(device)
+
+        print("huggingface ckpt loaded")
+
+        # warming up
+        input_ids = [1 for _ in range(2048)]
+        inputs = torch.as_tensor([input_ids], device=device)
+        out = model(
+            inputs,
+            start_pos=0,
+            chunk_prefilling=args.chunk_prefilling,
+            quant=args.precision in ["W4A16"],
+        )  # warmup
+
+        if not args.chunk_prefilling:
+            for context_length in args.context_length:
+                context_length = int("".join(context_length))
+                input_ids = [1 for _ in range(context_length)]
+                time_lis = []
+                print("-" * 80)
+                print("Context length: {}".format(context_length))
+                with torch.inference_mode():
+                    for i in range(10):  # Run ten times and get the average value
+                        start_pos = 0
+                        torch.cuda.synchronize()
+                        t_st = time.time()
+                        inputs = torch.as_tensor([input_ids], device=device)
+                        out = model(
+                            inputs,
+                            start_pos=start_pos,
+                            chunk_prefilling=args.chunk_prefilling,
+                            quant=args.precision in ["W4A16"],
+                        )
+                        start_pos += inputs.shape[1]
+                        torch.cuda.synchronize()
+                        t_ed = time.time()
+                        token = torch.argmax(out, keepdim=True)[0]
+                        time_lis.append(t_ed - t_st)
+                        if args.verbose:
+                            print(i, t_ed - t_st)
+                    print(f"Time To First Token: {np.mean(time_lis):.5f} s.")
+                    # decoing throughput
+                    time_lis = []
+                    start_pos = context_length
+                    torch.cuda.synchronize()
+                    t_st = time.time()
+                    for i in range(token_num):
+                        token = model(
+                            token,
+                            start_pos=start_pos,
+                            chunk_prefilling=args.chunk_prefilling,
+                            quant=args.precision in ["W4A16"],
+                        )
+                        start_pos += 1
+                        token = torch.argmax(token, keepdim=True)[0]
+                        torch.cuda.synchronize()
+                    t_ed = time.time()
+                    time_lis.append(t_ed - t_st)
+                    print(
+                        f"Decoding throughput: {token_num/sum(time_lis):.5f} token/s."
+                    )
+                    print("-" * 80)
+        else:
+            for context_length, question_length in zip(
+                args.context_length, args.question_length
+            ):
+                context_length = int("".join(context_length))
+                question_length = int("".join(question_length))
+                input_ids_old = [1 for _ in range(context_length)]
+                input_ids_new = [1 for _ in range(question_length)]
+                time_lis = []
+                print("-" * 80)
+                print(
+                    "History length: {} ; Question length: {}".format(
+                        context_length, question_length
+                    )
+                )
+                with torch.inference_mode():
+                    for i in range(10):  # Run ten times and get the average value
+                        # history rounds
+                        start_pos = 0
+                        if context_length > question_length:
+                            inputs = torch.as_tensor([input_ids_old], device=device)
+                            out = model(
+                                inputs,
+                                start_pos=start_pos,
+                                chunk_prefilling=args.chunk_prefilling,
+                                quant=args.precision in ["W4A16"],
+                            )
+                            start_pos += inputs.shape[1]
+
+                        # the present round
+                        torch.cuda.synchronize()
+                        t_st = time.time()
+                        inputs = torch.as_tensor([input_ids_new], device=device)
+                        out = model(
+                            inputs,
+                            start_pos=start_pos,
+                            chunk_prefilling=args.chunk_prefilling,
+                            quant=args.precision in ["W4A16"],
+                        )
+                        start_pos += inputs.shape[1]
+                        torch.cuda.synchronize()
+                        t_ed = time.time()
+
+                        token = out[:, -1].max(1)[1].unsqueeze(1)
+                        time_lis.append(t_ed - t_st)
+                        if args.verbose:
+                            print(i, t_ed - t_st)
+                    print(
+                        f"Time To First Token of this round: {np.mean(time_lis):.5f} s."
+                    )
+                    print("-" * 80)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/llm-awq/tinychat/demo.py b/llm-awq/tinychat/demo.py
new file mode 100644
index 0000000000000000000000000000000000000000..0306a91da52e8d8846ac9c1e3bf9ac2edc370d04
--- /dev/null
+++ b/llm-awq/tinychat/demo.py
@@ -0,0 +1,283 @@
+import argparse
+import time
+import numpy as np
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig, modeling_utils
+from attributedict.collections import AttributeDict
+from tinychat.stream_generators import StreamGenerator
+import tinychat.utils.constants
+from tinychat.utils.load_quant import load_awq_model, load_awq_llama_fast
+from tinychat.utils.prompt_templates import get_prompter, get_stop_token_ids
+from tinychat.utils.tune import device_warmup, tune_all_wqlinears
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
+# opt_params in TinyLLMEngine
+gen_params = AttributeDict(
+    [
+        ("seed", -1),  # RNG seed
+        ("n_threads", 1),  # TODO: fix this
+        ("n_predict", 512),  # new tokens to predict
+        ("n_parts", -1),  # amount of model parts (-1: determine from model dimensions)
+        ("n_ctx", 512),  # context size
+        ("n_batch", 512),  # batch size for prompt processing (must be >=32 to use BLAS)
+        ("n_keep", 0),  # number of tokens to keep from initial prompt
+        ("n_vocab", 50272),  # vocabulary size
+        # sampling parameters
+        ("logit_bias", dict()),  # logit bias for specific tokens: <int, float>
+        ("top_k", 40),  # <= 0 to use vocab size
+        ("top_p", 0.95),  # 1.0 = disabled
+        ("tfs_z", 1.00),  # 1.0 = disabled
+        ("typical_p", 1.00),  # 1.0 = disabled
+        ("temp", 0.70),  # 1.0 = disabled
+        ("repeat_penalty", 1.10),  # 1.0 = disabled
+        (
+            "repeat_last_n",
+            64,
+        ),  # last n tokens to penalize (0 = disable penalty, -1 = context size)
+        ("frequency_penalty", 0.00),  # 0.0 = disabled
+        ("presence_penalty", 0.00),  # 0.0 = disabled
+        ("mirostat", 0),  # 0 = disabled, 1 = mirostat, 2 = mirostat 2.0
+        ("mirostat_tau", 5.00),  # target entropy
+        ("mirostat_eta", 0.10),  # learning rate
+    ]
+)
+
+
+def stream_output(output_stream):
+    print(f"ASSISTANT: ", end="", flush=True)
+    pre = 0
+    for outputs in output_stream:
+        output_text = outputs["text"]
+        output_text = output_text.strip().split(" ")
+        now = len(output_text) - 1
+        if now > pre:
+            print(" ".join(output_text[pre:now]), end=" ", flush=True)
+            pre = now
+    print(" ".join(output_text[pre:]), flush=True)
+    if "timing" in outputs and outputs["timing"] is not None:
+        timing = outputs["timing"]
+        context_tokens = timing["context_tokens"]
+        context_time = timing["context_time"]
+        total_tokens = timing["total_tokens"]
+        generation_time_list = timing["generation_time_list"]
+        generation_tokens = len(generation_time_list)
+        average_speed = (context_time + np.sum(generation_time_list)) / (
+            context_tokens + generation_tokens
+        )
+        print("=" * 50)
+        print("Speed of Inference")
+        print("-" * 50)
+        print(f"TTFT : { context_time:.3f} s for {context_tokens} tokens")
+        print(
+            f"Speed of Generation : {np.average(generation_time_list)*1000:.2f} ms/token"
+        )
+        print("=" * 50)
+    return " ".join(output_text), total_tokens
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_type", type=str, default="LLaMa", help="type of the model"
+    )
+    parser.add_argument(
+        "--dtype", type=str, default="float16", choices=["float16", "bfloat16"]
+    )
+    parser.add_argument(
+        "--model_path",
+        type=str,
+        help="path to the model",
+    )
+    parser.add_argument(
+        "--precision", type=str, default="W4A16", help="compute precision"
+    )
+    parser.add_argument("--device", type=str, default="cuda:0")
+    parser.add_argument("--q_group_size", type=int, default=128)
+    parser.add_argument(
+        "--load_quant",
+        type=str,
+        help="path to the pre-quanted 4-bit weights",
+    )
+    parser.add_argument(
+        "--max_seq_len",
+        type=int,
+        default=2048,
+        help="maximum sequence length for kv cache",
+    )
+    parser.add_argument(
+        "--max_batch_size", type=int, default=1, help="maximum batch size for kv cache"
+    )
+    parser.add_argument(
+        "--mem_efficient_load",
+        action="store_true",
+        help="enable mem_efficient_load mod",
+    )
+    parser.add_argument(
+        "--single_round",
+        action="store_true",
+        help="whether to memorize previous conversations",
+    )
+    parser.add_argument(
+        "--flash_attn",
+        action="store_true",
+        help="whether to use flash attention",
+    )
+    parser.add_argument(
+        "--chunk_prefilling",
+        action="store_true",
+        help="If used, in context stage, the history tokens will not be recalculated, greatly speeding up the calculation",
+    )
+
+    args = parser.parse_args()
+    assert args.model_type.lower() in [
+        "llama",
+        "falcon",
+        "mpt",
+        "qwen",
+    ], "We only support llama & falcon & mpt now"
+    assert args.precision in ["W4A16", "W16A16"], "We only support W4A16/W16A16 now"
+
+    gen_params.n_predict = 1024
+    gen_params.n_vocab = 32000
+    tinychat.utils.constants.max_batch_size = args.max_batch_size
+    tinychat.utils.constants.max_seq_len = args.max_seq_len
+    tinychat.utils.constants.mem_efficient_load = args.mem_efficient_load
+    if tinychat.utils.constants.mem_efficient_load:
+        print("=" * 80)
+        print(
+            "[Info] You have activated mem_efficient_load mode.\n       Less on-chip memory will be consumed when loading the model.\n       However, the loading process will take more time."
+        )
+        print("=" * 80)
+    # TODO (Haotian): a more elegant implementation here.
+    # We need to update these global variables before models use them.
+    from tinychat.models import (
+        FalconForCausalLM,
+        LlamaForCausalLM,
+        MPTForCausalLM,
+        Qwen2ForCausalLM,
+    )
+
+    def skip(*args, **kwargs):
+        pass
+
+    torch.nn.init.kaiming_uniform_ = skip
+    torch.nn.init.kaiming_normal_ = skip
+    torch.nn.init.uniform_ = skip
+    torch.nn.init.normal_ = skip
+
+    config = AutoConfig.from_pretrained(args.model_path, trust_remote_code=True)
+    if "mpt" in config.__class__.__name__.lower():
+        # config.init_device="meta"
+        tokenizer = AutoTokenizer.from_pretrained(
+            config.tokenizer_name, trust_remote_code=True
+        )
+    else:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.model_path, use_fast=False, trust_remote_code=True
+        )
+    torch_dtype = torch.float16 if args.dtype == "float16" else torch.bfloat16
+    modeling_utils._init_weights = False
+    torch.set_default_dtype(torch_dtype)
+
+    model_type_dict = {
+        "llama": LlamaForCausalLM,
+        "falcon": FalconForCausalLM,
+        "mpt": MPTForCausalLM,
+        "qwen": Qwen2ForCausalLM,
+    }
+
+    if args.precision == "W4A16":
+        if args.model_type.lower() == "llama":
+            model = model_type_dict["llama"](config).to(torch_dtype)
+            model = load_awq_llama_fast(
+                model, args.load_quant, 4, args.q_group_size, args.device
+            )
+        elif args.model_type.lower() == "qwen":
+            model = model_type_dict["qwen"](config).to(torch_dtype)
+            model = load_awq_llama_fast(
+                model, args.load_quant, 4, args.q_group_size, args.device
+            )
+        else:
+            model = model_type_dict[args.model_type.lower()](config).to(torch_dtype)
+            model = load_awq_model(
+                model, args.load_quant, 4, args.q_group_size, args.device
+            )
+    else:
+        loaded_model = AutoModelForCausalLM.from_pretrained(
+            args.model_path,
+            config=config,
+            torch_dtype=torch_dtype,
+            trust_remote_code=True,
+        )
+        model = (
+            model_type_dict[args.model_type.lower()](config)
+            .to(torch_dtype)
+            .to(args.device)
+        )
+        model.load_state_dict(loaded_model.state_dict())
+    # device warm up
+    device_warmup(args.device)
+
+    # autotune split_k_iters
+    # tune_all_wqlinears(model)
+
+    # TODO (Haotian): Verify if the StreamGenerator still works for the unmodified falcon impl.
+    stream_generator = StreamGenerator
+
+    # Optimize AWQ quantized model
+    if args.precision == "W4A16" and (
+        args.model_type.lower() == "llama" or args.model_type.lower() == "qwen"
+    ):
+        from tinychat.modules import make_quant_norm, make_quant_attn
+
+        if args.flash_attn:
+            make_quant_attn(model, args.device, args.flash_attn)
+        else:
+            make_quant_attn(model, args.device)
+        make_quant_norm(model)
+    model(
+        torch.randint(0, 1000, (1, 512), dtype=torch.int, device="cuda:0"),
+        0,
+        quant=args.precision == "W4A16",
+    )
+    if args.max_seq_len <= 1024:
+        short_prompt = True
+    else:
+        short_prompt = False
+    model_prompter = get_prompter(args.model_type, args.model_path, short_prompt)
+    stop_token_ids = get_stop_token_ids(args.model_type, args.model_path)
+    count = 0
+    start_pos = 0
+    print("=" * 50)
+    while True:
+        # Get input from the user
+        input_prompt = input("USER: ")
+        if input_prompt == "":
+            print("EXIT...")
+            break
+        model_prompter.insert_prompt(input_prompt)
+        output_stream = stream_generator(
+            model,
+            tokenizer,
+            model_prompter.model_input,
+            start_pos,
+            gen_params,
+            device=args.device,
+            stop_token_ids=stop_token_ids,
+            chunk_prefilling=args.chunk_prefilling,
+            quant_llm=args.precision == "W4A16",
+        )
+        outputs, total_tokens = stream_output(output_stream)
+        if args.chunk_prefilling:
+            start_pos += total_tokens
+        else:
+            start_pos = 0
+        if (
+            args.single_round is not True and args.max_seq_len > 512
+        ):  # Only memorize previous conversations when kv_cache_size > 512
+            model_prompter.update_template(outputs, args.chunk_prefilling)
+        count += 1
diff --git a/llm-awq/tinychat/internvl_benchmark.py b/llm-awq/tinychat/internvl_benchmark.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1ee1274d56acfe09da30939d021f5e19e21075d
--- /dev/null
+++ b/llm-awq/tinychat/internvl_benchmark.py
@@ -0,0 +1,167 @@
+import argparse
+
+from termcolor import colored
+
+import llava
+from llava import conversation as clib
+from llava.media import Image, Video
+import torch
+from awq.quantize import fake_quant
+from awq.quantize.quantizer import real_quantize_model_weight
+from transformers import AutoConfig
+import tinychat
+
+from torchao.quantization import quantize_, Int4WeightOnlyConfig
+
+import os
+
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+def skip(*args, **kwargs):
+    pass
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model-path",
+        "-m",
+        type=str,
+        default="/home/yuming/workspace/qwen/models/nvila-internal-8b-v1",
+    )
+    parser.add_argument(
+        "--quant_path",
+        type=str,
+        default="/PATH/TO/QUANT",
+    )
+    # parser.add_argument("--model-path", "-m", type=str, default="Efficient-Large-Model/J65")
+    # parser.add_argument("--quant_path", type=str, default="/home/yuming/workspace/qwen/models/J65/llm/vila2-J65-w4-g128-awq-v2.pt")
+    parser.add_argument("--conv-mode", "-c", type=str, default="auto")
+    # parser.add_argument("--media", type=str, default="/home/yuming/workspace/space_woaudio.mp4")
+    parser.add_argument("--device", type=str, default="cuda:0")
+    parser.add_argument(
+        "--act_scale_path",
+        type=str,
+        default="/PATH/TO/SCALE",
+    )
+    # quantization options
+    parser.add_argument("--quant_llm", action="store_true")
+    parser.add_argument("--quant_VT", action="store_true")
+    # Four basic tasks
+    parser.add_argument("--video_caption", action="store_true")
+    parser.add_argument("--video_QA", action="store_true")
+    parser.add_argument("--image_caption", action="store_true")
+    parser.add_argument("--image_QA", action="store_true")
+
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Whether to quantize visiontower and llm, and test all 4 tasks",
+    )
+    parser.add_argument(
+        "--fakequant_VT",
+        action="store_true",
+        help="Use fake quant or real quant for VisionTower",
+    )
+    parser.add_argument(
+        "--all_task", action="store_true", help="Whether to test all 4 tasks"
+    )
+    parser.add_argument(
+        "--video_path", type=str, default="../figures/nvila_demo_video.mp4"
+    )
+    parser.add_argument("--image_path", type=str, default="../figures/vila-logo.jpg")
+    parser.add_argument("--max_seq_len", type=int, default=8192)
+    args = parser.parse_args()
+
+    torch.nn.init.kaiming_uniform_ = skip
+    torch.nn.init.kaiming_normal_ = skip
+    torch.nn.init.uniform_ = skip
+    torch.nn.init.normal_ = skip
+    import tinychat.utils.constants
+
+    tinychat.utils.constants.max_seq_len = args.max_seq_len
+    from transformers import modeling_utils
+
+    modeling_utils._init_weights = False
+
+    # Load model
+    from tinychat.models import InternVL3
+    
+    config = AutoConfig.from_pretrained(args.model_path, trust_remote_code=True)
+    config.resume_path = args.model_path
+    model = InternVL3(config).half()
+    model.language_model = model.language_model.eval()
+    if args.quant_llm or args.all:
+        from tinychat.modules import (
+            make_quant_norm,
+            make_quant_attn,
+            make_fused_mlp,
+            make_fused_vision_attn,
+        )
+
+        real_quantize_model_weight(
+            model.language_model,
+            w_bit=4,
+            q_config=dict(q_group_size=128, zero_point=True),
+            init_only=True,
+        )
+        make_quant_attn(model.language_model, "cuda", True)
+        make_quant_norm(model.language_model)
+        make_fused_mlp(model.language_model)
+        model = model.to("cuda")
+    model = model.to(args.device)
+    if args.quant_VT or args.all:
+        from tinychat.modules import QuantInternVisionEncoder
+        model.vision_model.encoder = QuantInternVisionEncoder(model.vision_model.encoder)
+        model.vision_model.encoder = torch.compile(model.vision_model.encoder)
+    
+    model = model.cuda().eval()
+
+    if args.video_caption or args.all or args.all_task:
+        print("-" * 80)
+        print("Video_Caption")
+        # Set conversation mode
+        clib.default_conversation = clib.conv_templates[args.conv_mode].copy()
+        media = Video(args.video_path)
+        text = "Elaborate on the visual and narrative elements of the video in detail."  # + "1"+" 1"*3069
+        prompt = [media, text]
+        # Generate response
+        with torch.no_grad():
+            response = model.benchmark(prompt, args.quant_llm)
+    if args.video_QA or args.all or args.all_task:
+        print("-" * 80)
+        print("Video_QA")
+        # Set conversation mode
+        clib.default_conversation = clib.conv_templates[args.conv_mode].copy()
+        media = Video(args.video_path)
+        text = "What is the person in the video doing? Select the option that best describes their action: A. Folding paper B. Playing computer games C. Sleeping."  # + "1"+" 1"*3069
+        prompt = [media, text]
+        # Generate response
+        with torch.no_grad():
+            response = model.benchmark(prompt, args.quant_llm)
+    if args.image_caption or args.all or args.all_task:
+        print("-" * 80)
+        print("Image_Caption")
+        # Set conversation mode
+        clib.default_conversation = clib.conv_templates[args.conv_mode].copy()
+        media = Image(args.image_path)
+        text = "Describe the image in detail."
+        prompt = [media, text]
+        # Generate response
+        with torch.no_grad():
+            response = model.benchmark(prompt, args.quant_llm)
+    if args.image_QA or args.all or args.all_task:
+        print("-" * 80)
+        print("Image_QA")
+        # Set conversation mode
+        clib.default_conversation = clib.conv_templates[args.conv_mode].copy()
+        media = Image(args.image_path)
+        text = "What does the text in the image say? Choose the option that best matches: A. VILA B. AIIV C. ALIV."
+        prompt = [media, text]
+        # Generate response
+        with torch.no_grad():
+            response = model.benchmark(prompt, args.quant_llm)
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/llm-awq/tinychat/split_ckpt.py b/llm-awq/tinychat/split_ckpt.py
new file mode 100644
index 0000000000000000000000000000000000000000..2553283a83fbf4602396f1575b2e0fcabe518c7f
--- /dev/null
+++ b/llm-awq/tinychat/split_ckpt.py
@@ -0,0 +1,51 @@
+import os
+import re
+import torch
+import argparse
+
+
+def split(
+    ckpt_path: str,
+    out_folder_path: str,
+):
+    os.system(f"mkdir -p {out_folder_path}")
+    ckpt = torch.load(ckpt_path)
+    count = 0
+    for key, value in ckpt.items():
+        output_dict = {key: value}
+        output_name = out_folder_path + "/" + key + ".pt"
+        torch.save(output_dict, output_name)
+        count += 1
+    print(f"Finished splitting the original checkpoint into {count} shards.")
+
+
+def ckpt_folder_reader(ckpt_folder_path: str):
+    file_list = [f for f in os.listdir(ckpt_folder_path) if f.endswith(".pt")]
+    for ckpt in file_list:
+        print(ckpt)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--input_path",
+        type=str,
+        default=None,
+        help="Path to the original checkpoint (ends with *.pt)",
+    )
+    parser.add_argument(
+        "--output_path",
+        type=str,
+        default=None,
+        help="Folder to store the splitted checkpoint shards",
+    )
+
+    args = parser.parse_args()
+    assert (
+        args.input_path is not None
+    ), "Please specify the path to the original checkpoint."
+    if args.output_path is None:
+        suffix = r"\.pt$"
+        args.output_path = re.sub(suffix, "", args.input_path)
+
+    split(args.input_path, args.output_path)
diff --git a/llm-awq/tinychat/vila15_demo.py b/llm-awq/tinychat/vila15_demo.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4aea70b51a8829a5d84a67a5349c0a508226cd7
--- /dev/null
+++ b/llm-awq/tinychat/vila15_demo.py
@@ -0,0 +1,264 @@
+import argparse
+import torch
+
+from PIL import Image
+from tqdm import tqdm
+
+from transformers import AutoConfig, AutoTokenizer
+from accelerate import load_checkpoint_and_dispatch
+
+from tinychat.utils.tune import (
+    device_warmup,
+    tune_all_wqlinears,
+    tune_llava_patch_embedding,
+)
+from tinychat.utils.prompt_templates import (
+    get_prompter,
+    get_stop_token_ids,
+    get_image_token,
+)
+from tinychat.utils.llava_image_processing import (
+    process_images,
+    load_images,
+    vis_images,
+)
+import tinychat.utils.constants
+
+# from tinychat.models.llava_llama import LlavaLlamaForCausalLM
+from tinychat.models.vila_llama import VilaLlamaForCausalLM
+from tinychat.stream_generators.llava_stream_gen import LlavaStreamGenerator
+from tinychat.utils.conversation_utils import gen_params, stream_output, TimeStats
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
+
+def image_parser(args):
+    out = args.image_file.split(args.im_sep)
+    return out
+
+
+def skip(*args, **kwargs):
+    pass
+
+
+def main(args):
+    # Accelerate model initialization
+    setattr(torch.nn.Linear, "reset_parameters", lambda self: None)
+    setattr(torch.nn.LayerNorm, "reset_parameters", lambda self: None)
+    torch.nn.init.kaiming_uniform_ = skip
+    torch.nn.init.kaiming_normal_ = skip
+    torch.nn.init.uniform_ = skip
+    torch.nn.init.normal_ = skip
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        os.path.join(args.model_path, "llm"), use_fast=False
+    )
+    tinychat.utils.constants.LLAVA_DEFAULT_IMAGE_PATCH_TOKEN_IDX = (
+        tokenizer.convert_tokens_to_ids(
+            [tinychat.utils.constants.LLAVA_DEFAULT_IMAGE_PATCH_TOKEN]
+        )[0]
+    )
+    config = AutoConfig.from_pretrained(args.model_path, trust_remote_code=True)
+    model = VilaLlamaForCausalLM(config).half()
+    tinychat.utils.constants.LLAVA_DEFAULT_IMAGE_PATCH_TOKEN_IDX = (
+        tokenizer.convert_tokens_to_ids(
+            [tinychat.utils.constants.LLAVA_DEFAULT_IMAGE_PATCH_TOKEN]
+        )[0]
+    )
+    vision_tower = model.get_vision_tower()
+    # if not vision_tower.is_loaded:
+    #     vision_tower.load_model()
+    image_processor = vision_tower.image_processor
+    # vision_tower = vision_tower.half()
+
+    if args.precision == "W16A16":
+        pbar = tqdm(range(1))
+        pbar.set_description("Loading checkpoint shards")
+        for i in pbar:
+            model.llm = load_checkpoint_and_dispatch(
+                model.llm,
+                os.path.join(args.model_path, "llm"),
+                no_split_module_classes=[
+                    "OPTDecoderLayer",
+                    "LlamaDecoderLayer",
+                    "BloomBlock",
+                    "MPTBlock",
+                    "DecoderLayer",
+                    "CLIPEncoderLayer",
+                ],
+            ).to(args.device)
+        model = model.to(args.device)
+
+    elif args.precision == "W4A16":
+        from tinychat.utils.load_quant import load_awq_model
+
+        model.llm = load_awq_model(model.llm, args.quant_path, 4, 128, args.device)
+        from tinychat.modules import (
+            make_quant_norm,
+            make_quant_attn,
+            make_fused_mlp,
+            make_fused_vision_attn,
+        )
+
+        if args.flash_attn:
+            print("Enabling flash-attention!")
+            make_quant_attn(model.llm, args.device, 1)
+        else:
+            print("Disabling flash-attention!")
+            make_quant_attn(model.llm, args.device)
+        make_quant_norm(model.llm)
+        # make_fused_mlp(model)
+        # make_fused_vision_attn(model,args.device)
+        model = model.to(args.device)
+
+    else:
+        raise NotImplementedError(f"Precision {args.precision} is not supported.")
+
+    image_files = image_parser(args)
+    image_num = len(image_files)
+    images = load_images(image_files)
+    if args.vis_image:
+        print("=" * 50)
+        print("Input Image:")
+        vis_images(image_files)
+    # Similar operation in model_worker.py
+    image_tensor = process_images(images, image_processor, model.config)
+    if type(image_tensor) is list:
+        image_tensor = [
+            image.to(args.device, dtype=torch.float16) for image in image_tensor
+        ]
+    else:
+        image_tensor = image_tensor.to(args.device, dtype=torch.float16)
+
+    device_warmup(args.device)
+    tune_llava_patch_embedding(vision_tower, device=args.device)
+
+    stream_generator = LlavaStreamGenerator
+
+    if args.max_seq_len <= 1024:
+        short_prompt = True
+    else:
+        short_prompt = False
+    model_prompter = get_prompter(
+        args.model_type, args.model_path, short_prompt, args.empty_prompt
+    )
+    stop_token_ids = get_stop_token_ids(args.model_type, args.model_path)
+    count = 0
+
+    if args.empty_prompt:
+        input_indicator = "Input: "
+        output_indicator = "Generated: "
+    else:
+        input_indicator = "USER: "
+        output_indicator = "ASSISTANT: "
+
+    model.eval()
+    time_stats = TimeStats()
+    start_pos = 0
+    while True:
+        # Get input from the user
+        print("=" * 50)
+        input_prompt = input(input_indicator)
+        print("-" * 50)
+        if input_prompt == "":
+            print("EXIT...")
+            time_stats.show()
+            break
+        if count == 0:  # Insert image here
+            image_token = get_image_token(model, args.model_path)
+            image_token_holder = (
+                tinychat.utils.constants.LLAVA_DEFAULT_IM_TOKEN_PLACE_HOLDER
+            )
+            im_token_count = input_prompt.count(image_token_holder)
+            if im_token_count == 0:
+                model_prompter.insert_prompt(image_token * image_num + input_prompt)
+            else:
+                assert im_token_count == image_num
+                input_prompt = input_prompt.replace(image_token_holder, image_token)
+                model_prompter.insert_prompt(input_prompt)
+        else:
+            model_prompter.insert_prompt(input_prompt)
+            if args.chunk_prefilling:
+                image_tensor = None  # Can insert more images in future
+        output_stream = stream_generator(
+            model,
+            tokenizer,
+            model_prompter.model_input,
+            start_pos,
+            gen_params,
+            device=args.device,
+            stop_token_ids=stop_token_ids,
+            image_tensor=image_tensor,
+            chunk_prefilling=args.chunk_prefilling,
+        )
+        print(output_indicator, end="", flush=True)
+        if count == 0:
+            outputs, total_tokens = stream_output(output_stream, time_stats)
+        else:
+            outputs, total_tokens = stream_output(output_stream)
+        if args.chunk_prefilling:
+            start_pos += total_tokens
+        if (
+            args.single_round is not True and args.max_seq_len > 512
+        ):  # Only memorize previous conversations when kv_cache_size > 512
+            model_prompter.update_template(outputs, args.chunk_prefilling)
+        count += 1
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_type", type=str, default="LLaMa", help="type of the model"
+    )
+    parser.add_argument(
+        "--model-path", type=str, default="/data/llm/checkpoints/llava/llava-v1.5-7b"
+    )
+    parser.add_argument(
+        "--quant-path",
+        type=str,
+        default="/data/llm/checkpoints/llava/llava-v1.5-7b-w4-g128-awq.pt",
+    )
+    parser.add_argument(
+        "--precision", type=str, default="W4A16", help="compute precision"
+    )
+    parser.add_argument(
+        "--image-file",
+        type=str,
+        default="https://llava.hliu.cc/file=/nobackup/haotian/code/LLaVA/llava/serve/examples/extreme_ironing.jpg",
+    )
+    parser.add_argument(
+        "--im-sep",
+        type=str,
+        default=",",
+    )
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--max_seq_len", type=int, default=2048)
+    parser.add_argument(
+        "--single_round",
+        action="store_true",
+        help="whether to memorize previous conversations",
+    )
+    parser.add_argument(
+        "--vis-image",
+        action="store_true",
+        help="whether to visualize the image while chatting",
+    )
+    parser.add_argument(
+        "--empty-prompt",
+        action="store_true",
+        help="whether to use empty prompt template",
+    )
+    parser.add_argument(
+        "--flash_attn",
+        action="store_true",
+        help="whether to use flash attention",
+    )
+    parser.add_argument(
+        "--chunk_prefilling",
+        action="store_true",
+        help="If used, in context stage, the history tokens will not be recalculated, greatly speeding up the calculation",
+    )
+    args = parser.parse_args()
+    main(args)
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_2/afrimgsm_sot.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_2/afrimgsm_sot.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5ad77562229ec921e07ebcfe8a35ce9c7b072d99
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_2/afrimgsm_sot.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: sot
+include: afrimgsm_yaml
+task: afrimgsm_sot_prompt_2
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_2/afrimgsm_yor.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_2/afrimgsm_yor.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6faf98bdd2ebe70aa1fbe7a0bc955eedce4c726a
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_2/afrimgsm_yor.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: yor
+include: afrimgsm_yaml
+task: afrimgsm_yor_prompt_2
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_ibo.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_ibo.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..fc451b94feac4afc4ba0405ee9643e0ab6790080
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_ibo.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: ibo
+include: afrimgsm_yaml
+task: afrimgsm_ibo_prompt_3
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_kin.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_kin.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f01edaae271f79a4f3f9e6ce444e62af86a85032
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_kin.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: kin
+include: afrimgsm_yaml
+task: afrimgsm_kin_prompt_3
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_sna.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_sna.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4000b9dc41fa79e16f673db2f54fa31d77dded02
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_sna.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: sna
+include: afrimgsm_yaml
+task: afrimgsm_sna_prompt_3
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_sot.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_sot.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a9941fce3105d32d2610c4e41b938360ac8b961c
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_sot.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: sot
+include: afrimgsm_yaml
+task: afrimgsm_sot_prompt_3
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_xho.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_xho.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..067e88d709cd0f06c217d6823ae2cd99ebd5f003
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_xho.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: xho
+include: afrimgsm_yaml
+task: afrimgsm_xho_prompt_3
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_yaml
new file mode 100644
index 0000000000000000000000000000000000000000..8dd3f5ca74a7c6d4dcba9daab9d8c7653b9c8e6e
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_yaml
@@ -0,0 +1,34 @@
+tag:
+    - afrimgsm_tasks
+    - afrimgsm_tasks_prompt_3
+dataset_path: masakhane/afrimgsm
+output_type: generate_until
+test_split: test
+doc_to_target: '{% if answer is not none %}{{answer[21:]}}{% else %}{{answer_number|string}}{% endif %}'
+doc_to_text: "Solve the following math question \n\nQuestion: {{question}} \nAnswer: "
+target_delimiter: ""
+generation_kwargs:
+  do_sample: false
+  until:
+  - 'Question:'
+  - </s>
+  - <|im_end|>
+filter_list:
+  - name: remove_whitespace
+    filter:
+      - function: remove_whitespace
+      - function: take_first
+  - filter:
+    - function: regex
+      group_select: -1
+      regex_pattern: (-?[$0-9.,]{2,})|(-?[0-9]+)
+    - function: take_first
+    name: flexible-extract
+metric_list:
+  - metric: exact_match
+    aggregation: mean
+    higher_is_better: true
+    ignore_case: true
+    ignore_punctuation: true
+metadata:
+  version: 2.0
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_yor.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_yor.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2d64481065491583c980a83d9ea40507b8830552
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_yor.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: yor
+include: afrimgsm_yaml
+task: afrimgsm_yor_prompt_3
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_zul.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_zul.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4b94a2c13dae19e6ed50ab49a321b1f73d326a97
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_3/afrimgsm_zul.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: zul
+include: afrimgsm_yaml
+task: afrimgsm_zul_prompt_3
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_ibo.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_ibo.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7d214574ade50c17d374e7daad4b4a8e1670db78
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_ibo.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: ibo
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_ibo_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_lin.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_lin.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..44d2d2f39bc83011268c1bcffaa4ea8564e3b5a4
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_lin.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: lin
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_lin_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_lug.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_lug.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d8a12945fd73da0abe42bc7504ec5a861ef86a8d
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_lug.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: lug
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_lug_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_orm.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_orm.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..dcf7123f8e45f9d5d32ffc97f5038c29d946958d
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_orm.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: orm
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_orm_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_sna.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_sna.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3d3414e3ca1273567847599c244e266e66e495dc
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_sna.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: sna
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_sna_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_sot.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_sot.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ac0017a36b03a55102fab40f5c6a3cb2d6fffa84
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_sot.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: sot
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_sot_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_swa.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_swa.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..043311d3e634759e7b08892126dfc64b94e39310
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_swa.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: swa
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_swa_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_twi.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_twi.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f3e030d0bc072ba50afa51a988ee0fa4d37f8e7f
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_twi.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: twi
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_twi_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_vai.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_vai.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2dbe04c16eab6ea207a384c01860cc2555ffb6bb
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_vai.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: vai
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_vai_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_wol.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_wol.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..55f546ab101fb6ee26158d5803fe1ad80f3cb8e4
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_wol.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: wol
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_wol_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_xho.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_xho.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a759549811b8e6f009ed49c7b4bd16bc46163d8f
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_xho.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: xho
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_xho_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_yor.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_yor.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..fd4d01bbf4f5ddb22b8057f3ffd99996c82b92d1
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_4/afrimgsm_yor.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: yor
+doc_to_text: "Answer the given question with the appropriate numerical value, ensuring\
+  \ that the response is clear and without any supplementary information. \n\nQuestion:\
+  \ {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_yor_prompt_4
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_amh.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_amh.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e7ad215fac134e19c62187205f141a73d1978e22
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_amh.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: amh
+doc_to_text: "For mathematical questions provided in Amharic language. Supply the\
+  \ accurate numeric answer to the provided question. \n\nQuestion: {{question}} \n\
+  Answer: "
+include: afrimgsm_yaml
+task: afrimgsm_amh_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_eng.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_eng.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a4de5e95948fd28d990f224c9cb0f6e82b6f5cf5
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_eng.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: eng
+doc_to_text: "For mathematical questions provided in English language. Supply the\
+  \ accurate numeric answer to the provided question. \n\nQuestion: {{question}} \n\
+  Answer: "
+include: afrimgsm_yaml
+task: afrimgsm_eng_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_ewe.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_ewe.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bdb3c4f278e1e31e5c20cb399df2a4a374aaa253
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_ewe.yaml
@@ -0,0 +1,6 @@
+# Generated by utils.py
+dataset_name: ewe
+doc_to_text: "For mathematical questions provided in Ewe language. Supply the accurate\
+  \ numeric answer to the provided question. \n\nQuestion: {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_ewe_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_fra.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_fra.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a93e79ec90099beb8c50baac1503bf824cb9bcda
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_fra.yaml
@@ -0,0 +1,6 @@
+# Generated by utils.py
+dataset_name: fra
+doc_to_text: "For mathematical questions provided in French language. Supply the accurate\
+  \ numeric answer to the provided question. \n\nQuestion: {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_fra_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_hau.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_hau.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..74fabdee06aa0669ada4ba5fe46bd9a6ad6bdd32
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_hau.yaml
@@ -0,0 +1,6 @@
+# Generated by utils.py
+dataset_name: hau
+doc_to_text: "For mathematical questions provided in Hausa language. Supply the accurate\
+  \ numeric answer to the provided question. \n\nQuestion: {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_hau_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_ibo.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_ibo.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c2dd77f238af5a67eccad3e05f6add96c3d1f321
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_ibo.yaml
@@ -0,0 +1,6 @@
+# Generated by utils.py
+dataset_name: ibo
+doc_to_text: "For mathematical questions provided in Igbo language. Supply the accurate\
+  \ numeric answer to the provided question. \n\nQuestion: {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_ibo_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_kin.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_kin.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ba3f3c2f2b264b333a6fe1903c6f84d6d6000692
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_kin.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: kin
+doc_to_text: "For mathematical questions provided in Kinyarwanda language. Supply\
+  \ the accurate numeric answer to the provided question. \n\nQuestion: {{question}}\
+  \ \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_kin_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_lin.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_lin.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..74131916ab079d9c1bee95d169517661e4d11b31
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_lin.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: lin
+doc_to_text: "For mathematical questions provided in Lingala language. Supply the\
+  \ accurate numeric answer to the provided question. \n\nQuestion: {{question}} \n\
+  Answer: "
+include: afrimgsm_yaml
+task: afrimgsm_lin_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_lug.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_lug.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..b92bc4e6574ac7df4aad89c143687747ed5d9863
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_lug.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: lug
+doc_to_text: "For mathematical questions provided in Luganda language. Supply the\
+  \ accurate numeric answer to the provided question. \n\nQuestion: {{question}} \n\
+  Answer: "
+include: afrimgsm_yaml
+task: afrimgsm_lug_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_orm.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_orm.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..0c33dd44cc0019f3485ca72368c767b9161ec983
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_orm.yaml
@@ -0,0 +1,6 @@
+# Generated by utils.py
+dataset_name: orm
+doc_to_text: "For mathematical questions provided in Oromo language. Supply the accurate\
+  \ numeric answer to the provided question. \n\nQuestion: {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_orm_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_swa.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_swa.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..0a08c8e3a98efcc19a3f48ec4dc46d220fd7a9ab
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_swa.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: swa
+doc_to_text: "For mathematical questions provided in Swahili language. Supply the\
+  \ accurate numeric answer to the provided question. \n\nQuestion: {{question}} \n\
+  Answer: "
+include: afrimgsm_yaml
+task: afrimgsm_swa_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_wol.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_wol.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4e711e8efa4b2e854d9924f953dce931ea3a0ba1
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_wol.yaml
@@ -0,0 +1,6 @@
+# Generated by utils.py
+dataset_name: wol
+doc_to_text: "For mathematical questions provided in Wolof language. Supply the accurate\
+  \ numeric answer to the provided question. \n\nQuestion: {{question}} \nAnswer: "
+include: afrimgsm_yaml
+task: afrimgsm_wol_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_xho.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_xho.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..728cacf881aef3014669a43c2ffc5316664decad
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct/prompt_5/afrimgsm_xho.yaml
@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: xho
+doc_to_text: "For mathematical questions provided in isiXhosa language. Supply the\
+  \ accurate numeric answer to the provided question. \n\nQuestion: {{question}} \n\
+  Answer: "
+include: afrimgsm_yaml
+task: afrimgsm_xho_prompt_5
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/afrimgsm_cot.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/afrimgsm_cot.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d07832b4ddb9d7b1306e36cc5c39f11ee840661b
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/afrimgsm_cot.yaml
@@ -0,0 +1,9 @@
+group: afrimgsm_cot-irokobench
+task:
+  - afrimgsm_cot_tasks
+aggregate_metric_list:
+  - metric: acc
+    aggregation: mean
+    weight_by_size: true
+metadata:
+  version: 2
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_amh.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_amh.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c9f0d9311aa462f2f4c3e9d38c5d0407ae7b72d7
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_amh.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: amh
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_amh_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_eng.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_eng.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..57c0e564b1b594fe21203a0d73737301167b63cb
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_eng.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: eng
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_eng_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_ewe.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_ewe.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..55fdff7c365f895a4835b6234a7027a28b7c42a3
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_ewe.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: ewe
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_ewe_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_fra.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_fra.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..717a45d98beabb763984f030350252b6d3424747
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_fra.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: fra
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_fra_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_hau.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_hau.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f42e0ee559e562a934c3151cc9fd535442c6cf28
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_hau.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: hau
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_hau_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_ibo.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_ibo.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..dfabc3e319236dd2112ab74bbb5d1181f63d8d55
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_ibo.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: ibo
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_ibo_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_kin.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_kin.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..55d20e011aa15f290f292411604391e2c761053f
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_kin.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: kin
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_kin_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_orm.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_orm.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7ce25aee61aa076b7c250c00a3a49f552c82f9d3
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_orm.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: orm
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_orm_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_sna.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_sna.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..fae029f19280d7bf4f0928a63022c6deeae09f6d
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_sna.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: sna
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_sna_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_sot.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_sot.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d0d1207791575accf84f4f6839e8b41f688ba0d9
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_1/afrimgsm_cot_sot.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: sot
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_sot_prompt_1
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_amh.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_amh.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6d5d43fb8562da74b469cc15636aaac35c082ef2
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_amh.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: amh
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_amh_prompt_2
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_fra.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_fra.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..987ac630ee57139c93588b86dc8ae53bbd6c466e
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_fra.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: fra
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_fra_prompt_2
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_hau.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_hau.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..488f693a60c4a31cec8adf1e2665cf7cd6430b18
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_hau.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: hau
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_hau_prompt_2
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_kin.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_kin.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e183dcd48f80b358ed54bdde2fd8d9e3ac64a9ba
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_kin.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: kin
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_kin_prompt_2
diff --git a/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_lin.yaml b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_lin.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..840a99acfacba2dacfe8c2883fed6445373f72e7
--- /dev/null
+++ b/lm-evaluation-harness/lm_eval/tasks/afrimgsm/direct_cot/prompt_2/afrimgsm_cot_lin.yaml
@@ -0,0 +1,4 @@
+# Generated by utils.py
+dataset_name: lin
+include: afrimgsm_cot_yaml
+task: afrimgsm_cot_lin_prompt_2