text stringlengths 1 93.6k |
|---|
import time
|
import os
|
import logging
|
import random
|
from datasets import load_dataset
|
class QuantAutoGPTQ:
|
def __init__(self, model_name_or_path, output_dir, dataset,
|
num_samples=128, trust_remote_code=False, cache_examples=True,
|
use_fast=True, use_triton=False, bits=[4], group_size=[128], damp=[0.01],
|
desc_act=[False], dtype='float16', seqlen=2048, batch_size=1, stop_file=None,
|
make_folder=False, GPU=0, cuda_alloc_conf=None):
|
# Limit visible GPU to the one specified
|
# We don't currently support multi-GPU, as AutoGPTQ can't use more than one GPU for quant anyway.
|
#os.environ["CUDA_VISIBLE_DEVICES"] = str(GPU)
|
# Allow specifying CUDA allocation config, eg PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:32
|
# This can allow for quantising larger models without running out of VRAM
|
#if cuda_alloc_conf is not None:
|
# os.environ["PYTORCH_CUDA_ALLOC_CONF"] = cuda_alloc_conf
|
self.pretrained_model_dir = model_name_or_path
|
self.output_dir_base = output_dir
|
self.dataset = dataset
|
self.num_samples = num_samples
|
self.trust_remote_code = trust_remote_code
|
self.cache_examples = cache_examples
|
self.use_fast = use_fast
|
self.use_triton = use_triton
|
def check_list(item):
|
return item if isinstance(item, list) else [item]
|
self.bits = check_list(bits)
|
self.group_size = check_list(group_size)
|
self.desc_act = check_list(desc_act)
|
self.damp = check_list(damp)
|
self.dtype = dtype
|
self.seqlen = seqlen
|
self.batch_size = batch_size
|
self.stop_file = stop_file
|
self.make_folder = make_folder
|
self.logger = logging.getLogger(__name__)
|
self.logger.propagate = True
|
from transformers import AutoTokenizer
|
self.logger.info("Loading tokenizer")
|
self.tokenizer = AutoTokenizer.from_pretrained(self.pretrained_model_dir,
|
use_fast=self.use_fast,
|
trust_remote_code=self.trust_remote_code)
|
@staticmethod
|
def append_dataset(tokenized, num_samples, seqlen):
|
import numpy as np
|
import torch
|
random.seed(0)
|
np.random.seed(0)
|
torch.random.manual_seed(0)
|
traindataset = []
|
for _ in range(num_samples):
|
i = random.randint(0, tokenized.input_ids.shape[1] - seqlen - 1)
|
j = i + seqlen
|
inp = tokenized.input_ids[:, i:j]
|
attention_mask = torch.ones_like(inp)
|
traindataset.append({'input_ids':inp,'attention_mask': attention_mask})
|
return traindataset
|
#TODO: make a generic method that can load a dataset from HF hub and be told what column(s) to use
|
def get_math(self):
|
data = load_dataset('andersonbcdefg/math', split='train')
|
extract = data[0:2000]
|
text = ''
|
for input, output in zip(extract['message_1'], extract['message_2']):
|
text += input + ': ' + output + '\n'
|
self.logger.info("Tokenising Maths dataset")
|
tokenized = self.tokenizer(text, return_tensors='pt')
|
return self.append_dataset(tokenized, self.num_samples, self.seqlen)
|
def get_medical(self):
|
data = load_dataset('medalpaca/medical_meadow_wikidoc', split='train')
|
extract = data[0:1000]
|
text = ''
|
for input, output in zip(extract['input'], extract['output']):
|
text += input + ' ' + output + '\n'
|
self.logger.info("Tokenising Medical dataset")
|
tokenized = self.tokenizer(text, return_tensors='pt')
|
return self.append_dataset(tokenized, self.num_samples, self.seqlen)
|
def get_code(self):
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.