# File: optimum-quanto-main/bench/generation/evaluate_configurations.py
import argparse
import json
import torch
from evaluate_model import evaluate
from gen_barchart import gen_barchart
from transformers import AutoConfig
from optimum.quanto import qtype

def evaluate_model_configurations(model_id: str, metric: str, device: torch.device, batch_size: int=32, dtype: torch.dtype=torch.float16):
    weights = ['int4', 'int8', 'float8']
    activations = ['none', 'float8']

    def short_name(qtype: qtype):
        return {'none': 'f16' if dtype == torch.float16 else 'bf16', 'int4': 'i4', 'int8': 'i8', 'float8': 'f8'}[qtype]
    results = {}
    config_name = f"W{short_name('none')}A{short_name('none')}"
    print(f'{model_id}[{config_name}]:')
    results[config_name] = evaluate(model_id, metric, 'quanto', 'none', 'none', batch_size, device, dtype)
    for w in weights:
        for a in activations:
            config_name = f'W{short_name(w)}A{short_name(a)}'
            print(f'{model_id}[{config_name}]:')
            results[config_name] = evaluate(model_id, metric, 'quanto', w, a, batch_size, device, dtype)
    return results

def main():
    parser = argparse.ArgumentParser(description='Evaluate quantized model predictions on Lambada Dataset')
    parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)')
    parser.add_argument('--model', type=str, default='facebook/opt-350m', help='The name of the trained Model.')
    parser.add_argument('--device', type=str, default=None, help='The device to use for generation.')
    parser.add_argument('--metric', type=str, default='prediction', choices=['latency', 'prediction', 'perplexity'])
    parser.add_argument('--batch_size', type=int, default=32, help='The batch size during evaluation.')
    parser.add_argument('--dtype', type=str, help='Use the following dtype to load the model.')
    parser.add_argument('--json', action='store_true', help='Dump the results to a json file.')
    parser.add_argument('--png', action='store_true', help='Generate a PNG.')
    args = parser.parse_args()
    torch.manual_seed(args.seed)
    if args.device is None:
        if torch.cuda.is_available():
            device = torch.device('cuda')
        elif torch.backends.mps.is_available():
            device = torch.device('mps')
        else:
            device = torch.device('cpu')
    else:
        device = torch.device(args.device)
    if args.dtype is None:
        config = AutoConfig.from_pretrained(args.model)
        dtype = getattr(config, 'torch_dtype', torch.float16)
    else:
        dtype = torch.float16 if args.dtype == 'fp16' else torch.bfloat16
    results = evaluate_model_configurations(args.model, args.metric, device, batch_size=args.batch_size, dtype=dtype)
    if args.json:
        model_name = args.model.split('/')[-1]
        json_path = f'{model_name}-{args.metric}.json'
        with open(json_path, 'w') as fp:
            json.dump({model_name: results}, fp, indent=4)
    if args.png:
        if args.metric == 'latency':
            title = f'{args.model}: Mean latency per token'
            label = 'Latency (ms)'
        elif args.metric == 'prediction':
            title = f'{args.model}: Prediction accuracy on Lambada dataset'
            label = 'Accuracy'
        elif args.metric == 'perplexity':
            title = f'{args.model}: Perplexity evaluated on WikiText dataset'
            label = 'Perplexity'
        gen_barchart(args.model, title, label, results, dtype)
if __name__ == '__main__':
    main()

# File: optimum-quanto-main/bench/generation/evaluate_model.py
import argparse
import torch
from datasets import load_dataset
from metrics.latency import latency
from metrics.perplexity import perplexity
from metrics.prediction import prediction_accuracy
from setup.awq import setup as awq_setup
from setup.bnb import setup as bnb_setup
from setup.hqq import setup as hqq_setup
from setup.quanto import setup as quanto_setup
from transformers import AutoConfig

@torch.no_grad()
def calibrate(model, tokenizer, batch_size, batches):
    samples = batch_size * batches
    cal_dataset = load_dataset('lambada', split=['validation'])[0]
    model.eval()
    total = 0
    for batch in cal_dataset.iter(batch_size=batch_size):
        inputs = tokenizer(batch['text'], return_tensors='pt', padding=True)
        input_ids = inputs.input_ids.to(model.device)
        attention_mask = inputs.attention_mask.to(model.device)
        model(input_ids, attention_mask=attention_mask)
        total += input_ids.size(0)
        if total >= samples:
            break

def evaluate(model_id: str, metric: str, quantizer: str, weights: str, activations: str, batch_size: int, device: torch.device, dtype: torch.dtype=None):
    if quantizer == 'quanto':
        if dtype is None:
            config = AutoConfig.from_pretrained(model_id)
            dtype = getattr(config, 'torch_dtype', torch.float16)
        (model, tokenizer) = quanto_setup(model_id, weights, activations, batch_size, device, dtype)
    elif quantizer == 'awq':
        (model, tokenizer) = awq_setup(model_id, weights, activations, group_size=128)
    elif quantizer == 'bnb':
        (model, tokenizer) = bnb_setup(model_id, weights, activations, device)
    elif quantizer == 'hqq':
        (model, tokenizer) = hqq_setup(model_id, weights, activations, device)
    else:
        raise ValueError(f'Unsupported quantizer {quantizer}')
    dtype = next(model.parameters()).dtype
    weights = dtype if weights == 'none' else weights
    activations = dtype if activations == 'none' else activations
    print(f'Evaluating {model_id} {metric} with {weights} weights and {activations} activations.')
    if metric == 'latency':
        return latency(model, tokenizer, device, batch_size=1, prompt_length=512, nb_tokens=512, iterations=3)
    elif metric == 'prediction':
        return prediction_accuracy(model, tokenizer, batch_size)
    elif metric == 'perplexity':
        return perplexity(model, tokenizer)

def main():
    parser = argparse.ArgumentParser(description='Evaluate quantized model metrics')
    parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)')
    parser.add_argument('--model', type=str, default='facebook/opt-350m', help='The name of the trained Model.')
    parser.add_argument('--device', type=str, default=None, help='The device to use for generation.')
    parser.add_argument('--metric', type=str, default='prediction', choices=['latency', 'prediction', 'perplexity'])
    parser.add_argument('--quantizer', type=str, default='quanto', choices=['quanto', 'awq', 'bnb', 'hqq'])
    parser.add_argument('--weights', type=str, default='none', choices=['none', 'int4', 'int8', 'float8'])
    parser.add_argument('--activations', type=str, default='none', choices=['none', 'int8', 'float8'])
    parser.add_argument('--batch_size', type=int, default=32, help='The batch size during evaluation.')
    parser.add_argument('--dtype', type=str, default='none', choices=['none', 'fp16', 'bf16'])
    args = parser.parse_args()
    torch.manual_seed(args.seed)
    if args.device is None:
        if torch.cuda.is_available():
            device = torch.device('cuda')
        elif torch.backends.mps.is_available():
            device = torch.device('mps')
        else:
            device = torch.device('cpu')
    else:
        device = torch.device(args.device)
    dtype = {'none': None, 'fp16': torch.float16, 'bf16': torch.bfloat16}[args.dtype]
    evaluate(args.model, args.metric, args.quantizer, args.weights, args.activations, args.batch_size, device, dtype)
if __name__ == '__main__':
    main()

# File: optimum-quanto-main/bench/generation/gen_barchart.py
import argparse
import json
import matplotlib.pyplot as plt
import numpy as np
import torch

def save_bar_chart(title, labels, ylabel, series, save_path):
    x = np.arange(len(labels))
    width = 0.15
    multiplier = 0
    (fig, ax) = plt.subplots(layout='constrained')
    fig.set_figwidth(10)
    max_value = 0
    for (attribute, measurement) in series.items():
        max_value = max(max_value, max(measurement))
        offset = width * multiplier
        rects = ax.bar(x + offset, measurement, width, label=attribute)
        ax.bar_label(rects, padding=5)
        multiplier += 1
    ax.set_ylabel(ylabel)
    ax.set_title(title)
    ax.set_xticks(x + width, labels)
    ax.legend(loc='upper left', ncols=4)
    ax.set_ylim(0, max_value * 1.2)
    plt.savefig(save_path)

def gen_barchart(model_id, title, label, results, dtype):
    dtype_str = 'f16' if dtype is torch.float16 else 'bf16'
    activations = (dtype_str, 'f8')
    weights = ('i4', 'i8', 'f8')
    series = {}
    reference = round(results[f'W{dtype_str}A{dtype_str}'], 2)
    series[f'Weights {dtype_str}'] = [reference] * len(activations)
    for w in weights:
        name = f'Weights {w}'
        series[name] = []
        for a in activations:
            result = results[f'W{w}A{a}']
            series[name].append(round(result, 2))
    model_name = model_id.replace('/', '-')
    metric_name = label.replace(' ', '_').replace('(', '_').replace(')', '_')
    save_bar_chart(title=title, labels=[f'Activations {a}' for a in activations], series=series, ylabel=label, save_path=f'{model_name}_{dtype_str}_{metric_name}.png')

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('benchmark', type=str, help='A benchmark result file (.json).')
    parser.add_argument('--title', type=str, required=True, help='The graph title.')
    parser.add_argument('--label', type=str, required=True, help='The graph vertical label.')
    args = parser.parse_args()
    with open(args.benchmark) as f:
        benchmark = json.load(f)
        for (model_id, results) in benchmark.items():
            gen_barchart(model_id, args.title, args.label, results)
if __name__ == '__main__':
    main()

# File: optimum-quanto-main/bench/generation/metrics/latency.py
import gc
import time
import numpy as np
import torch
from tqdm.auto import tqdm
from transformers import GenerationConfig

def latency(model, tokenizer, device, batch_size=1, prompt_length=512, nb_tokens=512, iterations=10):

    def synchronize(device):
        if device.type == 'cuda':
            torch.cuda.synchronize()
        elif device.type == 'mps':
            torch.mps.synchronize()
        else:
            torch.cpu.synchronize()

    def timing_event(device):
        if device.type == 'cuda':
            return torch.cuda.Event(enable_timing=True)
        elif device.type == 'mps':
            return torch.mps.Event(enable_timing=True)

        class CPUEvent:

            def __init__(self):
                self.time = None

            def record(self):
                self.time = time.time()

            def elapsed_time(self, other):
                assert self.time is not None
                assert other.time is not None
                return (other.time - self.time) * 1000
        return CPUEvent()
    generation_config = GenerationConfig(max_new_tokens=nb_tokens, min_new_tokens=nb_tokens, use_cache=True, pad_token_id=tokenizer.pad_token_id, num_beams=1, do_sample=False, eos_token_id=None)
    if getattr(model, 'generation_config', None) is not None:
        model.generation_config.eos_token_id = None
    synchronize(device)
    if device.type == 'cuda':
        torch.cuda.reset_peak_memory_stats()
    memory = get_device_memory(device)
    if memory is not None:
        print(f'Device memory: {memory / 2 ** 30:.4f} GB')
    latencies = []
    input_ids = torch.randint(1, model.config.vocab_size - 1, size=(batch_size, prompt_length)).to(device)
    masks = torch.ones(batch_size, prompt_length, dtype=torch.int32).to(device)
    for _ in tqdm(range(iterations)):
        start_event = timing_event(device)
        end_event = timing_event(device)
        synchronize(device)
        start_event.record()
        _ = model.generate(input_ids, attention_mask=masks, generation_config=generation_config)
        end_event.record()
        synchronize(device)
        latency_ms = start_event.elapsed_time(end_event)
        latencies.append(latency_ms)
    if device.type == 'cuda':
        peak_memory = torch.cuda.max_memory_allocated()
        print(f'Peak memory during benchmark: {peak_memory / 2 ** 30:.4f} GB')
    mean_latency = np.mean(latencies) / generation_config.min_new_tokens
    print(f'Average latency per token: {mean_latency} ms')
    return mean_latency

def get_device_memory(device):
    gc.collect()
    if device.type == 'cuda':
        torch.cuda.empty_cache()
        return torch.cuda.memory_allocated()
    elif device.type == 'mps':
        torch.mps.empty_cache()
        return torch.mps.current_allocated_memory()
    return None

# File: optimum-quanto-main/bench/generation/metrics/perplexity.py
import sys
import numpy as np
import torch
from datasets import load_dataset
from tqdm import tqdm

class Perplexity:

    def __init__(self, model, tokenizer, dataset_path='wikitext', dataset_name=None, split='test', text_column='text'):
        self._model = model
        self._tokenizer = tokenizer
        self._dataset_path = dataset_path
        self._dataset_name = dataset_name
        self._split = split
        self._text_column = text_column
        self._text = self._prepare_data()

    def _prepare_data(self):
        if self._dataset_path == 'wikitext':
            self._dataset_name = 'wikitext-2-raw-v1'
        data = load_dataset(self._dataset_path, self._dataset_name, split=self._split)
        text_list = [' \n' if s == '' else s for s in data[self._text_column]]
        return ''.join(text_list)

    @staticmethod
    def softmax(logits):
        e_x = np.exp(logits - np.max(logits))
        return e_x / e_x.sum(axis=0)

    def calculate_perplexity(self, n_ctx=512, n_batch=512):
        self._tokenizer.model_max_length = sys.maxsize
        tokens = self._tokenizer(self._text, truncation=False, return_tensors='pt').input_ids.to(self._model.device)
        nll = 0.0
        count = 0
        curr_ppl = 0
        all_perplexity = []
        with tqdm(range(len(tokens[0]) // n_ctx), desc='Perplexity: - ') as progress:
            for i in progress:
                (nll, count) = self._process_batch(i, n_ctx, n_batch, tokens, nll, count)
                curr_ppl = np.exp(nll / count)
                all_perplexity.append(curr_ppl)
                progress.set_description(f'Perplexity: {curr_ppl:.4f}')
        return all_perplexity

    def _process_batch(self, i, n_ctx, n_batch, tokens, nll, count):
        start = i * n_ctx
        end = start + n_ctx
        num_batches = (n_ctx + n_batch - 1) // n_batch
        logits = []
        for j in range(num_batches):
            batch_start = start + j * n_batch
            batch_size = min(end - batch_start, n_batch)
            token_org = tokens[0][batch_start].item()
            if j == 0:
                tokens[0][batch_start] = self._tokenizer.bos_token_id
            batch_logits = self._compute_batch_logits(tokens, batch_start, batch_size)
            tokens[0][batch_start] = token_org
            logits.append(batch_logits)
        for j in range(min(512, n_ctx // 2), n_ctx - 1):
            tok_logits = logits[0][0][j].cpu().numpy()
            prob = self.softmax(tok_logits)[tokens[0][start + j + 1]]
            nll += -np.log(prob, where=prob > 0)
            count += 1
        return (nll, count)

    def _compute_batch_logits(self, tokens, batch_start, batch_size):
        with torch.no_grad():
            outputs = self._model(tokens[:, batch_start:batch_start + batch_size])
        return outputs.logits.detach()

def perplexity(model, tokenizer, stride: int=512):
    print('Evaluating perplexity')
    ppl = Perplexity(model, tokenizer)
    ppl_value = np.mean(ppl.calculate_perplexity(n_ctx=stride))
    return ppl_value

# File: optimum-quanto-main/bench/generation/metrics/prediction.py
import time
import torch
from datasets import load_dataset

@torch.no_grad()
def prediction_accuracy(model, tokenizer, batch_size, samples=None):
    test_dataset = load_dataset('lambada', split=['test'])[0]
    model.eval()
    (total, hit) = (0, 0)
    start = time.time()
    for batch in test_dataset.iter(batch_size=batch_size):
        inputs = tokenizer(batch['text'], return_tensors='pt', padding=True)
        input_ids = inputs.input_ids.to(model.device)
        attention_mask = inputs.attention_mask.to(model.device)
        labels = input_ids[:, -1]
        outputs = model(input_ids[:, :-1], attention_mask=attention_mask[:, :-1])
        preds = outputs.logits[:, -1, :].argmax(dim=-1)
        total += labels.size(0)
        hit += (preds == labels).sum().item()
        if samples is not None and total >= samples:
            break
    end = time.time()
    acc = hit / total
    print(f'{total} sequences evaluated in {end - start:.2f} s. accuracy = {acc:.2f}')
    return acc

# File: optimum-quanto-main/bench/generation/setup/awq.py
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

def prepare_inputs_for_generation(input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs):
    if past_key_values is not None:
        cache_length = past_length = past_key_values[0][0].shape[2]
        max_cache_length = None
        if attention_mask is not None and attention_mask.shape[1] > input_ids.shape[1]:
            input_ids = input_ids[:, -(attention_mask.shape[1] - past_length):]
        elif past_length < input_ids.shape[1]:
            input_ids = input_ids[:, past_length:]
        if max_cache_length is not None and attention_mask is not None and (cache_length + input_ids.shape[1] > max_cache_length):
            attention_mask = attention_mask[:, -max_cache_length:]
    position_ids = kwargs.get('position_ids', None)
    if attention_mask is not None and position_ids is None:
        position_ids = attention_mask.long().cumsum(-1) - 1
        position_ids.masked_fill_(attention_mask == 0, 1)
        if past_key_values:
            position_ids = position_ids[:, -input_ids.shape[1]:]
    if inputs_embeds is not None and past_key_values is None:
        model_inputs = {'inputs_embeds': inputs_embeds}
    else:
        model_inputs = {'input_ids': input_ids}
    model_inputs.update({'position_ids': position_ids, 'past_key_values': past_key_values, 'use_cache': kwargs.get('use_cache'), 'attention_mask': attention_mask})
    return model_inputs

def setup(model_id: str, weights: str, activations: str, group_size: int=64, version='GEMV_FAST'):
    if activations != 'none':
        raise ValueError('Activation quantization is not supported by HQQ')
    if weights != 'int4':
        raise ValueError('AWQ only supports int4 weights.')
    quant_config = {'zero_point': True, 'q_group_size': group_size, 'w_bit': 4, 'version': version}
    model = AutoAWQForCausalLM.from_pretrained(model_id)
    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
    tokenizer.pad_token_id = tokenizer.eos_token_id
    tokenizer.padding_side = 'left'
    model.quantize(tokenizer, quant_config=quant_config)
    quant_path = model_id.replace('/', '-') + f'_{group_size}_{version}'
    model.save_quantized(quant_path)
    model = AutoAWQForCausalLM.from_quantized(quant_path)
    model.model.prepare_inputs_for_generation = prepare_inputs_for_generation
    model.device = next(model.parameters()).device
    return (model, tokenizer)

# File: optimum-quanto-main/bench/generation/setup/bnb.py
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

def setup(model_id: str, weights: str, activations: str, device: torch.device):
    if activations != 'none':
        raise ValueError('Activation quantization is not supported by BitsAndBytes')
    if weights == 'int4':
        quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type='fp4')
    elif weights == 'int8':
        quantization_config = BitsAndBytesConfig(load_in_8bit=True)
    else:
        raise ValueError('BitsAndBytes only supports int4 and int8 weights.')
    dtype = torch.float32 if device.type == 'cpu' else torch.float16
    tokenizer = AutoTokenizer.from_pretrained(model_id)
    tokenizer.pad_token_id = tokenizer.eos_token_id
    tokenizer.padding_side = 'left'
    quantization_config.bnb_4bit_compute_dtype = dtype
    model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=dtype, low_cpu_mem_usage=True, quantization_config=quantization_config)
    return (model, tokenizer)

# File: optimum-quanto-main/bench/generation/setup/hqq.py
import torch
from hqq.core.quantize import BaseQuantizeConfig
from hqq.engine.hf import HQQModelForCausalLM
from transformers import AutoTokenizer

def setup(model_id: str, weights: str, activations: str, device: torch.device, group_size: int=64):
    if activations != 'none':
        raise ValueError('Activation quantization is not supported by HQQ')
    if weights == 'int4':
        quant_config = BaseQuantizeConfig(nbits=4, group_size=group_size)
    elif weights == 'int8':
        quant_config = BaseQuantizeConfig(nbits=8, group_size=group_size)
    else:
        raise ValueError('HQQ only supports int4 and int8 weights.')
    model = HQQModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float16)
    model.quantize_model(quant_config=quant_config, compute_dtype=torch.float16, device=device)
    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
    tokenizer.pad_token_id = tokenizer.eos_token_id
    tokenizer.padding_side = 'left'
    return (model, tokenizer)

# File: optimum-quanto-main/bench/generation/setup/quanto.py
import time
import torch
from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from optimum.quanto import Calibration, freeze, qfloat8, qint4, qint8, quantize

@torch.no_grad()
def calibrate(model, tokenizer, batch_size, batches):
    samples = batch_size * batches
    cal_dataset = load_dataset('lambada', split=['validation'])[0]
    model.eval()
    total = 0
    for batch in cal_dataset.iter(batch_size=batch_size):
        inputs = tokenizer(batch['text'], return_tensors='pt', padding=True)
        input_ids = inputs.input_ids.to(model.device)
        attention_mask = inputs.attention_mask.to(model.device)
        model(input_ids, attention_mask=attention_mask)
        total += input_ids.size(0)
        if total >= samples:
            break

def setup(model_id: str, weights: str, activations: str, batch_size: int, device: torch.device, dtype: torch.dtype):
    weights = keyword_to_qtype(weights)
    activations = keyword_to_qtype(activations)
    tokenizer = AutoTokenizer.from_pretrained(model_id)
    tokenizer.pad_token_id = tokenizer.eos_token_id
    tokenizer.padding_side = 'left'
    model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=dtype, low_cpu_mem_usage=True).to(device)
    if weights is not None or activations is not None:
        print('Quantizing')
        start = time.time()
        quantization_root = model
        if hasattr(model, 'model'):
            quantization_root = model.model
        quantize(quantization_root, weights=weights, activations=activations)
        if activations is not None:
            print('Calibrating')
            with Calibration():
                calibrate(model, tokenizer, batch_size, batches=4)
        print('Freezing')
        freeze(model)
        print(f'Finished: {time.time() - start:.2f}')
    return (model, tokenizer)

def keyword_to_qtype(k):
    return {'none': None, 'int4': qint4, 'int8': qint8, 'float8': qfloat8}[k]

# File: optimum-quanto-main/bench/kernels/benchmark.py
import argparse
import time
from contextlib import nullcontext
import numpy as np
import torch
from tqdm.auto import tqdm
from optimum.quanto.library import disable_extensions

def get_unpack_bench(bits, device):
    qmax = 2 ** bits
    a = torch.randint(0, qmax, [10240, 10240], dtype=torch.uint8).to(device)

    def bench_fn():
        return torch.ops.quanto.unpack(a, bits)
    return bench_fn

def timing(get_bench_func, device, iterations=10):

    def synchronize(device):
        if device.type == 'cuda':
            torch.cuda.synchronize()
        elif device.type == 'mps':
            torch.mps.synchronize()
        else:
            torch.cpu.synchronize()

    def timing_event(device):
        if device.type == 'cuda':
            return torch.cuda.Event(enable_timing=True)
        elif device.type == 'mps':
            return torch.mps.Event(enable_timing=True)

        class CPUEvent:

            def __init__(self):
                self.time = None

            def record(self):
                self.time = time.time()

            def elapsed_time(self, other):
                assert self.time is not None
                assert other.time is not None
                return (other.time - self.time) * 1000
        return CPUEvent()
    synchronize(device)
    bench_func = get_bench_func(device)
    bench_func()
    latencies = np.empty((iterations, 2))
    for i in tqdm(range(iterations)):
        for (j, context) in enumerate([disable_extensions(), nullcontext()]):
            start_event = timing_event(device)
            end_event = timing_event(device)
            synchronize(device)
            start_event.record()
            with context:
                bench_func()
            end_event.record()
            synchronize(device)
            latencies[i, j] = start_event.elapsed_time(end_event)
    return (np.mean(latencies[:, 0]), np.mean(latencies[:, 1]))
GET_BENCH_FUNCTIONS = {'unpack_2bit': lambda device: get_unpack_bench(2, device), 'unpack_4bit': lambda device: get_unpack_bench(4, device)}

def main():
    parser = argparse.ArgumentParser(description='Kernel benchmark')
    parser.add_argument('--kernel', type=str, default=None, help='The kernel to benchmark. None to test all of them')
    parser.add_argument('--device', type=str, default=None, help='The device to use for benchmark.')
    parser.add_argument('--it', type=int, default=10, help='The number of benchmark iterations')
    args = parser.parse_args()
    if args.device is None:
        if torch.cuda.is_available():
            device = torch.device('cuda')
        elif torch.backends.mps.is_available():
            device = torch.device('mps')
        else:
            device = torch.device('cpu')
    else:
        device = torch.device(args.device)
    all_kernels = GET_BENCH_FUNCTIONS.keys()
    kernels = all_kernels if args.kernel is None else [args.kernel]
    for kernel in kernels:
        get_bench_fn = GET_BENCH_FUNCTIONS[kernel]
        (python_ms, ext_ms) = timing(get_bench_fn, device, iterations=args.it)
        ratio = python_ms / ext_ms
        print(f'\n{kernel}[{device.type}]: python = {python_ms:.3f} ms, ext = {ext_ms:.3f} ms, ratio = {ratio:.1f}x')
if __name__ == '__main__':
    main()

# File: optimum-quanto-main/bench/kernels/benchmark_marlin_fp8.py
import argparse
from typing import Optional
import numpy as np
import torch
from optimum.quanto.tensor.weights.marlin.packed import pack_fp8_as_int32
M_SHAPES = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]
N_SHAPES = [4096]
K_SHAPES = [4096]

def run_benchmark(m: Optional[int], n: Optional[int], k: Optional[int], n_runs: int, n_warmup: int, dtype: torch.dtype=torch.float16):
    print(f'\n----------- m={m}, n={n}, k={k}')
    n_tokens = m
    in_features = k
    out_features = n
    assert m is not None
    device = torch.device('cuda')
    inputs = torch.rand(n_tokens, in_features, dtype=dtype, device=device)
    other_shape = (in_features, out_features)
    other_data = torch.rand(other_shape, dtype=dtype, device=device).to(torch.float8_e4m3fn)
    other_data_int32 = pack_fp8_as_int32(other_data)
    perm = torch.empty(0, dtype=torch.int, device=device)
    other_data_repack = torch.ops.quanto.gptq_marlin_repack(b_q_weight=other_data_int32, perm=perm, size_k=in_features, size_n=out_features, num_bits=8)
    other_scale = torch.rand(1, dtype=dtype, device=device)
    other_scale = other_scale.repeat(1, out_features)
    workspace = torch.zeros(out_features // 64 * 16, dtype=torch.int, device=device)
    latencies_marlin_fp8 = []
    latencies_torch = []
    with torch.no_grad():
        for i in range(n_runs):
            start_event = torch.cuda.Event(enable_timing=True)
            end_event = torch.cuda.Event(enable_timing=True)
            torch.cuda.synchronize(device)
            start_event.record()
            _ = torch.ops.quanto.fp8_marlin_gemm(a=inputs, b_q_weight=other_data_repack, b_scales=other_scale, workspace=workspace, num_bits=8, size_m=n_tokens, size_n=out_features, size_k=in_features)
            end_event.record()
            torch.cuda.synchronize(device)
            latency_ms = start_event.elapsed_time(end_event)
            if i >= n_warmup:
                latencies_marlin_fp8.append(latency_ms)
            start_event = torch.cuda.Event(enable_timing=True)
            end_event = torch.cuda.Event(enable_timing=True)
            torch.cuda.synchronize(device)
            start_event.record()
            other = other_data.to(dtype) * other_scale
            _ = torch.matmul(inputs, other)
            end_event.record()
            torch.cuda.synchronize(device)
            latency_ms = start_event.elapsed_time(end_event)
            if i >= n_warmup:
                latencies_torch.append(latency_ms)
    mean_latency_torch = np.mean(latencies_torch)
    mean_latency_marlin_fp8 = np.mean(latencies_marlin_fp8)
    print('mean_latency_torch:', mean_latency_torch)
    print('mean_latency_marlin_fp8:', mean_latency_marlin_fp8)
    return (mean_latency_torch, mean_latency_marlin_fp8)
if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Marlin FP8 kernel benchmark')
    parser.add_argument('--nruns', type=int, default=20, help='The number of benchmark iterations')
    parser.add_argument('--nwarmup', type=int, default=2, help='The number of warmup iterations (deducted from nruns)')
    parser.add_argument('--m', type=int, help='m dimension of A=m*k', default=None)
    parser.add_argument('--n', type=int, help='n dimension of B=k*n (out_features)', default=None)
    parser.add_argument('--k', type=int, help='k dimension of A=m*k and B=k*n (in_features), hidden_size', default=None)
    args = parser.parse_args()
    if args.m is not None:

        def shape_generator():
            yield (args.m, args.n, args.k)
    else:

        def shape_generator():
            for m in M_SHAPES:
                for n in N_SHAPES:
                    for k in K_SHAPES:
                        yield (m, n, k)
    result = 'm,n_out,k_in,torch_latency_ms,marlin_fp8_latency_ms\n'
    for (m, n, k) in shape_generator():
        (mean_latency_torch, mean_latency_marlin_fp8) = run_benchmark(m, n, k, args.nruns, args.nwarmup)
        result += ','.join([str(m), str(n), str(k), f'{mean_latency_torch:.4f}', f'{mean_latency_marlin_fp8:.4f}']) + '\n'
    print('\nResults:')
    print(result)

# File: optimum-quanto-main/external/awq/pack_intweight.py
import torch

def pack_intweight(unpacked_qweight, interleave, kstride):
    N = unpacked_qweight.shape[0]
    K = unpacked_qweight.shape[1]
    Packed_Kernel = unpacked_qweight.cpu().numpy().reshape(N, K // 32, 32)
    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 4, 4, 2).transpose(0, 1, 3, 2, 4)
    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 32)
    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 4, 8)
    Packed_Kernel = Packed_Kernel.reshape(N, K // 32, 4, 4, 2).transpose(0, 1, 2, 4, 3)
    Packed_Kernel = Packed_Kernel.reshape(N, K)
    Packed_Kernel = Packed_Kernel.reshape(N // interleave, interleave, K // kstride, kstride)
    Packed_Kernel = Packed_Kernel.transpose(0, 2, 1, 3)
    Packed_Kernel = Packed_Kernel.reshape(N // interleave, K // kstride, kstride, interleave)
    Packed_Kernel = Packed_Kernel[..., 0] | Packed_Kernel[..., 1] << 4 | Packed_Kernel[..., 2] << 8 | Packed_Kernel[..., 3] << 12
    Packed_Kernel = Packed_Kernel.reshape(N // interleave, K)
    qweight = torch.tensor(Packed_Kernel.astype('int16')).to(unpacked_qweight.device).contiguous()
    return qweight

# File: optimum-quanto-main/external/awq/packing_utils.py
import torch
AWQ_ORDER = [0, 2, 4, 6, 1, 3, 5, 7]
AWQ_REVERSE_ORDER = [0, 4, 1, 5, 2, 6, 3, 7]

def pack_awq(intweight: torch.Tensor, reorder=False):
    bits = 4
    pack_num = 32 // bits
    qweight = torch.zeros(intweight.shape[0], intweight.shape[1] // pack_num, dtype=torch.int32, device=intweight.device)
    for col in range(intweight.shape[1] // pack_num):
        if reorder:
            order_map = [0, 2, 4, 6, 1, 3, 5, 7]
        else:
            order_map = [0, 1, 2, 3, 4, 5, 6, 7]
        for i in range(pack_num):
            qweight_col = intweight[:, col * pack_num + order_map[i]]
            qweight[:, col] |= qweight_col << i * bits
    return qweight

def unpack_awq(qweight: torch.Tensor, bits: int):
    shifts = torch.arange(0, 32, bits, device=qweight.device)
    iweights = torch.bitwise_right_shift(qweight[:, :, None], shifts[None, None, :]).to(torch.int8)
    iweights = iweights.view(iweights.shape[0], -1)
    return iweights

def reverse_awq_order(iweights: torch.Tensor, bits: int):
    reverse_order_tensor = torch.arange(iweights.shape[-1], dtype=torch.int32, device=iweights.device)
    reverse_order_tensor = reverse_order_tensor.view(-1, 32 // bits)
    reverse_order_tensor = reverse_order_tensor[:, AWQ_REVERSE_ORDER]
    reverse_order_tensor = reverse_order_tensor.view(-1)
    iweights = iweights[:, reverse_order_tensor]
    return iweights

def pack_exllama(iweights: torch.Tensor, izeros: torch.Tensor, bits: int):
    shifts = torch.arange(0, 32, bits, device=iweights.device)
    iweights = iweights.view(iweights.shape[0] // (32 // bits), 32 // bits, -1)
    qweight = torch.bitwise_left_shift(iweights, shifts[None, :, None]).sum(dim=1).to(torch.int32)
    izeros = izeros.view(-1, izeros.shape[1] // (32 // bits), 32 // bits)
    qzeros = torch.bitwise_left_shift(izeros, shifts[None, None, :]).sum(dim=-1).to(torch.int32)
    return (qweight, qzeros)

def unpack_reorder_pack(qweight, qzeros, bits):
    (iweight, izeros) = unpack_awq(qweight, qzeros, bits)
    (iweight, izeros) = reverse_awq_order(iweight, izeros, bits)
    iweight = torch.bitwise_and(iweight, 2 ** bits - 1)
    izeros = torch.bitwise_and(izeros, 2 ** bits - 1)
    izeros = izeros - 1
    (qweight, qzeros) = pack_exllama(iweight, izeros, bits)
    return (qweight, qzeros)

def dequantize_gemm(qweight, qzeros, scales, bits, group_size):
    (iweight, izeros) = unpack_awq(qweight, qzeros, bits)
    (iweight, izeros) = reverse_awq_order(iweight, izeros, bits)
    iweight = torch.bitwise_and(iweight, 2 ** bits - 1)
    izeros = torch.bitwise_and(izeros, 2 ** bits - 1)
    scales = scales.repeat_interleave(group_size, dim=0)
    izeros = izeros.repeat_interleave(group_size, dim=0)
    iweight = (iweight - izeros) * scales
    return iweight

# File: optimum-quanto-main/external/smoothquant/smoothquant.py
import argparse
import functools
import os
import torch
import torch.nn as nn
from datasets import load_dataset
from tqdm import tqdm
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.models.bloom.modeling_bloom import BloomBlock
from transformers.models.opt.modeling_opt import OPTDecoderLayer
from transformers.models.llama.modeling_llama import LlamaDecoderLayer, LlamaRMSNorm
from transformers.models.mistral.modeling_mistral import MistralDecoderLayer, MistralRMSNorm

def get_act_scales(model, tokenizer, dataset, num_samples=512, seq_len=512):
    model.eval()
    device = next(model.parameters()).device
    act_scales = {}

    def stat_tensor(name, tensor):
        hidden_dim = tensor.shape[-1]
        tensor = tensor.view(-1, hidden_dim).abs().detach()
        comming_max = torch.max(tensor, dim=0)[0].float().cpu()
        if name in act_scales:
            act_scales[name] = torch.max(act_scales[name], comming_max)
        else:
            act_scales[name] = comming_max

    def stat_input_hook(m, x, y, name):
        if isinstance(x, tuple):
            x = x[0]
        stat_tensor(name, x)
    hooks = []
    for (name, m) in model.named_modules():
        if isinstance(m, nn.Linear):
            hooks.append(m.register_forward_hook(functools.partial(stat_input_hook, name=name)))
    for i in tqdm(range(num_samples)):
        input_ids = tokenizer(dataset[i]['text'], return_tensors='pt', max_length=seq_len, truncation=True).input_ids.to(device)
        model(input_ids)
    for h in hooks:
        h.remove()
    return act_scales

@torch.no_grad()
def smooth_ln_fcs(ln, fcs, act_scales, alpha=0.5):
    if not isinstance(fcs, list):
        fcs = [fcs]
    assert isinstance(ln, (nn.LayerNorm, LlamaRMSNorm, MistralRMSNorm))
    for fc in fcs:
        assert isinstance(fc, nn.Linear)
        assert ln.weight.numel() == fc.in_features == act_scales.numel()
    (device, dtype) = (fcs[0].weight.device, fcs[0].weight.dtype)
    act_scales = act_scales.to(device=device, dtype=dtype)
    weight_scales = torch.cat([fc.weight.abs().max(dim=0, keepdim=True)[0] for fc in fcs], dim=0)
    weight_scales = weight_scales.max(dim=0)[0].clamp(min=1e-05)
    scales = (act_scales.pow(alpha) / weight_scales.pow(1 - alpha)).clamp(min=1e-05).to(device).to(dtype)
    ln.weight.div_(scales)
    if getattr(ln, 'bias', None) is not None:
        ln.bias.div_(scales)
    for fc in fcs:
        fc.weight.mul_(scales.view(1, -1))

@torch.no_grad()
def smooth_lm(model, scales, alpha=0.5):
    for (name, module) in model.named_modules():
        if isinstance(module, OPTDecoderLayer):
            attn_ln = module.self_attn_layer_norm
            qkv = [module.self_attn.q_proj, module.self_attn.k_proj, module.self_attn.v_proj]
            qkv_input_scales = scales[name + '.self_attn.q_proj']
            smooth_ln_fcs(attn_ln, qkv, qkv_input_scales, alpha)
            ffn_ln = module.final_layer_norm
            fc1 = module.fc1
            fc1_input_scales = scales[name + '.fc1']
            smooth_ln_fcs(ffn_ln, fc1, fc1_input_scales, alpha)
        elif isinstance(module, BloomBlock):
            attn_ln = module.input_layernorm
            qkv = module.self_attention.query_key_value
            qkv_input_scales = scales[name + '.self_attention.query_key_value']
            smooth_ln_fcs(attn_ln, qkv, qkv_input_scales, alpha)
            ffn_ln = module.post_attention_layernorm
            fc1 = module.mlp.dense_h_to_4h
            fc1_input_scales = scales[name + '.mlp.dense_h_to_4h']
            smooth_ln_fcs(ffn_ln, fc1, fc1_input_scales, alpha)
        elif isinstance(module, (LlamaDecoderLayer, MistralDecoderLayer)):
            attn_ln = module.input_layernorm
            qkv = [module.self_attn.q_proj, module.self_attn.k_proj, module.self_attn.v_proj]
            qkv_input_scales = scales[name + '.self_attn.q_proj']
            smooth_ln_fcs(attn_ln, qkv, qkv_input_scales, alpha)
            ffn_ln = module.post_attention_layernorm
            fc = [module.mlp.gate_proj, module.mlp.up_proj]
            fc_input_scales = scales[name + '.mlp.gate_proj']
            smooth_ln_fcs(ffn_ln, fc, fc_input_scales, alpha)

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--model', type=str, default='facebook/opt-125m', help='model name')
    parser.add_argument('--save-path', type=str, default=None, help='smoothed model model save path')
    parser.add_argument('--num-samples', type=int, default=512)
    parser.add_argument('--seq-len', type=int, default=512)
    parser.add_argument('--device', type=str, default=None, help='The device to use for generation.')
    args = parser.parse_args()
    if args.device is None:
        if torch.cuda.is_available():
            device = torch.device('cuda')
        elif torch.backends.mps.is_available():
            device = torch.device('mps')
        else:
            device = torch.device('cpu')
    else:
        device = torch.device(args.device)
    dataset = load_dataset('lambada', split=f'validation[:{args.num_samples}]').shuffle()
    tokenizer = AutoTokenizer.from_pretrained(args.model, model_max_length=args.seq_len)
    model = AutoModelForCausalLM.from_pretrained(args.model, torch_dtype='auto').to(device)
    act_scales = get_act_scales(model, tokenizer, dataset, args.num_samples, args.seq_len)
    smooth_lm(model, act_scales, 0.5)
    save_path = args.save_path
    if save_path is None:
        save_path = os.path.join('smoothed_models', args.model)
    model.save_pretrained(save_path)
    tokenizer.save_pretrained(save_path)
if __name__ == '__main__':
    main()

# File: optimum-quanto-main/optimum/quanto/calibrate.py
from typing import Optional
import torch
from torch.nn.modules.module import register_module_forward_hook, register_module_forward_pre_hook
from torch.overrides import TorchFunctionMode
from .nn import QModuleMixin
from .tensor import ActivationQBytesTensor, QTensor, axis_to_dim, dtype_info, qint8, qtype
__all__ = ['Calibration', 'absmax_scale']

def _updated_scale(scale, new_scale, momentum):
    if torch.all(scale == 1):
        return new_scale
    return momentum * scale + new_scale * (1.0 - momentum)

def absmax_scale(base: torch.Tensor, qtype: qtype=qint8, axis: Optional[int]=None) -> torch.Tensor:
    base = torch.abs(base)
    if axis is None:
        qranges = torch.max(base)
    else:
        dim = axis_to_dim(base, axis)
        qranges = torch.amax(base, dim=dim, keepdim=True)
    info = dtype_info(qtype.dtype)
    return qranges / info.max

class Calibration(TorchFunctionMode):

    def __init__(self, *args, momentum: float=0.9, streamline=True, debug=False, **kwargs):
        super().__init__(*args, **kwargs)
        self.momentum = momentum
        self.streamline = streamline
        if streamline:
            self.modules_qactivations = {}
            self.streamline_hooks = {}
        self.debug = debug

    def __torch_function__(self, func, types, args=(), kwargs=None):
        kwargs = kwargs if kwargs is not None else {}
        qinput = QTensor in types
        output = func(*args, **kwargs)
        if self.streamline and qinput:
            for (i, arg) in enumerate(args):
                module = getattr(arg, 'src_module', None)
                if module is not None:
                    if isinstance(output, ActivationQBytesTensor):
                        self.modules_qactivations[module] = True
                    elif isinstance(output, torch.Tensor):
                        qactivations_required = self.modules_qactivations.get(module, False)
                        self.modules_qactivations[module] = qactivations_required
        return output

    def __enter__(self):
        super().__enter__()
        self.pre_handle = register_module_forward_pre_hook(self.calibrate_input)
        self.post_handle = register_module_forward_hook(self.calibrate_output)

    def __exit__(self, exc_type, exc_val, exc_tb):
        super().__exit__(exc_type, exc_val, exc_tb)
        self.pre_handle.remove()
        self.post_handle.remove()
        if self.streamline:
            for handle in self.streamline_hooks.values():
                handle.remove()

    def calibrate_input(self, module: torch.nn.Module, input, momentum: float=0.9):
        if isinstance(module, QModuleMixin) and module.activation_qtype is not None:
            input = input[0]
            if isinstance(input, ActivationQBytesTensor):
                module.input_scale = torch.max(input._scale)
            else:
                input_scale = absmax_scale(input, module.activation_qtype)
                module.input_scale = _updated_scale(module.input_scale, input_scale, momentum)
            if self.streamline and module not in self.streamline_hooks:
                self.streamline_hooks[module] = module.register_forward_hook(self.tag_outputs)
            return input

    def calibrate_output(self, module: torch.nn.Module, input: torch.Tensor, output: torch.Tensor):
        if isinstance(module, QModuleMixin) and module.activation_qtype is not None:
            output_scale = absmax_scale(output, module.activation_qtype, axis=None)
            module.output_scale = _updated_scale(module.output_scale, output_scale, self.momentum)
            return output
        else:
            if self.streamline:
                for (name, child) in module.named_children():
                    if isinstance(child, QModuleMixin) and child.activation_qtype is not None:
                        qactivations_required = self.modules_qactivations.get(child, False)
                        if not qactivations_required:
                            child.disable_output_quantization()
            if self.debug:
                for (name, child) in module.named_children():
                    if isinstance(child, QModuleMixin):
                        classname = child.__class__.__name__
                        trace = f'{name}({classname}) activations are'
                        if child.activation_qtype is None:
                            trace += ' not quantized.'
                        else:
                            trace += f' quantized to {child.activation_qtype} with scale {child.output_scale}.'
                        print(trace)

    def tag_outputs(self, module: torch.nn.Module, input: torch.Tensor, output: torch.Tensor):
        output.src_module = module

# File: optimum-quanto-main/optimum/quanto/library/extensions/cpp/__init__.py
import os
import torch
from ..extension import Extension
__all__ = []
ext = Extension('quanto_cpp', root_dir=os.path.dirname(__file__), sources=['unpack.cpp', 'pybind_module.cpp'], extra_cflags=['-O3'])

@torch.library.impl('quanto_ext::unpack', ['CPU'])
def unpack_cpp(t: torch.Tensor, bits: int):
    return ext.lib.unpack(t, bits)

# File: optimum-quanto-main/optimum/quanto/library/extensions/cuda/__init__.py
import os
import torch
from ..extension import Extension
__all__ = []

def get_max_cuda_arch():
    capability_list = []
    supported_sm = [int(arch.split('_')[1]) for arch in torch.cuda.get_arch_list() if 'sm_' in arch]
    if supported_sm:
        max_supported_sm = max(((sm // 10, sm % 10) for sm in supported_sm))
        for i in range(torch.cuda.device_count()):
            capability = torch.cuda.get_device_capability(i)
            capability = min(max_supported_sm, capability)
            if capability not in capability_list:
                capability_list.append(capability)
    max_capability = max(sorted(capability_list)) if len(capability_list) > 0 else (0, 0)
    return f'{max_capability[0]}{max_capability[1]}0'
extra_cflags = ['-g', '-O3', '-fopenmp', '-lgomp', '-std=c++17', '-DENABLE_BF16']
extra_cuda_cflags = ['-O3', '-std=c++17', '-DENABLE_BF16', '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_BFLOAT16_OPERATORS__', '-U__CUDA_NO_BFLOAT16_CONVERSIONS__', '-U__CUDA_NO_BFLOAT162_OPERATORS__', '-U__CUDA_NO_BFLOAT162_CONVERSIONS__', '--expt-relaxed-constexpr', '--expt-extended-lambda', '--use_fast_math', '--threads=8']
quanto_cuda_arch = get_max_cuda_arch()
extra_cuda_cflags += [f'-DQUANTO_CUDA_ARCH={quanto_cuda_arch}']
module_path = os.path.dirname(__file__)
sources = ['unpack.cu', 'awq/v2/gemm_cuda.cu', 'awq/v2/gemv_cuda.cu', 'marlin/fp8_marlin.cu', 'marlin/gptq_marlin_repack.cu', 'pybind_module.cpp']
ext = Extension('quanto_cuda', root_dir=os.path.dirname(__file__), sources=sources, extra_cflags=extra_cflags, extra_cuda_cflags=extra_cuda_cflags)

@torch.library.impl('quanto_ext::unpack', ['CUDA'])
def unpack_cuda(t: torch.Tensor, bits: int):
    return ext.lib.unpack(t, bits)
torch.library.define('quanto::gemm', '(Tensor input, Tensor other, Tensor other_scale, Tensor other_shift, int rows, int out_cols, int in_cols, int bits, int group_size) -> Tensor')

@torch.library.impl('quanto::gemm', ['CUDA'])
def gemm_cuda(input: torch.Tensor, other: torch.Tensor, scales: torch.Tensor, shift: torch.Tensor, rows: int, out_cols: int, in_cols: int, bits: int, group_size: int):
    assert out_cols >= 128
    assert input.dtype == torch.float16
    assert input.numel() == rows * in_cols
    assert other.dtype == torch.int16
    assert scales.dtype == torch.float16
    assert scales.shape[-1] == out_cols
    assert shift.dtype == torch.float16
    assert shift.shape[-1] == out_cols
    assert bits == 4
    assert group_size == 128
    if rows < 8:
        return ext.lib.awq_v2_gemv_f16i4(input, other, scales, shift, rows, out_cols, in_cols, group_size)
    return ext.lib.awq_v2_gemm_f16i4(input, other, scales, shift)

@torch.library.custom_op('quanto::fp8_marlin_gemm', mutates_args=(), device_types=['cuda'])
def fp8_marlin_gemm(a: torch.Tensor, b_q_weight: torch.Tensor, b_scales: torch.Tensor, workspace: torch.Tensor, num_bits: int, size_m: int, size_n: int, size_k: int) -> torch.Tensor:
    assert b_scales.dtype == torch.float16 or b_scales.dtype == torch.bfloat16
    assert b_q_weight.dim() == 2
    assert b_q_weight.dtype == torch.int32
    return ext.lib.fp8_marlin_gemm(a, b_q_weight, b_scales, workspace, num_bits, size_m, size_n, size_k)

@torch.library.custom_op('quanto::gptq_marlin_repack', mutates_args=(), device_types=['cuda'])
def gptq_marlin_repack(b_q_weight: torch.Tensor, perm: torch.Tensor, size_k: int, size_n: int, num_bits: int) -> torch.Tensor:
    assert b_q_weight.dim() == 2
    assert b_q_weight.dtype == torch.int32
    return ext.lib.gptq_marlin_repack(b_q_weight, perm, size_k, size_n, num_bits)

# File: optimum-quanto-main/optimum/quanto/library/extensions/extension.py
import os
import shutil
import warnings
from typing import List
import torch
from torch.utils.cpp_extension import load

class Extension(object):

    def __init__(self, name: str, root_dir: str, sources: List[str], extra_cflags: List[str]=None, extra_cuda_cflags: List[str]=None):
        self.name = name
        self.sources = [f'{root_dir}/{source}' for source in sources]
        self.extra_cflags = extra_cflags
        self.extra_cuda_cflags = extra_cuda_cflags
        self.build_directory = os.path.join(root_dir, 'build')
        self._lib = None

    @property
    def lib(self):
        if self._lib is None:
            version_file = os.path.join(self.build_directory, 'pytorch_version.txt')
            if os.path.exists(version_file):
                with open(version_file, 'r') as f:
                    pytorch_build_version = f.read().rstrip()
                    if pytorch_build_version != torch.__version__:
                        shutil.rmtree(self.build_directory)
                        warnings.warn(f'{self.name} was compiled with pytorch {pytorch_build_version}, but {torch.__version__} is installed: it will be recompiled.')
            os.makedirs(self.build_directory, exist_ok=True)
            self._lib = load(name=self.name, sources=self.sources, extra_cflags=self.extra_cflags, extra_cuda_cflags=self.extra_cuda_cflags, build_directory=self.build_directory)
            if not os.path.exists(version_file):
                with open(version_file, 'w') as f:
                    f.write(torch.__version__)
        return self._lib

# File: optimum-quanto-main/optimum/quanto/library/extensions/mps/__init__.py
import os
import torch
from ..extension import Extension
__all__ = []
ext = Extension('quanto_mps', root_dir=os.path.dirname(__file__), sources=['unpack.mm', 'pybind_module.cpp'], extra_cflags=['-std=c++17'])

@torch.library.impl('quanto_ext::unpack', 'MPS')
def unpack_mps(t: torch.Tensor, bits: int):
    return ext.lib.unpack(t, bits)

# File: optimum-quanto-main/optimum/quanto/library/ops.py
import warnings
from contextlib import contextmanager
import torch
_ext_enabled = True

@contextmanager
def disable_extensions():
    try:
        global _ext_enabled
        _ext_enabled = False
        yield
    finally:
        _ext_enabled = True

def define(name, schema):
    for libname in ['quanto', 'quanto_py', 'quanto_ext']:
        torch.library.define(f'{libname}::{name}', schema)

    @torch.library.impl(f'quanto::{name}', 'default')
    def impl(*args, **kwargs):
        if _ext_enabled:
            try:
                return getattr(torch.ops.quanto_ext, name)(*args, **kwargs)
            except Exception as e:
                if isinstance(e, NotImplementedError):
                    message = f'No optimized kernel found for quanto::{name}.'
                else:
                    message = f'An exception was raised while calling the optimized kernel for quanto::{name}: {e}'
                warnings.warn(message + ' Falling back to default implementation.')
        return getattr(torch.ops.quanto_py, name)(*args, **kwargs)
define('unpack', '(Tensor self, int bits) -> Tensor')

# File: optimum-quanto-main/optimum/quanto/library/python/unpack.py
import torch

@torch.library.impl('quanto_py::unpack', 'default')
def unpack(packed: torch.Tensor, bits: int) -> torch.Tensor:
    unpacked = []
    values_per_item = 8 // bits

    def rshift(t: torch.Tensor, bits: int):
        if t.device.type == 'mps':
            return t // 2 ** bits
        return t >> bits
    for i in range(values_per_item):
        mask = 2 ** (bits * (i + 1)) - 1
        unpacked.append(rshift(packed & mask, bits * i))
    return torch.cat(unpacked).to(torch.uint8)

# File: optimum-quanto-main/optimum/quanto/library/qbytes_mm.py
import torch
from packaging import version
__all__ = []
torch.library.define('quanto::qbytes_mm', '(Tensor A, Tensor B, Tensor scales) -> Tensor')

def qbytes_mm(activations: torch.Tensor, weights: torch.Tensor, output_scales: torch.Tensor) -> torch.Tensor:
    activations = activations.to(output_scales.dtype)
    if weights.dtype.is_floating_point:
        weights = weights.to(output_scales.dtype)
    weights = output_scales * weights
    return torch.matmul(activations, weights.t())

def qbytes_int_mm(activations: torch.Tensor, weights: torch.Tensor, output_scales: torch.Tensor) -> torch.Tensor:
    in_features = activations.shape[-1]
    out_features = weights.shape[0]
    weights = weights.t()
    if activations.ndim == 2:
        out_data = torch._int_mm(activations, weights)
    else:
        output_shape = activations.shape[:-1] + (out_features,)
        out_data = torch._int_mm(activations.view(-1, in_features), weights)
        out_data = out_data.view(output_shape)
    fp32_output = out_data.to(torch.float32) * output_scales.t()
    return fp32_output.to(output_scales.dtype)

def qbytes_int8pack_mm(activations: torch.Tensor, weights: torch.Tensor, output_scales: torch.Tensor) -> torch.Tensor:
    output_scales = output_scales.flatten()
    if activations.ndim == 2:
        return torch._weight_int8pack_mm(activations, weights, output_scales)
    else:
        in_features = activations.shape[-1]
        out_features = weights.shape[0]
        output_shape = activations.shape[:-1] + (out_features,)
        out_data = torch._weight_int8pack_mm(activations.view(-1, in_features), weights, output_scales)
        return out_data.view(output_shape)

@torch.library.impl('quanto::qbytes_mm', 'default')
def qbytes_mm_impl_default(activations: torch.Tensor, weights: torch.Tensor, output_scales: torch.Tensor) -> torch.Tensor:
    return qbytes_mm(activations, weights, output_scales)

@torch.library.impl('quanto::qbytes_mm', 'CUDA')
def qbytes_mm_impl_cuda(activations: torch.Tensor, weights: torch.Tensor, output_scales: torch.Tensor) -> torch.Tensor:
    assert activations.ndim in (2, 3)
    in_features = activations.shape[-1]
    tokens = activations.shape[0] if activations.ndim == 2 else activations.shape[0] * activations.shape[1]
    out_features = weights.shape[0]
    if activations.dtype == torch.int8 and weights.dtype == torch.int8 and (tokens > 16) and (tokens % 8 == 0) and (in_features % 8 == 0) and (out_features % 8 == 0):
        return qbytes_int_mm(activations, weights, output_scales)
    return qbytes_mm(activations, weights, output_scales)

@torch.library.impl('quanto::qbytes_mm', 'CPU')
def qbytes_mm_impl_cpu(activations: torch.Tensor, weights: torch.Tensor, output_scales: torch.Tensor) -> torch.Tensor:
    if version.parse(torch.__version__).release > version.parse('2.4.0').release and activations.dtype == torch.int8 and (weights.dtype == torch.int8):
        return qbytes_int_mm(activations, weights, output_scales)
    in_features = activations.shape[-1]
    if activations.dtype == torch.bfloat16 and weights.dtype == torch.int8 and (in_features % 4 == 0):
        if type(activations) is not torch.Tensor:
            activations = activations.dequantize()
        return qbytes_int8pack_mm(activations, weights, output_scales)
    return qbytes_mm(activations, weights, output_scales)

@torch.library.impl('quanto_py::qbytes_mm', 'MPS')
def qbytes_mm_impl_mps(activations: torch.Tensor, weights: torch.Tensor, output_scales: torch.Tensor) -> torch.Tensor:
    in_features = activations.shape[-1]
    out_features = weights.shape[0]
    if version.parse(torch.__version__).release >= version.parse('2.4.0').release and activations.dtype == torch.bfloat16 and (weights.dtype == torch.int8) and (in_features % 32 == 0) and (out_features % 32 == 0):
        if type(activations) is not torch.Tensor:
            activations = activations.dequantize()
        return qbytes_int8pack_mm(activations, weights, output_scales)
    return qbytes_mm(activations, weights, output_scales)

# File: optimum-quanto-main/optimum/quanto/library/quantize.py
from typing import Union
import torch
from ..tensor import dtype_info, group

@torch.library.custom_op('quanto::quantize_symmetric', mutates_args=())
def quantize_symmetric(base: torch.Tensor, dtype: torch.dtype, axis: Union[int, None], scale: torch.Tensor) -> torch.Tensor:
    if axis is None:
        if scale.ndim > 0:
            raise ValueError('Scale must be a scalar when quantizing per-tensor')
    else:
        if base.ndim == 1:
            raise ValueError('1D Tensors cannot be quantized per-axis')
        if axis == base.ndim - 1:
            axis = -1
        if axis not in (0, -1):
            raise ValueError('Quantization is only supported along the first or last axis.')
        if base.shape[axis] == 1:
            raise ValueError(f'Cannot quantize Tensor of shape {base.shape} along axis {axis} of size 1')
        if torch.squeeze(scale).ndim > 1:
            raise ValueError('Quantizing along multiple axis is not supported')
        if scale.ndim != base.ndim:
            raise ValueError('When quantizing per-axis, the scale must be broadcastable to the base (Tip: try to add missing dims of length zero).')
    data = base / scale
    if not dtype.is_floating_point:
        data = torch.round(data)
    info = dtype_info(dtype)
    return torch.clamp(data, min=info.min, max=info.max).to(dtype)

@torch.library.custom_op('quanto::quantize_affine', mutates_args=())
def quantize_affine(base: torch.Tensor, bits: int, axis: int, group_size: Union[int, None], scale: torch.Tensor, shift: torch.Tensor) -> torch.Tensor:
    if axis not in (0, -1):
        raise ValueError('QBitsTensor axis parameter must be 0 (first axis) or -1 (last axis)')
    if group_size is not None:
        base = group(base, axis=axis, group_size=group_size)
    if shift.dtype.is_floating_point:
        data = torch.round((base + shift) / scale)
    else:
        data = torch.round(base / scale) + shift
    return torch.clamp(data, min=0, max=2 ** bits - 1).to(torch.uint8)

# File: optimum-quanto-main/optimum/quanto/models/__init__.py
import importlib
import os
from collections.abc import Mapping
from typing import Any, Dict, List, Optional, Union

def is_transformers_available() -> bool:
    return importlib.util.find_spec('transformers') is not None

def is_diffusers_available() -> bool:
    return importlib.util.find_spec('diffusers') is not None
if is_transformers_available():
    from .transformers_models import *
if is_diffusers_available():
    from .diffusers_models import *

# File: optimum-quanto-main/optimum/quanto/models/diffusers_models.py
import json
import os
from pathlib import Path
from typing import Any, List, Optional, Union
from huggingface_hub import ModelHubMixin, snapshot_download
from ..quantize import Optimizer, freeze, qtype, quantization_map, quantize, requantize
from . import is_diffusers_available
__all__ = ['QuantizedDiffusersModel', 'QuantizedPixArtTransformer2DModel']
if not is_diffusers_available():
    raise ImportError(f'{__all__} require the diffusers library')
from diffusers import PixArtTransformer2DModel
from diffusers.models.model_loading_utils import load_state_dict
from diffusers.models.modeling_utils import ModelMixin
from diffusers.utils import CONFIG_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFETENSORS_WEIGHTS_NAME, _get_checkpoint_shard_files, is_accelerate_available
from .shared_dict import ShardedStateDict

class QuantizedDiffusersModel(ModelHubMixin):
    BASE_NAME = 'quanto'
    base_class = None

    def __init__(self, model: ModelMixin):
        if not isinstance(model, ModelMixin) or len(quantization_map(model)) == 0:
            raise ValueError('The source model must be a quantized diffusers model.')
        self._wrapped = model

    def __getattr__(self, name: str) -> Any:
        try:
            return super().__getattr__(name)
        except AttributeError:
            wrapped = self.__dict__['_wrapped']
            return getattr(wrapped, name)

    def forward(self, *args, **kwargs):
        return self._wrapped.forward(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        return self._wrapped.forward(*args, **kwargs)

    @staticmethod
    def _qmap_name():
        return f'{QuantizedDiffusersModel.BASE_NAME}_qmap.json'

    @classmethod
    def quantize(cls, model: ModelMixin, weights: Optional[Union[str, qtype]]=None, activations: Optional[Union[str, qtype]]=None, optimizer: Optional[Optimizer]=None, include: Optional[Union[str, List[str]]]=None, exclude: Optional[Union[str, List[str]]]=None):
        if not isinstance(model, ModelMixin):
            raise ValueError('The source model must be a diffusers model.')
        quantize(model, weights=weights, activations=activations, optimizer=optimizer, include=include, exclude=exclude)
        freeze(model)
        return cls(model)

    @classmethod
    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs):
        if cls.base_class is None:
            raise ValueError('The `base_class` attribute needs to be configured.')
        if not is_accelerate_available():
            raise ValueError('Reloading a quantized diffusers model requires the accelerate library.')
        from accelerate import init_empty_weights
        if os.path.isdir(pretrained_model_name_or_path):
            working_dir = pretrained_model_name_or_path
        else:
            working_dir = snapshot_download(pretrained_model_name_or_path, **kwargs)
        qmap_path = os.path.join(working_dir, cls._qmap_name())
        if not os.path.exists(qmap_path):
            raise ValueError(f'No quantization map found in {pretrained_model_name_or_path}: is this a quantized model ?')
        model_config_path = os.path.join(working_dir, CONFIG_NAME)
        if not os.path.exists(model_config_path):
            raise ValueError(f'{CONFIG_NAME} not found in {pretrained_model_name_or_path}.')
        with open(qmap_path, 'r', encoding='utf-8') as f:
            qmap = json.load(f)
        with open(model_config_path, 'r', encoding='utf-8') as f:
            original_model_cls_name = json.load(f)['_class_name']
        configured_cls_name = cls.base_class.__name__
        if configured_cls_name != original_model_cls_name:
            raise ValueError(f'Configured base class ({configured_cls_name}) differs from what was derived from the provided configuration ({original_model_cls_name}).')
        config = cls.base_class.load_config(pretrained_model_name_or_path, **kwargs)
        with init_empty_weights():
            model = cls.base_class.from_config(config)
        checkpoint_file = os.path.join(working_dir, SAFE_WEIGHTS_INDEX_NAME)
        if os.path.exists(checkpoint_file):
            (_, sharded_metadata) = _get_checkpoint_shard_files(working_dir, checkpoint_file)
            state_dict = ShardedStateDict(working_dir, sharded_metadata['weight_map'])
        else:
            checkpoint_file = os.path.join(working_dir, SAFETENSORS_WEIGHTS_NAME)
            if not os.path.exists(checkpoint_file):
                raise ValueError(f'No safetensor weights found in {pretrained_model_name_or_path}.')
            state_dict = load_state_dict(checkpoint_file)
        requantize(model, state_dict=state_dict, quantization_map=qmap)
        model.eval()
        return cls(model)

    def _save_pretrained(self, save_directory: Path) -> None:
        self._wrapped.save_pretrained(save_directory)
        qmap_name = os.path.join(save_directory, self._qmap_name())
        qmap = quantization_map(self._wrapped)
        with open(qmap_name, 'w', encoding='utf8') as f:
            json.dump(qmap, f, indent=4)

class QuantizedPixArtTransformer2DModel(QuantizedDiffusersModel):
    base_class = PixArtTransformer2DModel

# File: optimum-quanto-main/optimum/quanto/models/shared_dict.py
import os
from collections.abc import Mapping
from typing import Any, Dict
from safetensors import safe_open

class ShardedStateDict(Mapping):

    def __init__(self, base_dir: str, tensor_index: Dict[str, str]):
        self._base_dir = base_dir
        self._index = tensor_index
        self._handles = {}

    def __iter__(self):
        yield from self._index

    def __len__(self):
        return self._index.__len__()

    def __getitem__(self, key: Any) -> Any:
        filename = self._index.__getitem__(key)
        if filename not in self._handles:
            f = safe_open(os.path.join(self._base_dir, filename), framework='pytorch')
            self._handles[filename] = f
        f = self._handles[filename]
        return f.get_tensor(key)

    def __contains__(self, key: object) -> bool:
        return self._index.__contains__(key)

    def keys(self):
        return self._index.keys()

# File: optimum-quanto-main/optimum/quanto/models/transformers_models.py
import json
import os
from pathlib import Path
from typing import Any, List, Optional, Union
from huggingface_hub import ModelHubMixin, snapshot_download
from ..nn import QModuleMixin
from ..quantize import Optimizer, freeze, qtype, quantization_map, quantize, requantize
from . import is_transformers_available
from .shared_dict import ShardedStateDict
__all__ = ['QuantizedTransformersModel', 'QuantizedModelForCausalLM']
if not is_transformers_available():
    raise ImportError(f'{__all__} require the transformers library')
from transformers import AutoConfig, AutoModelForCausalLM, PreTrainedModel
from transformers.modeling_utils import get_checkpoint_shard_files, load_state_dict
from transformers.utils import SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, is_accelerate_available

class QuantizedTransformersModel(ModelHubMixin):
    BASE_NAME = 'quanto'
    auto_class = None

    def __init__(self, model: PreTrainedModel):
        if not isinstance(model, PreTrainedModel) or len(quantization_map(model)) == 0:
            raise ValueError('The source model must be a quantized transformers model.')
        self._wrapped = model

    def __getattr__(self, name: str) -> Any:
        try:
            return super().__getattr__(name)
        except AttributeError:
            wrapped = self.__dict__['_wrapped']
            return getattr(wrapped, name)

    def forward(self, *args, **kwargs):
        return self._wrapped.forward(*args, **kwargs)

    @staticmethod
    def _qmap_name():
        return f'{QuantizedTransformersModel.BASE_NAME}_qmap.json'

    @classmethod
    def quantize(cls, model: PreTrainedModel, weights: Optional[Union[str, qtype]]=None, activations: Optional[Union[str, qtype]]=None, optimizer: Optional[Optimizer]=None, include: Optional[Union[str, List[str]]]=None, exclude: Optional[Union[str, List[str]]]=None):
        if not isinstance(model, PreTrainedModel):
            raise ValueError('The source model must be a transformers model.')
        quantize(model, weights=weights, activations=activations, optimizer=optimizer, include=include, exclude=exclude)
        freeze(model)
        return cls(model)

    @classmethod
    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs):
        if cls.auto_class is None:
            raise ValueError('Quantized models cannot be reloaded using {cls}: use a specialized quantized class such as QuantizedModelForCausalLM instead.')
        if not is_accelerate_available():
            raise ValueError('Reloading a quantized transformers model requires the accelerate library.')
        from accelerate import init_empty_weights
        if os.path.isdir(pretrained_model_name_or_path):
            working_dir = pretrained_model_name_or_path
        else:
            working_dir = snapshot_download(pretrained_model_name_or_path, **kwargs)
        qmap_path = os.path.join(working_dir, cls._qmap_name())
        if not os.path.exists(qmap_path):
            raise ValueError(f'No quantization map found in {pretrained_model_name_or_path}: is this a quantized model ?')
        with open(qmap_path, 'r', encoding='utf-8') as f:
            qmap = json.load(f)
        config = AutoConfig.from_pretrained(pretrained_model_name_or_path, **kwargs)
        with init_empty_weights():
            model = cls.auto_class.from_config(config)
        checkpoint_file = os.path.join(working_dir, SAFE_WEIGHTS_INDEX_NAME)
        if os.path.exists(checkpoint_file):
            (checkpoint_file, sharded_metadata) = get_checkpoint_shard_files(working_dir, checkpoint_file)
            state_dict = ShardedStateDict(working_dir, sharded_metadata['weight_map'])
        else:
            checkpoint_file = os.path.join(working_dir, SAFE_WEIGHTS_NAME)
            if not os.path.exists(checkpoint_file):
                raise ValueError(f'No safetensor weights found in {pretrained_model_name_or_path}.')
            state_dict = load_state_dict(checkpoint_file)
        requantize(model, state_dict=state_dict, quantization_map=qmap)
        if getattr(model.config, 'tie_word_embeddings', True):
            model.tie_weights()
        model.eval()
        return cls(model)

    def _save_pretrained(self, save_directory: Path) -> None:
        model = self._wrapped
        if getattr(model.config, 'tie_word_embeddings', True):
            if isinstance(model.get_input_embeddings(), QModuleMixin) or isinstance(model.get_output_embeddings(), QModuleMixin):
                model.config.tie_word_embeddings = False
        self._wrapped.save_pretrained(save_directory, safe_serialization=True)
        qmap_name = os.path.join(save_directory, self._qmap_name())
        qmap = quantization_map(self._wrapped)
        with open(qmap_name, 'w', encoding='utf8') as f:
            json.dump(qmap, f, indent=4)

class QuantizedModelForCausalLM(QuantizedTransformersModel):
    auto_class = AutoModelForCausalLM

# File: optimum-quanto-main/optimum/quanto/nn/qconv2d.py
from typing import Optional
import torch
from ..tensor import Optimizer, qtype
from .qmodule import QModuleMixin, register_qmodule
__all__ = ['QConv2d']

@register_qmodule(torch.nn.Conv2d)
class QConv2d(QModuleMixin, torch.nn.Conv2d):

    @classmethod
    def qcreate(cls, module, weights: qtype, activations: Optional[qtype]=None, optimizer: Optional[Optimizer]=None, device: Optional[torch.device]=None):
        return cls(in_channels=module.in_channels, out_channels=module.out_channels, kernel_size=module.kernel_size, stride=module.stride, padding=module.padding, dilation=module.dilation, groups=module.groups, bias=module.bias is not None, padding_mode=module.padding_mode, dtype=module.weight.dtype, device=device, weights=weights, activations=activations, optimizer=optimizer)

    def forward(self, input: torch.Tensor) -> torch.Tensor:
        return self._conv_forward(input, self.qweight, self.bias)

# File: optimum-quanto-main/optimum/quanto/nn/qlayernorm.py
from typing import Optional
import torch
from ..tensor import Optimizer, qtype
from .qmodule import QModuleMixin, register_qmodule
__all__ = ['QLayerNorm']

@register_qmodule(torch.nn.LayerNorm)
class QLayerNorm(QModuleMixin, torch.nn.LayerNorm):

    @classmethod
    def qcreate(cls, module, weights: Optional[qtype]=None, activations: Optional[qtype]=None, optimizer: Optional[Optimizer]=None, device: Optional[torch.device]=None):
        if activations is None:
            return None
        return cls(module.normalized_shape, module.eps, module.elementwise_affine, module.bias is not None, dtype=module.weight.dtype, device=device, weights=None, activations=activations, optimizer=None)

    def forward(self, input: torch.Tensor) -> torch.Tensor:
        return torch.nn.functional.layer_norm(input, self.normalized_shape, self.weight, self.bias, self.eps)

# File: optimum-quanto-main/optimum/quanto/nn/qlinear.py
from typing import Optional
import torch
from ..tensor import Optimizer, qtype
from .qmodule import QModuleMixin, register_qmodule
__all__ = ['QLinear']

@register_qmodule(torch.nn.Linear)
class QLinear(QModuleMixin, torch.nn.Linear):

    @classmethod
    def qcreate(cls, module, weights: qtype, activations: Optional[qtype]=None, optimizer: Optional[Optimizer]=None, device: Optional[torch.device]=None):
        return cls(module.in_features, module.out_features, module.bias is not None, dtype=module.weight.dtype, device=device, weights=weights, activations=activations, optimizer=optimizer, quantize_input=True)

    def forward(self, input: torch.Tensor) -> torch.Tensor:
        return torch.nn.functional.linear(input, self.qweight, bias=self.bias)

# File: optimum-quanto-main/optimum/quanto/nn/qmodule.py
from abc import ABC
from typing import Optional, Union
import torch
from ..tensor import ActivationQBytesTensor, Optimizer, QBitsTensor, QTensor, WeightQBytesTensor, qint2, qint4, qtype, qtypes, quantize_activation, quantize_weight
__all__ = ['QModuleMixin', 'register_qmodule', 'quantize_module']
_QMODULE_TABLE = {}

def register_qmodule(module_cls):

    def wrapper(cls):
        _QMODULE_TABLE[module_cls] = cls
        return cls
    return wrapper

def quantize_module(module, weights: Optional[Union[qtype, str]]=None, activations: Optional[Union[qtype, str]]=None, optimizer: Optional[Optimizer]=None):
    for cls in _QMODULE_TABLE:
        if isinstance(module, cls):
            qcls = _QMODULE_TABLE[cls]
            return qcls.from_module(module, weights=weights, activations=activations, optimizer=optimizer)
    return None

class QModuleMixin(ABC):

    def __init__(self, *args, weights: Optional[Union[qtype, str]]=None, activations: Optional[Union[qtype, str]]=None, optimizer: Optional[Optimizer]=None, quantize_input: Optional[bool]=False, device: Optional[torch.device]=None, **kwargs):
        mro = self.__class__.__mro__
        if torch.nn.Module not in mro:
            raise TypeError('Quantized modules must inherit from a torch.nn.Module class')
        if mro.index(__class__) > mro.index(torch.nn.Module):
            raise TypeError('QModuleMixin must be placed before any torch.nn.Module class in quantized module inheritance.')
        super().__init__(*args, device=device, **kwargs)
        if weights is not None and (not isinstance(weights, qtype)):
            weights = qtypes[weights]
        if activations is not None and (not isinstance(activations, qtype)):
            activations = qtypes[activations]
        self.weight_qtype = weights
        self.weight_group_size = None
        if self.weight_qtype in (qint2, qint4):
            out_features = self.weight.shape[0]
            in_features = self.weight.numel() // out_features
            group_size = 128
            if in_features > group_size:
                while in_features % group_size != 0 and group_size > 32:
                    group_size -= 32
                if in_features % group_size == 0:
                    self.weight_group_size = group_size
        self.activation_qtype = activations
        self._quantize_hooks = {}
        if activations is not None:
            if quantize_input:
                self._quantize_hooks['input'] = self.register_forward_pre_hook(self.quantize_input)
            self._quantize_hooks['output'] = self.register_forward_hook(self.quantize_output)
        self.optimizer = optimizer
        self.register_buffer('input_scale', torch.ones((), dtype=self.weight.dtype, device=device))
        self.register_buffer('output_scale', torch.ones((), dtype=self.weight.dtype, device=device))

    def disable_output_quantization(self):
        if 'output' in self._quantize_hooks:
            self._quantize_hooks['output'].remove()

    def _save_to_state_dict(self, destination, prefix, keep_vars):
        if self.weight_qtype is None or not self.frozen:
            destination[prefix + 'weight'] = self.weight if keep_vars else self.weight.detach()
        else:
            self.weight.save_to_state_dict(destination, prefix + 'weight.', keep_vars)
        if self.bias is not None:
            destination[prefix + 'bias'] = self.bias if keep_vars else self.bias.detach()
        destination[prefix + 'input_scale'] = self.input_scale if keep_vars else self.input_scale.detach()
        destination[prefix + 'output_scale'] = self.output_scale if keep_vars else self.output_scale.detach()

    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
        weight_name = prefix + 'weight'
        if self.weight_qtype is not None and weight_name not in state_dict:
            weight_prefix = weight_name + '.'
            if self.weight_qtype.bits == 8:
                deserialized_weight = WeightQBytesTensor.load_from_state_dict(state_dict, weight_prefix, qtype=self.weight_qtype, axis=0, size=self.weight.size(), stride=self.weight.stride(), activation_qtype=self.activation_qtype, missing_keys=missing_keys)
            else:
                deserialized_weight = QBitsTensor.load_from_state_dict(state_dict, weight_prefix, qtype=self.weight_qtype, axis=0, group_size=self.weight_group_size, size=self.weight.size(), stride=self.weight.stride(), missing_keys=missing_keys)
            if deserialized_weight is not None:
                deserialized_weight = deserialized_weight.optimize()
            assign_to_params_buffers = local_metadata.get('assign_to_params_buffers', False)
            if assign_to_params_buffers and deserialized_weight is not None:
                self.weight = torch.nn.Parameter(deserialized_weight)
            elif deserialized_weight is not None:
                if type(self.weight.data) is not type(deserialized_weight):
                    self.weight = torch.nn.Parameter(deserialized_weight.to(self.weight.device))
                else:
                    self.weight = torch.nn.Parameter(deserialized_weight.to(self.weight.device))
        super()._load_from_state_dict(state_dict, prefix, local_metadata, False, missing_keys, unexpected_keys, error_msgs)

    @classmethod
    def from_module(cls, module: torch.nn.Module, weights: Optional[qtype]=None, activations: Optional[qtype]=None, optimizer: Optional[Optimizer]=None):
        qmodule = cls.qcreate(module, weights, activations, optimizer, device='meta')
        if qmodule is None:
            return None
        qmodule = qmodule.to_empty(device=module.weight.device)
        qmodule.input_scale = torch.ones_like(qmodule.input_scale)
        qmodule.output_scale = torch.ones_like(qmodule.output_scale)
        with torch.no_grad():
            qmodule.weight = module.weight
            if module.bias is not None:
                qmodule.bias = module.bias
        return qmodule.to(module.weight.device)

    @classmethod
    def qcreate(cls, module: torch.nn.Module, weights: Optional[qtype], activations: Optional[qtype]=None, optimizer: Optional[Optimizer]=None, device: Optional[torch.device]=None):
        raise NotImplementedError

    @property
    def qweight(self):
        if self.weight_qtype is None:
            return None
        if isinstance(self.weight, QTensor):
            return self.weight
        return quantize_weight(self.weight, qtype=self.weight_qtype, axis=0, group_size=self.weight_group_size, optimizer=self.optimizer, activation_qtype=self.activation_qtype)

    def qforward(self, input: torch.Tensor) -> torch.Tensor:
        raise NotImplementedError

    def quantize_input(self, module: torch.nn.Module, input: torch.Tensor) -> torch.Tensor:
        input = input[0]
        if isinstance(input, ActivationQBytesTensor):
            if input.qtype != self.activation_qtype:
                raise ValueError(f'Models with heterogeneous quantized activations are not supported: expected {self.activation_qtype.name} input but got {input.qtype.name} instead.')
        else:
            input = quantize_activation(input, qtype=self.activation_qtype, scale=self.input_scale)
        return input

    def quantize_output(self, module: torch.nn.Module, input: torch.Tensor, output: torch.Tensor) -> torch.Tensor:
        return quantize_activation(output, qtype=self.activation_qtype, scale=self.output_scale)

    def freeze(self):
        qweight = self.qweight
        if qweight is not None:
            self.weight = torch.nn.Parameter(qweight)

    @property
    def frozen(self):
        return isinstance(self.weight, QTensor)

# File: optimum-quanto-main/optimum/quanto/quantize.py
from fnmatch import fnmatch
from typing import Any, Dict, List, Optional, Union
import torch
from .nn import QModuleMixin, quantize_module
from .tensor import Optimizer, qtype
__all__ = ['quantize', 'freeze', 'requantize', 'quantization_map']

def set_module_by_name(parent_module, name, child_module):
    module_names = name.split('.')
    if len(module_names) == 1:
        setattr(parent_module, name, child_module)
    else:
        parent_module_name = name[:name.rindex('.')]
        parent_module = parent_module.get_submodule(parent_module_name)
        setattr(parent_module, module_names[-1], child_module)

def _quantize_submodule(model: torch.nn.Module, name: str, module: torch.nn.Module, weights: Optional[Union[str, qtype]]=None, activations: Optional[Union[str, qtype]]=None, optimizer: Optional[Optimizer]=None):
    qmodule = quantize_module(module, weights=weights, activations=activations, optimizer=optimizer)
    if qmodule is not None:
        set_module_by_name(model, name, qmodule)
        qmodule.name = name
        for (name, param) in module.named_parameters():
            setattr(module, name, None)
            del param

def quantize(model: torch.nn.Module, weights: Optional[Union[str, qtype]]=None, activations: Optional[Union[str, qtype]]=None, optimizer: Optional[Optimizer]=None, include: Optional[Union[str, List[str]]]=None, exclude: Optional[Union[str, List[str]]]=None):
    if include is not None:
        include = [include] if isinstance(include, str) else include
    if exclude is not None:
        exclude = [exclude] if isinstance(exclude, str) else exclude
    for (name, m) in model.named_modules():
        if include is not None and (not any((fnmatch(name, pattern) for pattern in include))):
            continue
        if exclude is not None and any((fnmatch(name, pattern) for pattern in exclude)):
            continue
        _quantize_submodule(model, name, m, weights=weights, activations=activations, optimizer=optimizer)

def requantize(model: torch.nn.Module, state_dict: Dict[str, Any], quantization_map: Dict[str, Dict[str, str]], device: torch.device=None):
    if device is None:
        device = next(model.parameters()).device
        if device.type == 'meta':
            device = torch.device('cpu')
    for (name, m) in model.named_modules():
        qconfig = quantization_map.get(name, None)
        if qconfig is not None:
            weights = qconfig['weights']
            if weights == 'none':
                weights = None
            activations = qconfig['activations']
            if activations == 'none':
                activations = None
            _quantize_submodule(model, name, m, weights=weights, activations=activations)
    for (name, m) in model.named_modules():

        def move_tensor(t, device):
            if t.device.type == 'meta':
                return torch.empty_like(t, device=device)
            return t.to(device)
        for (name, param) in m.named_parameters(recurse=False):
            setattr(m, name, torch.nn.Parameter(move_tensor(param, 'cpu')))
        for (name, param) in m.named_buffers(recurse=False):
            setattr(m, name, move_tensor(param, 'cpu'))
    model.to(device)
    model.load_state_dict(state_dict, strict=False)

def freeze(model):
    for (name, m) in model.named_modules():
        if isinstance(m, QModuleMixin):
            m.freeze()

def quantization_map(model: torch.nn.Module) -> Dict[str, Dict[str, str]]:
    config = {}
    for (name, m) in model.named_modules():
        if isinstance(m, QModuleMixin):
            config[name] = {'weights': m.weight_qtype.name, 'activations': 'none' if m.activation_qtype is None else m.activation_qtype.name}
    return config

# File: optimum-quanto-main/optimum/quanto/subpackage/commands/base.py
from optimum.commands import BaseOptimumCLICommand, CommandInfo
from optimum.commands.optimum_cli import optimum_cli_subcommand
from .quantize import QuantizeCommand
__all__ = ['QuantoCommand']

@optimum_cli_subcommand()
class QuantoCommand(BaseOptimumCLICommand):
    COMMAND = CommandInfo(name='quanto', help='Hugging Face models quantization tools')
    SUBCOMMANDS = (CommandInfo(name='quantize', help='Quantize Hugging Face models.', subcommand_class=QuantizeCommand),)

# File: optimum-quanto-main/optimum/quanto/subpackage/commands/quantize.py
""""""
from typing import TYPE_CHECKING
import torch
from optimum.commands import BaseOptimumCLICommand
from optimum.exporters import TasksManager
from ...models import QuantizedTransformersModel
if TYPE_CHECKING:
    from argparse import ArgumentParser
SUPPORTED_LIBRARIES = ['transformers']

def parse_quantize_args(parser: 'ArgumentParser'):
    required_group = parser.add_argument_group('Required arguments')
    required_group.add_argument('output', type=str, help='The path to save the quantized model.')
    required_group.add_argument('-m', '--model', type=str, required=True, help='Hugging Face Hub model id or path to a local model.')
    required_group.add_argument('--weights', type=str, default='int8', choices=['int2', 'int4', 'int8', 'float8'], help='The Hugging Face library to use to load the model.')
    optional_group = parser.add_argument_group('Optional arguments')
    optional_group.add_argument('--revision', type=str, default=None, help='The Hugging Face model revision.')
    optional_group.add_argument('--trust_remote_code', action='store_true', default=False, help='Trust remote code when loading the model.')
    optional_group.add_argument('--library', type=str, default=None, choices=SUPPORTED_LIBRARIES, help='The Hugging Face library to use to load the model.')
    optional_group.add_argument('--task', type=str, default=None, help='The model task (useful for models supporting multiple tasks).')
    optional_group.add_argument('--torch_dtype', type=str, default='auto', choices=['auto', 'fp16', 'bf16'], help='The torch dtype to use when loading the model weights.')
    optional_group.add_argument('--device', type=str, default='cpu', help='The device to use when loading the model.')

class QuantizeCommand(BaseOptimumCLICommand):

    @staticmethod
    def parse_args(parser: 'ArgumentParser'):
        return parse_quantize_args(parser)

    def run(self):
        model_name_or_path = self.args.model
        library_name = self.args.library
        if library_name is None:
            library_name = TasksManager.infer_library_from_model(model_name_or_path)
        if library_name not in SUPPORTED_LIBRARIES:
            raise ValueError(f'{library_name} models are not supported by this CLI, but can be quantized using the python API directly.')
        task = self.args.task
        if task is None:
            task = TasksManager.infer_task_from_model(model_name_or_path)
        torch_dtype = self.args.torch_dtype
        if torch_dtype != 'auto':
            torch_dtype = torch.float16 if self.args.torch_dtype == 'fp16' else torch.bfloat16
        model = TasksManager.get_model_from_task(task, model_name_or_path, revision=self.args.revision, trust_remote_code=self.args.trust_remote_code, framework='pt', torch_dtype=torch_dtype, device=torch.device(self.args.device), library_name=library_name, low_cpu_mem_usage=True)
        weights = f'q{self.args.weights}'
        qmodel = QuantizedTransformersModel.quantize(model, weights=weights)
        qmodel.save_pretrained(self.args.output)

# File: optimum-quanto-main/optimum/quanto/tensor/activations/qbytes.py
import ast
import torch
from torch.autograd import Function
from ..qbytes import QBytesTensor
from ..qtensor import qfallback
from ..qtype import qtype, qtypes
__all__ = ['ActivationQBytesTensor']

class ActivationQBytesQuantizer(Function):

    @staticmethod
    def forward(ctx, base: torch.Tensor, qtype: qtype, scale: torch.Tensor) -> torch.Tensor:
        if qtype.bits != 8:
            raise ValueError('QBytesTensor can only be of 8-bit qtype')
        size = base.size()
        stride = base.stride()
        data = torch.ops.quanto.quantize_symmetric(base, dtype=qtype.dtype, axis=None, scale=scale)
        return ActivationQBytesTensor(qtype, size, stride, data, scale)

    @staticmethod
    def backward(ctx, gO):
        return (gO, None, None, None, None, None)

class ActivationQBytesTensor(QBytesTensor):

    @staticmethod
    def __new__(cls, qtype, size, stride, data, scale, requires_grad=False):
        assert data.device == scale.device
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=scale.dtype, device=data.device, requires_grad=requires_grad)

    def __init__(self, qtype, size, stride, data, scale, requires_grad=False):
        super().__init__(qtype, None, size, stride, data, scale, requires_grad)

    @classmethod
    def quantize(cls, base: torch.Tensor, qtype: qtype, scale: torch.Tensor) -> torch.Tensor:
        return ActivationQBytesQuantizer.apply(base, qtype, scale)

    def __tensor_flatten__(self):
        inner_tensors = ['_data', '_scale']
        meta = {'qtype': self._qtype.name, 'size': str(list(self.size())), 'stride': str(list(self.stride()))}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 2
        assert len(meta) == 3
        (data, scale) = (inner_tensors['_data'], inner_tensors['_scale'])
        qtype = qtypes[meta['qtype']]
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return ActivationQBytesTensor(qtype, size, stride, data, scale)

    @classmethod
    def __torch_dispatch__(cls, op, types, args, kwargs=None):
        from .qbytes_ops import get_qbytestensor_op_dispatch
        kwargs = kwargs or {}
        op = op.overloadpacket
        qdispatch = get_qbytestensor_op_dispatch(op)
        if qdispatch is not None:
            return qdispatch(*args, **kwargs)
        return qfallback(op, *args, **kwargs)

# File: optimum-quanto-main/optimum/quanto/tensor/activations/qbytes_ops.py
import numbers
from functools import partial
from typing import Callable, List
import torch
from ..core import dtype_info
from ..qtensor import QTensor, qfallback
from ..qtype import qint8
from .qbytes import ActivationQBytesTensor
from .quantization import quantize_activation
__all__ = ['get_qbytestensor_op_dispatch', 'register_qbytestensor_op']
_QBYTESTENSOR_OP_TABLE = {}

def register_qbytestensor_op(aten_ops: List[Callable]):

    def wrapper(op):
        for aten_op in aten_ops:
            _QBYTESTENSOR_OP_TABLE[aten_op] = partial(op, aten_op)
    return wrapper

def get_qbytestensor_op_dispatch(aten_op):
    return _QBYTESTENSOR_OP_TABLE.get(aten_op, None)

def is_scalar(t):
    return isinstance(t, numbers.Number) or (type(t) is torch.Tensor and len(t.shape) == 0)

@register_qbytestensor_op([torch.ops.aten._to_copy, torch.ops.aten.to])
def _to_copy(op, t, dtype=None, **kwargs):
    out_data = op(t._data, dtype=t._data.dtype, **kwargs)
    out_scale = op(t._scale, dtype=dtype, **kwargs)
    return ActivationQBytesTensor(t.qtype, t.size(), t.stride(), out_data, out_scale)

@register_qbytestensor_op([torch.ops.aten.detach])
def detach(op, t):
    out_data = op(t._data)
    out_scale = op(t._scale)
    return ActivationQBytesTensor(t.qtype, t.size(), t.stride(), out_data, out_scale)

@register_qbytestensor_op([torch.ops.aten.cat])
def cat(op, inputs, dim=0):
    if len(inputs) == 2:
        (t1, t2) = inputs
        if isinstance(t1, ActivationQBytesTensor) and isinstance(t2, ActivationQBytesTensor) and torch.equal(t1._scale, t2._scale) and (t1.qtype == t2.qtype):
            if t1.qtype.is_floating_point or t2.qtype.is_floating_point:
                return qfallback(op, inputs, dim)
            out_data = op([t1._data, t2._data], dim)
            return ActivationQBytesTensor(t1.qtype, out_data.size(), out_data.stride(), out_data, t1._scale)
    return qfallback(op, inputs, dim)

@register_qbytestensor_op([torch.ops.aten.lt])
def lt(op, input, other):
    if isinstance(input, ActivationQBytesTensor) and isinstance(other, ActivationQBytesTensor) and torch.equal(input._scale, other._scale):
        return op(input._data, other._data)
    return qfallback(op, input, other)

@register_qbytestensor_op([torch.ops.aten.clone])
def clone(op, t, memory_format=torch.preserve_format):
    data_shape = t._data.shape
    out_data = t._data.reshape(t.shape)
    out_data = op(t._data, memory_format=memory_format)
    out_stride = out_data.stride()
    out_data = out_data.reshape(data_shape)
    out_scale = op(t._scale, memory_format=memory_format)
    return ActivationQBytesTensor(t.qtype, t.size(), out_stride, out_data, out_scale)

@register_qbytestensor_op([torch.ops.aten.copy_])
def copy_(op, dest, src):
    assert dest.qtype == src.qtype
    dest._data = op(dest._data, src._data)
    dest._scale = op(dest._scale, src._scale)
    return dest

@register_qbytestensor_op([torch.ops.aten.div])
def div(op, input, other):
    if not is_scalar(other):
        return op(input.dequantize(), other)
    return ActivationQBytesTensor(input.qtype, input.size(), input.stride(), input._data, op(input._scale, other))

@register_qbytestensor_op([torch.ops.aten.neg])
def neg(op, input, *args, **kwargs):
    if input.qtype.is_floating_point:
        return op(input.dequantize(), *args, **kwargs)
    out_data = op(input._data, *args, **kwargs)
    return ActivationQBytesTensor(input.qtype, input.size(), input.stride(), out_data, input._scale)

@register_qbytestensor_op([torch.ops.aten.expand, torch.ops.aten.permute, torch.ops.aten.select, torch.ops.aten.slice, torch.ops.aten.unsqueeze])
def unary_type_agnostic_op(op, input, *args, **kwargs):
    if input.axis is not None:
        return op(input.dequantize(), *args, **kwargs)
    out_data = op(input._data, *args, **kwargs)
    return ActivationQBytesTensor(input.qtype, out_data.size(), out_data.stride(), out_data, input._scale)

@register_qbytestensor_op([torch.ops.aten.is_same_size])
def is_same_size(op, input, other):
    a = input._data if isinstance(input, ActivationQBytesTensor) else input
    b = other._data if isinstance(other, ActivationQBytesTensor) else other
    return op(a, b)

def cannot_mm(t: QTensor):
    return t.axis is not None and t.size() != t._data.size()

@register_qbytestensor_op([torch.ops.aten.bmm])
def bmm(op, input, other):
    if not isinstance(input, ActivationQBytesTensor):
        return op(input, other.dequantize())
    if not isinstance(other, QTensor) or input.axis is not None:
        return op(input.dequantize(), other)
    if input.qtype != qint8 or other.qtype != qint8 or cannot_mm(other):
        return qfallback(op, input, other)
    out_data = op(input._data.to(torch.float32), other._data.to(torch.float32))
    out_scale = (input._scale * other._scale).to(torch.float32)
    return (out_data * out_scale).to(input._scale.dtype)

@register_qbytestensor_op([torch.ops.aten.mul])
def mul(op, input, other):
    if is_scalar(input):
        return ActivationQBytesTensor(other.qtype, other.size(), other.stride(), other._data, input * other._scale)
    if is_scalar(other):
        return ActivationQBytesTensor(input.qtype, input.size(), input.stride(), input._data, other * input._scale)
    return qfallback(op, input, other)

@register_qbytestensor_op([torch.ops.aten.relu])
def relu(op, input):
    if input.qtype.is_floating_point:
        return qfallback(op, input)
    out_data = op(input._data)
    return ActivationQBytesTensor(input.qtype, input.size(), input.stride(), out_data, input._scale)

@register_qbytestensor_op([torch.ops.aten._softmax])
def _softmax(op, input, dim, half_to_float):
    float_data = op(input.dequantize(), dim, half_to_float)
    out_scale = torch.tensor(1 / dtype_info(input.qtype.dtype).max, dtype=input._scale.dtype).to(input.device)
    return quantize_activation(float_data, qtype=input.qtype, scale=out_scale)

@register_qbytestensor_op([torch.ops.aten.stack])
def stack(op, inputs, dim=0):
    if len(inputs) == 2:
        (t1, t2) = inputs
        if isinstance(t1, ActivationQBytesTensor) and isinstance(t2, ActivationQBytesTensor) and (t1.axis is None) and (t2.axis is None) and torch.equal(t1._scale, t2._scale) and (t1.qtype == t2.qtype):
            out_data = op([t1._data, t2._data], dim)
            return ActivationQBytesTensor(t1.qtype, out_data.size(), out_data.stride(), out_data, t1._scale)
    return qfallback(inputs, dim)

@register_qbytestensor_op([torch.ops.aten.split])
def split(op, input, *args, **kwargs):
    if input.axis is not None:
        return qfallback(op, input, *args, **kwargs)
    out_datas = op(input._data, *args, **kwargs)
    return [ActivationQBytesTensor(input.qtype, input.size(), input.stride(), out_data, input._scale) for out_data in out_datas]

@register_qbytestensor_op([torch.ops.aten.transpose])
def transpose(op, input, *args):
    out_data = op(input._data, *args)
    out_size = out_data.size()
    out_stride = out_data.stride()
    out_scale = input._scale
    return ActivationQBytesTensor(input.qtype, out_size, out_stride, out_data, out_scale)

@register_qbytestensor_op([torch.ops.aten.t])
def transpose2d(op, input):
    out_data = op(input._data)
    out_scale = input._scale
    (dim0, dim1) = input.size()
    out_size = torch.Size([dim1, dim0])
    out_stride = input.stride()[::-1]
    return ActivationQBytesTensor(input.qtype, out_size, out_stride, out_data, out_scale)

@register_qbytestensor_op([torch.ops.aten.view, torch.ops.aten._unsafe_view])
def view(op, input, *shape):
    if input.axis is None:
        out_data = op(input._data, *shape)
        return ActivationQBytesTensor(input.qtype, out_data.size(), out_data.stride(), out_data, input._scale)
    return qfallback(op, input, *shape)

@register_qbytestensor_op([torch.ops.aten.where])
def where(op, condition, input, other):
    if isinstance(condition, QTensor) or isinstance(other, QTensor):
        raise NotImplementedError
    float_data = op(condition, input.dequantize(), other)
    if input.axis is None:
        return quantize_activation(float_data, qtype=input.qtype, scale=input._scale)
    return float_data

# File: optimum-quanto-main/optimum/quanto/tensor/activations/quantization.py
import torch
from ..qtype import qtype
from .qbytes import ActivationQBytesTensor
__all__ = ['quantize_activation']

def quantize_activation(t: torch.Tensor, qtype: qtype, scale: torch.Tensor):
    if scale.numel() != 1:
        raise ValueError('Parameter scale must be a scalar because activations can only be quantized per-tensor')
    return ActivationQBytesTensor.quantize(t, qtype, scale)

# File: optimum-quanto-main/optimum/quanto/tensor/core.py
import torch
__all__ = ['axis_to_dim', 'dtype_info']

def dtype_info(dtype):
    info = torch.finfo if dtype.is_floating_point else torch.iinfo
    return info(dtype)

def axis_to_dim(t, axis):
    dim = list(range(t.ndim))
    if axis == -1:
        dim = dim[:-1]
    else:
        dim.remove(axis)
    return dim

# File: optimum-quanto-main/optimum/quanto/tensor/function.py
import torch
__all__ = ['QuantizedLinearFunction']

class QuantizedLinearFunction(torch.autograd.Function):

    @staticmethod
    def forward(ctx, input, other, bias=None):
        ctx.save_for_backward(input, other)
        output = torch.matmul(input, other.t())
        if bias is not None:
            output = output + bias
        return output

    def backward(ctx, gO):
        input_gO = other_gO = bias_gO = None
        (input, other) = ctx.saved_tensors
        (out_features, in_features) = other.shape
        if ctx.needs_input_grad[0]:
            input_gO = torch.matmul(gO, other)
        if ctx.needs_input_grad[1]:
            other_gO = torch.matmul(gO.view(-1, out_features).t(), input.view(-1, in_features))
        if ctx.needs_input_grad[2]:
            dim = tuple(range(gO.ndim - 1))
            bias_gO = gO.sum(dim)
        return (input_gO, other_gO, bias_gO)

# File: optimum-quanto-main/optimum/quanto/tensor/optimizers/absmax_optimizer.py
from typing import Optional, Tuple, Union
import torch
from .symmetric_optimizer import SymmetricOptimizer
__all__ = ['AbsmaxOptimizer']

class AbsmaxOptimizer(SymmetricOptimizer):

    def optimize(self, base: torch.Tensor, qmax: float, axis: Optional[int]=None) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
        base = torch.abs(base)
        if axis is None:
            rmax = torch.max(base)
        else:
            dim = list(range(1, base.ndim)) if axis == 0 else list(range(0, base.ndim - 1))
            rmax = torch.amax(torch.abs(base), dim=dim, keepdim=True)
        return rmax / qmax

# File: optimum-quanto-main/optimum/quanto/tensor/optimizers/affine_optimizer.py
from typing import Optional, Tuple
import torch
from ..qbits import group
from .optimizer import Optimizer
__all__ = ['AffineOptimizer']

class AffineOptimizer(Optimizer):

    def __call__(self, base: torch.Tensor, bits: int, axis: int, group_size: Optional[int]=None) -> Tuple[torch.Tensor, torch.Tensor]:
        if axis not in [0, -1]:
            raise ValueError('axis parameter must be 0 (first axis) or -1 (last axis)')
        if group_size is not None:
            base = group(base, axis, group_size)
        (scale, shift) = self.optimize(base, bits, axis)
        assert scale.dtype == base.dtype
        assert shift.dtype == base.dtype
        return (scale, shift)

    def optimize(self, base: torch.Tensor, bits: int, axis: int) -> Tuple[torch.Tensor, torch.Tensor]:
        raise NotImplementedError

# File: optimum-quanto-main/optimum/quanto/tensor/optimizers/hqq_optimizer.py
from typing import Optional, Tuple, Union
import torch
from ..qbits import QBitsTensor
from ..qtype import qint2, qint4
from .max_optimizer import MaxOptimizer
__all__ = ['HqqOptimizer']

def shrink_lp_op(x: torch.Tensor, beta: float, lp_norm: float) -> torch.Tensor:
    if lp_norm == 1:
        return torch.sign(x) * torch.nn.functional.relu(torch.abs(x) - 1.0 / beta)
    else:
        return torch.sign(x) * torch.nn.functional.relu(torch.abs(x) - 1.0 / beta * torch.pow(torch.abs(x), lp_norm - 1))

class HqqOptimizer(MaxOptimizer):

    def __init__(self, lp_norm: Optional[float]=0.7, beta: Optional[int]=10.0, kappa: Optional[float]=1.01, iters: Optional[int]=20, verbose: Optional[bool]=False) -> None:
        self.lp_norm = lp_norm
        self.beta = beta
        self.kappa = kappa
        self.iters = iters
        self.verbose = verbose

    def optimize(self, base: torch.Tensor, bits: int, axis: int) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
        (scale, shift) = super().optimize(base, bits, axis)
        best_error = None
        beta = self.beta
        qtype = qint2 if bits == 2 else qint4
        base_q = QBitsTensor.quantize(base, qtype, axis, None, scale, shift)
        for i in range(self.iters):
            error = base - base_q
            if best_error is None:
                best_error = float(torch.abs(base - base_q).mean())
                if self.verbose:
                    print(f'Start error: {best_error:.6f}')
            e = shrink_lp_op(error, beta, self.lp_norm)
            mean_axis = 0 if axis == -1 else -1
            hqq_shift = torch.mean(base_q._data * scale - (base - e), axis=mean_axis, keepdim=True)
            base_q = QBitsTensor.quantize(base, qtype, axis, None, scale, hqq_shift)
            mean_error = float(torch.abs(base - base_q).mean())
            if self.verbose:
                print(f'HQQ error at it #{i}: {mean_error:.6f}')
            if mean_error < best_error:
                best_error = mean_error
                shift = hqq_shift
                beta *= self.kappa
            else:
                break
        return (scale, shift)

# File: optimum-quanto-main/optimum/quanto/tensor/optimizers/max_optimizer.py
from typing import Tuple, Union
import torch
from .affine_optimizer import AffineOptimizer
__all__ = ['MaxOptimizer']

class MaxOptimizer(AffineOptimizer):

    def optimize(self, base: torch.Tensor, bits: int, axis: int) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
        dim = list(range(1, base.ndim)) if axis == 0 else list(range(0, base.ndim - 1))
        rmin = torch.amin(base, dim=dim, keepdim=True)
        rmax = torch.amax(base, dim=dim, keepdim=True)
        qmin = -2 ** (bits - 1)
        qmax = 2 ** (bits - 1) - 1
        scale = (rmax - rmin) / (qmax - qmin)
        shift = -rmin
        return (scale, shift)

# File: optimum-quanto-main/optimum/quanto/tensor/optimizers/symmetric_optimizer.py
from typing import Optional
import torch
from .optimizer import Optimizer
__all__ = ['SymmetricOptimizer']

class SymmetricOptimizer(Optimizer):

    def __call__(self, base: torch.Tensor, qmax: float, axis: Optional[int]=None) -> torch.Tensor:
        if axis not in [None, 0, -1]:
            raise ValueError('axis parameter must be None, 0 (first axis) or -1 (last axis)')
        if qmax <= 0.0:
            raise ValueError('qmax must be set to the maximum positive value that can be represented by the quantized type.')
        scale = self.optimize(base, qmax, axis)
        assert scale.dtype == base.dtype
        return scale

    def optimize(self, base: torch.Tensor, qmax: float, axis: Optional[int]=None) -> torch.Tensor:
        raise NotImplementedError

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/awq/packed.py
import ast
from copy import copy
from enum import Enum
import numpy as np
import torch
from torch.utils import _pytree as pytree
__all__ = ['AWQPackedTensor', 'AWQPacking']
AWQ_ORDER = [0, 2, 4, 6, 1, 3, 5, 7]
AWQ_REVERSE_ORDER = [0, 4, 1, 5, 2, 6, 3, 7]

def pack(unpacked: torch.Tensor, reorder=False):
    bits = 4
    pack_num = 32 // bits
    packed = torch.zeros(unpacked.shape[0], unpacked.shape[1] // pack_num, dtype=torch.int32, device=unpacked.device)
    for col in range(unpacked.shape[1] // pack_num):
        if reorder:
            order_map = AWQ_ORDER
        else:
            order_map = [0, 1, 2, 3, 4, 5, 6, 7]
        for i in range(pack_num):
            packed_col = unpacked[:, col * pack_num + order_map[i]].to(torch.int32)
            packed[:, col] |= packed_col << i * bits
    return packed

def reverse_awq_order(t: torch.Tensor):
    bits = 4
    reverse_order_tensor = torch.arange(t.shape[-1], dtype=torch.int32, device=t.device)
    reverse_order_tensor = reverse_order_tensor.view(-1, 32 // bits)
    reverse_order_tensor = reverse_order_tensor[:, AWQ_REVERSE_ORDER]
    reverse_order_tensor = reverse_order_tensor.view(-1)
    t = t[:, reverse_order_tensor]
    return t

def unpack(packed: torch.Tensor, reorder=False):
    bits = 4
    shifts = torch.arange(0, 32, bits, device=packed.device)
    unpacked = torch.bitwise_right_shift(packed[:, :, None], shifts[None, None, :]).to(torch.int8)
    unpacked = unpacked.view(unpacked.shape[0], -1)
    if reorder:
        unpacked = reverse_awq_order(unpacked)
    unpacked = torch.bitwise_and(unpacked, 2 ** bits - 1)
    return unpacked

def pack_v2(unpacked: torch.Tensor) -> torch.Tensor:
    assert unpacked.device.type == 'cuda'
    assert unpacked.ndim == 2
    (N, K) = unpacked.shape
    I = 4
    S = 64
    packed = unpacked.reshape(N, K // 32, 4, 4, 2).permute(0, 1, 3, 2, 4)
    packed = packed.permute(0, 1, 2, 4, 3)
    packed = packed.reshape(N, K)
    packed = packed.reshape(N // I, I, K // S, S)
    packed = packed.permute(0, 2, 1, 3)
    packed = packed.reshape(N // I, K // S, S, I)
    packed = packed.to(torch.int32)
    packed = packed[..., 0] | packed[..., 1] << 4 | packed[..., 2] << 8 | packed[..., 3] << 12
    packed = packed.reshape(N // I, K)
    return packed.to(torch.int16).contiguous()

def unpack_v2(packed):
    assert packed.device.type == 'cuda'
    assert packed.ndim == 2
    I = 4
    S = 64
    (N_div_I, K) = packed.shape
    N = N_div_I * I
    unpacked = packed.reshape(N // I, K // S, S, 1)
    unpacked = unpacked.cpu().numpy().astype(np.uint16)
    unpacked = torch.cat([torch.tensor((unpacked & 15).astype(np.uint8)).to(packed.device), torch.tensor(((unpacked & 240) >> 4).astype(np.uint8)).to(packed.device), torch.tensor(((unpacked & 3840) >> 8).astype(np.uint8)).to(packed.device), torch.tensor(((unpacked & 61440) >> 12).astype(np.uint8)).to(packed.device)], axis=-1)
    unpacked = unpacked.reshape(N // I, K // S, I, S)
    unpacked = unpacked.permute(0, 2, 1, 3)
    unpacked = unpacked.reshape(N, K)
    unpacked = unpacked.reshape(N, K // 32, 4, 2, 4).permute(0, 1, 2, 4, 3)
    unpacked = unpacked.permute(0, 1, 3, 2, 4)
    unpacked = unpacked.reshape(N, K)
    return unpacked

class AWQPacking(Enum):
    V1 = 1
    V2 = 2

class AWQPackedTensor(torch.Tensor):

    @staticmethod
    def __new__(cls, data, packing, reorder, size, stride, requires_grad=False):
        assert data.device.type == 'cuda'
        assert data.dtype == torch.int32 if packing == AWQPacking.V1 else torch.int16
        assert requires_grad is False
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=torch.uint8, device=data.device, requires_grad=requires_grad)

    def __init__(self, data, packing, reorder, size, stride, requires_grad=False):
        self._data = data
        self._packing = packing
        self._reorder = reorder

    def __repr__(self):
        return f'AWQPackedTensor({self._data}, packing={self._packing}, reorder={self._reorder})'

    @classmethod
    def pack(cls, t, packing=AWQPacking.V1, reorder=False):
        if packing == AWQPacking.V1:
            data = pack(t, reorder=reorder)
        else:
            data = pack_v2(t)
        return AWQPackedTensor(data, packing, reorder, t.size(), t.stride())

    def unpack(self):
        if self._packing == AWQPacking.V1:
            return unpack(self._data, self._reorder)
        return unpack_v2(self._data)

    @property
    def dtype(self):
        return torch.uint8

    def __tensor_flatten__(self):
        inner_tensors = ['_data']
        meta = {'packing': str(self._packing), 'reorder': str(self._reorder), 'size': str(list(self.size())), 'stride': str(self.stride())}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 1
        assert len(meta) == 4
        data = inner_tensors['_data']
        packing = ast.literal_eval(meta['packing'])
        reorder = ast.literal_eval(meta['reorder'])
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return AWQPackedTensor(data, packing, reorder, size, stride)
    __torch_function__ = torch._C._disabled_torch_function_impl

    @classmethod
    def __torch_dispatch__(cls, op, types, args, kwargs=None):
        if op.overloadpacket is torch.ops.aten.detach:
            t = args[0]
            data = op(t._data)
            return AWQPackedTensor(data, t._packing, t._reorder, t.size(), t.stride())
        elif op.overloadpacket in (torch.ops.aten._to_copy, torch.ops.aten.to):
            t = args[0]
            dtype = kwargs.get('dtype', torch.uint8)
            if dtype != torch.uint8:
                raise ValueError(f'AWQPackedTensor are torch.uint8 only and cannot be moved to {dtype}.')
            device = kwargs.get('device', t.device)
            if device.type == 'cuda':
                data_kwargs = copy(kwargs)
                data_kwargs['dtype'] = t._data.dtype
                data = op(t._data, **data_kwargs)
                return AWQPackedTensor(data, t._packing, t._reorder, t.size(), t.stride())
        (args, kwargs) = pytree.tree_map_only(AWQPackedTensor, lambda x: x.unpack(), (args, kwargs or {}))
        return op(*args, **kwargs)

    def numpy(self):
        return self.unpack().cpu().numpy()

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/awq/qbits.py
import ast
import torch
from torch.autograd import Function
from ...function import QuantizedLinearFunction
from ...qtype import qtypes
from ..group import group, ungroup
from ..qbits import QBitsTensor
from .packed import AWQPackedTensor, AWQPacking
__all__ = ['AWQBitsTensor']

class AWQBitsDequantizer(Function):

    @staticmethod
    def forward(ctx, t):
        unpacked = t._data.unpack()
        scale = t._scale
        shift = t._shift
        unpacked = group(unpacked, axis=0, group_size=t._group_size)
        n_scales = scale.numel()
        scale = scale.t().reshape((n_scales, 1))
        shift = shift.t().reshape((n_scales, 1))
        dqt = scale * unpacked + shift
        return ungroup(dqt, axis=t.axis, orig_shape=t.shape)

    @staticmethod
    def backward(ctx, gO):
        return gO

class AWQBitsLinearFunction(QuantizedLinearFunction):

    @staticmethod
    def forward(ctx, input, other, bias):
        ctx.save_for_backward(input, other)
        if type(input) is not torch.Tensor:
            input = input.dequantize()
        (out_features, in_features) = other.shape
        rows = input.numel() // in_features
        output = torch.ops.quanto.gemm(input, other._data._data, other._scale, other._shift, rows=rows, out_cols=out_features, in_cols=in_features, bits=4, group_size=other._group_size)
        if bias is not None:
            output = output + bias
        return output

class AWQBitsTensor(QBitsTensor):

    @staticmethod
    def __new__(cls, qtype, axis, group_size, size, stride, data, scale, shift, requires_grad=False):
        assert data.device.type == 'cuda'
        assert data.device == scale.device
        assert data.device == shift.device
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=scale.dtype, device=data.device, requires_grad=requires_grad)

    def __init__(self, qtype, axis, group_size, size, stride, data, scale, shift, requires_grad=False):
        assert axis == 0
        if not isinstance(data, AWQPackedTensor):
            assert type(data) is torch.Tensor
            ungrouped = ungroup(data, axis=0, orig_shape=size)
            data = AWQPackedTensor.pack(ungrouped, packing=AWQPacking.V2)
            (out_features, in_features) = size
            scale = scale.reshape(out_features, in_features // group_size).t().contiguous()
            shift = shift.reshape(out_features, in_features // group_size).t()
            if not shift.dtype.is_floating_point:
                shift = scale * shift
            shift = -shift.contiguous()
        super().__init__(qtype, axis, group_size, size, stride, data, scale, shift)

    def dequantize(self):
        return AWQBitsDequantizer.apply(self)

    def qbits_tensor(self):
        data = group(self._data.unpack(), axis=self.axis, group_size=self._group_size)
        n_scales = self._scale.numel()
        scale = self._scale.t().reshape((n_scales, 1))
        shift = -self._shift.t().reshape((n_scales, 1))
        return QBitsTensor(self._qtype, self._axis, self._group_size, self.size(), self.stride(), data, scale, shift)

    def __tensor_flatten__(self):
        inner_tensors = ['_data', '_scale', '_shift']
        meta = {'qtype': self._qtype.name, 'axis': str(self._axis), 'group_size': str(self._group_size), 'size': str(list(self.size())), 'stride': str(list(self.stride()))}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 3
        assert len(meta) == 5
        (data, scale, shift) = (inner_tensors['_data'], inner_tensors['_scale'], inner_tensors['_shift'])
        qtype = qtypes[meta['qtype']]
        axis = ast.literal_eval(meta['axis'])
        group_size = ast.literal_eval(meta['group_size'])
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return AWQBitsTensor(qtype, axis, group_size, size, stride, data, scale, shift)

    @classmethod
    def __torch_function__(cls, func, types, args=(), kwargs=None):
        kwargs = kwargs or {}
        if func is torch.nn.functional.linear:

            def qlinear(input, other, bias=None):
                return AWQBitsLinearFunction.apply(input, other, bias)
            return qlinear(*args, **kwargs)
        with torch._C.DisableTorchFunctionSubclass():
            return func(*args, **kwargs)

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/group.py
import math
from typing import List
import torch
__all__ = ['group', 'ungroup', 'grouped_shape']

def grouped_shape(shape: List, axis: int, group_size: int) -> List:
    if axis not in (0, -1):
        raise ValueError('Axis must be 0 or -1 for group-wise quantization')
    n_groups = math.prod(shape) // group_size
    return (n_groups, group_size) if axis == 0 else (group_size, n_groups)

def group(base: torch.Tensor, axis: int, group_size: int):
    if axis not in (0, -1):
        raise ValueError('Axis must be 0 or -1 for group-wise quantization')
    axis_dim = base.shape[axis]
    axis_numel = base.numel() // axis_dim
    if group_size > axis_numel or axis_numel % group_size != 0:
        raise ValueError(f'Group size ({group_size}) must be a divisor of ({axis_numel})')
    axis_groups = axis_numel // group_size
    if axis == 0:
        return base.reshape([-1, group_size])
    grouped = base.reshape((axis_groups, group_size, axis_dim))
    grouped = grouped.permute(1, 2, 0)
    return grouped.reshape(group_size, axis_dim * axis_groups)

def ungroup(grouped: torch.Tensor, axis: int, orig_shape: torch.Size):
    if grouped.shape == orig_shape:
        return grouped
    if axis == 0:
        return grouped.reshape(orig_shape)
    group_size = grouped.shape[0] if axis == -1 else grouped.shape[-1]
    axis_dim = orig_shape[axis]
    axis_groups = grouped.numel() // axis_dim // group_size
    ungrouped = grouped.reshape(group_size, axis_dim, axis_groups)
    ungrouped = ungrouped.permute(2, 0, 1)
    return ungrouped.reshape(orig_shape)

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/packed.py
import ast
import torch
from torch.utils import _pytree as pytree
__all__ = ['PackedTensor']

def pack_weights(intweights: torch.Tensor, bits: int) -> torch.Tensor:
    original_shape = intweights.shape
    values_per_item = 8 // bits
    row_dim = (original_shape[0] + values_per_item - 1) // values_per_item
    if len(original_shape) == 1:
        packed_tensor_shape = (row_dim,)
    else:
        packed_tensor_shape = (row_dim, *original_shape[1:])
    packed = torch.zeros(packed_tensor_shape, device=intweights.device, dtype=torch.uint8)
    unpacked = intweights.to(torch.uint8)

    def lshift(t: torch.Tensor, bits: int):
        if t.device.type == 'mps':
            return t * 2 ** bits
        return t << bits
    it = min(values_per_item, original_shape[0] // row_dim + 1)
    for i in range(it):
        start = i * row_dim
        end = min(start + row_dim, original_shape[0])
        packed[:end - start] |= lshift(unpacked[start:end], bits * i)
    return packed

class PackedTensor(torch.Tensor):

    @staticmethod
    def __new__(cls, data, bits, size, stride, requires_grad=False):
        assert data.dtype == torch.uint8
        assert requires_grad is False
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=torch.uint8, device=data.device, requires_grad=requires_grad)

    def __init__(self, data, bits, size, stride, requires_grad=False):
        self._bits = bits
        self._data = data

    def __repr__(self):
        autograd_info = f', grad_fn={self.grad_fn}' if self.grad_fn else ', requires_grad=True' if self.requires_grad else ''
        return f'PackedTensor({self._data}, bits={self._bits}, public_dtype={self.dtype}{autograd_info})'

    @classmethod
    def pack(cls, t, bits=4):
        assert bits in (2, 4)
        assert t.dtype == torch.uint8
        data = pack_weights(t, bits)
        return PackedTensor(data, bits, t.size(), t.stride())

    def unpack(self):
        unpacked_data = torch.ops.quanto.unpack(self._data, self._bits)
        return unpacked_data[:self.shape[0]]

    @property
    def bits(self):
        return self._bits

    @property
    def dtype(self):
        return torch.uint8

    @staticmethod
    def load_from_state_dict(state_dict, prefix, bits, size, stride, missing_keys):
        if prefix + '_data' not in state_dict:
            missing_keys.append(prefix + '_data')
            return
        inner_tensors_dict = {'_data': state_dict.pop(prefix + '_data')}
        meta = [name.replace(prefix, '') for name in state_dict.keys() if name.startswith(prefix)]
        meta = {'bits': str(bits), 'size': str(list(size)), 'stride': str(stride)}
        return PackedTensor.__tensor_unflatten__(inner_tensors_dict, meta, None, None)

    def __tensor_flatten__(self):
        inner_tensors = ['_data']
        meta = {'bits': str(self._bits), 'size': str(list(self.size())), 'stride': str(self.stride())}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 1
        assert len(meta) == 3
        data = inner_tensors['_data']
        bits = ast.literal_eval(meta['bits'])
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return PackedTensor(data, bits, size, stride)
    __torch_function__ = torch._C._disabled_torch_function_impl

    @classmethod
    def __torch_dispatch__(cls, op, types, args, kwargs=None):
        if op.overloadpacket is torch.ops.aten.detach:
            t = args[0]
            data = op(t._data)
            return PackedTensor(data, t._bits, t.size(), t.stride())
        elif op.overloadpacket in (torch.ops.aten._to_copy, torch.ops.aten.to):
            t = args[0]
            dtype = kwargs.get('dtype', torch.uint8)
            if dtype != torch.uint8:
                raise ValueError(f'PackedTensor are torch.uint8 only and cannot be moved to {dtype}.')
            data = op(t._data, **kwargs)
            return PackedTensor(data, t._bits, t.size(), t.stride())
        (args, kwargs) = pytree.tree_map_only(PackedTensor, lambda x: x.unpack(), (args, kwargs or {}))
        return op(*args, **kwargs)

    def numpy(self):
        return self.unpack().cpu().numpy()

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/qbits.py
import ast
import torch
from packaging import version
from torch.autograd import Function
from ..function import QuantizedLinearFunction
from ..qtensor import QTensor, qfallback
from ..qtype import qint2, qint4, qtype, qtypes
from .group import grouped_shape, ungroup
from .packed import PackedTensor
__all__ = ['QBitsTensor']

class QBitsQuantizer(Function):

    @staticmethod
    def forward(ctx, base: torch.Tensor, qtype: qtype, axis: int, group_size: int, scale: torch.Tensor, shift: torch.Tensor):
        if qtype not in (qint2, qint4):
            raise ValueError('QBitsTensor can only be of qint2 or qint4 qtype')
        if axis not in (0, -1):
            raise ValueError('QBitsTensor axis parameter must be 0 (first axis) or -1 (last axis)')
        size = base.size()
        stride = base.stride()
        data = torch.ops.quanto.quantize_affine(base, bits=qtype.bits, axis=axis, group_size=group_size, scale=scale, shift=shift)
        return QBitsTensor.create(qtype, axis, group_size, size, stride, data, scale, shift)

    @staticmethod
    def backward(ctx, gO):
        return (gO, None, None, None, None, None)

class QBitsDequantizer(Function):

    @staticmethod
    def forward(ctx, t):
        data = t._data.unpack()
        shift = t._shift
        if not shift.dtype.is_floating_point:
            data = data.to(torch.int8) - shift.to(torch.int8)
        if t.qtype.is_floating_point:
            dqt = t._scale * data.to(t._scale.dtype)
        else:
            dqt = t._scale * data
        if shift.dtype.is_floating_point:
            dqt -= shift
        if t.axis is None:
            return dqt
        return ungroup(dqt, axis=t.axis, orig_shape=t.shape)

    @staticmethod
    def backward(ctx, gO):
        return gO

class QBitsTensor(QTensor):

    @staticmethod
    def create(qtype, axis, group_size, size, stride, data, scale, shift, requires_grad=False):
        from .awq import AWQBitsTensor
        from .tinygemm import TinyGemmQBitsTensor
        if qtype == qint4 and size[0] >= 128 and (scale.dtype == torch.float16) and (axis == 0) and (group_size == 128) and (len(size) == 2) and (data.device.type == 'cuda') and (torch.cuda.get_device_capability(data.device)[0] >= 8):
            if type(data) is PackedTensor:
                data = data.unpack()
            return AWQBitsTensor(qtype, axis, group_size, size, stride, data, scale, shift, requires_grad)
        if qtype == qint4 and scale.dtype == torch.bfloat16 and (axis == 0) and (group_size == 128) and (len(size) == 2):
            if data.device.type == 'cpu' or (data.device.type == 'cuda' and version.parse(torch.version.cuda).release >= (12, 1) and (torch.cuda.get_device_capability(data.device)[0] >= 8)):
                if type(data) is PackedTensor:
                    data = data.unpack()
                return TinyGemmQBitsTensor(qtype, axis, group_size, size, stride, data, (scale, shift), requires_grad)
        return QBitsTensor(qtype, axis, group_size, size, stride, data, scale, shift, requires_grad)

    @staticmethod
    def __new__(cls, qtype, axis, group_size, size, stride, data, scale, shift, requires_grad=False):
        assert data.device == scale.device
        assert data.device == shift.device
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=scale.dtype, device=data.device, requires_grad=requires_grad)

    def __init__(self, qtype, axis, group_size, size, stride, data, scale, shift, requires_grad=False):
        super().__init__(qtype, axis)
        if type(data) is torch.Tensor:
            data = PackedTensor.pack(data, qtype.bits)
        self._data = data
        self._scale = scale
        self._shift = shift
        self._group_size = group_size

    def __repr__(self):
        return f'{type(self).__name__}({self._data}, scale={self._scale}, shift={self._shift}, dtype={self.dtype})'

    @classmethod
    def quantize(cls, base: torch.Tensor, qtype: qtype, axis: int, group_size: int, scale: torch.Tensor, shift: torch.Tensor):
        return QBitsQuantizer.apply(base, qtype, axis, group_size, scale, shift)

    def dequantize(self):
        return QBitsDequantizer.apply(self)

    @staticmethod
    def load_from_state_dict(state_dict, prefix, qtype, axis, group_size, size, stride, missing_keys):
        if group_size is None:
            data_size = size
            data_stride = stride
        else:
            data_size = grouped_shape(size, axis, group_size)
            assert len(data_size) == 2
            data_stride = (data_size[1], 1)
        inner_tensors_dict = {'_data': PackedTensor.load_from_state_dict(state_dict, prefix + '_data.', qtype.bits, data_size, data_stride, missing_keys=missing_keys)}
        missing = inner_tensors_dict['_data'] is None
        for name in ['_scale', '_shift']:
            if prefix + name not in state_dict:
                missing_keys.append(prefix + name)
                missing = True
            else:
                inner_tensors_dict[name] = state_dict.pop(prefix + name)
        if missing:
            return None
        meta = {'qtype': qtype.name, 'axis': str(axis), 'group_size': str(group_size), 'size': str(list(size)), 'stride': str(list(stride))}
        return QBitsTensor.__tensor_unflatten__(inner_tensors_dict, meta, None, None)

    def optimize(self):
        if type(self) is not QBitsTensor:
            return self
        data = self._data.unpack()
        return QBitsTensor.create(self.qtype, self.axis, self._group_size, self.size(), self.stride(), data, self._scale, self._shift, self.requires_grad)

    def save_to_state_dict(self, destination, prefix, keep_vars):
        if type(self) is QBitsTensor:
            super().save_to_state_dict(destination, prefix, keep_vars)
        else:
            self.qbits_tensor().save_to_state_dict(destination, prefix, keep_vars)

    def qbits_tensor(self):
        raise NotImplementedError

    def __tensor_flatten__(self):
        inner_tensors = ['_data', '_scale', '_shift']
        meta = {'qtype': self._qtype.name, 'axis': str(self._axis), 'group_size': str(self._group_size), 'size': str(list(self.size())), 'stride': str(list(self.stride()))}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 3
        assert len(meta) == 5
        (data, scale, shift) = (inner_tensors['_data'], inner_tensors['_scale'], inner_tensors['_shift'])
        qtype = qtypes[meta['qtype']]
        axis = ast.literal_eval(meta['axis'])
        group_size = ast.literal_eval(meta['group_size'])
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return QBitsTensor(qtype, axis, group_size, size, stride, data, scale, shift)

    @classmethod
    def __torch_function__(cls, func, types, args=(), kwargs=None):
        kwargs = kwargs or {}
        if func is torch.nn.functional.linear:

            def qlinear(input, other, bias=None):
                return QuantizedLinearFunction.apply(input, other, bias)
            return qlinear(*args, **kwargs)
        elif func is torch.equal:
            (input, other) = args
            return input.equal(other)
        with torch._C.DisableTorchFunctionSubclass():
            return func(*args, **kwargs)

    @classmethod
    def __torch_dispatch__(cls, op, types, args, kwargs=None):
        from .qbits_ops import get_qbitstensor_op_dispatch
        op = op.overloadpacket
        qdispatch = get_qbitstensor_op_dispatch(op)
        if qdispatch is not None:
            return qdispatch(*args, **kwargs)
        return qfallback(op, *args, **kwargs)

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/qbits_ops.py
from functools import partial
from typing import Callable, List
import torch
from .qbits import QBitsTensor
__all__ = ['get_qbitstensor_op_dispatch', 'register_qbitstensor_op']
_QBITSTENSOR_OP_TABLE = {}

def register_qbitstensor_op(aten_ops: List[Callable]):

    def wrapper(op):
        for aten_op in aten_ops:
            _QBITSTENSOR_OP_TABLE[aten_op] = partial(op, aten_op)
    return wrapper

def get_qbitstensor_op_dispatch(aten_op):
    return _QBITSTENSOR_OP_TABLE.get(aten_op, None)

@register_qbitstensor_op([torch.ops.aten._to_copy])
def _to_copy(op, t, dtype=None, device=None, **kwargs):
    if dtype is not None and dtype != t.dtype:
        raise ValueError('The dtype of a QBitsTensor cannot be changed')
    if type(t) is not QBitsTensor and t.device.type != device.type:
        t = t.qbits_tensor()
    scale = op(t._scale, dtype=dtype, device=device, **kwargs)
    data = op(t._data, device=device, **kwargs)
    shift = op(t._shift, device=device, **kwargs)
    return QBitsTensor.create(t._qtype, t._axis, t._group_size, t.size(), t.stride(), data, scale, shift)

@register_qbitstensor_op([torch.ops.aten.detach])
def detach(op, t):
    (inner_tensor_names, meta) = t.__tensor_flatten__()
    detached_tensors = {}
    for inner_name in inner_tensor_names:
        detached_tensors[inner_name] = op(getattr(t, inner_name))
    return t.__class__.__tensor_unflatten__(detached_tensors, meta, t.size(), t.stride())

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/tinygemm/packed.py
import ast
from copy import copy
import torch
from packaging import version
from torch.utils import _pytree as pytree
__all__ = ['TinyGemmPackedTensor']

class TinyGemmPackedTensor(torch.Tensor):

    @staticmethod
    def __new__(cls, data, size, stride, requires_grad=False):
        assert data.dtype == torch.int32
        assert requires_grad is False
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=torch.uint8, device=data.device, requires_grad=requires_grad)

    def __init__(self, data, size, stride, requires_grad=False):
        self._data = data

    def __repr__(self):
        return f'TinyGemmPackedTensor({self._data})'

    @classmethod
    def pack(cls, t):
        inner_ktiles = 2
        t = t.to(torch.int32).contiguous()
        if version.parse(torch.__version__).release >= version.parse('2.5.0').release:
            t_uint8 = (t[:, ::2] << 4 | t[:, 1::2]).to(torch.uint8)
            data = torch._convert_weight_to_int4pack(t_uint8, innerKTiles=inner_ktiles)
        else:
            data = torch._convert_weight_to_int4pack(t, innerKTiles=inner_ktiles)
        return TinyGemmPackedTensor(data, t.size(), t.stride())

    def unpack(self):
        (out_features, in_features) = self.size()
        group_size = 32
        scale_and_shift_shape = (in_features // group_size, out_features, 2)
        id_scale_and_shift = torch.ones(scale_and_shift_shape, dtype=torch.bfloat16, device=self.device)
        id_scale_and_shift[:, :, 1] = 8
        identity = torch.eye(in_features, dtype=torch.bfloat16, device=self.device)
        unpacked_data = torch._weight_int4pack_mm(identity, self._data, group_size, id_scale_and_shift)
        return unpacked_data.t().to(torch.uint8)

    @property
    def dtype(self):
        return torch.uint8

    def __tensor_flatten__(self):
        inner_tensors = ['_data']
        meta = {'size': str(list(self.size())), 'stride': str(self.stride())}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 1
        assert len(meta) == 2
        data = inner_tensors['_data']
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return TinyGemmPackedTensor(data, size, stride)
    __torch_function__ = torch._C._disabled_torch_function_impl

    @classmethod
    def __torch_dispatch__(cls, op, types, args, kwargs=None):
        if op.overloadpacket is torch.ops.aten.detach:
            t = args[0]
            data = op(t._data)
            return TinyGemmPackedTensor(data, t.size(), t.stride())
        elif op.overloadpacket in (torch.ops.aten._to_copy, torch.ops.aten.to):
            t = args[0]
            dtype = kwargs.get('dtype', torch.uint8)
            if dtype != torch.uint8:
                raise ValueError(f'TinyGemmPackedTensor are torch.uint8 only and cannot be moved to {dtype}.')
            data_kwargs = copy(kwargs)
            data_kwargs['dtype'] = t._data.dtype
            if kwargs.get('device', t.device).type != t.device.type:
                unpacked = t.unpack()
                unpacked = op(unpacked, **data_kwargs)
                return TinyGemmPackedTensor.pack(unpacked)
            data = op(t._data, **data_kwargs)
            return TinyGemmPackedTensor(data, t.size(), t.stride())
        (args, kwargs) = pytree.tree_map_only(TinyGemmPackedTensor, lambda x: x.unpack(), (args, kwargs or {}))
        return op(*args, **kwargs)

    def numpy(self):
        return self.unpack().cpu().numpy()

# File: optimum-quanto-main/optimum/quanto/tensor/qbits/tinygemm/qbits.py
import ast
import torch
from torch.autograd import Function
from ...function import QuantizedLinearFunction
from ...qtype import qtypes
from ..group import group, ungroup
from ..qbits import QBitsTensor
from .packed import TinyGemmPackedTensor
__all__ = ['TinyGemmQBitsTensor']

class TinyGemmQBitsDequantizer(Function):

    @staticmethod
    def forward(ctx, t):
        qbt = t.qbits_tensor()
        return qbt.dequantize()

    @staticmethod
    def backward(ctx, gO):
        return gO

class TinyGemmQBitsLinearFunction(QuantizedLinearFunction):

    @staticmethod
    def forward(ctx, input, other, bias):
        ctx.save_for_backward(input, other)
        if type(input) is not torch.Tensor:
            input = input.dequantize()
        in_features = input.shape[-1]
        out_features = other.shape[0]
        output_shape = input.shape[:-1] + (out_features,)
        output = torch._weight_int4pack_mm(input.view(-1, in_features), other._data._data, other._group_size, other._scale_shift)
        output = output.view(output_shape)
        if bias is not None:
            output = output + bias
        return output

class TinyGemmQBitsTensor(QBitsTensor):

    @staticmethod
    def __new__(cls, qtype, axis, group_size, size, stride, data, scale_shift, requires_grad=False):
        if isinstance(scale_shift, torch.Tensor):
            dtype = scale_shift.dtype
            assert data.device == scale_shift.device
        else:
            assert isinstance(scale_shift, (tuple, list))
            (scale, shift) = scale_shift
            dtype = scale.dtype
            assert shift.dtype == dtype
            assert data.device == scale.device
            assert data.device == shift.device
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=dtype, device=data.device, requires_grad=requires_grad)

    def __init__(self, qtype, axis, group_size, size, stride, data, scale_shift, requires_grad=False):
        assert axis == 0
        if not isinstance(data, TinyGemmPackedTensor):
            assert type(data) is torch.Tensor
            assert isinstance(scale_shift, (tuple, list))
            ungrouped = ungroup(data, axis=0, orig_shape=size)
            self._data = TinyGemmPackedTensor.pack(ungrouped)
            (out_features, in_features) = size
            (scale, shift) = scale_shift
            scale = scale.reshape(out_features, in_features // group_size, 1)
            shift = shift.reshape(out_features, in_features // group_size, 1)
            if not shift.dtype.is_floating_point:
                shift = scale * shift
            min_range = -shift
            half_qrange = 2 ** (qtype.bits - 1) * scale
            shift = min_range + half_qrange
            self._scale_shift = torch.cat([scale, shift], 2).transpose(0, 1).contiguous()
        else:
            self._data = data
            self._scale_shift = scale_shift
        self._qtype = qtype
        self._axis = axis
        self._group_size = group_size

    def dequantize(self):
        return TinyGemmQBitsDequantizer.apply(self)

    def qbits_tensor(self):
        data = group(self._data.unpack(), axis=self.axis, group_size=self._group_size)
        n_scales = self._scale_shift.numel() // 2
        scale = self._scale_shift[:, :, 0].t().reshape((n_scales, 1))
        shift = self._scale_shift[:, :, 1].t().reshape((n_scales, 1))
        half_qrange = 2 ** (self.qtype.bits - 1) * scale
        shift = half_qrange - shift
        return QBitsTensor(self._qtype, self._axis, self._group_size, self.size(), self.stride(), data, scale, shift)

    def __tensor_flatten__(self):
        inner_tensors = ['_data', '_scale_shift']
        meta = {'qtype': self._qtype.name, 'axis': str(self._axis), 'group_size': str(self._group_size), 'size': str(list(self.size())), 'stride': str(list(self.stride()))}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 2
        assert len(meta) == 5
        (data, scale_shift) = (inner_tensors['_data'], inner_tensors['_scale_shift'])
        qtype = qtypes[meta['qtype']]
        axis = ast.literal_eval(meta['axis'])
        group_size = ast.literal_eval(meta['group_size'])
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return TinyGemmQBitsTensor(qtype, axis, group_size, size, stride, data, scale_shift)

    @classmethod
    def __torch_function__(cls, func, types, args=(), kwargs=None):
        kwargs = kwargs or {}
        if func is torch.nn.functional.linear:

            def qlinear(input, other, bias=None):
                return TinyGemmQBitsLinearFunction.apply(input, other, bias)
            return qlinear(*args, **kwargs)
        with torch._C.DisableTorchFunctionSubclass():
            return func(*args, **kwargs)

# File: optimum-quanto-main/optimum/quanto/tensor/qbytes.py
from torch.autograd import Function
from .qtensor import QTensor
__all__ = ['QBytesTensor']

class QBytesDequantizer(Function):

    @staticmethod
    def forward(ctx, t):
        if t.qtype.is_floating_point:
            dqt = t._scale * t._data.to(t._scale.dtype)
        else:
            dqt = t._scale * t._data
        return dqt

    @staticmethod
    def backward(ctx, gO):
        return gO

class QBytesTensor(QTensor):

    def __init__(self, qtype, axis, size, stride, data, scale, requires_grad=False):
        super().__init__(qtype, axis)
        self._data = data
        self._scale = scale

    def __repr__(self):
        return f'{self.__class__}({self._data}, scale={self._scale}, dtype={self.dtype})'

    def dequantize(self):
        return QBytesDequantizer.apply(self)

# File: optimum-quanto-main/optimum/quanto/tensor/qtensor.py
import torch
from torch.utils import _pytree as pytree
__all__ = ['QTensor', 'qfallback']

def qfallback(callable, *args, **kwargs):
    (args, kwargs) = pytree.tree_map_only(QTensor, lambda x: x.dequantize(), (args, kwargs or {}))
    return callable(*args, **kwargs)

class QTensor(torch.Tensor):

    def __init__(self, qtype, axis):
        self._qtype = qtype
        self._axis = axis

    def dequantize(self):
        raise NotImplementedError

    def save_to_state_dict(self, destination, prefix, keep_vars):

        def serialize_tensor_subclass(t, destination, prefix, keep_vars):
            (inner_tensors, meta) = t.__tensor_flatten__()
            for name in inner_tensors:
                inner_tensor = getattr(t, name)
                if type(inner_tensor) is torch.Tensor:
                    destination[prefix + name] = inner_tensor if keep_vars else inner_tensor.detach()
                else:
                    serialize_tensor_subclass(inner_tensor, destination, prefix + name + '.', keep_vars)
        serialize_tensor_subclass(self, destination, prefix, keep_vars)

    @property
    def axis(self):
        return self._axis

    @property
    def qtype(self):
        return self._qtype

    def numpy(self):
        return self.dequantize().cpu().numpy()

    def equal(self, other):
        if type(self) is not type(other):
            return False
        (self_tensors, self_meta) = self.__tensor_flatten__()
        (_, other_meta) = other.__tensor_flatten__()
        for (name, value) in self_meta.items():
            if other_meta[name] != value:
                return False
        for name in self_tensors:
            self_t = getattr(self, name)
            other_t = getattr(other, name)
            if self_t.device.type == 'cpu' and self_t.dtype in (torch.float8_e4m3fn, torch.float8_e5m2):
                if self_t.dtype != other_t.dtype:
                    return False
                if not torch.equal(self_t.to(torch.float32), other_t.to(torch.float32)):
                    return False
            elif not torch.equal(self_t, other_t):
                return False
        return True

# File: optimum-quanto-main/optimum/quanto/tensor/qtype.py
from dataclasses import dataclass
import torch

@dataclass
class qtype:
    name: str
    is_floating_point: bool
    bits: int
    dtype: torch.dtype
    qmin: float
    qmax: float

    def __str__(self):
        return f'quanto.{self.name}'

    def __hash__(self):
        return hash(str(self))

def qint(bits):
    qmin = -2 ** (bits - 1)
    qmax = 2 ** (bits - 1) - 1
    return qtype(f'qint{bits}', is_floating_point=False, bits=bits, dtype=torch.int8, qmin=qmin, qmax=qmax)
qint2 = qint(2)
qint4 = qint(4)
qint8 = qint(8)

def qfloat(dtype: torch.dtype):
    finfo = torch.finfo(dtype)
    qmin = finfo.min
    qmax = finfo.max
    return qtype(f'q{finfo.dtype}', is_floating_point=True, bits=8, dtype=dtype, qmin=qmin, qmax=qmax)
qfloat8_e4m3fn = qfloat(torch.float8_e4m3fn)
qfloat8_e5m2 = qfloat(torch.float8_e5m2)
qfloat8 = qfloat8_e4m3fn
qtypes = {name: q for (name, q) in locals().items() if isinstance(q, qtype)}
__all__ = ['qtype', 'qtypes'] + [str(name) for name in qtypes.keys()]

# File: optimum-quanto-main/optimum/quanto/tensor/weights/marlin/marlin.py
import ast
import torch
from ...function import QuantizedLinearFunction
from ...qtype import qfloat8_e4m3fn, qtypes
from ..qbytes import WeightQBytesTensor
from .packed import MarlinF8PackedTensor, get_scale_perms

class MarlinF8QBytesLinearFunction(QuantizedLinearFunction):

    @staticmethod
    def forward(ctx, input, other, bias=None):
        ctx.save_for_backward(input, other)
        input_shape = input.shape
        if input.ndim > 2:
            input = input.view(-1, input_shape[-1])
        output = torch.ops.quanto.fp8_marlin_gemm(input, b_q_weight=other._data._data, b_scales=other._scale, workspace=other._workspace, num_bits=8, size_m=input.shape[0], size_n=other._scale.shape[1], size_k=input.shape[1])
        if len(input_shape) > 2:
            output = output.reshape(input_shape[:-1] + (other._scale.shape[1],))
        return output

class MarlinF8QBytesTensor(WeightQBytesTensor):

    @staticmethod
    def __new__(cls, qtype, axis, size, stride, data, scale, requires_grad=False):
        assert data.device.type == 'cuda'
        assert data.device == scale.device
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=scale.dtype, device=data.device, requires_grad=requires_grad)

    def __init__(self, qtype, axis, size, stride, data, scale, requires_grad=False):
        assert axis == 0
        assert data.ndim == 2
        out_features = size[0]
        self._workspace = torch.zeros(out_features // 64 * 16, dtype=torch.int, device=data.device)
        if data.dtype != torch.int32:
            assert scale.shape == (out_features, 1)
            scale_perm_single = get_scale_perms()
            scale = scale.reshape((-1, len(scale_perm_single)))[:, scale_perm_single]
            scale = scale.reshape(-1, out_features).contiguous()
            data_packed = MarlinF8PackedTensor.pack(data)
        else:
            data_packed = data
        super().__init__(qtype, axis, size, stride, data_packed, scale, activation_qtype=qfloat8_e4m3fn, requires_grad=requires_grad)

    def dequantize(self):
        float8_data = self._data.unpack()
        scale_perm_single = get_scale_perms()
        scale_perm_single_rev = torch.empty_like(scale_perm_single)
        scale_perm_single_rev[scale_perm_single] = torch.arange(len(scale_perm_single))
        scale_reordered = self._scale.reshape((-1, len(scale_perm_single_rev)))[:, scale_perm_single_rev]
        scale_reordered = scale_reordered.reshape(-1, self._scale.shape[1]).contiguous()
        return float8_data.to(scale_reordered.dtype) * scale_reordered.T

    def __repr__(self):
        return f'MarlinF8QBytesTensor({self._data}, scale={self._scale}, dtype={self.dtype})'

    def weight_qbytes_tensor(self):
        data = self._data.unpack()
        scale_perm_single = get_scale_perms()
        scale_perm_single_rev = torch.empty_like(scale_perm_single)
        scale_perm_single_rev[scale_perm_single] = torch.arange(len(scale_perm_single))
        scale_reordered = self._scale.reshape((-1, len(scale_perm_single_rev)))[:, scale_perm_single_rev]
        scale_reordered = scale_reordered.reshape(-1, self._scale.shape[1]).t().contiguous()
        return WeightQBytesTensor(self._qtype, self._axis, self.size(), self.stride(), data, scale_reordered, self.activation_qtype)

    def __tensor_flatten__(self):
        inner_tensors = ['_data', '_scale']
        meta = {'qtype': self._qtype.name, 'axis': str(self._axis), 'size': str(list(self.size())), 'stride': str(list(self.stride()))}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 2
        assert len(meta) == 4
        (data, scale) = (inner_tensors['_data'], inner_tensors['_scale'])
        qtype = qtypes[meta['qtype']]
        axis = ast.literal_eval(meta['axis'])
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return MarlinF8QBytesTensor(qtype, axis, size, stride, data, scale)

    @classmethod
    def __torch_function__(cls, func, types, args=(), kwargs=None):
        kwargs = kwargs or {}
        if func is torch.nn.functional.linear:

            def qlinear(input, other, bias=None):
                return MarlinF8QBytesLinearFunction.apply(input, other, bias)
            return qlinear(*args, **kwargs)
        elif func is torch.equal:
            (input, other) = args
            return input.equal(other)
        with torch._C.DisableTorchFunctionSubclass():
            return func(*args, **kwargs)

# File: optimum-quanto-main/optimum/quanto/tensor/weights/marlin/packed.py
import ast
from copy import copy
import torch
from torch.utils import _pytree as pytree

def pack_fp8_as_int32(fp8_tensor: torch.Tensor) -> torch.Tensor:
    assert fp8_tensor.dtype == torch.float8_e4m3fn
    if fp8_tensor.shape[0] % 4 != 0:
        raise ValueError(f'Leading tensor dimension is not divisable by 4: {fp8_tensor.shape[0]}')
    reshaped = fp8_tensor.reshape(-1, 4, *fp8_tensor.shape[1:])
    byte_tensor = reshaped.view(torch.uint8)
    packed = torch.zeros(fp8_tensor.shape[0] // 4, fp8_tensor.shape[1], dtype=torch.int32, device=fp8_tensor.device)
    for i in range(4):
        packed.bitwise_or_(byte_tensor[:, i].to(torch.int32) << i * 8)
    return packed

def unpack_int32_to_fp8(int32_tensor: torch.Tensor) -> torch.Tensor:
    bits = 8
    unpacked = []
    for i in range(4):
        mask = 2 ** (bits * (i + 1)) - 1
        tmp = (int32_tensor & mask) >> bits * i
        tmp = tmp.to(torch.uint8)
        unpacked.append(tmp)
    unpacked = torch.cat(unpacked).view(torch.float8_e4m3fn)
    return unpacked

def get_scale_perms() -> torch.Tensor:
    scale_perm_single = []
    for i in range(4):
        scale_perm_single.extend([2 * i + j for j in [0, 1, 8, 9, 16, 17, 24, 25]])
    return torch.tensor(scale_perm_single, dtype=torch.int64)

def get_row_permutation(n_rows: int) -> torch.Tensor:
    modulo = n_rows // 4 * 16 - 8
    b = n_rows // 2
    rows_idx = [i * 16 % modulo for i in range(b)]
    rows_idx[-1] = rows_idx[-2] + 16 if b > 2 else 8
    rows_idx = torch.tensor(rows_idx)
    rows_idx = torch.cat((rows_idx, rows_idx + 1))
    rows_idx = torch.tile(rows_idx[:, None], (1, 4))
    rows_idx = rows_idx + torch.tensor([[0, 2, 4, 6]])
    rows_idx = rows_idx.reshape(-1)
    rows_idx_rev = torch.empty_like(rows_idx)
    rows_idx_rev[rows_idx] = torch.arange(len(rows_idx))
    return rows_idx_rev

def get_column_permutation(n_col: int) -> torch.Tensor:
    tile_size = 256
    n_blocks = n_col // tile_size
    a = torch.arange(tile_size)
    rest = a % 8
    frac = a // 8
    original_index = 32 * rest + frac
    original_index = torch.arange(n_blocks)[:, None] * 256 + original_index
    original_index = original_index.reshape(-1)
    original_index = original_index.reshape(4 * n_blocks, 64)
    tmp1 = torch.arange(4)
    tmp1 = tmp1.repeat(n_blocks, 1).T.reshape(-1)
    tmp2 = torch.arange(n_blocks) * 4
    tmp2 = tmp2.repeat(4)
    remap_col_index = tmp1 + tmp2
    original_index = original_index[remap_col_index]
    original_index = original_index.reshape(-1)
    return original_index

class MarlinF8PackedTensor(torch.Tensor):

    def __new__(cls, data, size, stride, requires_grad=False):
        assert data.device.type == 'cuda'
        assert data.dtype == torch.int32
        assert requires_grad is False
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=torch.int32, device=data.device, requires_grad=requires_grad)

    def __init__(self, data, size, stride, requires_grad=False):
        self._data = data

    def __repr__(self):
        return f'MarlinF8PackedTensor({self._data})'

    @classmethod
    def pack(cls, tensor: torch.Tensor):
        (out_features, in_features) = tensor.shape
        data_int32 = pack_fp8_as_int32(tensor.T)
        perm = torch.empty(0, dtype=torch.int, device=tensor.device)
        data_int32 = torch.ops.quanto.gptq_marlin_repack(b_q_weight=data_int32, perm=perm, size_k=in_features, size_n=out_features, num_bits=8)
        return cls(data_int32, size=tensor.size(), stride=tensor.stride())

    def unpack(self) -> torch.Tensor:
        float8_data = unpack_int32_to_fp8(self._data)
        uint8_data = float8_data.view(torch.uint8)
        (n_rows, n_col) = uint8_data.shape
        column_map = get_column_permutation(n_col=n_col)
        uint8_data = uint8_data.T.contiguous()
        uint8_data = uint8_data[column_map]
        uint8_data = uint8_data.T.contiguous()
        uint8_data = uint8_data.reshape(uint8_data.shape[0] * 4, -1)
        row_map = get_row_permutation(n_rows=n_rows)
        uint8_data = uint8_data[row_map]
        float8_data = uint8_data.view(torch.float8_e4m3fn)
        float8_data = float8_data.T
        return float8_data

    @property
    def dtype(self):
        return torch.int32

    def __tensor_flatten__(self):
        inner_tensors = ['_data']
        meta = {'size': str(list(self.size())), 'stride': str(self.stride())}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 1
        assert len(meta) == 2
        data = inner_tensors['_data']
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        return MarlinF8PackedTensor(data, size, stride)
    __torch_function__ = torch._C._disabled_torch_function_impl

    @classmethod
    def __torch_dispatch__(cls, op, types, args, kwargs=None):
        if op.overloadpacket is torch.ops.aten.detach:
            t = args[0]
            data = op(t._data)
            return cls(data, t.size(), t.stride())
        elif op.overloadpacket in (torch.ops.aten._to_copy, torch.ops.aten.to):
            t = args[0]
            dtype = kwargs.get('dtype', torch.uint8)
            if dtype != torch.float8_e4m3fn:
                raise ValueError(f'MarlinF8PackedTensor are torch.int32 only and cannot be moved to {dtype}.')
            device = kwargs.get('device', t.device)
            if device.type == 'cuda':
                data_kwargs = copy(kwargs)
                data_kwargs['dtype'] = t._data.dtype
                data = op(t._data, **data_kwargs)
                return cls(data, t.size(), t.stride())
        else:
            (args, kwargs) = pytree.tree_map_only(cls, lambda x: x.unpack(), (args, kwargs or {}))
            return op(*args, **kwargs)

# File: optimum-quanto-main/optimum/quanto/tensor/weights/qbytes.py
import ast
from typing import Optional
import torch
from torch.autograd import Function
from ..function import QuantizedLinearFunction
from ..qbytes import QBytesTensor
from ..qtensor import qfallback
from ..qtype import qtype, qtypes
__all__ = ['WeightQBytesTensor']

class WeightQBytesQuantizer(Function):

    @staticmethod
    def forward(ctx, base: torch.Tensor, qtype: qtype, axis: int, scale: torch.Tensor, activation_qtype: Optional[qtype]) -> torch.Tensor:
        if qtype.bits != 8:
            raise ValueError('QBytesTensor can only be of 8-bit qtype')
        data = torch.ops.quanto.quantize_symmetric(base, dtype=qtype.dtype, axis=axis, scale=scale)
        return WeightQBytesTensor.create(qtype, axis, size=base.size(), stride=base.stride(), data=data, scale=scale, activation_qtype=activation_qtype)

    @staticmethod
    def backward(ctx, gO):
        return (gO, None, None, None, None, None)

class WeightQBytesLinearFunction(QuantizedLinearFunction):

    @staticmethod
    def forward(ctx, input, other, bias=None):
        ctx.save_for_backward(input, other)
        if isinstance(input, QBytesTensor):
            output = torch.ops.quanto.qbytes_mm(input._data, other._data, input._scale * other._scale)
        else:
            output = torch.ops.quanto.qbytes_mm(input, other._data, other._scale)
        if bias is not None:
            output = output + bias
        return output

class WeightQBytesTensor(QBytesTensor):

    @staticmethod
    def create(qtype, axis, size, stride, data, scale, activation_qtype: Optional[qtype]=None, requires_grad=False):
        from .marlin import MarlinF8QBytesTensor
        if qtype == qtypes['qfloat8_e4m3fn'] and activation_qtype is None and (scale.dtype in [torch.float16, torch.bfloat16]) and (len(size) == 2) and (data.device.type == 'cuda') and (axis == 0) and (torch.cuda.get_device_capability(data.device)[0] >= 8):
            if data.dtype == torch.int32 or (data.shape[0] % 64 == 0 and data.shape[1] % 16 == 0):
                return MarlinF8QBytesTensor(qtype, axis, size, stride, data, scale, requires_grad)
        return WeightQBytesTensor(qtype, axis, size, stride, data, scale, activation_qtype, requires_grad)

    @staticmethod
    def __new__(cls, qtype, axis, size, stride, data, scale, activation_qtype, requires_grad=False):
        assert data.device == scale.device
        return torch.Tensor._make_wrapper_subclass(cls, size, strides=stride, dtype=scale.dtype, device=data.device, requires_grad=requires_grad)

    def __init__(self, qtype, axis, size, stride, data, scale, activation_qtype, requires_grad=False):
        super().__init__(qtype, axis, size, stride, data, scale, requires_grad=requires_grad)
        self.activation_qtype = activation_qtype

    @classmethod
    def quantize(cls, base: torch.Tensor, qtype: qtype, axis: int, scale: torch.Tensor, activation_qtype: Optional[qtype]=None) -> torch.Tensor:
        return WeightQBytesQuantizer.apply(base, qtype, axis, scale, activation_qtype)

    @staticmethod
    def load_from_state_dict(state_dict, prefix, qtype, axis, size, stride, activation_qtype, missing_keys):
        inner_tensors_dict = {}
        missing = False
        for name in ['_data', '_scale']:
            if prefix + name not in state_dict:
                missing_keys.append(prefix + name)
                missing = True
            else:
                inner_tensors_dict[name] = state_dict.pop(prefix + name)
        if missing:
            return None
        meta = {'qtype': qtype.name, 'axis': str(axis), 'size': str(list(size)), 'stride': str(list(stride)), 'activation_qtype': 'none' if activation_qtype is None else activation_qtype.name}
        return WeightQBytesTensor.__tensor_unflatten__(inner_tensors_dict, meta, None, None)

    def optimize(self):
        if type(self) is not WeightQBytesTensor:
            return self
        return WeightQBytesTensor.create(self.qtype, self.axis, self.size(), self.stride(), self._data, self._scale, self.activation_qtype, self.requires_grad)

    def save_to_state_dict(self, destination, prefix, keep_vars):
        if type(self) is WeightQBytesTensor:
            super().save_to_state_dict(destination, prefix, keep_vars)
        else:
            self.weight_qbytes_tensor().save_to_state_dict(destination, prefix, keep_vars)

    def weight_qbytes_tensor(self):
        raise NotImplementedError

    def __tensor_flatten__(self):
        inner_tensors = ['_data', '_scale']
        meta = {'qtype': self._qtype.name, 'axis': str(self._axis), 'size': str(list(self.size())), 'stride': str(list(self.stride())), 'activation_qtype': 'none' if self.activation_qtype is None else self.activation_qtype.name}
        return (inner_tensors, meta)

    @staticmethod
    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
        assert len(inner_tensors) == 2
        assert len(meta) == 5
        (data, scale) = (inner_tensors['_data'], inner_tensors['_scale'])
        qtype = qtypes[meta['qtype']]
        axis = ast.literal_eval(meta['axis'])
        size = ast.literal_eval(meta['size'])
        stride = ast.literal_eval(meta['stride'])
        activation_qtype = None if meta['activation_qtype'] == 'none' else qtypes[meta['activation_qtype']]
        return WeightQBytesTensor(qtype, axis, size, stride, data, scale, activation_qtype)

    @classmethod
    def __torch_function__(cls, func, types, args=(), kwargs=None):
        kwargs = kwargs or {}
        if func is torch.nn.functional.linear:

            def qlinear(input, other, bias=None):
                return WeightQBytesLinearFunction.apply(input, other, bias)
            return qlinear(*args, **kwargs)
        elif func is torch.equal:
            (input, other) = args
            return input.equal(other)
        with torch._C.DisableTorchFunctionSubclass():
            return func(*args, **kwargs)

    @classmethod
    def __torch_dispatch__(cls, op, types, args, kwargs=None):
        op = op.overloadpacket
        if op is torch.ops.aten.detach:
            t = args[0]
            (inner_tensor_names, meta) = t.__tensor_flatten__()
            detached_tensors = {}
            for inner_name in inner_tensor_names:
                detached_tensors[inner_name] = op(getattr(t, inner_name))
            return cls.__tensor_unflatten__(detached_tensors, meta, t.size(), t.stride())
        elif op in [torch.ops.aten._to_copy, torch.ops.aten.to]:
            t = args[0]
            dtype = kwargs.pop('dtype', t.dtype)
            device = kwargs.pop('device', t.device)
            if dtype != t.dtype:
                raise ValueError('The dtype of a weights Tensor cannot be changed')
            if type(t) is not WeightQBytesTensor and t.device.type != device.type:
                t = t.weight_qbytes_tensor()
            out_data = op(t._data, device=device, **kwargs)
            out_scale = op(t._scale, device=device, **kwargs)
            return WeightQBytesTensor.create(t.qtype, t.axis, t.size(), t.stride(), out_data, out_scale, activation_qtype=t.activation_qtype, requires_grad=t.requires_grad)
        elif op is torch.ops.aten.t and cls is WeightQBytesTensor:
            t = args[0]
            out_data = op(t._data)
            out_scale = t._scale
            out_axis = t.axis
            (dim0, dim1) = t.size()
            out_size = torch.Size([dim1, dim0])
            out_stride = t.stride()[::-1]
            if t.axis is not None:
                out_scale = op(out_scale)
                out_axis = 0 if out_axis == -1 else -1
            return WeightQBytesTensor(t.qtype, out_axis, out_size, out_stride, out_data, out_scale, t.activation_qtype)
        kwargs = kwargs or {}
        return qfallback(op, *args, **kwargs)

# File: optimum-quanto-main/optimum/quanto/tensor/weights/quantization.py
from typing import Optional
import torch
from ..optimizers import AbsmaxOptimizer, AffineOptimizer, MaxOptimizer, Optimizer, SymmetricOptimizer
from ..qbits import QBitsTensor
from ..qtype import qtype
from .qbytes import WeightQBytesTensor
__all__ = ['quantize_weight']
default_affine_optimizer = MaxOptimizer()
default_symmetric_optimizer = AbsmaxOptimizer()

def quantize_weight(t: torch.Tensor, qtype: qtype, axis: int, group_size: Optional[int]=None, optimizer: Optional[Optimizer]=None, zeropoint: bool=False, activation_qtype: Optional[qtype]=None):
    if axis not in (0, -1):
        raise ValueError('axis parameter must be 0 (first axis) or -1 (last axis)')
    if qtype.bits == 8:
        if optimizer is None:
            optimizer = default_symmetric_optimizer
        elif not isinstance(optimizer, SymmetricOptimizer):
            raise ValueError('A SymmetricOptimizer is expected')
        if group_size is not None:
            raise ValueError('group_size cannot be specified for 8-bit qtypes.')
        if axis is not None and t.shape[axis] == 1:
            axis = None
        scale = optimizer(t, qtype.qmax, axis)
        return WeightQBytesTensor.quantize(t, qtype, axis, scale, activation_qtype)
    if optimizer is None:
        optimizer = default_affine_optimizer
    elif not isinstance(optimizer, AffineOptimizer):
        raise ValueError('An AffineOptimizer is expected')
    (scale, shift) = optimizer(t, qtype.bits, axis, group_size)
    if zeropoint:
        shift = torch.clamp(torch.round(shift / scale), 0, 2 ** qtype.bits - 1).to(torch.uint8)
    return QBitsTensor.quantize(t, qtype, axis, group_size, scale, shift)