Refactoring: quantization progress logs with ETA (#15)

* refactoring : QuantizationProgressTracker

* update CHANGELOG.md

---------

Co-authored-by: FKKimura <50981196+FKKimura@users.noreply.github.com>

Author: aki916f

CHANGELOG.md

@@ -1,15 +1,24 @@
 # Change log
 
-## [v1.1.1] 2026-05-07
+## [v1.1.1] 2026-05-19
 
-## Bug Fixes
+### New Feature: Quantization progress logging
+
+- Added `QuantizationProgressTracker` (`onecomp/utils/quantization_progress.py`) that emits a single `[progress]` INFO line per completed step with done/total, percentage, elapsed time, and a linear ETA estimate; supports an optional `thread_safe=True` mode for multi-GPU quantization
+- Added `report_progress: bool = True` flag to `Runner.__init__` (`onecomp/runner.py`) and to the underlying entry points `run_chunked_quantization` (`onecomp/runner_methods/chunked_quantization.py`), `run_multi_gpu_quantization` / `run_quantization_phase` (`onecomp/runner_methods/multi_gpu_quantization.py`), `run_quantize_with_qep` (`onecomp/qep/_quantize_with_qep.py`), and `run_quantize_with_qep_arch` (`onecomp/qep/_quantize_with_qep_arch.py`) so long quantization runs (calibration, chunked, multi-GPU, QEP) report progress by default; pass `report_progress=False` for quiet runs
+
+### Bug Fixes
 
 - Raise a clear error when ``Runner`` is configured with ``qep=True`` and a quantizer that does not support QEP (currently `JointQ`). Previously the run failed deep inside `quantize_with_qep` / `adjust_weight` with a confusing low-level error. `Runner.check()` now reports e.g. "Quantizer 'JointQ' (or one of its candidate quantizers) does not support QEP (Quantization Error Propagation). Set qep=False, or use a QEP-compatible quantizer (e.g., GPTQ, DBF, AutoBitQuantizer with QEP-compatible candidates)." Implementation: added `flag_qep_supported` (default `True`) on `Quantizer`, set to `False` on `JointQ`, and propagated via `AutoBitQuantizer._sync_flags` (only `True` when *all* candidate quantizers support QEP).
 
-## Tests
+### Tests
 
 - Added `tests/onecomp/test_runner_check.py` covering the new `qep=True` validation path: JointQ + qep=True raises a clear `ValueError`, while JointQ + qep=False and GPTQ + qep=True both pass `Runner.check()`.
 
+### New Contributors
+
+- [@sotanengel](https://github.com/sotanengel) made their first contribution in [#13](https://github.com/FujitsuResearch/OneCompression/pull/13)
+
 ## [v1.1.0] 2026-04-16
 
 ### Gemma 3 / Gemma 4 & VLM Support

onecomp/qep/_quantize_with_qep.py

@@ -27,6 +27,7 @@
 from onecomp.qep._qep_config import QEPConfig
 from onecomp.quantizer._quantizer import Quantizer
 from onecomp.utils import capture_input_activations
+from onecomp.utils.quantization_progress import QuantizationProgressTracker
 
 logger = getLogger(__name__)
 
@@ -37,7 +38,7 @@ def run_quantize_with_qep(
     qep_config: QEPConfig,
     calibration_config: CalibrationConfig,
     *,
-    quantization_progress: bool = True,
+    report_progress: bool = True,
 ):
     """Run quantization with Quantization Error Propagation (QEP).
 
@@ -53,7 +54,7 @@ def run_quantize_with_qep(
         qep_config (QEPConfig): Configuration for QEP
             (percdamp, perccorr, exclude_layer_keywords).
         calibration_config (CalibrationConfig): Calibration parameters.
-        quantization_progress (bool): When True, log ``[progress]`` with ETA per layer.
+        report_progress (bool): When True, log ``[progress]`` with ETA per layer.
 
     """
     model = model_config.load_model()
@@ -84,10 +85,7 @@ def run_quantize_with_qep(
     logger.info("Quantizing the model using %s", quantizer.name)
 
     progress = None
-    if quantization_progress:
-        # pylint: disable-next=import-outside-toplevel
-        from onecomp.utils.quantization_progress import QuantizationProgressTracker
-
+    if report_progress:
         progress = QuantizationProgressTracker(
             logger,
             len(quantizer.module_to_name),

onecomp/qep/_quantize_with_qep_arch.py

@@ -33,6 +33,7 @@
     move_kwargs_to_device,
     expand_kwargs_batch,
 )
+from onecomp.utils.quantization_progress import QuantizationProgressTracker
 
 logger = getLogger(__name__)
 
@@ -263,7 +264,7 @@ def run_quantize_with_qep_arch(
     qep_config: QEPConfig,
     calibration_config: CalibrationConfig,
     *,
-    quantization_progress: bool = True,
+    report_progress: bool = True,
 ):
     """Run architecture-aware quantization with QEP.
 
@@ -280,7 +281,7 @@ def run_quantize_with_qep_arch(
         qep_config (QEPConfig): Configuration for QEP
             (percdamp, perccorr, exclude_layer_keywords).
         calibration_config (CalibrationConfig): Calibration parameters.
-        quantization_progress (bool): When True, log ``[progress]`` with ETA per target layer.
+        report_progress (bool): When True, log ``[progress]`` with ETA per target layer.
 
     """
 
@@ -321,10 +322,7 @@ def run_quantize_with_qep_arch(
     }
 
     progress = None
-    if quantization_progress:
-        # pylint: disable-next=import-outside-toplevel
-        from onecomp.utils.quantization_progress import QuantizationProgressTracker
-
+    if report_progress:
         progress = QuantizationProgressTracker(
             logger,
             len(remaining_targets),

onecomp/runner.py

@@ -28,6 +28,7 @@
 from .quantizer.autobit import AutoBitQuantizer
 from .utils import calculate_accuracy as calc_accuracy
 from .utils import calculate_perplexity as calc_perplexity
+from .utils.quantization_progress import QuantizationProgressTracker
 from .log import setup_logger
 
 
@@ -86,7 +87,7 @@ def __init__(
         multi_gpu=False,
         gpu_ids=None,
         post_processes=None,
-        quantization_progress=True,
+        report_progress=True,
     ):
         """__init__ method
 
@@ -131,7 +132,7 @@ def __init__(
                 a quantized model on CPU (built via
                 ``create_quantized_model``) and may modify it in-place.
                 Processes are executed in order.  Default is None.
-            quantization_progress (bool):
+            report_progress (bool):
                 When ``True`` (default), emit ``[progress]`` log lines with
                 completed steps, elapsed time, and a linear ETA estimate
                 during long quantization (calibration, chunked, multi-GPU,
@@ -221,7 +222,7 @@ def __init__(
         self.lpcd_config = None
         if lpcd:
             self.lpcd_config = lpcd_config if lpcd_config is not None else LPCDConfig()
-        self.quantization_progress = quantization_progress
+        self.report_progress = report_progress
 
     def check(self):
         """Check the settings
@@ -602,10 +603,7 @@ def quantize_with_calibration(self):
         # Register hooks to all linear layers
         handles = []
         progress = None
-        if self.quantization_progress:
-            # pylint: disable-next=import-outside-toplevel
-            from .utils.quantization_progress import QuantizationProgressTracker
-
+        if self.report_progress:
             progress = QuantizationProgressTracker(
                 logger,
                 len(self.quantizer.module_to_name),
@@ -664,7 +662,7 @@ def quantize_with_calibration_chunked(self):
             model_config=self.model_config,
             quantizers=self.quantizers if self.quantizers is not None else [self.quantizer],
             calibration_config=self.calibration_config,
-            quantization_progress=self.quantization_progress,
+            report_progress=self.report_progress,
         )
 
     def quantize_with_calibration_on_multi_gpu(self):
@@ -693,7 +691,7 @@ def quantize_with_calibration_on_multi_gpu(self):
             quantizer=self.quantizer,
             calibration_config=self.calibration_config,
             gpu_ids=self.gpu_ids,
-            quantization_progress=self.quantization_progress,
+            report_progress=self.report_progress,
         )
 
         # Store results in quantizer.results
@@ -721,10 +719,7 @@ def quantize_without_calibration(self):
             self.quantizer.name,
         )
         progress = None
-        if self.quantization_progress:
-            # pylint: disable-next=import-outside-toplevel
-            from .utils.quantization_progress import QuantizationProgressTracker
-
+        if self.report_progress:
             progress = QuantizationProgressTracker(
                 logger,
                 len(self.quantizer.module_to_name),
@@ -754,7 +749,7 @@ def quantize_with_qep(self):
             quantizer=self.quantizer,
             qep_config=self.qep_config,
             calibration_config=self.calibration_config,
-            quantization_progress=self.quantization_progress,
+            report_progress=self.report_progress,
         )
 
         if self.qep_config.general:

onecomp/runner_methods/chunked_quantization.py

@@ -34,6 +34,7 @@
 from onecomp.calibration import CalibrationConfig, prepare_calibration_dataset
 from onecomp.model_config import ModelConfig
 from onecomp.quantizer._quantizer import Quantizer, QuantizationResult
+from onecomp.utils.quantization_progress import QuantizationProgressTracker
 
 logger = getLogger(__name__)
 
@@ -48,7 +49,7 @@ def run_chunked_quantization(
     quantizers: List[Quantizer],
     calibration_config: CalibrationConfig,
     *,
-    quantization_progress: bool = True,
+    report_progress: bool = True,
 ):
     """Run quantization for large-scale calibration data.
 
@@ -61,7 +62,7 @@ def run_chunked_quantization(
         quantizers (list[Quantizer]): List of quantizers. Each quantizer must have
             flag_hessian=True or flag_xtx=True.
         calibration_config (CalibrationConfig): Calibration parameters.
-        quantization_progress (bool): When True, log ``[progress]`` lines with ETA
+        report_progress (bool): When True, log ``[progress]`` lines with ETA
             for X^T X chunks and per-layer quantization.
 
     Note:
@@ -120,10 +121,7 @@ def run_chunked_quantization(
 
     num_groups = (len(all_layers) + num_layers_per_group - 1) // num_layers_per_group
     layer_progress = None
-    if quantization_progress:
-        # pylint: disable-next=import-outside-toplevel
-        from onecomp.utils.quantization_progress import QuantizationProgressTracker
-
+    if report_progress:
         layer_progress = QuantizationProgressTracker(
             logger,
             len(all_layers) * len(quantizers),
@@ -145,7 +143,7 @@ def run_chunked_quantization(
         )
 
         chunk_progress = None
-        if quantization_progress:
+        if report_progress:
             num_chunks = (total_samples + calibration_batch_size - 1) // calibration_batch_size
             chunk_progress = QuantizationProgressTracker(
                 logger,

onecomp/runner_methods/multi_gpu_quantization.py

@@ -23,6 +23,7 @@
 from onecomp.calibration import CalibrationConfig
 from onecomp.quantizer._quantizer import QuantizationResult
 from onecomp.utils import check_activations
+from onecomp.utils.quantization_progress import QuantizationProgressTracker
 
 logger = getLogger(__name__)
 
@@ -178,7 +179,7 @@ def run_quantization_phase(
     quantizer,
     gpu_ids: List[int],
     *,
-    quantization_progress: bool = True,
+    report_progress: bool = True,
 ) -> Dict[str, Dict]:
     """Phase 2: Parallel quantization using multiple threads.
 
@@ -196,10 +197,7 @@ def run_quantization_phase(
     start_time = time.time()
 
     progress = None
-    if quantization_progress:
-        # pylint: disable-next=import-outside-toplevel
-        from onecomp.utils.quantization_progress import QuantizationProgressTracker
-
+    if report_progress:
         progress = QuantizationProgressTracker(
             logger,
             len(layer_names),
@@ -359,7 +357,7 @@ def run_multi_gpu_quantization(
     calibration_config: CalibrationConfig,
     gpu_ids: Optional[List[int]] = None,
     *,
-    quantization_progress: bool = True,
+    report_progress: bool = True,
 ) -> Dict[str, Any]:
     """Main entry point for multi-GPU quantization.
 
@@ -368,7 +366,7 @@ def run_multi_gpu_quantization(
         quantizer: Quantizer instance.
         calibration_config (CalibrationConfig): Calibration parameters.
         gpu_ids: List of GPU IDs to use (all GPUs if None).
-        quantization_progress: When True, log ``[progress]`` with ETA per completed layer.
+        report_progress: When True, log ``[progress]`` with ETA per completed layer.
 
     Returns:
         Dict containing "results" with quantization results for each layer
@@ -394,7 +392,7 @@ def run_multi_gpu_quantization(
         layer_names=capture_result["layer_names"],
         quantizer=quantizer,
         gpu_ids=gpu_ids,
-        quantization_progress=quantization_progress,
+        report_progress=report_progress,
     )
 
     total_elapsed = time.time() - total_start

onecomp/utils/quantization_progress.py

@@ -68,11 +68,11 @@ def _step_complete_unlocked(self, detail: Optional[str]) -> None:
         done = min(self._done, self._total)
         elapsed = now - self._start
 
-        if done < self._total and done > 0:
+        if done < self._total:
             eta_sec = (elapsed / done) * (self._total - done)
             eta_str = _format_duration(eta_sec)
         else:
-            eta_str = "unknown" if done == 0 else "0s"
+            eta_str = "0s"
 
         pct = 100.0 * done / self._total
         suffix = f" ({detail})" if detail else ""