replace utils.Progressbar with logbar

examples/benchmark/generation_speed.py

@@ -24,11 +24,11 @@
 import torch
 from datasets import Dataset, load_dataset
 from gptqmodel import BACKEND, GPTQModel, QuantizeConfig
-from gptqmodel.utils.progress import ProgressBar
+from logbar import LogBar
 from transformers import AutoTokenizer, GenerationConfig
 from transformers.generation.logits_process import LogitsProcessor
 
-logger = logging.getLogger(__name__)
+logger = LogBar.shared()
 
 random.seed(0)
 
@@ -195,7 +195,7 @@ def load_model_tokenizer(
 def benchmark_generation_speed(model, tokenizer, examples, generation_config):
     generation_time_list = []
     num_generated_tokens_list = []
-    pb = ProgressBar(examples)
+    pb = logger.pb(examples)
     for example in pb:
         input_ids = example["input_ids"].to(model.device)
 

gptqmodel/looper/module_looper.py

@@ -32,12 +32,10 @@
 from ..utils.logger import setup_logger
 from ..utils.model import (find_modules, get_device, get_module, get_module_by_name_prefix,
                            get_moe_layer_modules, move_to, nested_move_to)
-from ..utils.progress import ProgressBar
 from ..utils.torch import torch_empty_cache
 
 logger = setup_logger()
 
-
 class ModuleLooper():
     def __init__(self, model: BaseGPTQModel, processors: List[LoopProcessor]):
         self.processors = processors
@@ -194,7 +192,7 @@ def loop(self, auto_gc=True, calibration_enable_gpu_cache=True, buffered_fwd=Fal
                                                   num_experts=num_experts)
 
         layer_count = len(layers)
-        quant_modules_pb = (ProgressBar(range(layer_count + 1 if self.gptq_model.quantize_config.lm_head else layer_count))
+        quant_modules_pb = (logger.pb(range(layer_count + 1 if self.gptq_model.quantize_config.lm_head else layer_count))
                             .manual()
                             .set(left_steps_offset=1))
 

gptqmodel/models/base.py

@@ -45,7 +45,6 @@
 from ..utils.logger import setup_logger
 from ..utils.model import (MODALITY, check_to_quantized, find_modules, get_device, get_module,
                            get_module_by_name_prefix, get_moe_layer_modules, move_to, nested_move_to, pack_model)
-from ..utils.progress import ProgressBar
 from ..utils.torch import torch_compile, torch_empty_cache
 from ._const import CALIBRATION_DATASET_CONCAT_CHAR, CPU, DEFAULT_MAX_SHARD_SIZE, DEVICE, SUPPORTS_MODULE_TYPES
 from .loader import ModelLoader
@@ -821,7 +820,7 @@ def store_input_hook(_, args, kwargs):
         quantizers = {}
 
         layer_count = len(layers)
-        quant_modules_pb = ProgressBar(range(layer_count + 1 if self.quantize_config.lm_head else layer_count)).manual()
+        quant_modules_pb = logger.pb(range(layer_count + 1 if self.quantize_config.lm_head else layer_count)).manual()
         gpu_memorys = []
         cpu_memorys = []
         durations = []

gptqmodel/nn_modules/qlinear/bitblas.py

@@ -24,11 +24,11 @@
 import torch
 import torch.nn as nn
 
-from ...models._const import DEVICE, PLATFORM
-from ...utils.logger import setup_logger
 from ...adapter.adapter import Adapter, Lora
+from ...models._const import DEVICE, PLATFORM
 from ...nn_modules.qlinear import PackableQuantLinear
 from ...utils import BACKEND
+from ...utils.logger import setup_logger
 
 logger = setup_logger()
 

gptqmodel/nn_modules/qlinear/dynamic_cuda.py

@@ -18,10 +18,10 @@
 
 import torch
 
-from ...utils.backend import BACKEND
-from ...models._const import DEVICE, PLATFORM
 from ...adapter.adapter import Adapter, Lora
+from ...models._const import DEVICE, PLATFORM
 from ...nn_modules.qlinear.torch import TorchQuantLinear
+from ...utils.backend import BACKEND
 from ...utils.logger import setup_logger
 
 logger = setup_logger()

gptqmodel/nn_modules/qlinear/exllama.py

@@ -21,10 +21,10 @@
 
 import torch
 
-from ...utils.backend import BACKEND
 from ...adapter.adapter import Adapter, Lora
 from ...models._const import DEVICE, PLATFORM
 from ...nn_modules.qlinear import BaseQuantLinear
+from ...utils.backend import BACKEND
 
 exllama_import_exception = None
 try:

gptqmodel/nn_modules/qlinear/exllama_eora.py

@@ -20,10 +20,10 @@
 import torch
 from torch.nn import Parameter
 
-from ...models._const import DEVICE, PLATFORM
-from ...utils.logger import setup_logger
 from ...adapter.adapter import Adapter, Lora
+from ...models._const import DEVICE, PLATFORM
 from ...nn_modules.qlinear import BaseQuantLinear
+from ...utils.logger import setup_logger
 
 exllama_v2v_import_exception = None
 

gptqmodel/nn_modules/qlinear/exllamav2.py

@@ -20,10 +20,10 @@
 
 import torch
 
-from ...utils.backend import BACKEND
 from ...adapter.adapter import Adapter, Lora
 from ...models._const import DEVICE, PLATFORM
 from ...nn_modules.qlinear import BaseQuantLinear
+from ...utils.backend import BACKEND
 from ...utils.logger import setup_logger
 
 exllama_v2_import_exception = None

gptqmodel/nn_modules/qlinear/ipex.py

@@ -18,11 +18,11 @@
 
 import torch
 
+from ...adapter.adapter import Adapter, Lora
+from ...models._const import DEVICE, PLATFORM
 from ...utils.backend import BACKEND
 from ...utils.logger import setup_logger
 from ...utils.torch import torch_compile
-from ...adapter.adapter import Adapter, Lora
-from ...models._const import DEVICE, PLATFORM
 from . import PackableQuantLinear
 
 logger = setup_logger()

gptqmodel/nn_modules/qlinear/marlin.py

@@ -23,12 +23,12 @@
 import torch
 from torch.nn.parameter import Parameter
 
-from ...models._const import DEVICE, PLATFORM
-from ...utils.logger import setup_logger
-from ...utils.rocm import IS_ROCM
 from ...adapter.adapter import Adapter, Lora
+from ...models._const import DEVICE, PLATFORM
 from ...nn_modules.qlinear import BaseQuantLinear
 from ...utils.backend import BACKEND
+from ...utils.logger import setup_logger
+from ...utils.rocm import IS_ROCM
 
 marlin_import_exception = None
 try:

gptqmodel/nn_modules/qlinear/torch.py

@@ -19,12 +19,12 @@
 import torch.nn as nn
 from transformers import PreTrainedModel
 
-from ...utils.backend import BACKEND
-from ...models._const import DEVICE, PLATFORM
-from ...utils.torch import torch_compile
 from ...adapter.adapter import Adapter, Lora
+from ...models._const import DEVICE, PLATFORM
 from ...nn_modules.qlinear import BaseQuantLinear, PackableQuantLinear
+from ...utils.backend import BACKEND
 from ...utils.logger import setup_logger
+from ...utils.torch import torch_compile
 
 logger = setup_logger()
 

gptqmodel/nn_modules/qlinear/tritonv2.py

@@ -19,10 +19,10 @@
 import torch
 from packaging import version
 
-from ...utils.backend import BACKEND
+from ...adapter.adapter import Adapter, Lora
 from ...models._const import DEVICE, PLATFORM
+from ...utils.backend import BACKEND
 from ...utils.logger import setup_logger
-from ...adapter.adapter import Adapter, Lora
 from . import PackableQuantLinear
 
 try:

gptqmodel/utils/bitblas.py

@@ -23,7 +23,6 @@
 from ..quantization import FORMAT, QuantizeConfig
 from ..utils.logger import setup_logger
 from .model import load_checkpoint_in_model_then_tie_weights
-from .progress import ProgressBar
 from .torch import torch_empty_cache
 
 logger = setup_logger()
@@ -92,7 +91,7 @@ def convert_to_bitblas(model, model_quantlinear, qcfg: QuantizeConfig, sym: bool
 
         # Note that due to tvm compilation of per layer modules shapes, the first layer loop is
         # relatively much slower if caching is not available. estimate time remaining is highly inaccurate
-        for name, module in ProgressBar(list(model.named_modules())).title(message):
+        for name, module in logger.pb(list(model.named_modules())).title(message):
             if not isinstance(module, model_quantlinear):
                 continue