Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,167 @@
+# CUDA
+*.egg-info*
+
+# cache
+/llm-awq/awq_cache/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "3rdparty/lmms-eval"]
+	path = 3rdparty/lmms-eval
+	url = git@github.com:LSY-noya/lmms-eval.git
+[submodule "3rdparty/LLaVA-NeXT"]
+	path = 3rdparty/LLaVA-NeXT
+	url = git@github.com:LSY-noya/LLaVA-NeXT.git

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "python.analysis.extraPaths": [
+        "./3rdparty/lmms-eval",
+        "./3rdparty/LLaVA-NeXT",
+    ]
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,181 @@
+# MBQ: Modality-Balanced Quantization for Large Vision-Language Models [[paper]](https://arxiv.org/abs/2412.19509)
+
+## Installation
+
+1. Clone this repo
+    ```bash
+    git clone --recurse-submodules git@github.com:thu-nics/MBQ.git
+    ```
+
+2. Create a conda env
+    ```bash
+    conda create -n qmllm python=3.10
+    ```
+
+3. Install packages and 3rdparty repos.
+    ```bash
+    # Install LLaVA-NeXT
+    cd ./3rdparty/LLaVA-NeXT
+    pip install -e .
+
+    # Install lmms-eval
+    cd ./3rdparty/lmms-eval
+    pip install -e .
+
+    # Install qmllm
+    pip install -r requirements.txt
+    pip install -e .
+    ```
+
+## Apply model quantization in `qmllm` package
+### Command-line Interface 
+
+Quantization search for MLLMs is executed based on `main_quant.py`. A variety of arguments are available to configure the quantization search process. We also support using YAML files for parameter configuration, you can refer to [yaml configs](./configs) to directly use and adjust parameters, or create your own custom configuration.
+
+1. Model arguments
+    * `--model` : Select which model type is processed during quantization search. Must be a string corresponding to the name of the model type. 
+        - only support `internvl2`, `llava_onevision`, `llava`, `qwen2_vl` now.
+    * `--model_args` : Control parameters passed to the model constructor. Accepts a string containing model path", for example `--model_args pretrained=OpenGVLab/InternVL2-8B`.
+
+2. Calibration arguments
+    * `--calib_data` : Select which calibration data type is used during quantization search. 
+        - only support `pileval` and `coco` now.
+    * `--n_samples` : The number of the samples used in quantization search.
+    * `--data_path` : Accept a string of the dataset path.
+        - for `pileval` , we use `mit-han-lab/pile-val-backup`.
+        - for `coco` , the data need to be a JSON or JSONL file, you can refer to [sharegpt4v](https://github.com/InternLM/InternLM-XComposer/blob/main/projects/ShareGPT4V/docs/Data.md#prepare-images) for data preparation.
+    * `--image_folder` : Accept a string of the image folder, you can refer to [sharegpt4v](https://github.com/InternLM/InternLM-XComposer/blob/main/projects/ShareGPT4V/docs/Data.md#prepare-images) for data preparation.
+    * `--few_shot_format` : Organize the calibration data in an interleaved format, currently by simply concatenating two samples.
+        - this option is valid only when `--calib_data=coco`.
+    * `--interleave_format` : Organize the calibration data with image-text pairs and pure text data, currently by simply insert 512 pure text token in two image-text pairs.
+        - this option is valid only when `--calib_data=coco`.
+    * `--text_data_path` : Accept a string of the pure text dataset path, this dataset will be used in interleave_format, we use `mit-han-lab/pile-val-backup`.
+
+3. Quantization arguments
+    * `--method` : Select the quantization search type, support `mbq` , `awq` , `smoothquant` and `rtn`.
+    * `--run_process` : Specify this parameter to run the quantization search.
+    * `--w_bit`: Specify the weight bit.
+    * `--w_group`: Specify the group size in `weight-only per-group` quantization.
+    * `--a_bit`: Specify the activation bit.
+    * `--alpha`: The hyperparameter of Smoothquant.
+    * `--reweight`: Specify this parameter to use gradient to reweight the loss during quantization search.
+    * `--distort`: Specify this parameter to use distort feature map during quantization search.
+    * `--loss_mode`: Select the loss type during quantization search, support `mae` , `mse`.
+    * `--scale_path`: The path for saving quantization search results.
+    * `--pseudo_quant`: Specify this parameter to perform pseudo quantization for the model.
+
+### Run Quantization
+* We support using YAML files for parameter configuration, you can use it as follows:
+    ```bash
+    python3 -W ignore main_quant.py \
+        --config configs/internvl2/MBQ_search/8b_weight_only.yaml
+    ```
+* For quantization, you should specify `--run_process` in the command and provide the appropriate `data path` and `quantization config`.
+* The quantization search results will be stored in `scale_path`, and we use the results to perform quantization.
+
+1. Weight-only Quantization with MBQ
+    ```bash
+    python3 -W ignore main_quant.py \
+        --model internvl2
+        --model_args pretrained="OpenGVLab/InternVL2-8B" \
+        --calib_data coco \
+        --data_path "your/data/path/" \
+        --image_folder "your/image/folder" \
+        --n_samples 128 \
+        --interleave_format \
+        --method mbq \
+        --run_process \
+        --w_bit 4 \
+        --w_group 128 \
+        --reweight \
+        --loss_mode mae \
+        --scale_path "scale_cache/mbq/internvl2_w4g128.pt"
+    ```
+2. Weight-Activation Quantization with MBQ
+    ```bash
+    python3 -W ignore main_quant.py \
+        --model internvl2
+        --model_args pretrained="OpenGVLab/InternVL2-8B" \
+        --calib_data coco \
+        --data_path "your/data/path/" \
+        --image_folder "your/image/folder" \
+        --n_samples 128 \
+        --method mbq \
+        --run_process \
+        --w_bit 4 \
+        --a_bit 8 \
+        --reweight \
+        --distort \
+        --loss_mode mae \
+        --scale_path "scale_cache/mbq/internvl2_w4a8.pt"
+    ```
+
+### Run Evaluation
+* We support using YAML files for parameter configuration, you can use it as follows:
+    ```bash
+    python3 -W ignore main.py \
+        --config configs/internvl2/Eval/eval.yaml
+    ```
+* For evaluation, you should specify `--pseudo_quant` in the command and provide the appropriate `scale path` and `quantization config`.
+
+1. Evaluation with weight-only quantization
+    ```bash
+    python3 -W ignore main.py \
+        --model internvl2
+        --model_args pretrained="OpenGVLab/InternVL2-8B" \
+        --tasks mmmu \
+        --batch_size 1 \
+        --log_samples \ 
+        --log_samples_suffix mmmu \
+        --method mbq \
+        --pseudo_quant \
+        --w_bit 4 \
+        --w_group 128 \
+        --output_path "your/output/path" \
+        --scale_path "scale_cache/mbq/internvl2_w4g128.pt"
+    ```
+
+2. Evaluation with weight-activation quantization
+    ```bash
+    python3 -W ignore main.py \
+        --model internvl2
+        --model_args pretrained="OpenGVLab/InternVL2-8B" \
+        --tasks mmmu \
+        --batch_size 1 \
+        --log_samples \ 
+        --log_samples_suffix mmmu \
+        --method mbq \
+        --pseudo_quant \
+        --w_bit 4 \
+        --a_bit 8 \
+        --output_path "your/output/path" \
+        --scale_path "scale_cache/mbq/internvl2_w4a8.pt"
+    ```
+
+## Citation
+```
+@misc{li2024mbq,
+      title={MBQ: Modality-Balanced Quantization for Large Vision-Language Models}, 
+      author={Shiyao Li and Yingchun Hu and Xuefei Ning and Xihui Liu and Ke Hong and Xiaotao Jia and Xiuhong Li and Yaqi Yan and Pei Ran and Guohao Dai and Shengen Yan and Huazhong Yang and Yu Wang},
+      year={2024},
+      eprint={2412.19509},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2412.19509}, 
+}
+```
+
+## Contact Us
+
+* Shiyao Li: lishiyao20@mails.tsinghua.edu.cn
+* Yingchun Hu: huych@buaa.edu.cn
+* Xuefei Ning: foxdoraame@gmail.com
+* Xiaotao Jia: jiaxt@buaa.edu.cn
+* Yu Wang: yu-wang@tsinghua.edu.cn
+
+This work is maintained by [NICS-EFC Lab](https://nicsefc.ee.tsinghua.edu.cn/) (Tsinghua University) and [Infinigence-AI](https://www.infini-ai.com/) (Beijing China).
+
+<p align="middle">
+  <img src="figures/logo_nicsefc.jpg" width="35%" hspace="30" />
+  <img src="figures/logo_Infinigence-ai.png" width="35%" hspace="30" />
+</p>

configs/internvl2/Eval/eval.yaml

@@ -0,0 +1,21 @@
+# model args
+model: internvl2
+model_args: pretrained="OpenGVLab/InternVL2-8B"
+
+# task args
+tasks: mmmu_val
+batch_size: 1
+log_samples: True
+log_samples_suffix: mmmu_val
+
+# quantization config
+method: mbq
+run_process: False # You don't need to run scale search, load the scale directly
+pseudo_quant: True # if True, conduct pseudo quantization on the model, otherwise the model will stay in fp16
+scale_path: scale_cache/mbq/internvl2_8b_w3g128.pt
+w_bit: 3
+w_group: 128
+
+# output args
+output_path: /your/output/log/path
+

configs/internvl2/MBQ_search/26b_weight_activation.yaml

@@ -0,0 +1,26 @@
+# model args
+model: internvl2
+model_args: pretrained="OpenGVLab/InternVL2-26B",device_map=auto
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 4
+a_bit: 8
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/internvl2_26b_w4a8.pt
+
+

configs/internvl2/MBQ_search/26b_weight_only.yaml

@@ -0,0 +1,26 @@
+# model args
+model: internvl2
+model_args: pretrained="OpenGVLab/InternVL2-26B",device_map=auto
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 3
+w_group: 128
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/internvl2_26b_w3g128.pt
+
+

configs/internvl2/MBQ_search/8b_weight_activation.yaml

@@ -0,0 +1,26 @@
+# model args
+model: internvl2
+model_args: pretrained="OpenGVLab/InternVL2-8B"
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 4
+a_bit: 8
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/internvl2_8b_w4a8.pt
+
+

configs/internvl2/MBQ_search/8b_weight_only.yaml

@@ -0,0 +1,26 @@
+# model args
+model: internvl2
+model_args: pretrained="OpenGVLab/InternVL2-8B"
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 3
+w_group: 128
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/internvl2_8b_w3g128.pt
+
+

configs/llava_onevision/Eval/eval.yaml

@@ -0,0 +1,21 @@
+# model args
+model: llava_onevision
+model_args: pretrained="lmms-lab/llava-onevision-qwen2-7b-ov"
+
+# task args
+tasks: mmmu_val
+batch_size: 1
+log_samples: True
+log_samples_suffix: mmmu_val
+
+# quantization config
+method: mbq
+run_process: False # You don't need to run scale search, load the scale directly
+pseudo_quant: True # if True, conduct pseudo quantization on the model, otherwise the model will stay in fp16
+scale_path: scale_cache/mbq/llava_ov_7b_w3g128.pt
+w_bit: 3
+w_group: 128
+
+# output args
+output_path: /your/output/log/path
+

configs/llava_onevision/MBQ_search/72b_weight_activation.yaml

@@ -0,0 +1,26 @@
+# model args
+model: llava_onevision
+model_args: pretrained="lmms-lab/llava-onevision-qwen2-72b-ov-sft",device_map=auto
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 4
+a_bit: 8
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/llava_ov_72b_w4a8.pt
+
+

configs/llava_onevision/MBQ_search/72b_weight_only.yaml

@@ -0,0 +1,26 @@
+# model args
+model: llava_onevision
+model_args: pretrained="lmms-lab/llava-onevision-qwen2-72b-ov-sft",device_map=auto
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 3
+w_group: 128
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/llava_ov_72b_w3g128.pt
+
+

configs/llava_onevision/MBQ_search/7b_weight_activation.yaml

@@ -0,0 +1,26 @@
+# model args
+model: llava_onevision
+model_args: pretrained="lmms-lab/llava-onevision-qwen2-7b-ov"
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 4
+a_bit: 8
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/llava_ov_7b_w4a8.pt
+
+

configs/llava_onevision/MBQ_search/7b_weight_only.yaml

@@ -0,0 +1,26 @@
+# model args
+model: llava_onevision
+model_args: pretrained="lmms-lab/llava-onevision-qwen2-7b-ov"
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 3
+w_group: 128
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/llava_ov_7b_w3g128.pt
+
+

configs/qwen2_vl/Eval/eval.yaml

@@ -0,0 +1,21 @@
+# model args
+model: qwen2_vl
+model_args: pretrained="Qwen/Qwen2-VL-7B-Instruct"
+
+# task args
+tasks: mmmu_val
+batch_size: 1
+log_samples: True
+log_samples_suffix: mmmu_val
+
+# quantization config
+method: mbq
+run_process: False # You don't need to run scale search, load the scale directly
+pseudo_quant: True # if True, conduct pseudo quantization on the model, otherwise the model will stay in fp16
+scale_path: scale_cache/mbq/qwen2_vl_7b_w3g128.pt
+w_bit: 3
+w_group: 128
+
+# output args
+output_path: /your/output/log/path
+

configs/qwen2_vl/MBQ_search/72b_weight_activation.yaml

@@ -0,0 +1,26 @@
+# model args
+model: qwen2_vl
+model_args: pretrained="Qwen/Qwen2-VL-72B-Instruct",device_map=auto
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 4
+a_bit: 8
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/qwen2_vl_72b_w4a8.pt
+
+

configs/qwen2_vl/MBQ_search/72b_weight_only.yaml

@@ -0,0 +1,26 @@
+# model args
+model: qwen2_vl
+model_args: pretrained="Qwen/Qwen2-VL-72B-Instruct",device_map=auto
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 3
+w_group: 128
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/qwen2_vl_72b_w3g128.pt
+
+

configs/qwen2_vl/MBQ_search/7b_weight_activation.yaml

@@ -0,0 +1,26 @@
+# model args
+model: qwen2_vl
+model_args: pretrained="Qwen/Qwen2-VL-7B-Instruct"
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 4
+a_bit: 8
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/qwen2_vl_7b_w4a8.pt
+
+

configs/qwen2_vl/MBQ_search/7b_weight_only.yaml

@@ -0,0 +1,26 @@
+# model args
+model: qwen2_vl
+model_args: pretrained="Qwen/Qwen2-VL-7B-Instruct"
+
+# calibration data args
+calib_data: coco
+n_samples: 128
+data_path: "your/coco/caption/path"
+image_folder: "your/coco/image/folder"
+few_shot_format: False # if True, concat two samples to simulate few shot
+interleave_format: False # if True, insert pure text data between two image-text pairs to simulate interleave data
+text_data_path: "" # You should specify this arg if you want to use interleave_format 
+
+# quantization config
+method: mbq
+run_process: True
+w_bit: 3
+w_group: 128
+distort: False # if True, use distort feature map during scale search process
+reweight: True # if True, use avg gradient to reweight the loss of each modality
+loss_mode: mae 
+
+# output args
+scale_path: scale_cache/mbq/qwen2_vl_7b_w3g128.pt
+
+

main.py

@@ -0,0 +1,567 @@
+import argparse
+import datetime
+import importlib
+import json
+import os
+import sys
+import traceback
+import warnings
+from functools import partial
+
+import numpy as np
+import yaml
+
+warnings.simplefilter("ignore", category=DeprecationWarning)
+
+import hashlib
+from pathlib import Path
+from typing import Union
+
+from accelerate import Accelerator
+from accelerate.utils import InitProcessGroupKwargs
+from loguru import logger as eval_logger
+
+from lmms_eval import evaluator, utils
+from lmms_eval.models import get_model
+from lmms_eval.evaluator import request_caching_arg_to_dict
+from lmms_eval.loggers import EvaluationTracker, WandbLogger
+from lmms_eval.tasks import TaskManager
+from lmms_eval.utils import (
+    make_table,
+    simple_parse_args_string,
+)
+
+from qmllm.quantization.quant_wrapper import qwrapper
+from qmllm.models import get_process_model
+from qmllm.calibration.pileval import get_calib_dataset
+from qmllm.calibration.coco_vl import get_multimodal_calib_dataset
+
+
+def _int_or_none_list_arg_type(min_len: int, max_len: int, defaults: str, value: str, split_char: str = ","):
+    def parse_value(item):
+        item = item.strip().lower()
+        if item == "none":
+            return None
+        try:
+            return int(item)
+        except ValueError:
+            raise argparse.ArgumentTypeError(f"{item} is not an integer or None")
+
+    items = [parse_value(v) for v in value.split(split_char)]
+    num_items = len(items)
+
+    if num_items == 1:
+        # Makes downstream handling the same for single and multiple values
+        items = items * max_len
+    elif num_items < min_len or num_items > max_len:
+        raise argparse.ArgumentTypeError(f"Argument requires {max_len} integers or None, separated by '{split_char}'")
+    elif num_items != max_len:
+        print(f"Argument requires {max_len} integers or None, separated by '{split_char}'. " "Missing values will be filled with defaults.")
+        default_items = [parse_value(v) for v in defaults.split(split_char)]
+        items.extend(default_items[num_items:])  # extend items list with missing defaults
+
+    return items
+
+
+def check_argument_types(parser: argparse.ArgumentParser):
+    """
+    Check to make sure all CLI args are typed, raises error if not
+    """
+    for action in parser._actions:
+        if action.dest != "help" and not action.const:
+            if action.type is None:
+                raise ValueError(f"Argument '{action.dest}' doesn't have a type specified.")
+            else:
+                continue
+
+
+def _handle_non_serializable(o):
+    if isinstance(o, np.int64) or isinstance(o, np.int32):
+        return int(o)
+    elif isinstance(o, set):
+        return list(o)
+    else:
+        return str(o)
+
+
+def parse_eval_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument("--config", default="", help="Path to a yaml file specifying all eval arguments, will ignore cli arguments if specified")
+    parser.add_argument("--model", default="hf", help="Name of model e.g. `hf`")
+    parser.add_argument(
+        "--tasks",
+        default=None,
+        help="To get full list of tasks, use the command lmms-eval --tasks list",
+    )
+    parser.add_argument(
+        "--model_args",
+        default="",
+        help="String arguments for model, e.g. `pretrained=EleutherAI/pythia-160m,dtype=float32`",
+    )
+    parser.add_argument(
+        "--num_fewshot",
+        type=int,
+        default=None,
+        help="Number of examples in few-shot context",
+    )
+    parser.add_argument(
+        "--batch_size",
+        "-b",
+        type=str,
+        default=1,
+        metavar="auto|auto:N|N",
+        help="Acceptable values are 'auto', 'auto:N' or N, where N is an integer. Default 1.",
+    )
+    parser.add_argument(
+        "--max_batch_size",
+        type=int,
+        default=None,
+        metavar="N",
+        help="Maximal batch size to try with --batch_size auto.",
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default=None,
+        help="Device to use (e.g. cuda, cuda:0, cpu)",
+    )
+    parser.add_argument(
+        "--output_path",
+        default=None,
+        type=str,
+        metavar="= [dir/file.jsonl] [DIR]",
+        help="The path to the output file where the result metrics will be saved. If the path is a directory and log_samples is true, the results will be saved in the directory. Else the parent directory will be used.",
+    )
+    parser.add_argument(
+        "--limit",
+        type=float,
+        default=None,
+        help="Limit the number of examples per task. " "If <1, limit is a percentage of the total number of examples.",
+    )
+    parser.add_argument(
+        "--use_cache",
+        "-c",
+        type=str,
+        default=None,
+        metavar="DIR",
+        help="A path to a sqlite db file for caching model responses. `None` if not caching.",
+    )
+    parser.add_argument(
+        "--cache_requests",
+        type=str,
+        default=None,
+        choices=["true", "refresh", "delete"],
+        help="Speed up evaluation by caching the building of dataset requests. `None` if not caching.",
+    )
+    parser.add_argument(
+        "--check_integrity",
+        action="store_true",
+        help="Whether to run the relevant part of the test suite for the tasks",
+    )
+    parser.add_argument(
+        "--write_out",
+        "-w",
+        action="store_true",
+        default=False,
+        help="Prints the prompt for the first few documents.",
+    )
+    parser.add_argument(
+        "--log_samples",
+        action="store_true",
+        default=False,
+        help="If True, write out all model outputs and documents for per-sample measurement and post-hoc analysis",
+    )
+    parser.add_argument(
+        "--wandb_log_samples",
+        action="store_true",
+        default=False,
+        help="If True, write out all model outputs and documents for per-sample measurement and post-hoc analysis to Weights and Biases",
+    )
+    parser.add_argument(
+        "--log_samples_suffix",
+        type=str,
+        default="model_outputs",
+        help="Specify a suffix for the log_samples file name.",
+    )
+    parser.add_argument(
+        "--system_instruction",
+        type=str,
+        default=None,
+        help="System instruction to be used in the prompt",
+    )
+    parser.add_argument(
+        "--apply_chat_template",
+        action="store_true",
+        default=False,
+        help="If True, applies the chat template to the prompt",
+    )
+    parser.add_argument(
+        "--fewshot_as_multiturn",
+        action="store_true",
+        default=False,
+        help="If True, uses the fewshot as a multi-turn conversation",
+    )
+    parser.add_argument(
+        "--show_config",
+        action="store_true",
+        default=False,
+        help="If True, shows the the full config of all tasks at the end of the evaluation.",
+    )
+    parser.add_argument(
+        "--include_path",
+        type=str,
+        default=None,
+        help="Additional path to include if there are external tasks to include.",
+    )
+    parser.add_argument(
+        "--gen_kwargs",
+        default="",
+        help=("String arguments for model generation on greedy_until tasks," " e.g. `temperature=0,top_k=0,top_p=0`"),
+    )
+    parser.add_argument(
+        "--verbosity",
+        type=str,
+        default="INFO",
+        help="Log error when tasks are not registered.",
+    )
+    parser.add_argument(
+        "--wandb_args",
+        default="",
+        help="Comma separated string arguments passed to wandb.init, e.g. `project=lmms-eval,job_type=eval",
+    )
+    parser.add_argument(
+        "--timezone",
+        default="Asia/Singapore",
+        help="Timezone for datetime string, e.g. Asia/Singapore, America/New_York, America/Los_Angeles. You can check the full list via `import pytz; print(pytz.common_timezones)`",
+    )
+    parser.add_argument(
+        "--hf_hub_log_args",
+        type=str,
+        default="",
+        help="Comma separated string arguments passed to Hugging Face Hub's log function, e.g. `hub_results_org=EleutherAI,hub_repo_name=lm-eval-results`",
+    )
+    parser.add_argument(
+        "--predict_only",
+        "-x",
+        action="store_true",
+        default=False,
+        help="Use with --log_samples. Only model outputs will be saved and metrics will not be evaluated.",
+    )
+    default_seed_string = "0,1234,1234,1234"
+    parser.add_argument(
+        "--seed",
+        type=partial(_int_or_none_list_arg_type, 3, 4, default_seed_string),
+        default=default_seed_string,  # for backward compatibility
+        help=(
+            "Set seed for python's random, numpy, torch, and fewshot sampling.\n"
+            "Accepts a comma-separated list of 4 values for python's random, numpy, torch, and fewshot sampling seeds, "
+            "respectively, or a single integer to set the same seed for all four.\n"
+            f"The values are either an integer or 'None' to not set the seed. Default is `{default_seed_string}` "
+            "(for backward compatibility).\n"
+            "E.g. `--seed 0,None,8,52` sets `random.seed(0)`, `torch.manual_seed(8)`, and fewshot sampling seed to 52. "
+            "Here numpy's seed is not set since the second value is `None`.\n"
+            "E.g, `--seed 42` sets all four seeds to 42."
+        ),
+    )
+    parser.add_argument(
+        "--trust_remote_code",
+        action="store_true",
+        help="Sets trust_remote_code to True to execute code to create HF Datasets from the Hub",
+    )
+
+    # calibration parameters
+    parser.add_argument("--calib_data", default="pileval", choices=["pileval", "coco", None])
+    parser.add_argument("--data_path", default="", type=str)
+    parser.add_argument("--image_folder", default="", type=str)
+    parser.add_argument("--n_samples", default=128, type=int)
+    parser.add_argument("--interleave_format", action="store_true")
+
+    # TODO: quantization parameters
+    parser.add_argument("--method", default="awq", choices=["awq", "smoothquant", "mbq", "rtn", None])
+    parser.add_argument("--w_bit", default=8, type=int)
+    parser.add_argument("--a_bit", default=16, type=int)
+    parser.add_argument("--w_group", default=128, type=int)
+    parser.add_argument("--alpha", default=0.5, type=int)
+    parser.add_argument("--reweight", action="store_true")
+    parser.add_argument("--distort", action="store_true")
+    parser.add_argument("--loss_mode", default="mae", choices=["mae", "mse"])
+    parser.add_argument("--scale_path", default=None, type=str)
+    parser.add_argument("--run_process", action="store_true")
+    parser.add_argument("--pseudo_quant", action="store_true")
+    args = parser.parse_args()
+    return args
+
+
+def cli_evaluate(args: Union[argparse.Namespace, None] = None) -> None:
+    if not args:
+        args = parse_eval_args()
+
+    # Check if no arguments were passed after parsing
+    if len(sys.argv) == 1:
+        print("┌───────────────────────────────────────────────────────────────────────────────┐")
+        print("│ Please provide arguments to evaluate the model. e.g.                          │")
+        print("│ `lmms-eval --model llava --model_path liuhaotian/llava-v1.6-7b --tasks okvqa` │")
+        print("│ Use `lmms-eval --help` for more information.                                  │")
+        print("└───────────────────────────────────────────────────────────────────────────────┘")
+        sys.exit(1)
+
+    if args.wandb_args:
+        if "name" not in args.wandb_args:
+            name = f"{args.model}_{args.model_args}_{utils.get_datetime_str(timezone=args.timezone)}"
+            name = utils.sanitize_long_string(name)
+            args.wandb_args += f",name={name}"
+        wandb_logger = WandbLogger(**simple_parse_args_string(args.wandb_args))
+
+    # reset logger
+    eval_logger.remove()
+    eval_logger.add(sys.stdout, colorize=True, level=args.verbosity)
+    eval_logger.info(f"Verbosity set to {args.verbosity}")
+    os.environ["VERBOSITY"] = args.verbosity
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+    args_list = []
+    results_list = []
+    if args.config:
+        if not os.path.exists(args.config):
+            raise ValueError(f"Config file does not exist: {args.config}")
+
+        with open(args.config, "r") as file:
+            config_args = yaml.safe_load(file)
+        config_args = [config_args] if type(config_args) != list else config_args
+        # multiple configs, create args list first
+        for config in config_args:
+            args_copy = argparse.Namespace(**vars(args))
+            for key, value in config.items():
+                setattr(args_copy, key, value)
+            args_list.append(args_copy)
+    else:
+        args_list.append(args)
+
+    # initialize Accelerator
+    kwargs_handler = InitProcessGroupKwargs(timeout=datetime.timedelta(seconds=60000))
+    accelerator = Accelerator(kwargs_handlers=[kwargs_handler])
+    if accelerator.is_main_process:
+        is_main_process = True
+    else:
+        is_main_process = False
+
+    for args in args_list:
+        try:
+            # if is_main_process and args.wandb_args:  # thoughtfully we should only init wandb once, instead of multiple ranks to avoid network traffics and unwanted behaviors.
+            #     wandb_logger = WandbLogger()
+
+            results, samples = cli_evaluate_single(args)
+            results_list.append(results)
+
+            accelerator.wait_for_everyone()
+            if is_main_process and args.wandb_args:
+                try:
+                    wandb_logger.post_init(results)
+                    wandb_logger.log_eval_result()
+                    if args.wandb_log_samples and samples is not None:
+                        wandb_logger.log_eval_samples(samples)
+                except Exception as e:
+                    eval_logger.info(f"Logging to Weights and Biases failed due to {e}")
+                # wandb_logger.finish()
+
+        except Exception as e:
+            if args.verbosity == "DEBUG":
+                raise e
+            else:
+                traceback.print_exc()
+                eval_logger.error(f"Error during evaluation: {e}. Please set `--verbosity=DEBUG` to get more information.")
+                results_list.append(None)
+
+    for args, results in zip(args_list, results_list):
+        # cli_evaluate will return none if the process is not the main process (rank 0)
+        if results is not None:
+            print(f"{args.model} ({args.model_args}), gen_kwargs: ({args.gen_kwargs}), limit: {args.limit}, num_fewshot: {args.num_fewshot}, " f"batch_size: {args.batch_size}")
+            print(make_table(results))
+            if "groups" in results:
+                print(make_table(results, "groups"))
+
+    if args.wandb_args:
+        wandb_logger.run.finish()
+
+
+def cli_evaluate_single(args: Union[argparse.Namespace, None] = None) -> None:
+    selected_task_list = args.tasks.split(",") if args.tasks else None
+
+    if args.include_path is not None:
+        eval_logger.info(f"Including path: {args.include_path}")
+    task_manager = TaskManager(args.verbosity, include_path=args.include_path, model_name=args.model)
+
+    # update the evaluation tracker args with the output path and the HF token
+    if args.output_path:
+        args.hf_hub_log_args += f",output_path={args.output_path}"
+    if os.environ.get("HF_TOKEN", None):
+        args.hf_hub_log_args += f",token={os.environ.get('HF_TOKEN')}"
+
+    evaluation_tracker_args = simple_parse_args_string(args.hf_hub_log_args)
+    eval_logger.info(f"Evaluation tracker args: {evaluation_tracker_args}")
+
+    evaluation_tracker = EvaluationTracker(**evaluation_tracker_args)
+
+    if args.predict_only:
+        args.log_samples = True
+    if (args.log_samples or args.predict_only) and not args.output_path:
+        raise ValueError("Specify --output_path if providing --log_samples or --predict_only")
+
+    if args.fewshot_as_multiturn and args.apply_chat_template is False:
+        raise ValueError("If fewshot_as_multiturn is set, apply_chat_template must be set to True.")
+
+    if (args.num_fewshot is None or args.num_fewshot == 0) and args.fewshot_as_multiturn:
+        raise ValueError("If fewshot_as_multiturn is set, num_fewshot must be greater than 0.")
+
+    if args.include_path is not None:
+        eval_logger.info(f"Including path: {args.include_path}")
+
+    if "push_samples_to_hub" in evaluation_tracker_args and not args.log_samples:
+        eval_logger.warning("Pushing samples to the Hub requires --log_samples to be set. Samples will not be pushed to the Hub.")
+
+    if args.limit:
+        eval_logger.warning(" --limit SHOULD ONLY BE USED FOR TESTING." "REAL METRICS SHOULD NOT BE COMPUTED USING LIMIT.")
+
+    if os.environ.get("LMMS_EVAL_PLUGINS", None):
+        args.include_path = [args.include_path] if args.include_path else []
+        for plugin in os.environ["LMMS_EVAL_PLUGINS"].split(","):
+            package_tasks_location = importlib.util.find_spec(f"{plugin}.tasks").submodule_search_locations[0]
+            args.include_path.append(package_tasks_location)
+
+    if args.tasks is None:
+        eval_logger.error("Need to specify task to evaluate.")
+        sys.exit()
+    elif args.tasks == "list":
+        eval_logger.info("Available Tasks:\n - {}".format(f"\n - ".join(sorted(task_manager.list_all_tasks()))))
+        sys.exit()
+    elif args.tasks == "list_groups":
+        eval_logger.info(task_manager.list_all_tasks(list_subtasks=False, list_tags=False))
+        sys.exit()
+    elif args.tasks == "list_tags":
+        eval_logger.info(task_manager.list_all_tasks(list_groups=False, list_subtasks=False))
+        sys.exit()
+    elif args.tasks == "list_subtasks":
+        eval_logger.info(task_manager.list_all_tasks(list_groups=False, list_tags=False))
+        sys.exit()
+    else:
+        if os.path.isdir(args.tasks):
+            import glob
+
+            task_names = []
+            yaml_path = os.path.join(args.tasks, "*.yaml")
+            for yaml_file in glob.glob(yaml_path):
+                config = utils.load_yaml_config(yaml_file)
+                task_names.append(config)
+        else:
+            task_list = args.tasks.split(",")
+            task_names = task_manager.match_tasks(task_list)
+            for task in [task for task in task_list if task not in task_names]:
+                if os.path.isfile(task):
+                    config = utils.load_yaml_config(task)
+                    task_names.append(config)
+            task_missing = [task for task in task_list if task not in task_names and "*" not in task]  # we don't want errors if a wildcard ("*") task name was used
+
+            if task_missing:
+                missing = ", ".join(task_missing)
+                eval_logger.error(
+                    f"Tasks were not found: {missing}\n" f"{utils.SPACING}Try `lm-eval --tasks list` for list of available tasks",
+                )
+                raise ValueError(
+                    f"Tasks not found: {missing}. Try `lm-eval --tasks {{list_groups,list_subtasks,list_tags,list}}` to list out all available names for task groupings; only (sub)tasks; tags; or all of the above, or pass '--verbosity DEBUG' to troubleshoot task registration issues."
+                )
+
+    eval_logger.info(f"Selected Tasks: {task_names}")
+    request_caching_args = request_caching_arg_to_dict(cache_requests=args.cache_requests)
+    datetime_str = utils.get_datetime_str(timezone=args.timezone)
+
+    # here we load MLLMs outside of the evaluator.
+    if args.model_args is None:
+        args.model_args = ""
+    
+    ModelClass = get_model(args.model)
+    lm = ModelClass.create_from_arg_string(
+        args.model_args,
+        {
+            "batch_size": args.batch_size,
+            "device": args.device,
+        },
+    )
+    # 
+    if args.pseudo_quant:
+        print("Pseudo quant...")
+        Process_ModelClass = get_process_model(args.model)
+        process_model = Process_ModelClass(lm._model, 
+                                        lm._tokenizer, 
+                                        lm.processor if hasattr(lm, 'processor') else None)
+
+        # 
+        prompt_inputs = None
+        prompt_kwargs = None
+        
+        # 
+        qwrapper(process_model, prompt_inputs, prompt_kwargs, args)
+
+    results = evaluator.simple_evaluate(
+        model=args.model,
+        lm=lm,
+        model_args=args.model_args,
+        tasks=task_names,
+        num_fewshot=args.num_fewshot,
+        batch_size=args.batch_size,
+        max_batch_size=args.max_batch_size,
+        device=args.device,
+        use_cache=args.use_cache,
+        limit=args.limit,
+        check_integrity=args.check_integrity,
+        write_out=args.write_out,
+        log_samples=args.log_samples,
+        evaluation_tracker=evaluation_tracker,
+        system_instruction=args.system_instruction,
+        apply_chat_template=args.apply_chat_template,
+        fewshot_as_multiturn=args.fewshot_as_multiturn,
+        gen_kwargs=args.gen_kwargs,
+        task_manager=task_manager,
+        verbosity=args.verbosity,
+        predict_only=args.predict_only,
+        random_seed=args.seed[0],
+        numpy_random_seed=args.seed[1],
+        torch_random_seed=args.seed[2],
+        fewshot_random_seed=args.seed[3],
+        cli_args=args,
+        datetime_str=datetime_str,
+        **request_caching_args,
+    )
+
+    if results is not None:
+        if args.log_samples:
+            samples = results.pop("samples")
+        else:
+            samples = None
+        dumped = json.dumps(results, indent=4, default=_handle_non_serializable)
+        if args.show_config:
+            print(dumped)
+
+        batch_sizes = ",".join(map(str, results["config"]["batch_sizes"]))
+
+        evaluation_tracker.save_results_aggregated(results=results, samples=samples if args.log_samples else None, datetime_str=datetime_str)
+
+        if args.log_samples:
+            for task_name, config in results["configs"].items():
+                evaluation_tracker.save_results_samples(task_name=task_name, samples=samples[task_name])
+
+        if evaluation_tracker.push_results_to_hub or evaluation_tracker.push_samples_to_hub:
+            evaluation_tracker.recreate_metadata_card()
+
+        return results, samples
+    return None, None
+
+
+def print_results(args, results):
+    print(f"{args.model} ({args.model_args}),\ngen_kwargs: ({args.gen_kwargs}),\nlimit: {args.limit},\nnum_fewshot: {args.num_fewshot},\nbatch_size: {args.batch_size}")
+    print(evaluator.make_table(results))
+    if "groups" in results:
+        print(evaluator.make_table(results, "groups"))
+
+
+if __name__ == "__main__":
+    cli_evaluate()

main_quant.py

@@ -0,0 +1,139 @@
+import argparse
+import datetime
+import importlib
+import json
+import os
+import sys
+import traceback
+import warnings
+from functools import partial
+
+import numpy as np
+import yaml
+
+warnings.simplefilter("ignore", category=DeprecationWarning)
+
+from typing import Union
+
+from lmms_eval.models import get_model
+
+from qmllm.quantization.quant_wrapper import qwrapper
+from qmllm.models import get_process_model
+from qmllm.calibration.pileval import get_calib_dataset
+from qmllm.calibration.coco_vl import get_multimodal_calib_dataset
+
+
+def parse_quant_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument("--config", default="", help="Path to a yaml file specifying all eval arguments, will ignore cli arguments if specified")
+    parser.add_argument("--model", default="hf", help="Name of model e.g. `hf`")
+    parser.add_argument(
+        "--model_args",
+        default="",
+        help="String arguments for model, e.g. `pretrained=EleutherAI/pythia-160m,dtype=float32`",
+    )
+    parser.add_argument(
+        "--batch_size",
+        "-b",
+        type=str,
+        default=1,
+        metavar="auto|auto:N|N",
+        help="Acceptable values are 'auto', 'auto:N' or N, where N is an integer. Default 1.",
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default=None,
+        help="Device to use (e.g. cuda, cuda:0, cpu)",
+    )
+    # calibration parameters
+    parser.add_argument("--calib_data", default="pileval", choices=["pileval", "coco", None])
+    parser.add_argument("--n_samples", default=128, type=int)
+    parser.add_argument("--data_path", default="", type=str)
+    parser.add_argument("--image_folder", default="", type=str)
+    parser.add_argument("--interleave_format", action="store_true")
+    parser.add_argument("--few_shot_format", action="store_true")
+    parser.add_argument("--text_data_path", default="", type=str)
+
+    # TODO: quantization parameters
+    parser.add_argument("--method", default="awq", choices=["awq", "smoothquant", "mbq", "rtn", None])
+    parser.add_argument("--w_bit", default=8, type=int)
+    parser.add_argument("--a_bit", default=16, type=int)
+    parser.add_argument("--w_group", default=128, type=int)
+    parser.add_argument("--alpha", default=0.5, type=int)
+    parser.add_argument("--reweight", action="store_true")
+    parser.add_argument("--distort", action="store_true")
+    parser.add_argument("--loss_mode", default="mae", choices=["mae", "mse"])
+    parser.add_argument("--scale_path", default=None, type=str)
+    parser.add_argument("--run_process", action="store_true")
+    parser.add_argument("--pseudo_quant", action="store_true")
+    args = parser.parse_args()
+    return args
+
+
+def cli_quant(args: Union[argparse.Namespace, None] = None) -> None:
+    if not args:
+        args = parse_quant_args()
+
+    args_list = []
+    if args.config:
+        if not os.path.exists(args.config):
+            raise ValueError(f"Config file does not exist: {args.config}")
+
+        with open(args.config, "r") as file:
+            config_args = yaml.safe_load(file)
+        config_args = [config_args] if type(config_args) != list else config_args
+        # multiple configs, create args list first
+        for config in config_args:
+            args_copy = argparse.Namespace(**vars(args))
+            for key, value in config.items():
+                setattr(args_copy, key, value)
+            args_list.append(args_copy)
+    else:
+        args_list.append(args)
+
+    for args in args_list:
+        cli_quant_single(args)
+
+
+def cli_quant_single(args: Union[argparse.Namespace, None] = None) -> None:
+    # here we load MLLMs outside of the evaluator.
+    if args.model_args is None:
+        args.model_args = ""
+    
+    ModelClass = get_model(args.model)
+    lm = ModelClass.create_from_arg_string(
+        args.model_args,
+        {
+            "batch_size": args.batch_size,
+            "device": args.device,
+        },
+    )
+
+    # Preprocess the MLLM here, use "lm._model" to get the fp16 mllm.
+    Process_ModelClass = get_process_model(args.model)
+    process_model = Process_ModelClass(lm._model, 
+                                       lm._tokenizer, 
+                                       lm.processor if hasattr(lm, 'processor') else None)
+
+    # Generate the calibration tokens.
+    prompt_inputs = None
+    prompt_kwargs = None
+
+    if args.calib_data == "pileval":
+        prompt_inputs, prompt_kwargs = get_calib_dataset(data_path=args.data_path, tokenizer=lm._tokenizer, n_samples=args.n_samples)
+    elif args.calib_data == "coco":
+        prompt_inputs, prompt_kwargs = get_multimodal_calib_dataset(data_path=args.data_path,
+                                                                    image_folder=args.image_folder,
+                                                                    model=process_model,
+                                                                    n_samples=args.n_samples,
+                                                                    few_shot_format=args.few_shot_format,
+                                                                    interleave_format=args.interleave_format,
+                                                                    text_data_path=args.text_data_path)
+
+    # Wrapper the quantized model.
+    qwrapper(process_model, prompt_inputs, prompt_kwargs, args)
+
+    
+if __name__ == "__main__":
+    cli_quant()

qmllm/calibration/coco_vl.py

@@ -0,0 +1,100 @@
+import os
+import json
+import torch
+import numpy as np
+
+from PIL import Image
+from datasets import load_dataset
+
+def load_image(image_path):
+    # Load the image using use PIL, we don't support tcs_loader
+    return Image.open(image_path).convert('RGB')
+
+
+def get_multimodal_calib_dataset(
+    data_path,
+    image_folder,
+    model,
+    n_samples=128,
+    few_shot_format=False,
+    interleave_format=False,
+    text_data_path=None,
+    shuffle=True, 
+):
+    if data_path.endswith(".jsonl"):
+        dataset = []
+        with open(data_path, "r") as json_file:
+            for line in json_file:
+                dataset.append(json.loads(line.strip()))
+    elif data_path.endswith(".json"):
+        with open(data_path, "r") as json_file:
+            dataset = json.load(json_file)
+    else:
+        raise ValueError(f"Unsupported file type: {data_path}")
+    
+    if shuffle:
+        rng = np.random.default_rng(seed=42)
+        rng.shuffle(dataset)
+
+    data_list = []
+    for i in range(n_samples):
+        i = i % len(dataset)
+        data_item = dataset[i]
+        if 'image' in data_item and len(data_item['image']) != 0:
+            if type(data_item['image']) == list:
+                images = []
+                for image_path in data_item['image']:
+                    # Merge the image path
+                    full_image_path = os.path.join(image_folder, image_path)
+                    image = load_image(full_image_path)
+                    images.append(image)
+            else:
+                images = []
+                image_path = data_item['image']
+                full_image_path = os.path.join(image_folder, image_path)
+                image = load_image(full_image_path)
+                images.append(image)
+        else:
+            images = None
+        
+        data_dict = model.preprocess_data(images, data_item)
+        data_list.append(data_dict)
+
+    examples = model.data_collator(data_list)
+    
+    if few_shot_format and interleave_format:
+        raise ValueError('You cannot specify both few_shot_format and interleave_format at the same time!')
+
+    if few_shot_format:
+        examples = model.few_shot_data_samples(examples)
+    if interleave_format:
+        if not text_data_path:
+            dataset = load_dataset("mit-han-lab/pile-val-backup", split="validation")
+        else:
+            # TODO: for other dataset, maybe we should not specify the split?
+            dataset = load_dataset(data_path, split="validation")
+        if shuffle:
+            dataset = dataset.shuffle(seed=42)
+        samples = []
+        n_run = 0
+        for data in dataset:
+            line = data["text"].strip()
+            line_encoded = model.tokenizer.encode(line)
+            
+            if len(line_encoded) > 512:
+                sample = torch.tensor(line_encoded[:512])
+                samples.append(sample)
+                n_run += 1
+                
+            if n_run == 128:
+                break
+        pure_text = samples
+
+        examples = model.interleave_data_samples(examples, pure_text=pure_text)
+
+    prompt_inputs, prompt_kwargs = model.generate_input(examples)
+
+    return prompt_inputs, prompt_kwargs 
+    
+
+

qmllm/calibration/pileval.py

@@ -0,0 +1,44 @@
+import torch
+from datasets import load_dataset
+
+def get_calib_dataset(data_path="", tokenizer=None, n_samples=512, block_size=512):
+    if not data_path:
+        dataset = load_dataset("mit-han-lab/pile-val-backup", split="validation")
+    else:
+        dataset = load_dataset(data_path, split="validation")
+    dataset = dataset.shuffle(seed=42)
+    samples = []
+    n_run = 0
+    for data in dataset:
+        line = data["text"]
+        line = line.strip()
+        line_encoded = tokenizer.encode(line)
+        if len(line_encoded) > 512:
+            continue
+        sample = torch.tensor([line_encoded])
+        if sample.numel() == 0:
+            continue
+        samples.append(sample)
+        n_run += 1
+        if n_run == n_samples:
+            break
+    # now concatenate all samples and split according to block size
+    cat_samples = torch.cat(samples, dim=1)
+    n_split = cat_samples.shape[1] // block_size
+    print(f" * Split into {n_split} blocks")
+
+    samples = [cat_samples[:, i * block_size : (i + 1) * block_size] for i in range(n_split)]
+    samples = torch.cat(samples, dim=0)
+
+    prompt_inputs = {
+        "input_ids": samples
+    }
+
+    prompt_kawrgs = {
+        "labels": samples,
+        "attention_mask": None,
+        "vision_mask": None,
+        "caption_mask": None,
+    }
+
+    return prompt_inputs, prompt_kawrgs

qmllm/datasets/multimodal_dataset.py

@@ -0,0 +1,50 @@
+import os
+import json
+import copy
+import torch
+import transformers
+import numpy as np
+from PIL import Image
+from dataclasses import dataclass, field
+from typing import  Dict, Optional, Sequence, List
+from torch.utils.data import Dataset, DataLoader
+
+# Import LLaVA modules
+try:
+    from llava.train.train import LazySupervisedDataset as LLaVA_LazySupervisedDataset
+    from llava.train.train import DataCollatorForSupervisedDataset as LLaVA_DataCollatorForSupervisedDataset
+except ImportError as e:
+    print(f"LLaVA is not installed. Please install LLaVA to use this model.\nError: {e}")
+
+# Import InternVL modules
+try:
+    from internvl.patch import concat_pad_data_collator
+    from internvl.train.internvl_chat_finetune import build_datasets
+except ImportError as e:
+    print(f"internvl-chat is not installed. Please install internvl-chat to use this model.\nError: {e}")
+
+def build_llava_dataloader(n_samples, tokenizer, shuffle, data_args):
+    train_dataset = LLaVA_LazySupervisedDataset(tokenizer=tokenizer, data_path=data_args.data_path, data_args=data_args)
+    data_collator = LLaVA_DataCollatorForSupervisedDataset(tokenizer=tokenizer)
+    dataloader = DataLoader(dataset=train_dataset, batch_size=n_samples, shuffle=shuffle, collate_fn=data_collator)
+
+    return dataloader
+
+def build_internvl_dataloader(n_samples, model, tokenizer, shuffle, data_args):
+    train_dataset = build_datasets(
+        data_args=data_args, 
+        tokenizer=tokenizer,
+        tcs_loader=None,
+        model=model,
+        group_by_length=True,
+        dynamic_image_size=data_args.dynamic_image_size,
+        use_thumbnail=data_args.use_thumbnail,
+        min_dynamic_patch=data_args.min_dynamic_patch,
+        max_dynamic_patch=data_args.max_dynamic_patch,
+        normalize_type=data_args.normalize_type
+    )
+    data_collator = concat_pad_data_collator
+    dataloader = DataLoader(dataset=train_dataset, batch_size=n_samples, shuffle=shuffle, collate_fn=data_collator)
+
+    return dataloader
+

qmllm/methods/awq/entry.py

@@ -0,0 +1,40 @@
+import torch
+
+from qmllm.methods.awq.quantize.pre_quant import run_awq, apply_awq
+from qmllm.methods.awq.quantize.quantizer import pseudo_quantize_model_weight
+
+
+def awq_entry(model, prompt_tokens, prompt_mask, run_awq_process: bool, scale_path: str=None, zero_point: str=True, q_group_size: int=128, w_bit: int=4):
+    '''
+    model: here the model is the LLM, you have to extract the LLM first! 
+    prompt_tokens: the prompt tokens
+    prompt_mask: the prompt mask, mask the answer language tokens
+    run_awq_process: whether to run the AWQ process
+    '''
+    q_config = {
+        "zero_point": zero_point,  # by default True
+        "q_group_size": q_group_size,  # whether to use group quantization
+    }
+
+    assert scale_path is not None
+
+    # reparameterization
+    if run_awq_process:
+        awq_results = run_awq(
+            model,
+            prompt_tokens,
+            prompt_mask,
+            w_bit=w_bit,
+            q_config=q_config,
+            auto_scale=True,
+        )
+        torch.save(awq_results, scale_path)
+        print("AWQ results saved at", scale_path)
+    else:
+        awq_results = torch.load(scale_path, map_location="cpu")
+        apply_awq(model, awq_results)
+
+    # weight quantization
+    pseudo_quantize_model_weight(model, w_bit=w_bit, q_config=q_config)
+        
+    return model

qmllm/methods/awq/quantize/auto_scale.py

@@ -0,0 +1,572 @@
+import gc
+import torch
+import torch.nn as nn
+
+from transformers.models.bloom.modeling_bloom import BloomBlock, BloomGelu
+from transformers.models.opt.modeling_opt import OPTDecoderLayer
+from transformers.models.llama.modeling_llama import LlamaDecoderLayer, LlamaRMSNorm
+from transformers.activations import GELUActivation
+
+from transformers.models.qwen2.modeling_qwen2 import Qwen2RMSNorm
+
+from .qmodule import ScaledActivation
+from qmllm.utils.search import get_op_by_name, get_op_name, set_op_by_name
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+
+__all__ = ["auto_scale_block", "apply_scale"]
+
+
+@torch.no_grad()
+def get_weight_scale(weight, q_group_size=-1):
+    org_shape = weight.shape
+    if q_group_size > 0:
+        weight = weight.view(-1, q_group_size)
+    scale = weight.abs() / weight.abs().amax(dim=1, keepdim=True)
+    scale = scale.view(org_shape)
+    scale = scale.mean(0)
+    return scale
+
+
+@torch.no_grad()
+def get_act_scale(x):
+    return x.abs().view(-1, x.shape[-1]).mean(0)
+
+
+@torch.no_grad()
+def scale_ln_fcs(ln, fcs, scales):
+    if not isinstance(fcs, list):
+        fcs = [fcs]
+
+    scales = scales.to(ln.weight.device)
+
+    ln.weight.div_(scales)
+    if hasattr(ln, "bias") and ln.bias is not None:
+        ln.bias.div_(scales)
+
+    for fc in fcs:
+        fc.weight.mul_(scales.view(1, -1))
+
+    for p in ln.parameters():
+        assert torch.isnan(p).sum() == 0
+    for fc in fcs:
+        for p in fc.parameters():
+            assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_fc_fc(fc1, fc2, scales):
+    assert isinstance(fc1, nn.Linear)
+    assert isinstance(fc2, nn.Linear)
+    # assert fc1.out_features == fc2.in_features
+
+    scales = scales.to(fc1.weight.device)
+
+    # fc1.weight.div_(scales.view(-1, 1))
+    fc1.weight[-scales.size(0) :].div_(scales.view(-1, 1))
+    if fc1.bias is not None:
+        fc1.bias.div_(scales.view(-1))
+
+    fc2.weight.mul_(scales.view(1, -1))
+
+    for p in fc1.parameters():
+        assert torch.isnan(p).sum() == 0
+    for p in fc2.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_gelu_fc(gelu, fc, scales):
+    assert isinstance(gelu, (nn.GELU, BloomGelu, GELUActivation))
+    assert isinstance(fc, nn.Linear)
+
+    fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+
+    for p in fc.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def auto_scale_block(module, module_kwargs, w_bit, q_config, input_feat, ans_mask):
+
+    # firstly, get the weight quantize function
+    if w_bit is not None:
+
+        def w_quantize_func(p):
+            return pseudo_quantize_tensor(
+                p,
+                n_bit=w_bit,
+                **q_config,
+            ).detach()
+
+    else:
+
+        def w_quantize_func(p):
+            return p
+
+    if "use_cache" in module_kwargs:
+        module_kwargs.pop("use_cache")
+
+    # find the best scale ratio
+    def _search_module_scale(block, linears2scale: list, x, kwargs={}):
+        # w: co, ci
+        # x: n, ci
+        x = x.to(next(block.parameters()).device)
+        with torch.no_grad():
+            org_out = block(x, **kwargs)
+            if isinstance(org_out, tuple):
+                org_out = org_out[0]
+
+        x_max = get_act_scale(x)
+
+        best_error = float("inf")
+        best_ratio = -1
+        best_scales = None
+
+        n_grid = 20
+        history = []
+
+        org_sd = {k: v.cpu() for k, v in block.state_dict().items()}
+        for ratio in range(n_grid):
+            ratio = ratio * 1 / n_grid
+            scales = x_max.pow(ratio).clamp(min=1e-4).view(-1)
+            scales = scales / (scales.max() * scales.min()).sqrt()
+            for fc in linears2scale:
+                fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+                fc.weight.data = w_quantize_func(fc.weight.data) / (scales.view(1, -1))
+            out = block(x, **kwargs)
+            if isinstance(out, tuple):
+                out = out[0]
+
+            # loss = (
+            #     (org_out - out).float().pow(2).mean().item()
+            # )  # float prevents overflow
+
+            if ans_mask is not None:
+                ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                masked_diff = ((org_out - out).float().pow(2) * ans_mask_expand)
+                loss = masked_diff.sum() / ans_mask_expand.sum() 
+            else:
+                loss = (
+                    (org_out - out).float().pow(2).mean().item()
+                )  # float prevents overflow
+            history.append(loss)
+            is_best = loss < best_error
+            if is_best:
+                best_error = loss
+                best_ratio = ratio
+                best_scales = scales
+            block.load_state_dict(org_sd)
+        if best_ratio == -1:
+            print(history)
+            raise Exception
+        # print(best_ratio)
+        best_scales = best_scales.view(-1)
+
+        assert torch.isnan(best_scales).sum() == 0, best_scales
+        return best_scales.detach()
+
+    def _auto_get_scale(prev_op, layers, inp, module2inspect=None, kwargs={}):
+        # module2inspect: if given, we will check the output diff of this module instead of layers
+        if module2inspect is None:
+            assert len(layers) == 1
+            module2inspect = layers[0]
+
+        scales = _search_module_scale(module2inspect, layers, inp, kwargs)
+        scales = scales.detach().cpu()
+        # prev_op_name, [layer_name], scale
+        return (
+            get_op_name(module, prev_op),
+            tuple([get_op_name(module, m) for m in layers]),
+            scales,
+        )
+
+    scales_list = []  # return the searched scales
+
+    if isinstance(module, OPTDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn_layer_norm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn.v_proj,
+                layers=[module.self_attn.out_proj],
+                inp=input_feat["self_attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.final_layer_norm,
+                layers=[module.fc1],
+                inp=input_feat["fc1"],
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.fc1,
+                layers=[module.fc2],
+                inp=input_feat["fc2"],
+            )
+        )
+
+    elif isinstance(module, LlamaDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+            )
+        )
+
+    elif isinstance(module, BloomBlock):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.self_attention.query_key_value],
+                inp=input_feat["self_attention.query_key_value"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/issues/2#issuecomment-1606297469
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.gelu_impl,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "mpt" in str(module.__class__).lower():
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_1,
+                layers=[module.attn.Wqkv],
+                inp=input_feat["attn.Wqkv"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.attn.Wqkv,
+                layers=[module.attn.out_proj],
+                inp=input_feat["attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_2,
+                layers=[module.ffn.up_proj],
+                inp=input_feat["ffn.up_proj"],
+                module2inspect=module.ffn,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ffn.act,
+                layers=[module.ffn.down_proj],
+                inp=input_feat["ffn.down_proj"],
+            )
+        )
+
+    elif "falcon" in str(module.__class__).lower():
+        # attn out
+        # Haotian: TBD: need to handle repeated scales for MQ
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1, as long as it is scaled, everything is screwed up
+        if "falcon-7b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.input_layernorm,
+                    layers=[
+                        module.mlp.dense_h_to_4h,
+                        module.self_attention.query_key_value,
+                    ],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        elif "falcon-40b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_attn,
+                    layers=[module.self_attention.query_key_value],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_mlp,
+                    layers=[module.mlp.dense_h_to_4h],
+                    inp=input_feat["mlp.dense_h_to_4h"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        else:
+            raise NotImplementedError(
+                "Unknown Falcon architecture, currently only falcon-7b and falcon-40b are supported"
+            )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "bigcode" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_1,
+                layers=[module.attn.c_attn],
+                inp=input_feat["attn.c_attn"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_2,
+                layers=[module.mlp.c_fc],
+                inp=input_feat["mlp.c_fc"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.c_proj],
+                inp=input_feat["mlp.c_proj"],
+            )
+        )
+    elif "neox" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.attention.query_key_value],
+                inp=input_feat["attention.query_key_value"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif module.__class__.__name__ == "Qwen2DecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+            )
+        )
+    elif module.__class__.__name__ == "InternLM2DecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.attention_norm,
+                layers=[
+                    module.attention.wqkv,
+                ],
+                inp=input_feat["attention.wqkv"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.attention.wqkv.weight.shape == module.attention.wo.weight.shape:
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.attention.wqkv,
+                    layers=[module.attention.wo],
+                    inp=input_feat["attention.wo"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ffn_norm,
+                layers=[module.feed_forward.w1, module.feed_forward.w3],
+                inp=input_feat["feed_forward.w1"],
+                module2inspect=module.feed_forward,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.feed_forward.w3,
+                layers=[module.feed_forward.w2],
+                inp=input_feat["feed_forward.w2"],
+            )
+        )
+    else:
+        raise NotImplementedError(f"{type(module)} not supported yet!")
+
+    return scales_list
+
+
+def apply_scale(module, scales_list, input_feat_dict=None):
+    for prev_op_name, layer_names, scales in scales_list:
+        prev_op = get_op_by_name(module, prev_op_name)
+        layers = [get_op_by_name(module, name) for name in layer_names]
+
+        prev_op.cuda()
+        for layer in layers:
+            layer.cuda()
+        scales.cuda()
+
+        if isinstance(prev_op, nn.Linear):
+            assert len(layers) == 1
+            scale_fc_fc(prev_op, layers[0], scales)
+        elif isinstance(prev_op, (nn.LayerNorm, LlamaRMSNorm, Qwen2RMSNorm)) or prev_op.__class__.__name__ == "InternLM2RMSNorm":
+            scale_ln_fcs(prev_op, layers, scales)
+        elif isinstance(prev_op, (nn.GELU, BloomGelu, GELUActivation)):
+            new_module = ScaledActivation(prev_op, scales)
+            set_op_by_name(module, prev_op_name, new_module)
+            scale_gelu_fc(prev_op, layers[0], scales)
+        else:
+            raise NotImplementedError(f"prev_op {type(prev_op)} not supported yet!")
+
+        # apply the scaling to input feat if given
+        if input_feat_dict is not None:
+            for layer_name in layer_names:
+                inp = input_feat_dict[layer_name]
+                inp.div_(scales.view(1, -1).to(inp.device))
+
+        prev_op.cpu()
+        for layer in layers:
+            layer.cpu()
+        scales.cpu()

qmllm/methods/awq/quantize/pre_quant.py

@@ -0,0 +1,207 @@
+import torch
+import torch.nn as nn
+import tqdm
+import gc
+import functools
+from collections import defaultdict
+from typing import List
+
+from transformers.models.bloom.modeling_bloom import BloomForCausalLM
+from transformers.models.opt.modeling_opt import OPTForCausalLM
+from transformers.models.llama.modeling_llama import LlamaForCausalLM
+
+from qmllm.calibration.pileval import get_calib_dataset
+from qmllm.calibration.coco_vl import get_multimodal_calib_dataset
+from qmllm.utils.search import append_str_prefix, get_op_name
+
+from qmllm.methods.awq.quantize.auto_scale import auto_scale_block, apply_scale
+
+__all__ = ["run_awq"]
+
+
+def get_named_linears(module):
+    return {name: m for name, m in module.named_modules() if isinstance(m, nn.Linear)}
+
+
+def get_blocks(model):
+    if model.__class__.__name__ == "LlamaForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaLlamaForCausalLM":
+        # layers = [model.model.layers, model.model.vision_tower.vision_tower.vision_model.encoder.layers]
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaQwenForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "InternLM2ForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "InternVLChatModel":
+        layers = model.language_model.model.layers
+    elif isinstance(model, OPTForCausalLM):
+        layers = model.model.decoder.layers
+    elif isinstance(model, BloomForCausalLM):
+        layers = model.transformer.h
+    elif "mpt" in str(model.__class__).lower():
+        layers = model.transformer.blocks
+    elif "falcon" in str(model.__class__).lower():
+        layers = model.transformer.h
+    elif "bigcode" in str(model.__class__).lower():
+        layers = model.transformer.h
+    elif "neox" in str(model.__class__).lower():
+        layers = model.gpt_neox.layers
+    else:
+        raise NotImplementedError(type(model))
+    return layers
+
+
+def move_embed(model, device):
+    if isinstance(model, LlamaForCausalLM):
+        model.model.embed_tokens = model.model.embed_tokens.to(device)
+        model.model.rotary_emb = model.model.rotary_emb.to(device)
+    elif isinstance(model, OPTForCausalLM):
+        model.model.decoder.embed_tokens = model.model.decoder.embed_tokens.to(device)
+        model.model.decoder.embed_positions = model.model.decoder.embed_positions.to(
+            device
+        )
+    elif isinstance(model, BloomForCausalLM):
+        model.transformer.word_embeddings = model.transformer.word_embeddings.to(device)
+        model.transformer.word_embeddings_layernorm = (
+            model.transformer.word_embeddings_layernorm.to(device)
+        )
+    elif "mpt" in str(model.__class__).lower():
+        model.transformer.wte = model.transformer.wte.to(device)
+        model.transformer.emb_drop = model.transformer.emb_drop.to(device)
+    elif "falcon" in str(model.__class__).lower():
+        model.transformer.word_embeddings = model.transformer.word_embeddings.to(device)
+    elif "bigcode" in str(model.__class__).lower():
+        model.transformer.wte = model.transformer.wte.to(device)
+        model.transformer.wpe = model.transformer.wpe.to(device)
+        model.transformer.drop = model.transformer.drop.to(device)
+    elif "neox" in str(model.__class__).lower():
+        model.gpt_neox.embed_in = model.gpt_neox.embed_in.to(device)
+        model.gpt_neox.emb_dropout = model.gpt_neox.emb_dropout.to(device)
+        model.embed_out = model.embed_out.to(device)
+    elif model.__class__.__name__ == "LlavaQwenForCausalLM":
+        model.embed_tokens = model.embed_tokens.to(device)
+        # model.model.rotary_emb = model.model.rotary_emb.to(device)
+    elif model.__class__.__name__ == "InternLM2ForCausalLM":
+        model.tok_embeddings = model.tok_embeddings.to(device)
+    elif model.__class__.__name__ == "InternVLChatModel":
+        model.model.tok_embeddings = model.model.tok_embeddings.to(device)  
+    else:
+        raise NotImplementedError(type(model))
+
+
+@torch.no_grad()
+def run_awq(
+    model,
+    prompt_tokens,
+    prompt_mask,
+    w_bit,
+    q_config,
+    auto_scale=True,
+):
+
+    if "bigcode" in str(model.__class__).lower():
+        # otherwise attention_mask will always be on cpu.
+        model.transformer.bias = model.transformer.bias.to("cuda")
+
+    layers = get_blocks(model)
+
+    inps = []
+    layer_kwargs = {}
+
+    layers[0] = layers[0].cuda()
+    move_embed(model, "cuda")
+
+    # get input and kwargs to layer 0
+    # with_kwargs is only supported in PyTorch 2.0
+    # use this Catcher hack for now
+    class Catcher(nn.Module):
+        def __init__(self, module):
+            super().__init__()
+            self.module = module
+
+        def forward(self, inp, **kwargs):
+            inps.append(inp)
+            layer_kwargs.update(kwargs)
+            raise ValueError  # early exit to break later inference
+
+    # patch layer 0 to catch input and kwargs
+    layers[0] = Catcher(layers[0])
+    model(prompt_tokens.to(next(model.parameters()).device), use_cache=False)
+
+    layers[0] = layers[0].module  # restore
+    inps = inps[0]
+
+    layers[0] = layers[0].cpu()
+    move_embed(model, "cpu")
+
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    awq_results = {
+        "scale": [],
+    }
+
+    # solve layer by layer
+    for i in tqdm.tqdm(range(len(layers)), desc="Running AWQ..."):
+        layer = layers[i]
+        layer = layer.cuda()
+        named_linears = get_named_linears(layer)
+
+        # firstly, get input features of all linear layers
+        def cache_input_hook(m, x, y, name, feat_dict):
+            x = x[0]
+            x = x.detach().cpu()
+            feat_dict[name].append(x)
+
+        input_feat = defaultdict(list)
+        handles = []
+        for name in named_linears:
+            handles.append(
+                named_linears[name].register_forward_hook(
+                    functools.partial(cache_input_hook, name=name, feat_dict=input_feat)
+                )
+            )
+        inps = inps.to(next(layer.parameters()).device)  # in case multi-gpu
+        # get output as next layer's input
+        inps = layer(inps, **layer_kwargs)[0]
+        for h in handles:
+            h.remove()
+        # now solve for scaling
+        input_feat = {k: torch.cat(v, dim=0) for k, v in input_feat.items()}
+
+        # Clear GPU memory
+        torch.cuda.empty_cache()
+
+        if (
+            auto_scale
+        ):  # if it applies, we should also modify the input_feat with scales
+            scales_list = auto_scale_block(
+                layer,
+                layer_kwargs,
+                w_bit=w_bit,
+                q_config=q_config,
+                input_feat=input_feat,
+                ans_mask=prompt_mask,
+            )
+            # apply_scale(layer, scales_list, input_feat_dict=input_feat)
+            apply_scale(layers[i], scales_list, input_feat_dict=input_feat)
+            # append prefix to make names global
+            awq_results["scale"] += append_str_prefix(
+                scales_list, get_op_name(model, layer) + "."
+            )
+
+        # Clear GPU memory
+        torch.cuda.empty_cache()
+
+        layer = layer.cpu()
+        # Haotian: check activation replacement
+        del input_feat
+        gc.collect()
+        torch.cuda.empty_cache()
+
+    return awq_results
+
+
+def apply_awq(model, awq_results):
+    apply_scale(model, awq_results["scale"])

qmllm/methods/awq/quantize/qmodule.py

@@ -0,0 +1,31 @@
+import math
+import torch
+import torch.nn as nn
+
+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
+
+
+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)

qmllm/methods/awq/quantize/quantizer.py

@@ -0,0 +1,76 @@
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+import gc
+from qmllm.methods.awq.quantize.qmodule import ScaledActivation
+from qmllm.utils.search import set_op_by_name
+
+from transformers.models.bloom.modeling_bloom import BloomBlock
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+
+EMBEDDING_KEYWORDS = ["embed"]
+LM_HEAD_KEYWORDS = ["lm_head", "embed_out", "output"]
+
+
+def scale_activations(module):
+    param = next(module.parameters())
+    dtype = param.dtype
+    device = param.device
+    if isinstance(module, BloomBlock):
+        if isinstance(module.mlp.gelu_impl, ScaledActivation):
+            return
+        c = module.mlp.dense_h_to_4h.out_features
+        act = ScaledActivation(
+            module.mlp.gelu_impl, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.gelu_impl", act)
+    elif "mptblock" in str(module.__class__.__name__).lower():
+        if isinstance(module.ffn.act, ScaledActivation):
+            return
+        c = module.ffn.up_proj.out_features
+        act = ScaledActivation(
+            module.ffn.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "ffn.act", act)
+    elif "falcon" in str(module.__class__).lower():
+        if isinstance(module.mlp.act, ScaledActivation):
+            return
+        c = module.mlp.dense_h_to_4h.out_features
+        act = ScaledActivation(
+            module.mlp.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.act", act)
+    elif "bigcode" in str(module.__class__).lower():
+        if isinstance(module.mlp.act, ScaledActivation):
+            return
+        c = module.mlp.c_proj.out_features
+        act = ScaledActivation(
+            module.mlp.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.act", act)
+    elif "neox" in str(module.__class__).lower():
+        if isinstance(module.mlp.act, ScaledActivation):
+            return
+        c = module.mlp.dense_h_to_4h.out_features
+        act = ScaledActivation(
+            module.mlp.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.act", act)
+
+@torch.no_grad()
+def pseudo_quantize_model_weight(
+    model,
+    w_bit,
+    q_config,
+):
+    from .pre_quant import get_blocks, get_named_linears
+
+    layers = get_blocks(model)
+    for i in tqdm(range(len(layers)), desc="pseudo weight quantization..."):
+        named_linears = get_named_linears(layers[i])
+        for n, m in named_linears.items():
+            m.cuda()
+            m.weight.data = pseudo_quantize_tensor(
+                m.weight.data, n_bit=w_bit, **q_config
+            )
+            m.cpu()

qmllm/methods/mbq/entry.py

@@ -0,0 +1,58 @@
+import os
+import torch
+
+from qmllm.methods.mbq.quantize.pre_quant import run_mbq, apply_mbq
+from qmllm.methods.mbq.quantize.quantizer import pseudo_quantize_model_weight, pseudo_quantize_model_weight_act
+
+
+def mbq_entry(model, prompt_inputs, prompt_kwargs, run_mbq_process: bool, pseudo_quant: bool, scale_path: str=None, zero_point: str=True, q_group_size: int=128, w_bit: int=4, a_bit: int=16, wa_quant: bool=False, reweight: bool=False, distort: bool=False, loss_mode: str="mae"):
+    '''
+    model: here the model is the LLM, you have to extract the LLM first! 
+    prompt_tokens: the prompt tokens
+    prompt_mask: the prompt mask, mask the answer language tokens
+    run_mbq_process: whether to run the MBQ process
+    '''
+    q_config = {
+        "zero_point": zero_point,  # by default True
+        "q_group_size": q_group_size,  # whether to use group quantization
+    }
+
+    assert scale_path is not None
+
+    scale_exist = os.path.exists(scale_path)
+    # reparameterization
+    if run_mbq_process and not scale_exist:
+        model.to_cpu()
+        mbq_results = run_mbq(
+            model,
+            prompt_inputs,
+            prompt_kwargs,
+            w_bit=w_bit,
+            a_bit=a_bit,
+            q_config=q_config,
+            auto_scale=True,
+            loss_mode=loss_mode,
+            wa_quant=wa_quant,
+            reweight=reweight,
+            distort=distort,
+        )
+        
+        dirpath = os.path.dirname(scale_path)
+        os.makedirs(dirpath, exist_ok=True)
+        
+        torch.save(mbq_results, scale_path)
+        print("MBQ results saved at", scale_path)
+
+    if pseudo_quant:
+        mbq_results = torch.load(scale_path, map_location="cpu")
+        apply_mbq(model.model, mbq_results)
+
+        if not wa_quant:
+            # weight quantization
+            pseudo_quantize_model_weight(model.model, w_bit=w_bit, q_config=q_config)
+        else:
+            # weight activation quantization
+            pseudo_quantize_model_weight_act(model.model, w_bit=w_bit, a_bit=a_bit)
+
+    model.to_cuda()
+    return model

qmllm/methods/mbq/quantize/auto_scale.py

@@ -0,0 +1,664 @@
+import gc
+import torch
+import torch.nn as nn
+
+from transformers.models.bloom.modeling_bloom import BloomBlock, BloomGelu
+from transformers.models.opt.modeling_opt import OPTDecoderLayer
+from transformers.models.llama.modeling_llama import LlamaDecoderLayer, LlamaRMSNorm
+from transformers.activations import GELUActivation
+
+from transformers.models.qwen2.modeling_qwen2 import Qwen2RMSNorm
+
+from .qmodule import ScaledActivation
+from qmllm.utils.search import get_op_by_name, get_op_name, set_op_by_name
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+
+__all__ = ["auto_scale_block", "apply_scale"]
+
+
+@torch.no_grad()
+def get_weight_scale(weight, q_group_size=-1):
+    org_shape = weight.shape
+    if q_group_size > 0:
+        weight = weight.view(-1, q_group_size)
+    scale = weight.abs() / weight.abs().amax(dim=1, keepdim=True)
+    scale = scale.view(org_shape)
+    scale = scale.mean(0)
+    return scale
+
+
+@torch.no_grad()
+def get_act_scale(x):
+    return x.abs().view(-1, x.shape[-1]).mean(0)
+
+
+@torch.no_grad()
+def scale_ln_fcs(ln, fcs, scales):
+    if not isinstance(fcs, list):
+        fcs = [fcs]
+
+    scales = scales.to(ln.weight.device)
+
+    ln.weight.div_(scales)
+    if hasattr(ln, "bias") and ln.bias is not None:
+        ln.bias.div_(scales)
+
+    for fc in fcs:
+        fc.weight.mul_(scales.view(1, -1))
+
+    for p in ln.parameters():
+        assert torch.isnan(p).sum() == 0
+    for fc in fcs:
+        for p in fc.parameters():
+            assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_fc_fc(fc1, fc2, scales):
+    assert isinstance(fc1, nn.Linear)
+    assert isinstance(fc2, nn.Linear)
+    # assert fc1.out_features == fc2.in_features
+
+    scales = scales.to(fc1.weight.device)
+
+    # fc1.weight.div_(scales.view(-1, 1))
+    fc1.weight[-scales.size(0) :].div_(scales.view(-1, 1))
+    if fc1.bias is not None:
+        fc1.bias.div_(scales.view(-1))
+
+    fc2.weight.mul_(scales.view(1, -1))
+
+    for p in fc1.parameters():
+        assert torch.isnan(p).sum() == 0
+    for p in fc2.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_gelu_fc(gelu, fc, scales):
+    assert isinstance(gelu, (nn.GELU, BloomGelu, GELUActivation))
+    assert isinstance(fc, nn.Linear)
+
+    fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+
+    for p in fc.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def auto_scale_block(module, module_kwargs, w_bit, q_config, input_feat, ans_mask, vis_mask, reweight_ratio_dict, loss_mode="mae"):
+
+    # firstly, get the weight quantize function
+    if w_bit is not None:
+
+        def w_quantize_func(p):
+            return pseudo_quantize_tensor(
+                p,
+                n_bits=w_bit,
+                **q_config,
+            ).detach()
+
+    else:
+
+        def w_quantize_func(p):
+            return p
+
+    if "use_cache" in module_kwargs:
+        module_kwargs.pop("use_cache")
+
+    # find the best scale ratio
+    def _search_module_scale(block, linears2scale: list, x, reweight_ratio=None, kwargs={}):
+        # w: co, ci
+        # x: n, ci
+        x = x.to(next(block.parameters()).device)
+        with torch.no_grad():
+            org_out = block(x, **kwargs)
+            if isinstance(org_out, tuple):
+                org_out = org_out[0]
+
+        x_max = get_act_scale(x)
+
+        best_error = float("inf")
+        best_ratio = -1
+        best_scales = None
+
+        n_grid = 20
+        history = []
+
+        org_sd = {k: v.cpu() for k, v in block.state_dict().items()}
+        for ratio in range(n_grid):
+            ratio = ratio * 1 / n_grid
+            scales = x_max.pow(ratio).clamp(min=1e-4).view(-1)
+            scales = scales / (scales.max() * scales.min()).sqrt()
+            for fc in linears2scale:
+                fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+                fc.weight.data = w_quantize_func(fc.weight.data) / (scales.view(1, -1))
+            out = block(x, **kwargs)
+            if isinstance(out, tuple):
+                out = out[0]
+
+            # loss = (
+            #     (org_out - out).float().pow(2).mean().item()
+            # )  # float prevents overflow
+
+            if loss_mode == "mse":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().pow(2) * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = masked_diff_ans.sum() / ans_mask_expand.sum() + reweight_ratio * (masked_diff_vis.sum() / vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().pow(2).mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().pow(2).mean().item()
+                    )  # float prevents overflow
+            elif loss_mode == "mae":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().abs() * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().abs() * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = (masked_diff_ans.sum() + reweight_ratio * masked_diff_vis.sum()) / (ans_mask_expand.sum() + vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().abs().mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().abs() * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().abs().mean().item()
+                    )  # float prevents overflow
+
+            history.append(loss)
+            is_best = loss < best_error
+            if is_best:
+                best_error = loss
+                best_ratio = ratio
+                best_scales = scales
+            block.load_state_dict(org_sd)
+        if best_ratio == -1:
+            print(history)
+            raise Exception
+        # print(best_ratio)
+        best_scales = best_scales.view(-1)
+
+        assert torch.isnan(best_scales).sum() == 0, best_scales
+        return best_scales.detach()
+
+    def _auto_get_scale(prev_op, layers, inp, reweight_ratio=None, module2inspect=None, kwargs={}):
+        # module2inspect: if given, we will check the output diff of this module instead of layers
+        if module2inspect is None:
+            assert len(layers) == 1
+            module2inspect = layers[0]
+
+        scales = _search_module_scale(module2inspect, layers, inp, reweight_ratio, kwargs)
+        scales = scales.detach().cpu()
+        # prev_op_name, [layer_name], scale
+        return (
+            get_op_name(module, prev_op),
+            tuple([get_op_name(module, m) for m in layers]),
+            scales,
+        )
+
+    scales_list = []  # return the searched scales
+
+    if isinstance(module, OPTDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn_layer_norm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn.v_proj,
+                layers=[module.self_attn.out_proj],
+                inp=input_feat["self_attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.final_layer_norm,
+                layers=[module.fc1],
+                inp=input_feat["fc1"],
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.fc1,
+                layers=[module.fc2],
+                inp=input_feat["fc2"],
+            )
+        )
+
+    elif isinstance(module, LlamaDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+
+    elif isinstance(module, BloomBlock):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.self_attention.query_key_value],
+                inp=input_feat["self_attention.query_key_value"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/issues/2#issuecomment-1606297469
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.gelu_impl,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "mpt" in str(module.__class__).lower():
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_1,
+                layers=[module.attn.Wqkv],
+                inp=input_feat["attn.Wqkv"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.attn.Wqkv,
+                layers=[module.attn.out_proj],
+                inp=input_feat["attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_2,
+                layers=[module.ffn.up_proj],
+                inp=input_feat["ffn.up_proj"],
+                module2inspect=module.ffn,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ffn.act,
+                layers=[module.ffn.down_proj],
+                inp=input_feat["ffn.down_proj"],
+            )
+        )
+
+    elif "falcon" in str(module.__class__).lower():
+        # attn out
+        # Haotian: TBD: need to handle repeated scales for MQ
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1, as long as it is scaled, everything is screwed up
+        if "falcon-7b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.input_layernorm,
+                    layers=[
+                        module.mlp.dense_h_to_4h,
+                        module.self_attention.query_key_value,
+                    ],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        elif "falcon-40b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_attn,
+                    layers=[module.self_attention.query_key_value],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_mlp,
+                    layers=[module.mlp.dense_h_to_4h],
+                    inp=input_feat["mlp.dense_h_to_4h"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        else:
+            raise NotImplementedError(
+                "Unknown Falcon architecture, currently only falcon-7b and falcon-40b are supported"
+            )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "bigcode" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_1,
+                layers=[module.attn.c_attn],
+                inp=input_feat["attn.c_attn"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_2,
+                layers=[module.mlp.c_fc],
+                inp=input_feat["mlp.c_fc"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.c_proj],
+                inp=input_feat["mlp.c_proj"],
+            )
+        )
+    elif "neox" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.attention.query_key_value],
+                inp=input_feat["attention.query_key_value"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif module.__class__.__name__ == "Qwen2DecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    elif module.__class__.__name__ == "InternLM2DecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.attention_norm,
+                layers=[
+                    module.attention.wqkv,
+                ],
+                inp=input_feat["attention.wqkv"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.attention.wqkv.weight.shape == module.attention.wo.weight.shape:
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.attention.wqkv,
+                    layers=[module.attention.wo],
+                    inp=input_feat["attention.wo"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ffn_norm,
+                layers=[module.feed_forward.w1, module.feed_forward.w3],
+                inp=input_feat["feed_forward.w1"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.feed_forward,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.feed_forward.w3,
+                layers=[module.feed_forward.w2],
+                inp=input_feat["feed_forward.w2"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    
+    elif module.__class__.__name__ == "Qwen2VLDecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    else:
+        raise NotImplementedError(f"{type(module)} not supported yet!")
+
+    return scales_list
+
+
+def apply_scale(module, scales_list, input_feat_dict=None):
+    for prev_op_name, layer_names, scales in scales_list:
+        prev_op = get_op_by_name(module, prev_op_name)
+        layers = [get_op_by_name(module, name) for name in layer_names]
+
+        prev_op.cuda()
+        for layer in layers:
+            layer.cuda()
+        scales.cuda()
+
+        if isinstance(prev_op, nn.Linear):
+            assert len(layers) == 1
+            scale_fc_fc(prev_op, layers[0], scales)
+        elif isinstance(prev_op, (nn.LayerNorm, LlamaRMSNorm)) or prev_op.__class__.__name__ == "InternLM2RMSNorm" or prev_op.__class__.__name__ == "Qwen2RMSNorm":
+            scale_ln_fcs(prev_op, layers, scales)
+        elif isinstance(prev_op, (nn.GELU, BloomGelu, GELUActivation)):
+            new_module = ScaledActivation(prev_op, scales)
+            set_op_by_name(module, prev_op_name, new_module)
+            scale_gelu_fc(prev_op, layers[0], scales)
+        else:
+            raise NotImplementedError(f"prev_op {type(prev_op)} not supported yet!")
+
+        # apply the scaling to input feat if given
+        if input_feat_dict is not None:
+            for layer_name in layer_names:
+                inp = input_feat_dict[layer_name]
+                inp.div_(scales.view(1, -1).to(inp.device))
+
+        prev_op.cpu()
+        for layer in layers:
+            layer.cpu()
+        scales.cpu()

qmllm/methods/mbq/quantize/auto_scale_distort.py

@@ -0,0 +1,784 @@
+import gc
+import torch
+import functools
+import torch.nn as nn
+
+from transformers.models.bloom.modeling_bloom import BloomBlock, BloomGelu
+from transformers.models.opt.modeling_opt import OPTDecoderLayer
+from transformers.models.llama.modeling_llama import LlamaDecoderLayer, LlamaRMSNorm
+from transformers.activations import GELUActivation
+
+from collections import defaultdict
+from transformers.models.qwen2.modeling_qwen2 import Qwen2RMSNorm
+
+from .qmodule import ScaledActivation
+from qmllm.utils.search import get_op_by_name, get_op_name, set_op_by_name
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+
+__all__ = ["auto_scale_block_distort", "apply_scale"]
+
+
+@torch.no_grad()
+def get_weight_scale(weight, q_group_size=-1):
+    org_shape = weight.shape
+    if q_group_size > 0:
+        weight = weight.view(-1, q_group_size)
+    scale = weight.abs() / weight.abs().amax(dim=1, keepdim=True)
+    scale = scale.view(org_shape)
+    scale = scale.mean(0)
+    return scale
+
+
+@torch.no_grad()
+def get_act_scale(x):
+    return x.abs().view(-1, x.shape[-1]).mean(0)
+
+
+@torch.no_grad()
+def scale_ln_fcs(ln, fcs, scales):
+    if not isinstance(fcs, list):
+        fcs = [fcs]
+
+    scales = scales.to(ln.weight.device)
+
+    ln.weight.div_(scales)
+    if hasattr(ln, "bias") and ln.bias is not None:
+        ln.bias.div_(scales)
+
+    for fc in fcs:
+        fc.weight.mul_(scales.view(1, -1))
+
+    for p in ln.parameters():
+        assert torch.isnan(p).sum() == 0
+    for fc in fcs:
+        for p in fc.parameters():
+            assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_fc_fc(fc1, fc2, scales):
+    assert isinstance(fc1, nn.Linear)
+    assert isinstance(fc2, nn.Linear)
+    # assert fc1.out_features == fc2.in_features
+
+    scales = scales.to(fc1.weight.device)
+
+    # fc1.weight.div_(scales.view(-1, 1))
+    fc1.weight[-scales.size(0) :].div_(scales.view(-1, 1))
+    if fc1.bias is not None:
+        fc1.bias.div_(scales.view(-1))
+
+    fc2.weight.mul_(scales.view(1, -1))
+
+    for p in fc1.parameters():
+        assert torch.isnan(p).sum() == 0
+    for p in fc2.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_gelu_fc(gelu, fc, scales):
+    assert isinstance(gelu, (nn.GELU, BloomGelu, GELUActivation))
+    assert isinstance(fc, nn.Linear)
+
+    fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+
+    for p in fc.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def auto_scale_block_distort(module, module_kwargs, w_bit, q_config, input_feat, ans_mask, vis_mask, reweight_ratio_dict, q_input, loss_mode="mae"):
+
+    # firstly, get the weight quantize function
+    if w_bit is not None:
+
+        def w_quantize_func(p):
+            return pseudo_quantize_tensor(
+                p,
+                n_bits=w_bit,
+                **q_config,
+            ).detach()
+
+    else:
+
+        def w_quantize_func(p):
+            return p
+
+    if "use_cache" in module_kwargs:
+        module_kwargs.pop("use_cache")
+
+    # find the best scale ratio
+    def _search_module_scale_distort(block, linears2scale: list, x, x_q, reweight_ratio=None, kwargs={}):
+        # w: co, ci
+        # x: n, ci
+        x = x.to(next(block.parameters()).device)
+        x_q = x_q.to(next(block.parameters()).device)
+        with torch.no_grad():
+            org_out = block(x, **kwargs)
+            if isinstance(org_out, tuple):
+                org_out = org_out[0]
+
+        x_max = get_act_scale(x_q)
+
+        best_error = float("inf")
+        best_ratio = -1
+        best_scales = None
+
+        n_grid = 20
+        history = []
+
+        org_sd = {k: v.cpu() for k, v in block.state_dict().items()}
+        for ratio in range(n_grid):
+            ratio = ratio * 1 / n_grid
+            scales = x_max.pow(ratio).clamp(min=1e-4).view(-1)
+            scales = scales / (scales.max() * scales.min()).sqrt()
+            for fc in linears2scale:
+                fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+                fc.weight.data = w_quantize_func(fc.weight.data) / (scales.view(1, -1))
+            out = block(x_q, **kwargs)
+            if isinstance(out, tuple):
+                out = out[0]
+
+            # loss = (
+            #     (org_out - out).float().pow(2).mean().item()
+            # )  # float prevents overflow
+
+            if loss_mode == "mse":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().pow(2) * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = masked_diff_ans.sum() / ans_mask_expand.sum() + reweight_ratio * (masked_diff_vis.sum() / vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().pow(2).mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().pow(2).mean().item()
+                    )  # float prevents overflow
+            elif loss_mode == "mae":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().abs() * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().abs() * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = (masked_diff_ans.sum() + reweight_ratio * masked_diff_vis.sum()) / (ans_mask_expand.sum() + vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().abs().mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().abs() * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().abs().mean().item()
+                    )  # float prevents overflow
+
+            history.append(loss)
+            is_best = loss < best_error
+            if is_best:
+                best_error = loss
+                best_ratio = ratio
+                best_scales = scales
+            block.load_state_dict(org_sd)
+        if best_ratio == -1:
+            print(history)
+            raise Exception
+        # print(best_ratio)
+        best_scales = best_scales.view(-1)
+
+        assert torch.isnan(best_scales).sum() == 0, best_scales
+        return best_scales.detach()
+
+    def _auto_get_scale_distort(prev_op, layers, inp, inp_q, reweight_ratio=None, module2inspect=None, kwargs={}):
+        # module2inspect: if given, we will check the output diff of this module instead of layers
+        if module2inspect is None:
+            assert len(layers) == 1
+            module2inspect = layers[0]
+
+        scales = _search_module_scale_distort(module2inspect, layers, inp, inp_q, reweight_ratio, kwargs)
+        scales = scales.detach().cpu()
+        # prev_op_name, [layer_name], scale
+        return (
+            get_op_name(module, prev_op),
+            tuple([get_op_name(module, m) for m in layers]),
+            scales,
+        )
+
+    scales_list = []  # return the searched scales
+
+
+    def _auto_get_input_feat_distort(inps_q, scales_list=None):
+
+        org_sd = {k: v.cpu() for k, v in module.state_dict().items()}
+        
+        named_linears = {name: m for name, m in module.named_modules() if isinstance(m, nn.Linear)}
+
+        if scales_list is not None:
+            apply_scale(module, scales_list)
+            module.cuda()
+            for name in named_linears:
+                named_linears[name].weight.data = w_quantize_func(named_linears[name].weight.data).cuda()
+
+        def cache_input_hook(m, x, y, name, feat_dict):
+            x = x[0]
+            x = x.detach().cpu()
+            feat_dict[name].append(x)
+
+        input_feat_q = defaultdict(list)
+        handles = []
+        for name in named_linears:
+            handles.append(
+                named_linears[name].register_forward_hook(
+                    functools.partial(cache_input_hook, name=name, feat_dict=input_feat_q)
+                )
+            )
+
+        inps_q = inps_q.to(next(module.parameters()).device)
+        module(inps_q, **module_kwargs)
+        for h in handles:
+            h.remove()
+    
+        input_feat_q = {k: torch.cat(v, dim=0) for k, v in input_feat_q.items()}
+
+        torch.cuda.empty_cache()
+
+        module.load_state_dict(org_sd)
+
+        return input_feat_q
+    
+
+    if isinstance(module, OPTDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn_layer_norm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn.v_proj,
+                layers=[module.self_attn.out_proj],
+                inp=input_feat["self_attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.final_layer_norm,
+                layers=[module.fc1],
+                inp=input_feat["fc1"],
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.fc1,
+                layers=[module.fc2],
+                inp=input_feat["fc2"],
+            )
+        )
+
+    elif isinstance(module, LlamaDecoderLayer):
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                inp_q=input_feat_q["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_distort(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                    inp_q=input_feat_q["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                inp_q=input_feat_q["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+                inp_q=input_feat_q["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+
+    elif isinstance(module, BloomBlock):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.self_attention.query_key_value],
+                inp=input_feat["self_attention.query_key_value"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/issues/2#issuecomment-1606297469
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.gelu_impl,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "mpt" in str(module.__class__).lower():
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_1,
+                layers=[module.attn.Wqkv],
+                inp=input_feat["attn.Wqkv"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.attn.Wqkv,
+                layers=[module.attn.out_proj],
+                inp=input_feat["attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_2,
+                layers=[module.ffn.up_proj],
+                inp=input_feat["ffn.up_proj"],
+                module2inspect=module.ffn,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ffn.act,
+                layers=[module.ffn.down_proj],
+                inp=input_feat["ffn.down_proj"],
+            )
+        )
+
+    elif "falcon" in str(module.__class__).lower():
+        # attn out
+        # Haotian: TBD: need to handle repeated scales for MQ
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1, as long as it is scaled, everything is screwed up
+        if "falcon-7b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.input_layernorm,
+                    layers=[
+                        module.mlp.dense_h_to_4h,
+                        module.self_attention.query_key_value,
+                    ],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        elif "falcon-40b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_attn,
+                    layers=[module.self_attention.query_key_value],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_mlp,
+                    layers=[module.mlp.dense_h_to_4h],
+                    inp=input_feat["mlp.dense_h_to_4h"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        else:
+            raise NotImplementedError(
+                "Unknown Falcon architecture, currently only falcon-7b and falcon-40b are supported"
+            )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "bigcode" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_1,
+                layers=[module.attn.c_attn],
+                inp=input_feat["attn.c_attn"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_2,
+                layers=[module.mlp.c_fc],
+                inp=input_feat["mlp.c_fc"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.c_proj],
+                inp=input_feat["mlp.c_proj"],
+            )
+        )
+    elif "neox" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.attention.query_key_value],
+                inp=input_feat["attention.query_key_value"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif module.__class__.__name__ == "Qwen2DecoderLayer":
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                inp_q=input_feat_q["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_distort(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                    inp_q=input_feat_q["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                inp_q=input_feat_q["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+                inp_q=input_feat_q["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    elif module.__class__.__name__ == "InternLM2DecoderLayer":
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.attention_norm,
+                layers=[
+                    module.attention.wqkv,
+                ],
+                inp=input_feat["attention.wqkv"],
+                inp_q=input_feat_q["attention.wqkv"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.attention.wqkv.weight.shape == module.attention.wo.weight.shape:
+            scales_list.append(
+                _auto_get_scale_distort(
+                    prev_op=module.attention.wqkv,
+                    layers=[module.attention.wo],
+                    inp=input_feat["attention.wo"],
+                    inp_q=input_feat_q["attention.wo"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.ffn_norm,
+                layers=[module.feed_forward.w1, module.feed_forward.w3],
+                inp=input_feat["feed_forward.w1"],
+                inp_q=input_feat_q["feed_forward.w1"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.feed_forward,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.feed_forward.w3,
+                layers=[module.feed_forward.w2],
+                inp=input_feat["feed_forward.w2"],
+                inp_q=input_feat_q["feed_forward.w2"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    
+    elif module.__class__.__name__ == "Qwen2VLDecoderLayer":
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                inp_q=input_feat_q["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_distort(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    inp=input_feat["self_attn.o_proj"],
+                    inp_q=input_feat_q["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                inp=input_feat["mlp.gate_proj"],
+                inp_q=input_feat_q["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_distort(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                inp=input_feat["mlp.down_proj"],
+                inp_q=input_feat_q["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    else:
+        raise NotImplementedError(f"{type(module)} not supported yet!")
+
+    return scales_list
+
+
+def apply_scale(module, scales_list, input_feat_dict=None):
+    for prev_op_name, layer_names, scales in scales_list:
+        prev_op = get_op_by_name(module, prev_op_name)
+        layers = [get_op_by_name(module, name) for name in layer_names]
+
+        prev_op.cuda()
+        for layer in layers:
+            layer.cuda()
+        scales.cuda()
+
+        if isinstance(prev_op, nn.Linear):
+            assert len(layers) == 1
+            scale_fc_fc(prev_op, layers[0], scales)
+        elif isinstance(prev_op, (nn.LayerNorm, LlamaRMSNorm)) or prev_op.__class__.__name__ == "InternLM2RMSNorm" or prev_op.__class__.__name__ == "Qwen2RMSNorm":
+            scale_ln_fcs(prev_op, layers, scales)
+        elif isinstance(prev_op, (nn.GELU, BloomGelu, GELUActivation)):
+            new_module = ScaledActivation(prev_op, scales)
+            set_op_by_name(module, prev_op_name, new_module)
+            scale_gelu_fc(prev_op, layers[0], scales)
+        else:
+            raise NotImplementedError(f"prev_op {type(prev_op)} not supported yet!")
+
+        # apply the scaling to input feat if given;
+        if input_feat_dict is not None:
+            for layer_name in layer_names:
+                inp = input_feat_dict[layer_name]
+                inp.div_(scales.view(1, -1).to(inp.device))
+
+        prev_op.cpu()
+        for layer in layers:
+            layer.cpu()
+        scales.cpu()

qmllm/methods/mbq/quantize/auto_scale_wa.py

@@ -0,0 +1,681 @@
+import gc
+import copy
+import torch
+import functools
+import torch.nn as nn
+
+from transformers.models.bloom.modeling_bloom import BloomBlock, BloomGelu
+from transformers.models.opt.modeling_opt import OPTDecoderLayer
+from transformers.models.llama.modeling_llama import LlamaDecoderLayer, LlamaRMSNorm
+from transformers.activations import GELUActivation
+
+from collections import defaultdict
+from transformers.models.qwen2.modeling_qwen2 import Qwen2RMSNorm
+
+from .qmodule import ScaledActivation
+from qmllm.utils.search import get_op_by_name, get_op_name, set_op_by_name
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+from qmllm.quantization.qlinear import WALinear
+
+__all__ = ["auto_scale_block_wa"]
+
+
+@torch.no_grad()
+def get_weight_scale(weight, q_group_size=-1):
+    org_shape = weight.shape
+    if q_group_size > 0:
+        weight = weight.view(-1, q_group_size)
+    scale = weight.abs() / weight.abs().amax(dim=1, keepdim=True)
+    scale = scale.view(org_shape)
+    scale = scale.mean(0)
+    return scale
+
+
+@torch.no_grad()
+def get_act_scale(x):
+    return x.abs().view(-1, x.shape[-1]).mean(0)
+
+
+@torch.no_grad()
+def scale_ln_fcs(ln, fcs, scales):
+    if not isinstance(fcs, list):
+        fcs = [fcs]
+
+    scales = scales.to(ln.weight.device)
+
+    ln.weight.div_(scales)
+    if hasattr(ln, "bias") and ln.bias is not None:
+        ln.bias.div_(scales)
+
+    for fc in fcs:
+        fc.weight.mul_(scales.view(1, -1))
+
+    for p in ln.parameters():
+        assert torch.isnan(p).sum() == 0
+    for fc in fcs:
+        for p in fc.parameters():
+            assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_fc_fc(fc1, fc2, scales):
+    assert isinstance(fc1, nn.Linear)
+    assert isinstance(fc2, nn.Linear)
+    # assert fc1.out_features == fc2.in_features
+
+    scales = scales.to(fc1.weight.device)
+
+    # fc1.weight.div_(scales.view(-1, 1))
+    fc1.weight[-scales.size(0) :].div_(scales.view(-1, 1))
+    if fc1.bias is not None:
+        fc1.bias.div_(scales.view(-1))
+
+    fc2.weight.mul_(scales.view(1, -1))
+
+    for p in fc1.parameters():
+        assert torch.isnan(p).sum() == 0
+    for p in fc2.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_gelu_fc(gelu, fc, scales):
+    assert isinstance(gelu, (nn.GELU, BloomGelu, GELUActivation))
+    assert isinstance(fc, nn.Linear)
+
+    fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+
+    for p in fc.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def auto_scale_block_wa(module, module_kwargs, w_bit, a_bit, q_config, input_feat, ans_mask, vis_mask, reweight_ratio_dict, loss_mode="mae"):
+
+    if "use_cache" in module_kwargs:
+        module_kwargs.pop("use_cache")
+
+    def _search_module_scale_wa(block, linears2scale: list, layers_name, x, reweight_ratio=None, kwargs={}):
+        # w: co, ci
+        # x: n, ci
+        x = x.to(next(block.parameters()).device)
+        with torch.no_grad():
+            org_out = block(x, **kwargs)
+            if isinstance(org_out, tuple):
+                org_out = org_out[0]
+
+        x_max = get_act_scale(x)
+
+        best_error = float("inf")
+        best_ratio = -1
+        best_scales = None
+
+        n_grid = 20
+        history = []
+
+        org_sd = {k: v.cpu() for k, v in block.state_dict().items()}
+        for ratio in range(n_grid):
+            ratio = ratio * 1 / n_grid
+            scales = x_max.pow(ratio).clamp(min=1e-4).view(-1)
+            scales = scales / (scales.max() * scales.min()).sqrt()
+
+            if isinstance(block, nn.Linear):
+                new_block = None
+            for fc, fc_name in zip(linears2scale, layers_name):
+                # fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+                # fc.weight.data = w_quantize_func(fc.weight.data) / (scales.view(1, -1))
+                fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+                new_fc = WALinear.from_float(fc, weight_quant="per_channel", act_quant="per_token", w_bit=w_bit, a_bit=a_bit)
+                
+                if isinstance(block, nn.Linear):
+                    new_block = copy.deepcopy(new_fc)                   
+                else:
+                    setattr(block, fc_name, new_fc)
+                    
+                del new_fc
+                torch.cuda.empty_cache()
+
+            x_scale = x / (scales.view(1, 1, -1)) 
+
+            if isinstance(block, nn.Linear):
+                out = new_block(x_scale, **kwargs)
+            else:
+                out = block(x_scale, **kwargs)
+
+            if isinstance(out, tuple):
+                out = out[0]
+
+            # loss = (
+            #     (org_out - out).float().pow(2).mean().item()
+            # )  # float prevents overflow
+
+            if loss_mode == "mse":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().pow(2) * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = masked_diff_ans.sum() / ans_mask_expand.sum() + reweight_ratio * (masked_diff_vis.sum() / vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().pow(2).mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().pow(2).mean().item()
+                    )  # float prevents overflow
+            elif loss_mode == "mae":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().abs() * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().abs() * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = (masked_diff_ans.sum() + reweight_ratio * masked_diff_vis.sum()) / (ans_mask_expand.sum() + vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().abs().mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().abs() * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().abs().mean().item()
+                    )  # float prevents overflow
+
+
+            history.append(loss)
+            is_best = loss < best_error
+            if is_best:
+                best_error = loss
+                best_ratio = ratio
+                best_scales = scales
+
+            # restore the block
+            for fc, fc_name in zip(linears2scale, layers_name):
+                if isinstance(block, nn.Linear):
+                    continue
+                else:
+                    setattr(block, fc_name, fc)
+            
+            if isinstance(block, nn.Linear):
+                del new_block 
+            torch.cuda.empty_cache()
+            block.load_state_dict(org_sd)
+        if best_ratio == -1:
+            print(history)
+            raise Exception
+        # print(best_ratio)
+        best_scales = best_scales.view(-1)
+
+        assert torch.isnan(best_scales).sum() == 0, best_scales
+        return best_scales.detach()
+
+    def _auto_get_scale_wa(prev_op, layers, layers_name, inp, reweight_ratio=None, module2inspect=None, kwargs={}):
+        # module2inspect: if given, we will check the output diff of this module instead of layers
+        if module2inspect is None:
+            assert len(layers) == 1
+            module2inspect = layers[0]
+
+        scales = _search_module_scale_wa(module2inspect, layers, layers_name, inp, reweight_ratio, kwargs)
+        scales = scales.detach().cpu()
+        # prev_op_name, [layer_name], scale
+        return (
+            get_op_name(module, prev_op),
+            tuple([get_op_name(module, m) for m in layers]),
+            scales,
+        )
+
+    scales_list = []  # return the searched scales
+
+    if isinstance(module, OPTDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn_layer_norm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn.v_proj,
+                layers=[module.self_attn.out_proj],
+                inp=input_feat["self_attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.final_layer_norm,
+                layers=[module.fc1],
+                inp=input_feat["fc1"],
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.fc1,
+                layers=[module.fc2],
+                inp=input_feat["fc2"],
+            )
+        )
+
+    elif isinstance(module, LlamaDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                layers_name=[
+                    "q_proj",
+                    "k_proj",
+                    "v_proj",
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    layers_name=["o_proj"],
+                    inp=input_feat["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                layers_name=["gate_proj", "up_proj"],
+                inp=input_feat["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                layers_name=["down_proj"],
+                inp=input_feat["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+
+    elif isinstance(module, BloomBlock):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.self_attention.query_key_value],
+                inp=input_feat["self_attention.query_key_value"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/issues/2#issuecomment-1606297469
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.gelu_impl,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "mpt" in str(module.__class__).lower():
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_1,
+                layers=[module.attn.Wqkv],
+                inp=input_feat["attn.Wqkv"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.attn.Wqkv,
+                layers=[module.attn.out_proj],
+                inp=input_feat["attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_2,
+                layers=[module.ffn.up_proj],
+                inp=input_feat["ffn.up_proj"],
+                module2inspect=module.ffn,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ffn.act,
+                layers=[module.ffn.down_proj],
+                inp=input_feat["ffn.down_proj"],
+            )
+        )
+
+    elif "falcon" in str(module.__class__).lower():
+        # attn out
+        # Haotian: TBD: need to handle repeated scales for MQ
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1, as long as it is scaled, everything is screwed up
+        if "falcon-7b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.input_layernorm,
+                    layers=[
+                        module.mlp.dense_h_to_4h,
+                        module.self_attention.query_key_value,
+                    ],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        elif "falcon-40b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_attn,
+                    layers=[module.self_attention.query_key_value],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_mlp,
+                    layers=[module.mlp.dense_h_to_4h],
+                    inp=input_feat["mlp.dense_h_to_4h"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        else:
+            raise NotImplementedError(
+                "Unknown Falcon architecture, currently only falcon-7b and falcon-40b are supported"
+            )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "bigcode" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_1,
+                layers=[module.attn.c_attn],
+                inp=input_feat["attn.c_attn"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_2,
+                layers=[module.mlp.c_fc],
+                inp=input_feat["mlp.c_fc"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.c_proj],
+                inp=input_feat["mlp.c_proj"],
+            )
+        )
+    elif "neox" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.attention.query_key_value],
+                inp=input_feat["attention.query_key_value"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif module.__class__.__name__ == "Qwen2DecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                layers_name=[
+                    "q_proj",
+                    "k_proj",
+                    "v_proj",
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    layers_name=["o_proj"],
+                    inp=input_feat["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                layers_name=["gate_proj", "up_proj"],
+                inp=input_feat["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                layers_name=["down_proj"],
+                inp=input_feat["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    elif module.__class__.__name__ == "InternLM2DecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.attention_norm,
+                layers=[
+                    module.attention.wqkv,
+                ],
+                layers_name=[
+                    "wqkv",
+                ],
+                inp=input_feat["attention.wqkv"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.attention.wqkv.weight.shape == module.attention.wo.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa(
+                    prev_op=module.attention.wqkv,
+                    layers=[module.attention.wo],
+                    layers_name=["wo"],
+                    inp=input_feat["attention.wo"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.ffn_norm,
+                layers=[module.feed_forward.w1, module.feed_forward.w3],
+                layers_name=["w1","w3"],
+                inp=input_feat["feed_forward.w1"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.feed_forward,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.feed_forward.w3,
+                layers=[module.feed_forward.w2],
+                layers_name=["w2"],
+                inp=input_feat["feed_forward.w2"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+
+    elif module.__class__.__name__ == "Qwen2VLDecoderLayer":
+        # attention input
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                layers_name=[
+                    "q_proj",
+                    "k_proj",
+                    "v_proj",
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    layers_name=["o_proj"],
+                    inp=input_feat["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                layers_name=["gate_proj", "up_proj"],
+                inp=input_feat["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale_wa(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                layers_name=["down_proj"],
+                inp=input_feat["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    else:
+        raise NotImplementedError(f"{type(module)} not supported yet!")
+
+    return scales_list
+

qmllm/methods/mbq/quantize/auto_scale_wa_distort.py

@@ -0,0 +1,840 @@
+import gc
+import copy
+import torch
+import functools
+import torch.nn as nn
+
+from transformers.models.bloom.modeling_bloom import BloomBlock, BloomGelu
+from transformers.models.opt.modeling_opt import OPTDecoderLayer
+from transformers.models.llama.modeling_llama import LlamaDecoderLayer, LlamaRMSNorm
+from transformers.activations import GELUActivation
+
+from collections import defaultdict
+from transformers.models.qwen2.modeling_qwen2 import Qwen2RMSNorm
+
+from .qmodule import ScaledActivation
+from .quantizer import get_module_by_name_suffix
+from qmllm.utils.search import get_op_by_name, get_op_name, set_op_by_name
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+from qmllm.quantization.qlinear import WALinear
+
+__all__ = ["auto_scale_block_wa_distort"]
+
+
+@torch.no_grad()
+def get_weight_scale(weight, q_group_size=-1):
+    org_shape = weight.shape
+    if q_group_size > 0:
+        weight = weight.view(-1, q_group_size)
+    scale = weight.abs() / weight.abs().amax(dim=1, keepdim=True)
+    scale = scale.view(org_shape)
+    scale = scale.mean(0)
+    return scale
+
+
+@torch.no_grad()
+def get_act_scale(x):
+    return x.abs().view(-1, x.shape[-1]).mean(0)
+
+
+@torch.no_grad()
+def scale_ln_fcs(ln, fcs, scales):
+    if not isinstance(fcs, list):
+        fcs = [fcs]
+
+    scales = scales.to(ln.weight.device)
+
+    ln.weight.div_(scales)
+    if hasattr(ln, "bias") and ln.bias is not None:
+        ln.bias.div_(scales)
+
+    for fc in fcs:
+        fc.weight.mul_(scales.view(1, -1))
+
+    for p in ln.parameters():
+        assert torch.isnan(p).sum() == 0
+    for fc in fcs:
+        for p in fc.parameters():
+            assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_fc_fc(fc1, fc2, scales):
+    assert isinstance(fc1, nn.Linear)
+    assert isinstance(fc2, nn.Linear)
+    # assert fc1.out_features == fc2.in_features
+
+    scales = scales.to(fc1.weight.device)
+
+    # fc1.weight.div_(scales.view(-1, 1))
+    fc1.weight[-scales.size(0) :].div_(scales.view(-1, 1))
+    if fc1.bias is not None:
+        fc1.bias.div_(scales.view(-1))
+
+    fc2.weight.mul_(scales.view(1, -1))
+
+    for p in fc1.parameters():
+        assert torch.isnan(p).sum() == 0
+    for p in fc2.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def scale_gelu_fc(gelu, fc, scales):
+    assert isinstance(gelu, (nn.GELU, BloomGelu, GELUActivation))
+    assert isinstance(fc, nn.Linear)
+
+    fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+
+    for p in fc.parameters():
+        assert torch.isnan(p).sum() == 0
+
+
+@torch.no_grad()
+def auto_scale_block_wa_distort(module, module_kwargs, w_bit, a_bit, q_config, input_feat, ans_mask, vis_mask, reweight_ratio_dict, q_input, loss_mode="mae"):
+
+    if "use_cache" in module_kwargs:
+        module_kwargs.pop("use_cache")
+
+    def _search_module_scale_wa_distort(block, linears2scale: list, layers_name, x, x_q, reweight_ratio, kwargs={}):
+        # w: co, ci
+        # x: n, ci
+        x = x.to(next(block.parameters()).device)
+        x_q = x_q.to(next(block.parameters()).device)
+        with torch.no_grad():
+            org_out = block(x, **kwargs)
+            if isinstance(org_out, tuple):
+                org_out = org_out[0]
+
+        x_max = get_act_scale(x_q)
+
+        best_error = float("inf")
+        best_ratio = -1
+        best_scales = None
+
+        n_grid = 20
+        history = []
+
+        org_sd = {k: v.cpu() for k, v in block.state_dict().items()}
+        for ratio in range(n_grid):
+            ratio = ratio * 1 / n_grid
+            scales = x_max.pow(ratio).clamp(min=1e-4).view(-1)
+            scales = scales / (scales.max() * scales.min()).sqrt()
+
+            if isinstance(block, nn.Linear):
+                new_block = None
+            for fc, fc_name in zip(linears2scale, layers_name):
+                # fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+                # fc.weight.data = w_quantize_func(fc.weight.data) / (scales.view(1, -1))
+                fc.weight.mul_(scales.view(1, -1).to(fc.weight.device))
+                new_fc = WALinear.from_float(fc, weight_quant="per_channel", act_quant="per_token", w_bit=w_bit, a_bit=a_bit)
+                
+                if isinstance(block, nn.Linear):
+                    new_block = copy.deepcopy(new_fc)                   
+                else:
+                    setattr(block, fc_name, new_fc)
+                    
+                del new_fc
+                torch.cuda.empty_cache()
+
+            x_scale = x_q / (scales.view(1, 1, -1)) 
+
+            if isinstance(block, nn.Linear):
+                out = new_block(x_scale, **kwargs)
+            else:
+                out = block(x_scale, **kwargs)
+
+            if isinstance(out, tuple):
+                out = out[0]
+
+            # loss = (
+            #     (org_out - out).float().pow(2).mean().item()
+            # )  # float prevents overflow
+
+            if loss_mode == "mse":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().pow(2) * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = masked_diff_ans.sum() / ans_mask_expand.sum() + reweight_ratio * (masked_diff_vis.sum() / vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().pow(2).mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().pow(2) * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().pow(2).mean().item()
+                    )  # float prevents overflow
+            elif loss_mode == "mae":
+                if ans_mask is not None and vis_mask is not None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    vis_mask_expand = vis_mask.unsqueeze(-1).expand_as(out).cuda()
+                    masked_diff_ans = ((org_out - out).float().abs() * ans_mask_expand)
+                    masked_diff_vis = ((org_out - out).float().abs() * vis_mask_expand)
+                    if reweight_ratio is not None:
+                        loss = (masked_diff_ans.sum() + reweight_ratio * masked_diff_vis.sum()) / (ans_mask_expand.sum() + vis_mask_expand.sum())
+                    else:
+                        loss = (
+                            (org_out - out).float().abs().mean().item()
+                        ) 
+                elif ans_mask is not None and vis_mask is None:
+                    ans_mask_expand = ans_mask.unsqueeze(-1).expand_as(out)
+                    masked_diff = ((org_out - out).float().abs() * ans_mask_expand)
+                    loss = masked_diff.sum() / ans_mask_expand.sum() 
+                else:
+                    loss = (
+                        (org_out - out).float().abs().mean().item()
+                    )  # float prevents overflow
+
+            history.append(loss)
+            is_best = loss < best_error
+            if is_best:
+                best_error = loss
+                best_ratio = ratio
+                best_scales = scales
+
+            # restore the block
+            for fc, fc_name in zip(linears2scale, layers_name):
+                if isinstance(block, nn.Linear):
+                    continue
+                else:
+                    setattr(block, fc_name, fc)
+            
+            if isinstance(block, nn.Linear):
+                del new_block 
+            torch.cuda.empty_cache()
+            block.load_state_dict(org_sd)
+        if best_ratio == -1:
+            print(history)
+            raise Exception
+        # print(best_ratio)
+        best_scales = best_scales.view(-1)
+
+        assert torch.isnan(best_scales).sum() == 0, best_scales
+        return best_scales.detach()
+
+    def _auto_get_scale_wa_distort(prev_op, layers, layers_name, inp, inp_q, reweight_ratio, module2inspect=None, kwargs={}):
+        # module2inspect: if given, we will check the output diff of this module instead of layers
+        if module2inspect is None:
+            assert len(layers) == 1
+            module2inspect = layers[0]
+
+        scales = _search_module_scale_wa_distort(module2inspect, layers, layers_name, inp, inp_q, reweight_ratio, kwargs)
+        scales = scales.detach().cpu()
+        # prev_op_name, [layer_name], scale
+        return (
+            get_op_name(module, prev_op),
+            tuple([get_op_name(module, m) for m in layers]),
+            scales,
+        )
+
+    scales_list = []  # return the searched scales
+
+
+    def _auto_get_input_feat_distort(inps_q, scales_list=None):
+
+        # org_sd = {k: v.cpu() for k, v in module.state_dict().items()}
+
+        new_module = copy.deepcopy(module)
+
+        named_linears = {name: m for name, m in new_module.named_modules() if isinstance(m, nn.Linear)}
+
+        if scales_list is not None:
+            apply_scale(new_module, scales_list)
+            new_module.cuda()
+            for n, m in named_linears.items():
+                new_linear = WALinear.from_float(m, weight_quant="per_channel", act_quant="per_token", w_bit=w_bit, a_bit=a_bit)
+                father_module = get_module_by_name_suffix(new_module, '.'.join(n.split(".")[:-1]))
+                setattr(father_module, n.split('.')[-1], new_linear)
+                del new_linear, m
+                torch.cuda.empty_cache()
+
+            named_linears = {name: m for name, m in new_module.named_modules() if isinstance(m, WALinear)}  
+        
+
+        def cache_input_hook(m, x, y, name, feat_dict):
+            x = x[0]
+            x = x.detach().cpu()
+            feat_dict[name].append(x)
+
+        input_feat_q = defaultdict(list)
+        handles = []
+        for name in named_linears:
+            handles.append(
+                named_linears[name].register_forward_hook(
+                    functools.partial(cache_input_hook, name=name, feat_dict=input_feat_q)
+                )
+            )
+
+        inps_q = inps_q.to(next(new_module.parameters()).device)
+        new_module(inps_q, **module_kwargs)
+        for h in handles:
+            h.remove()
+    
+        input_feat_q = {k: torch.cat(v, dim=0) for k, v in input_feat_q.items()}
+
+        del new_module
+        torch.cuda.empty_cache()
+
+        # module.load_state_dict(org_sd)
+
+        return input_feat_q
+
+
+    if isinstance(module, OPTDecoderLayer):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn_layer_norm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.self_attn.v_proj,
+                layers=[module.self_attn.out_proj],
+                inp=input_feat["self_attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.final_layer_norm,
+                layers=[module.fc1],
+                inp=input_feat["fc1"],
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.fc1,
+                layers=[module.fc2],
+                inp=input_feat["fc2"],
+            )
+        )
+
+    elif isinstance(module, LlamaDecoderLayer):
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                layers_name=[
+                    "q_proj",
+                    "k_proj",
+                    "v_proj",
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                inp_q=input_feat_q["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa_distort(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    layers_name=["o_proj"],
+                    inp=input_feat["self_attn.o_proj"],
+                    inp_q=input_feat_q["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                layers_name=["gate_proj", "up_proj"],
+                inp=input_feat["mlp.gate_proj"],
+                inp_q=input_feat_q["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                layers_name=["down_proj"],
+                inp=input_feat["mlp.down_proj"],
+                inp_q=input_feat_q["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+
+    elif isinstance(module, BloomBlock):
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.self_attention.query_key_value],
+                inp=input_feat["self_attention.query_key_value"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/issues/2#issuecomment-1606297469
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.gelu_impl,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "mpt" in str(module.__class__).lower():
+        # attention input
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_1,
+                layers=[module.attn.Wqkv],
+                inp=input_feat["attn.Wqkv"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+
+        # attn out
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.attn.Wqkv,
+                layers=[module.attn.out_proj],
+                inp=input_feat["attn.out_proj"],
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.norm_2,
+                layers=[module.ffn.up_proj],
+                inp=input_feat["ffn.up_proj"],
+                module2inspect=module.ffn,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ffn.act,
+                layers=[module.ffn.down_proj],
+                inp=input_feat["ffn.down_proj"],
+            )
+        )
+
+    elif "falcon" in str(module.__class__).lower():
+        # attn out
+        # Haotian: TBD: need to handle repeated scales for MQ
+        """
+        scales_list.append(_auto_get_scale(
+            prev_op=module.self_attention.query_key_value,
+            layers=[module.self_attention.dense],
+            inp=input_feat['self_attention.dense'],
+        ))
+        """
+        # fc1, as long as it is scaled, everything is screwed up
+        if "falcon-7b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.input_layernorm,
+                    layers=[
+                        module.mlp.dense_h_to_4h,
+                        module.self_attention.query_key_value,
+                    ],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        elif "falcon-40b" in str(module.__class__).lower():
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_attn,
+                    layers=[module.self_attention.query_key_value],
+                    inp=input_feat["self_attention.query_key_value"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+            scales_list.append(
+                _auto_get_scale(
+                    prev_op=module.ln_mlp,
+                    layers=[module.mlp.dense_h_to_4h],
+                    inp=input_feat["mlp.dense_h_to_4h"],
+                    module2inspect=module,
+                    kwargs=module_kwargs,
+                )
+            )
+        else:
+            raise NotImplementedError(
+                "Unknown Falcon architecture, currently only falcon-7b and falcon-40b are supported"
+            )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif "bigcode" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_1,
+                layers=[module.attn.c_attn],
+                inp=input_feat["attn.c_attn"],
+                module2inspect=module.attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.ln_2,
+                layers=[module.mlp.c_fc],
+                inp=input_feat["mlp.c_fc"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.c_proj],
+                inp=input_feat["mlp.c_proj"],
+            )
+        )
+    elif "neox" in str(module.__class__).lower():
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.input_layernorm,
+                layers=[module.attention.query_key_value],
+                inp=input_feat["attention.query_key_value"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # fc1
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.dense_h_to_4h],
+                inp=input_feat["mlp.dense_h_to_4h"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        scales_list.append(
+            _auto_get_scale(
+                prev_op=module.mlp.act,
+                layers=[module.mlp.dense_4h_to_h],
+                inp=input_feat["mlp.dense_4h_to_h"],
+            )
+        )
+    elif module.__class__.__name__ == "Qwen2DecoderLayer":
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                layers_name=[
+                    "q_proj",
+                    "k_proj",
+                    "v_proj",
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                inp_q=input_feat_q["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa_distort(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    layers_name=["o_proj"],
+                    inp=input_feat["self_attn.o_proj"],
+                    inp_q=input_feat_q["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                layers_name=["gate_proj", "up_proj"],
+                inp=input_feat["mlp.gate_proj"],
+                inp_q=input_feat_q["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                layers_name=["down_proj"],
+                inp=input_feat["mlp.down_proj"],
+                inp_q=input_feat_q["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    elif module.__class__.__name__ == "InternLM2DecoderLayer":
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.attention_norm,
+                layers=[
+                    module.attention.wqkv,
+                ],
+                layers_name=[
+                    "wqkv",
+                ],
+                inp=input_feat["attention.wqkv"],
+                inp_q=input_feat_q["attention.wqkv"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.attention,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.attention.wqkv.weight.shape == module.attention.wo.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa_distort(
+                    prev_op=module.attention.wqkv,
+                    layers=[module.attention.wo],
+                    layers_name=["wo"],
+                    inp=input_feat["attention.wo"],
+                    inp_q=input_feat_q["attention.wo"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.ffn_norm,
+                layers=[module.feed_forward.w1, module.feed_forward.w3],
+                layers_name=["w1","w3"],
+                inp=input_feat["feed_forward.w1"],
+                inp_q=input_feat_q["feed_forward.w1"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.feed_forward,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.feed_forward.w3,
+                layers=[module.feed_forward.w2],
+                layers_name=["w2"],
+                inp=input_feat["feed_forward.w2"],
+                inp_q=input_feat_q["feed_forward.w2"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    elif module.__class__.__name__ == "Qwen2VLDecoderLayer":
+        # attention input
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.input_layernorm,
+                layers=[
+                    module.self_attn.q_proj,
+                    module.self_attn.k_proj,
+                    module.self_attn.v_proj,
+                ],
+                layers_name=[
+                    "q_proj",
+                    "k_proj",
+                    "v_proj",
+                ],
+                inp=input_feat["self_attn.q_proj"],
+                inp_q=input_feat_q["self_attn.q_proj"],
+                reweight_ratio=reweight_ratio_dict["attn"],
+                module2inspect=module.self_attn,
+                kwargs=module_kwargs,
+            )
+        )
+        # attn out
+        # Please refer to https://github.com/mit-han-lab/llm-awq/pull/67#issue-1850622696
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        if module.self_attn.v_proj.weight.shape == module.self_attn.o_proj.weight.shape:
+            scales_list.append(
+                _auto_get_scale_wa_distort(
+                    prev_op=module.self_attn.v_proj,
+                    layers=[module.self_attn.o_proj],
+                    layers_name=["o_proj"],
+                    inp=input_feat["self_attn.o_proj"],
+                    inp_q=input_feat_q["self_attn.o_proj"],
+                    reweight_ratio=reweight_ratio_dict["attn"],
+                )
+            )
+        # fc1
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.post_attention_layernorm,
+                layers=[module.mlp.gate_proj, module.mlp.up_proj],
+                layers_name=["gate_proj", "up_proj"],
+                inp=input_feat["mlp.gate_proj"],
+                inp_q=input_feat_q["mlp.gate_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+                module2inspect=module.mlp,
+            )
+        )
+        # fc2
+        input_feat_q = _auto_get_input_feat_distort(
+            inps_q=q_input,
+            scales_list=scales_list,
+        )
+        scales_list.append(
+            _auto_get_scale_wa_distort(
+                prev_op=module.mlp.up_proj,
+                layers=[module.mlp.down_proj],
+                layers_name=["down_proj"],
+                inp=input_feat["mlp.down_proj"],
+                inp_q=input_feat_q["mlp.down_proj"],
+                reweight_ratio=reweight_ratio_dict["mlp"],
+            )
+        )
+    else:
+        raise NotImplementedError(f"{type(module)} not supported yet!")
+
+    return scales_list
+
+def apply_scale(module, scales_list, input_feat_dict=None):
+    for prev_op_name, layer_names, scales in scales_list:
+        prev_op = get_op_by_name(module, prev_op_name)
+        layers = [get_op_by_name(module, name) for name in layer_names]
+
+        prev_op.cuda()
+        for layer in layers:
+            layer.cuda()
+        scales.cuda()
+
+        if isinstance(prev_op, nn.Linear):
+            assert len(layers) == 1
+            scale_fc_fc(prev_op, layers[0], scales)
+        elif isinstance(prev_op, (nn.LayerNorm, LlamaRMSNorm)) or prev_op.__class__.__name__ == "InternLM2RMSNorm" or prev_op.__class__.__name__ == "Qwen2RMSNorm":
+            scale_ln_fcs(prev_op, layers, scales)
+        elif isinstance(prev_op, (nn.GELU, BloomGelu, GELUActivation)):
+            new_module = ScaledActivation(prev_op, scales)
+            set_op_by_name(module, prev_op_name, new_module)
+            scale_gelu_fc(prev_op, layers[0], scales)
+        else:
+            raise NotImplementedError(f"prev_op {type(prev_op)} not supported yet!")
+
+        # apply the scaling to input feat if given;
+        if input_feat_dict is not None:
+            for layer_name in layer_names:
+                inp = input_feat_dict[layer_name]
+                inp.div_(scales.view(1, -1).to(inp.device))
+
+        prev_op.cpu()
+        for layer in layers:
+            layer.cpu()
+        scales.cpu()

qmllm/methods/mbq/quantize/pre_quant.py

@@ -0,0 +1,481 @@
+import torch
+import torch.nn as nn
+import tqdm
+import copy
+import gc
+import functools
+from collections import defaultdict
+from typing import List
+
+import numpy as np
+from torch.nn import CrossEntropyLoss
+from transformers.models.bloom.modeling_bloom import BloomForCausalLM
+from transformers.models.opt.modeling_opt import OPTForCausalLM
+from transformers.models.llama.modeling_llama import LlamaForCausalLM
+
+from qmllm.utils.search import append_str_prefix, get_op_name
+
+from qmllm.methods.mbq.quantize.auto_scale_wa_distort import auto_scale_block_wa_distort
+from qmllm.methods.mbq.quantize.auto_scale_wa import auto_scale_block_wa
+from qmllm.methods.mbq.quantize.auto_scale_distort import auto_scale_block_distort
+from qmllm.methods.mbq.quantize.auto_scale import auto_scale_block, apply_scale
+from qmllm.quantization.qlinear import WALinear
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+from .quantizer import get_module_by_name_suffix
+
+
+__all__ = ["run_mbq"]
+
+
+class GradCacheHook:
+    def __init__(self, vis_masks, cap_masks):
+        if vis_masks is None or cap_masks is None:
+            raise ValueError
+        self.hooks = []
+        self.vis_masks = vis_masks.cpu()
+        self.cap_masks = cap_masks.cpu()
+        self.steps = {}
+        self.grad_dict = {}
+
+
+    def cache_grad_hook(self, module, inp, out, name):
+        # initialize step counter, we use step counter to find the right mask for the grad
+        if name not in self.steps:
+            self.steps[name] = 0
+
+        if name not in self.grad_dict:
+            self.grad_dict[name] = {"vis_grad": [], "cap_grad": []}
+
+        output_grad = out[0].float()
+        step = self.steps[name]
+
+        B, N, C = output_grad.shape
+
+        for batch_idx in range(B):
+            vis_mask = self.vis_masks[step]
+            cap_mask = self.cap_masks[step]
+
+            vis_grad = output_grad[batch_idx][vis_mask]
+            cap_grad = output_grad[batch_idx][cap_mask]
+
+            vis_grad_avg = vis_grad.abs().mean()
+            cap_grad_avg = cap_grad.abs().mean()
+
+            self.grad_dict[name]["vis_grad"].append(vis_grad_avg.detach().cpu())
+            self.grad_dict[name]["cap_grad"].append(cap_grad_avg.detach().cpu())
+
+            step = step + 1
+
+        self.steps[name] = step
+
+
+    def register_hooks(self, layers):
+        for n, m in layers.named_modules():
+            if isinstance(m, nn.Linear) and any([_ in n for _ in ["wo", "w2", "down_proj", "o_proj", "v_proj", "gate_proj", "up_proj", "w1", "w3"]]):
+                # print(f"Registering hook for layer.{n}")
+                self.hooks.append(
+                    m.register_full_backward_hook(
+                        functools.partial(self.cache_grad_hook, name=f"layers.{n}")
+                    )
+                )
+
+
+    def remove_hooks(self):
+        for h in self.hooks:
+            h.remove()
+        self.hooks.clear()
+
+
+    def get_grad_dict(self):
+        return self.grad_dict
+    
+
+    def get_avg_grad_dict(self):
+        avg_grad_dict = {}
+
+        for name, grad_values in self.grad_dict.items():
+            mean_vis = torch.mean(torch.stack(grad_values["vis_grad"]))
+            mean_cap = torch.mean(torch.stack(grad_values["cap_grad"]))
+
+            avg_grad_dict[name] = {
+                "vis_avg_grad": mean_vis.item(),
+                "cap_avg_grad": mean_cap.item()
+            }
+
+        return avg_grad_dict
+    
+
+def get_named_linears(module):
+    return {name: m for name, m in module.named_modules() if isinstance(m, nn.Linear)}
+
+
+def get_blocks(model):
+    if model.__class__.__name__ == "LlamaForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaLlamaForCausalLM":
+        # layers = [model.model.layers, model.model.vision_tower.vision_tower.vision_model.encoder.layers]
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaQwenForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "InternLM2ForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "InternVLChatModel":
+        layers = model.language_model.model.layers
+    elif model.__class__.__name__ == "Qwen2VLForConditionalGeneration":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaLlamaModel":
+        layers = model.llm.model.layers
+    elif isinstance(model, OPTForCausalLM):
+        layers = model.model.decoder.layers
+    elif isinstance(model, BloomForCausalLM):
+        layers = model.transformer.h
+    elif "mpt" in str(model.__class__).lower():
+        layers = model.transformer.blocks
+    elif "falcon" in str(model.__class__).lower():
+        layers = model.transformer.h
+    elif "bigcode" in str(model.__class__).lower():
+        layers = model.transformer.h
+    elif "neox" in str(model.__class__).lower():
+        layers = model.gpt_neox.layers
+    else:
+        raise NotImplementedError(type(model))
+    return layers
+
+
+def move_embed(model, device):
+    if isinstance(model, LlamaForCausalLM):
+        model.model.embed_tokens = model.model.embed_tokens.to(device)
+        model.model.rotary_emb = model.model.rotary_emb.to(device)
+    elif isinstance(model, OPTForCausalLM):
+        model.model.decoder.embed_tokens = model.model.decoder.embed_tokens.to(device)
+        model.model.decoder.embed_positions = model.model.decoder.embed_positions.to(
+            device
+        )
+    elif isinstance(model, BloomForCausalLM):
+        model.transformer.word_embeddings = model.transformer.word_embeddings.to(device)
+        model.transformer.word_embeddings_layernorm = (
+            model.transformer.word_embeddings_layernorm.to(device)
+        )
+    elif "mpt" in str(model.__class__).lower():
+        model.transformer.wte = model.transformer.wte.to(device)
+        model.transformer.emb_drop = model.transformer.emb_drop.to(device)
+    elif "falcon" in str(model.__class__).lower():
+        model.transformer.word_embeddings = model.transformer.word_embeddings.to(device)
+    elif "bigcode" in str(model.__class__).lower():
+        model.transformer.wte = model.transformer.wte.to(device)
+        model.transformer.wpe = model.transformer.wpe.to(device)
+        model.transformer.drop = model.transformer.drop.to(device)
+    elif "neox" in str(model.__class__).lower():
+        model.gpt_neox.embed_in = model.gpt_neox.embed_in.to(device)
+        model.gpt_neox.emb_dropout = model.gpt_neox.emb_dropout.to(device)
+        model.embed_out = model.embed_out.to(device)
+    elif model.__class__.__name__ == "LlavaLlamaForCausalLM":
+        model.model.embed_tokens = model.model.embed_tokens.to(device)
+        model.model.vision_tower.vision_tower.vision_model.embeddings.to(device)
+    elif model.__class__.__name__ == "LlavaQwenForCausalLM":
+        model.model.embed_tokens = model.model.embed_tokens.to(device)
+        # model.model.rotary_emb = model.model.rotary_emb.to(device)
+    elif model.__class__.__name__ == "InternLM2ForCausalLM":
+        model.model.tok_embeddings = model.model.tok_embeddings.to(device)
+    elif model.__class__.__name__ == "InternVLChatModel":
+        model.language_model.model.tok_embeddings = model.language_model.model.tok_embeddings.to(device)  
+    elif model.__class__.__name__ == "Qwen2VLForConditionalGeneration":
+        model.model.embed_tokens = model.model.embed_tokens.to(device)
+    elif model.__class__.__name__ == "LlavaLlamaModel":
+        model.llm.model.embed_tokens = model.llm.model.embed_tokens.to(device)
+    else:
+        raise NotImplementedError(type(model))
+
+
+def process_input(prompt_inputs, prompt_kwargs):
+    inputs = {**prompt_inputs, **prompt_kwargs}
+    inputs["use_cache"] = False
+    vision_mask = inputs.pop("vision_mask", None)
+    caption_mask = inputs.pop("caption_mask", None)
+    
+    return inputs, vision_mask, caption_mask
+
+
+@torch.no_grad()
+def run_mbq(
+    model,
+    prompt_inputs,
+    prompt_kwargs,
+    w_bit,
+    a_bit,
+    q_config,
+    auto_scale=True,
+    loss_mode="mae",
+    wa_quant=False,
+    reweight=False,
+    distort=False
+):
+    if "bigcode" in str(model.model.__class__).lower():
+        # otherwise attention_mask will always be on cpu.
+        model.transformer.bias = model.transformer.bias.to("cuda")
+
+    layers = get_blocks(model.model)
+
+    inps = []
+    layer_kwargs = {}
+
+    layers[0] = layers[0].cuda()
+    move_embed(model.model, "cuda")
+
+    # get input and kwargs to layer 0
+    # with_kwargs is only supported in PyTorch 2.0
+    # use this Catcher hack for now
+    class Catcher(nn.Module):
+        def __init__(self, module):
+            super().__init__()
+            self.module = module
+
+        def forward(self, inp, **kwargs):
+            inps.append(inp)
+            layer_kwargs.update(kwargs)
+            raise ValueError  # early exit to break later inference
+
+    # patch layer 0 to catch input and kwargs
+    layers[0] = Catcher(layers[0])
+
+    inputs, vision_mask, caption_mask = process_input(prompt_inputs, prompt_kwargs)
+
+    model.to_cuda()
+    try:
+        model(**inputs)
+    except ValueError: # work with early exit
+        pass
+
+    model.to_cpu()
+    layers[0] = layers[0].module  # restore
+    inps = inps[0]
+    layer_kwargs["use_cache"] = False
+
+    layers[0] = layers[0].cpu()
+    move_embed(model.model, "cpu")
+
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    mbq_results = {
+        "scale": [],
+    }
+
+
+    if reweight:
+        model.to_cuda()
+        print("Save gradient...")
+        # save gradient
+        grad_cache = GradCacheHook(vis_masks=vision_mask, cap_masks=caption_mask)        
+        grad_cache.register_hooks(layers=layers)
+        
+        with torch.enable_grad():
+            mini_batch = 1
+            total_samples = next(iter(prompt_inputs.values())).shape[0]
+            accum_steps = int(total_samples/mini_batch)
+            
+            for i in tqdm.tqdm(range(0, total_samples, mini_batch), desc="Running gradient calculation..."):
+                mini_inputs = {}
+                for k in inputs:
+                    if isinstance(inputs[k], torch.Tensor):
+                        mini_inputs[k] = inputs[k][i:i+mini_batch]
+                
+                outputs = model(**mini_inputs)
+
+                loss = outputs[0]
+
+                loss = loss / accum_steps
+                loss.backward()
+
+        model.to_cpu()
+        grad_avg_dict = grad_cache.get_avg_grad_dict()
+        grad_cache.remove_hooks()
+        del grad_cache
+
+        attn_list = []
+        mlp_list = []
+
+        for key_name in grad_avg_dict:
+            if "down_" in key_name or "w2" in key_name:
+                mlp_list.append(grad_avg_dict[key_name]["vis_avg_grad"] / grad_avg_dict[key_name]["cap_avg_grad"])
+            if "o_proj" in key_name or "wo" in key_name:
+                attn_list.append(grad_avg_dict[key_name]["vis_avg_grad"] / grad_avg_dict[key_name]["cap_avg_grad"])
+
+        attn_median = np.median(attn_list)
+        mlp_median = np.median(mlp_list)
+
+
+    if distort:
+        # assert wa_quant, "We only support distort input in weight-activation quantization!!!"
+        print("Use distort input...")
+        inps_distort = copy.deepcopy(inps)
+
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    # solve layer by layer
+    for i in tqdm.tqdm(range(len(layers)), desc="Running MBQ..."):
+        layer = layers[i]
+        layer = layer.cuda()
+        named_linears = get_named_linears(layer)
+
+        # firstly, get input features of all linear layers
+        def cache_input_hook(m, x, y, name, feat_dict):
+            x = x[0]
+            x = x.detach().cpu()
+            feat_dict[name].append(x)
+
+        input_feat = defaultdict(list)
+        handles = []
+        for name in named_linears:
+            handles.append(
+                named_linears[name].register_forward_hook(
+                    functools.partial(cache_input_hook, name=name, feat_dict=input_feat)
+                )
+            )
+        inps = inps.to(next(layer.parameters()).device)  # in case multi-gpu
+        # get output as next layer's input
+
+        for k in layer_kwargs:
+            if isinstance(layer_kwargs[k], torch.Tensor):
+                layer_kwargs[k] = layer_kwargs[k].to(next(layer.parameters()).device)
+
+        inps = layer(inps, **layer_kwargs)[0]
+        for h in handles:
+            h.remove()
+        # now solve for scaling
+        input_feat = {k: torch.cat(v, dim=0) for k, v in input_feat.items()}
+
+        # Clear GPU memory
+        torch.cuda.empty_cache()
+
+        if reweight:
+            scale_reweight_ratio_dict = {}
+            for key, value in grad_avg_dict.items():
+                item_list = key.split(".")
+                if str(i) in item_list:
+                    if "wo" in item_list or "o_proj" in item_list:
+                        scale_reweight_ratio_dict["attn"] = max((value["vis_avg_grad"] / value["cap_avg_grad"]), attn_median)
+                    elif "w2" in item_list or "down_proj" in item_list:
+                        scale_reweight_ratio_dict["mlp"] = max((value["vis_avg_grad"] / value["cap_avg_grad"]), mlp_median)
+        else:
+            scale_reweight_ratio_dict = {
+                "attn": None,
+                "mlp": None
+            }
+
+        if (
+            auto_scale
+        ):  # if it applies, we should also modify the input_feat with scales
+            if not reweight:
+                ans_mask = None
+                vis_mask = None
+            else:
+                ans_mask = caption_mask
+                vis_mask = vision_mask
+            
+            if wa_quant:
+                if distort:
+                    scales_list = auto_scale_block_wa_distort(
+                        layer,
+                        layer_kwargs,
+                        w_bit=w_bit,
+                        a_bit=a_bit,
+                        q_config=q_config,
+                        input_feat=input_feat,
+                        ans_mask=ans_mask,
+                        vis_mask=vis_mask,
+                        reweight_ratio_dict=scale_reweight_ratio_dict,
+                        q_input=inps_distort,
+                        loss_mode=loss_mode
+                    )
+                else:
+                    scales_list = auto_scale_block_wa(
+                        layer,
+                        layer_kwargs,
+                        w_bit=w_bit,
+                        a_bit=a_bit,
+                        q_config=q_config,
+                        input_feat=input_feat,
+                        ans_mask=ans_mask,
+                        vis_mask=vis_mask,
+                        reweight_ratio_dict=scale_reweight_ratio_dict,
+                        loss_mode=loss_mode
+                    )
+            else:
+                if distort:
+                    scales_list = auto_scale_block_distort(
+                        layer,
+                        layer_kwargs,
+                        w_bit=w_bit,
+                        q_config=q_config,
+                        input_feat=input_feat,
+                        ans_mask=ans_mask,
+                        vis_mask=vis_mask,
+                        reweight_ratio_dict=scale_reweight_ratio_dict,
+                        q_input=inps_distort,
+                        loss_mode=loss_mode
+                    )
+                else:
+                    scales_list = auto_scale_block(
+                        layer,
+                        layer_kwargs,
+                        w_bit=w_bit,
+                        q_config=q_config,
+                        input_feat=input_feat,
+                        ans_mask=ans_mask,
+                        vis_mask=vis_mask,
+                        reweight_ratio_dict=scale_reweight_ratio_dict,
+                        loss_mode=loss_mode
+                    )
+
+            # apply_scale(layer, scales_list, input_feat_dict=input_feat)
+            apply_scale(layers[i], scales_list, input_feat_dict=input_feat)
+
+            if distort:
+                # get distort output as next layer's input
+                if wa_quant:
+                    layer_q = copy.deepcopy(layer)
+                    layer_q = layer_q.cuda()
+                    named_linears_q = get_named_linears(layer_q)
+                    for n, m in named_linears_q.items():
+                        new_linear = WALinear.from_float(m, weight_quant="per_channel", act_quant="per_token", w_bit=w_bit, a_bit=a_bit)
+                        father_module = get_module_by_name_suffix(layer_q, '.'.join(n.split(".")[:-1]))
+                        setattr(father_module, n.split('.')[-1], new_linear)
+                        del new_linear, m
+                        torch.cuda.empty_cache()
+                    
+                    inps_distort = inps_distort.to(next(layer_q.parameters()).device)  # in case multi-gpu
+                    inps_distort = layer_q(inps_distort, **layer_kwargs)[0]
+                    del layer_q 
+                else:
+                    layer_q = copy.deepcopy(layer)
+                    layer_q = layer_q.cuda()
+                    named_linears_q = get_named_linears(layer_q)
+                    for n, m in named_linears_q.items():
+                        m.weight.data = pseudo_quantize_tensor(m.weight.data, n_bits=w_bit, **q_config)
+                        torch.cuda.empty_cache()
+                    
+                    inps_distort = inps_distort.to(next(layer_q.parameters()).device)  # in case multi-gpu
+                    inps_distort = layer_q(inps_distort, **layer_kwargs)[0]
+                    del layer_q 
+
+            # append prefix to make names global
+            mbq_results["scale"] += append_str_prefix(
+                scales_list, get_op_name(model.model, layer) + "."
+            )
+
+        # Clear GPU memory
+        torch.cuda.empty_cache()
+
+        layer = layer.cpu()
+        # Haotian: check activation replacement
+        del input_feat
+        gc.collect()
+        torch.cuda.empty_cache()
+
+    return mbq_results
+
+
+def apply_mbq(model, mbq_results):
+    apply_scale(model, mbq_results["scale"])

qmllm/methods/mbq/quantize/qmodule.py

@@ -0,0 +1,31 @@
+import math
+import torch
+import torch.nn as nn
+
+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
+
+
+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)

qmllm/methods/mbq/quantize/quantizer.py

@@ -0,0 +1,102 @@
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+import gc
+from qmllm.methods.mbq.quantize.qmodule import ScaledActivation
+from qmllm.utils.search import set_op_by_name
+
+from transformers.models.bloom.modeling_bloom import BloomBlock
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+from qmllm.quantization.qlinear import WALinear
+
+EMBEDDING_KEYWORDS = ["embed"]
+LM_HEAD_KEYWORDS = ["lm_head", "embed_out", "output"]
+
+
+def scale_activations(module):
+    param = next(module.parameters())
+    dtype = param.dtype
+    device = param.device
+    if isinstance(module, BloomBlock):
+        if isinstance(module.mlp.gelu_impl, ScaledActivation):
+            return
+        c = module.mlp.dense_h_to_4h.out_features
+        act = ScaledActivation(
+            module.mlp.gelu_impl, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.gelu_impl", act)
+    elif "mptblock" in str(module.__class__.__name__).lower():
+        if isinstance(module.ffn.act, ScaledActivation):
+            return
+        c = module.ffn.up_proj.out_features
+        act = ScaledActivation(
+            module.ffn.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "ffn.act", act)
+    elif "falcon" in str(module.__class__).lower():
+        if isinstance(module.mlp.act, ScaledActivation):
+            return
+        c = module.mlp.dense_h_to_4h.out_features
+        act = ScaledActivation(
+            module.mlp.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.act", act)
+    elif "bigcode" in str(module.__class__).lower():
+        if isinstance(module.mlp.act, ScaledActivation):
+            return
+        c = module.mlp.c_proj.out_features
+        act = ScaledActivation(
+            module.mlp.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.act", act)
+    elif "neox" in str(module.__class__).lower():
+        if isinstance(module.mlp.act, ScaledActivation):
+            return
+        c = module.mlp.dense_h_to_4h.out_features
+        act = ScaledActivation(
+            module.mlp.act, torch.ones(c, dtype=dtype, device=device)
+        )
+        set_op_by_name(module, "mlp.act", act)
+
+@torch.no_grad()
+def pseudo_quantize_model_weight(
+    model,
+    w_bit,
+    q_config,
+):
+    from .pre_quant import get_blocks, get_named_linears
+
+    layers = get_blocks(model)
+    for i in tqdm(range(len(layers)), desc="pseudo weight quantization..."):
+        named_linears = get_named_linears(layers[i])
+        for n, m in named_linears.items():
+            # m.cuda()
+            m.weight.data = pseudo_quantize_tensor(
+                m.weight.data, n_bits=w_bit, **q_config
+            )
+            # m.cpu()
+
+
+def get_module_by_name_suffix(model, module_name: str):
+    for name, module in model.named_modules():
+        if name.endswith(module_name):
+            return module
+
+
+@torch.no_grad()
+def pseudo_quantize_model_weight_act(
+    model,
+    w_bit,
+    a_bit,
+):
+    from .pre_quant import get_blocks, get_named_linears
+
+    layers = get_blocks(model)
+    for i in tqdm(range(len(layers)), desc="pseudo weight activation quantization..."):
+        named_linears = get_named_linears(layers[i])
+        for n, m in named_linears.items():
+            new_linear = WALinear.from_float(m, weight_quant="per_channel", act_quant="per_token", w_bit=w_bit, a_bit=a_bit)
+            father_module = get_module_by_name_suffix(layers[i], '.'.join(n.split(".")[:-1]))
+            setattr(father_module, n.split('.')[-1], new_linear)
+            del new_linear, m
+            torch.cuda.empty_cache()

qmllm/methods/rtn/entry.py

@@ -0,0 +1,21 @@
+import os
+import torch
+from qmllm.methods.rtn.quantizer import pseudo_quantize_model_weight, pseudo_quantize_model_weight_act
+
+def rtn_entry(model, pseudo_quant: bool, wa_quant: bool, zero_point: str=True, q_group_size: int=128, w_bit: int=4, a_bit: int=16):
+    q_config = {
+        "zero_point": zero_point,  # by default True
+        "q_group_size": q_group_size,  # whether to use group quantization
+    }
+
+    if pseudo_quant:
+        if not wa_quant:
+            # weight quantization
+            pseudo_quantize_model_weight(model.model, w_bit=w_bit, q_config=q_config)
+        else:
+            # weight activation quantization
+            pseudo_quantize_model_weight_act(model.model, w_bit=w_bit, a_bit=a_bit)
+
+    model.to_cuda()
+
+    return model

qmllm/methods/rtn/quantizer.py

@@ -0,0 +1,85 @@
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from qmllm.quantization.quant_funcs import pseudo_quantize_tensor
+from qmllm.quantization.qlinear import WALinear
+from transformers.models.bloom.modeling_bloom import BloomForCausalLM
+from transformers.models.opt.modeling_opt import OPTForCausalLM
+
+def get_named_linears(module):
+    return {name: m for name, m in module.named_modules() if isinstance(m, nn.Linear)}
+
+
+def get_blocks(model):
+    if model.__class__.__name__ == "LlamaForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaLlamaForCausalLM":
+        # layers = [model.model.layers, model.model.vision_tower.vision_tower.vision_model.encoder.layers]
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaQwenForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "InternLM2ForCausalLM":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "InternVLChatModel":
+        layers = model.language_model.model.layers
+    elif model.__class__.__name__ == "Qwen2VLForConditionalGeneration":
+        layers = model.model.layers
+    elif model.__class__.__name__ == "LlavaLlamaModel":
+        layers = model.llm.model.layers
+    elif isinstance(model, OPTForCausalLM):
+        layers = model.model.decoder.layers
+    elif isinstance(model, BloomForCausalLM):
+        layers = model.transformer.h
+    elif "mpt" in str(model.__class__).lower():
+        layers = model.transformer.blocks
+    elif "falcon" in str(model.__class__).lower():
+        layers = model.transformer.h
+    elif "bigcode" in str(model.__class__).lower():
+        layers = model.transformer.h
+    elif "neox" in str(model.__class__).lower():
+        layers = model.gpt_neox.layers
+    else:
+        raise NotImplementedError(type(model))
+    return layers
+
+
+@torch.no_grad()
+def pseudo_quantize_model_weight(
+    model,
+    w_bit,
+    q_config,
+):
+
+    layers = get_blocks(model)
+    for i in tqdm(range(len(layers)), desc="pseudo weight quantization..."):
+        named_linears = get_named_linears(layers[i])
+        for n, m in named_linears.items():
+            # m.cuda()
+            m.weight.data = pseudo_quantize_tensor(
+                m.weight.data, n_bits=w_bit, **q_config
+            )
+            # m.cpu()
+
+
+def get_module_by_name_suffix(model, module_name: str):
+    for name, module in model.named_modules():
+        if name.endswith(module_name):
+            return module
+
+
+@torch.no_grad()
+def pseudo_quantize_model_weight_act(
+    model,
+    w_bit,
+    a_bit,
+):
+    
+    layers = get_blocks(model)
+    for i in tqdm(range(len(layers)), desc="pseudo weight activation quantization..."):
+        named_linears = get_named_linears(layers[i])
+        for n, m in named_linears.items():
+            new_linear = WALinear.from_float(m, weight_quant="per_channel", act_quant="per_token", w_bit=w_bit, a_bit=a_bit)
+            father_module = get_module_by_name_suffix(layers[i], '.'.join(n.split(".")[:-1]))
+            setattr(father_module, n.split('.')[-1], new_linear)
+            del new_linear, m
+            torch.cuda.empty_cache()