Improve model card: Add metadata, links, and usage example

This PR significantly enhances the model card for the `GuidedQuant` model by:
- Adding `pipeline_tag: text-generation` and `library_name: transformers` to the metadata, improving discoverability and enabling Hub features.
- Correcting the `license` to `mit` based on the official GitHub repository's explicit declaration.
- Adding a `tags: [quantization]` entry to further categorize the model.
- Providing a concise overview based on the paper's abstract.
- Including explicit links to the Hugging Face Papers page, the original arXiv paper, the official project page, and the GitHub repository for comprehensive information.
- Integrating a practical Python code snippet for quick inference, allowing users to easily get started with the model using the `AnyPrecisionForCausalLM` class.
- Adding the full "Acknowledgement" and "Citation" information from the project's GitHub README.

These updates aim to make the model more accessible, informative, and compliant for the Hugging Face community.

README.md

@@ -1,21 +1,106 @@
 ---
 base_model:
 - Qwen/Qwen3-32B
+license: mit
 base_model_relation: quantized
-license: bigscience-openrail-m
+pipeline_tag: text-generation
+library_name: transformers
+tags:
+- quantization
+- text-generation
+- llm
+- qwen
+- 3bit
 ---
-# Model Card
 
-- Base model: `Qwen/Qwen3-32B`
-- Quantization method: SqueezeLLM
-- Target bit-width: 3
-- Backend kernel: Any-Precision-LLM kernel (`ap-gemv`)
-- Calibration data: RedPajama (1024 sentences / 4096 tokens)
-- Calibration objective: Next-token prediction
+# GuidedQuant: Large Language Model Quantization via Exploiting End Loss Guidance
 
+**GuidedQuant** introduces a novel post-training quantization approach that integrates gradient information from the end loss into the quantization objective while preserving critical cross-weight dependencies within output channels. This method addresses limitations of existing techniques by accounting for the varying importance of hidden features and preserving crucial weight interactions. GuidedQuant consistently boosts the performance of state-of-the-art quantization methods across weight-only scalar, weight-only vector, and weight-and-activation quantization. Additionally, it introduces a novel non-uniform scalar quantization algorithm (LNQ), which is guaranteed to monotonically decrease the quantization objective value, and outperforms existing methods in this category.
 
-# How to run
-- Follow the instruction in https://github.com/snu-mllab/GuidedQuant.
+*   **Paper (Hugging Face Papers)**: [GuidedQuant: Large Language Model Quantization via Exploiting End Loss Guidance](https://huggingface.co/papers/2505.07004)
+*   **Paper (arXiv)**: [https://arxiv.org/abs/2505.07004](https://arxiv.org/abs/2505.07004)
+*   **Project Page**: [https://jusjinuk.me/blog/guidedquant/](https://jusjinuk.me/blog/guidedquant/)
+*   **Code (GitHub)**: [https://github.com/snu-mllab/GuidedQuant](https://github.com/snu-mllab/GuidedQuant)
 
-# References
-- [Model Paper](https://arxiv.org/abs/2505.07004)
+---
+
+## Model Card Details
+
+This model is a 3-bit quantized version of `Qwen/Qwen3-32B` using the SqueezeLLM method, derived from the GuidedQuant project.
+
+-   Base model: `Qwen/Qwen3-32B`
+-   Quantization method: SqueezeLLM
+-   Target bit-width: 3
+-   Backend kernel: Any-Precision-LLM kernel (`ap-gemv`)
+-   Calibration data: RedPajama (1024 sentences / 4096 tokens)
+-   Calibration objective: Next-token prediction
+
+## Quick Start / How to run
+
+You can easily load and test this quantized model using the `AnyPrecisionForCausalLM` class from the `any_precision` library, which integrates with Hugging Face `transformers` components. The example below runs efficiently on one RTX 3090.
+
+First, ensure you have the necessary libraries installed, including `transformers` and the `ap-gemv` kernel. You can find detailed installation instructions on the [GitHub repository](https://github.com/snu-mllab/GuidedQuant).
+
+```bash
+pip install transformers torch accelerate
+# Install ap-gemv kernel (e.g., for CUDA 12.4)
+pip install ap-gemv -i https://jusjinuk.me/whl/cu124
+```
+
+Then, use the following Python code snippet for inference:
+
+```python
+from any_precision.modules.AnyPrecisionForCausalLM import AnyPrecisionForCausalLM
+from transformers import AutoTokenizer, TextStreamer
+import torch
+
+# This model is a Qwen-based model, so bfloat16 is typically used.
+quantized_model_name = "jusjinuk/Qwen3-32B-3bit-GuidedQuant-SqueezeLLM" 
+dtype = torch.bfloat16
+
+model = AnyPrecisionForCausalLM.from_quantized(quantized_model_name, torch_dtype=dtype)
+tokenizer = AutoTokenizer.from_pretrained(quantized_model_name)
+streamer = TextStreamer(tokenizer)
+
+prompt = "Write me a short and concise story about a cat who loves to read.\
+"
+chat = [
+    {"role": "system", "content": "You are a helpful assistant.\
+"},
+    {"role": "user", "content": prompt},
+]
+
+inputs = tokenizer.apply_chat_template(
+    chat, tokenize=True, return_tensors="pt", add_generation_prompt=True
+).to(model.device)
+
+model.generate(inputs, 
+    max_new_tokens=200, do_sample=False, temperature=1.0, streamer=streamer, pad_token_id=tokenizer.eos_token_id
+)
+```
+
+For more detailed instructions, including installation, inference speed-up, and various quantization methods, please refer to the [GitHub repository](https://github.com/snu-mllab/GuidedQuant).
+
+## Acknowledgement
+This code is heavily based on the following repositories:
+- [Any-Precision-LLM](https://github.com/SNU-ARC/any-precision-llm)
+- [QTIP](https://github.com/Cornell-RelaxML/qtip)
+- [SpinQuant](https://github.com/facebookresearch/SpinQuant)
+- [AQLM](https://github.com/Vahe1994/AQLM)
+- [Fast Hadamard Transform](https://github.com/Dao-AILab/fast-hadamard-transform)
+- [gpt-fast](https://github.com/pytorch-labs/gpt-fast)
+
+We thank the authors for their open-source implementations and contributions to the community.
+
+## Citation
+
+Please cite our paper if you find our work useful:
+
+```
+@inproceedings{kim2025guidedquant,
+      title={GuidedQuant: Large Language Model Quantization via Exploiting End Loss Guidance}, 
+      author={Jinuk Kim and Marwa El Halabi and Wonpyo Park and Clemens JS Schaefer and Deokjae Lee and Yeonhong Park and Jae W. Lee and Hyun Oh Song},
+      booktitle = {International Conference on Machine Learning (ICML)},
+      year={2025},
+}
+```