PyPI - mct-nightly - Versions diffs - 2.0.0.20240410.422__tar.gz → 2.0.0.20240411.406__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.0.0.20240410.422
+Version: 2.0.0.20240411.406
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.0.0.20240410.422
+Version: 2.0.0.20240411.406
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
-__version__ = "2.0.0.20240410.000422"
+__version__ = "2.0.0.20240411.000406"

@@ -42,14 +42,14 @@ def calculate_quantization_params(graph: Graph,
     """
-    Logger.info(f"Running quantization parameters search. "
+    Logger.info(f"\nRunning quantization parameters search. "
                 f"This process might take some time, "
                 f"depending on the model size and the selected quantization methods.\n")
     # Create a list of nodes to compute their thresholds
     nodes_list: List[BaseNode] = nodes if specific_nodes else graph.nodes()
-    for n in tqdm(nodes_list, "Calculating quantization params"):  # iterate only nodes that we should compute their thresholds
+    for n in tqdm(nodes_list, "Calculating quantization parameters"):  # iterate only nodes that we should compute their thresholds
         for candidate_qc in n.candidates_quantization_cfg:
             for attr in n.get_node_weights_attributes():
                 if n.is_weights_quantization_enabled(attr):

@@ -90,7 +90,7 @@ if FOUND_TF:
                                                                                         fw_impl=C.keras.keras_implementation.KerasImplementation())).build_model()
         exportable_model.trainable = False
-        Logger.info("Please run your accuracy evaluation on the exported quantized model to verify it's accuracy.\n"
+        Logger.info("\nPlease run your accuracy evaluation on the exported quantized model to verify it's accuracy.\n"
                     "Checkout the FAQ and Troubleshooting pages for resolving common issues and improving the quantized model accuracy:\n"
                     "FAQ: https://github.com/sony/model_optimization/tree/main/FAQ.md\n"
                     "Quantization Troubleshooting: https://github.com/sony/model_optimization/tree/main/quantization_troubleshooting.md")

@@ -301,21 +301,23 @@ class KerasGPTQTrainer(GPTQTrainer):
         Returns: None
         """
-        for _ in tqdm(range(n_epochs)):
-            for data in tqdm(data_function()):
-                input_data = [d * self.input_scale for d in data]
-                loss_value_step, grads = self.nano_training_step(input_data, in_compute_gradients,
-                                                                 in_optimizer_with_param, is_training)
-                # Run one step of gradient descent by updating
-                # the value of the variables to minimize the loss.
-                for i, (o, p) in enumerate(in_optimizer_with_param):
-                    o.apply_gradients(zip(grads[i], p))
-                if self.gptq_config.log_function is not None:
-                    self.gptq_config.log_function(loss_value_step, grads[0], in_optimizer_with_param[0][-1],
-                                                  self.compare_points)
-                self.loss_list.append(loss_value_step.numpy())
-                Logger.debug(f'last loss value: {self.loss_list[-1]}')
+        with tqdm(range(n_epochs), "Running GPTQ optimization") as epochs_pbar:
+            for _ in epochs_pbar:
+                with tqdm(data_function(), position=1, leave=False) as data_pbar:
+                    for data in data_pbar:
+                        input_data = [d * self.input_scale for d in data]
+                        loss_value_step, grads = self.nano_training_step(input_data, in_compute_gradients,
+                                                                         in_optimizer_with_param, is_training)
+                        # Run one step of gradient descent by updating
+                        # the value of the variables to minimize the loss.
+                        for i, (o, p) in enumerate(in_optimizer_with_param):
+                            o.apply_gradients(zip(grads[i], p))
+                        if self.gptq_config.log_function is not None:
+                            self.gptq_config.log_function(loss_value_step, grads[0], in_optimizer_with_param[0][-1],
+                                                          self.compare_points)
+                        self.loss_list.append(loss_value_step.numpy())
+                        Logger.debug(f'last loss value: {self.loss_list[-1]}')
     def update_graph(self):
         """

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
+from tqdm import tqdm
 from typing import Callable
 from model_compression_toolkit.gptq import RoundingType, GradientPTQConfig, GradientPTQConfig
@@ -35,7 +36,7 @@ def get_regularization(gptq_config: GradientPTQConfig, representative_data_gen:
     if gptq_config.rounding_type == RoundingType.SoftQuantizer:
         # dry run on the representative dataset to count number of batches
         num_batches = 0
-        for _ in representative_data_gen():
+        for _ in tqdm(representative_data_gen(), "GPTQ initialization"):
             num_batches += 1
         return SoftQuantizerRegularization(total_gradient_steps=num_batches * gptq_config.n_epochs)

@@ -248,22 +248,24 @@ class PytorchGPTQTrainer(GPTQTrainer):
             data_function: A callable function that give a batch of samples.
             n_epochs: Number of update iterations of representative dataset.
         """
-        for _ in tqdm(range(n_epochs)):
-            for data in tqdm(data_function()):
-                input_data = [d * self.input_scale for d in data]
-                input_tensor = to_torch_tensor(input_data)
-                y_float = self.float_model(input_tensor)  # running float model
-                loss_value, grads = self.compute_gradients(y_float, input_tensor)
-                # Run one step of gradient descent by updating the value of the variables to minimize the loss.
-                for (optimizer, _) in self.optimizer_with_param:
-                    optimizer.step()
-                    optimizer.zero_grad()
-                if self.gptq_config.log_function is not None:
-                    self.gptq_config.log_function(loss_value.item(),
-                                                  torch_tensor_to_numpy(grads),
-                                                  torch_tensor_to_numpy(self.optimizer_with_param[0][-1]))
-                self.loss_list.append(loss_value.item())
-                Logger.debug(f'last loss value: {self.loss_list[-1]}')
+        with tqdm(range(n_epochs), "Running GPTQ optimization") as epochs_pbar:
+            for _ in epochs_pbar:
+                with tqdm(data_function(), position=1, leave=False) as data_pbar:
+                    for data in data_pbar:
+                        input_data = [d * self.input_scale for d in data]
+                        input_tensor = to_torch_tensor(input_data)
+                        y_float = self.float_model(input_tensor)  # running float model
+                        loss_value, grads = self.compute_gradients(y_float, input_tensor)
+                        # Run one step of gradient descent by updating the value of the variables to minimize the loss.
+                        for (optimizer, _) in self.optimizer_with_param:
+                            optimizer.step()
+                            optimizer.zero_grad()
+                        if self.gptq_config.log_function is not None:
+                            self.gptq_config.log_function(loss_value.item(),
+                                                          torch_tensor_to_numpy(grads),
+                                                          torch_tensor_to_numpy(self.optimizer_with_param[0][-1]))
+                        self.loss_list.append(loss_value.item())
+                        Logger.debug(f'last loss value: {self.loss_list[-1]}')
     def update_graph(self) -> Graph:
         """

mct-nightly 2.0.0.20240410.422__tar.gz → 2.0.0.20240411.406__tar.gz

mct-nightly 2.0.0.20240410.422tar.gz → 2.0.0.20240411.406tar.gz