spellcheck (#3318)

### Changes

Fix grammar

Author: AlexanderDokuchaev

docs/usage/training_time_compression/quantization_aware_training/Usage.md

@@ -74,7 +74,7 @@ ov_quantized_model = ov.convert_model(stripped_model)
 <details open><summary><b>PyTorch</b></summary>
 
 The complete information about compression is defined by a compressed model and a NNCF config.
-The model characterizes the weights and topology of the network. The NNCF config - how to restore additional modules intoduced by NNCF.
+The model characterizes the weights and topology of the network. The NNCF config - how to restore additional modules introduced by NNCF.
 The NNCF config can be obtained by `quantized_model.nncf.get_config()` on saving and passed to the
 `nncf.torch.load_from_config` helper function to load additional modules from the given NNCF config.
 The quantized model saving allows to load quantized modules to the target model in a new python process and

examples/post_training_quantization/openvino/anomaly_stfpm_quantize_with_accuracy_control/README.md

@@ -29,7 +29,7 @@ pip install -r requirements.txt
 
 It's pretty simple. The example does not require additional preparation. It will do the preparation itself, such as loading the dataset and model, etc.
 
-The maximum accuracy drop you can pass as a command line argument. F1 score is calculted in range [0,1] for STFPM. Thus if you want to specify the maximum accuracy drop between the quantized and pre-trained model of 0.5% you must specify 0.005 as a command line argument:
+The maximum accuracy drop you can pass as a command line argument. F1 score is calculated in range [0,1] for STFPM. Thus if you want to specify the maximum accuracy drop between the quantized and pre-trained model of 0.5% you must specify 0.005 as a command line argument:
 
 ```bash
 python main.py 0.005

examples/post_training_quantization/openvino/yolov8/README.md

@@ -26,7 +26,7 @@ pip install -r requirements.txt
 
 ## Run Example
 
-The example is fully automated. Just run the following comman in the prepared Python environment:
+The example is fully automated. Just run the following command in the prepared Python environment:
 
 ```bash
 python main.py

nncf/common/graph/graph_matching.py

@@ -92,13 +92,13 @@ def _is_subgraph_matching_strict(graph: nx.DiGraph, pattern: nx.DiGraph, subgrap
         predecessors_keys = graph.pred[node_from_graph].keys()
         successor_keys = graph.succ[node_from_graph].keys()
         has_external_successors = any(successor_key not in subgraph for successor_key in successor_keys)
-        has_external_predcessors = any(predecessor_key not in subgraph for predecessor_key in predecessors_keys)
+        has_external_predecessors = any(predecessor_key not in subgraph for predecessor_key in predecessors_keys)
         if node_from_pattern in starting_nodes and has_external_successors:
             return False
-        if node_from_pattern in last_nodes and has_external_predcessors:
+        if node_from_pattern in last_nodes and has_external_predecessors:
             return False
         if (node_from_pattern not in last_nodes and node_from_pattern not in starting_nodes) and (
-            has_external_successors or has_external_predcessors
+            has_external_successors or has_external_predecessors
         ):
             return False
     return True

nncf/common/graph/utils.py

@@ -203,7 +203,7 @@ def get_bias_shape_legacy(layer_attributes: WeightedLayerAttributes) -> int:
 
 def get_num_filters_legacy(layer_attributes: WeightedLayerAttributes) -> int:
     """
-    Returns hard-coded number of filters for the given layer attribues.
+    Returns hard-coded number of filters for the given layer attributes.
     Applicable only for eager PyTorch and Tensorflow models.
 
     :param layer_attributes: Layer attributes of a NNCFNode.

nncf/common/insertion_point_graph.py

@@ -314,9 +314,9 @@ def get_ip_graph_with_merged_hw_optimized_operations(
         single node; the resulting InsertionPointGraph no longer has accessible the pre- and post-hooks that were
         located in  the middle of the fused pattern.
         If the InsertionPointGraph should be filtered from constant nodes before the node fusing,
-        then 'known_non_constant_node_keys' should be pass. This is the list of the node known that are non constansts.
+        then 'known_non_constant_node_keys' should be pass. This is the list of the node known that are non constants.
 
-        :param full_fusing_pattern: The GraphPatttern object representing a composition of fusing pattern variants.
+        :param full_fusing_pattern: The GraphPattern object representing a composition of fusing pattern variants.
         :return: The InsertionPointGraph with nodes fused according to pattern matching.
         """
         merged_ip_graph = deepcopy(self)

nncf/common/pruning/shape_pruning_processor.py

@@ -184,7 +184,7 @@ def get_next_nodes(
         :param pruning_groups: `Clusterization` of pruning groups.
         :return Dictionary of next nodes by cluster {cluster_id: [node]}.
         """
-        # 1. Propagate symbolic masks throught the net
+        # 1. Propagate symbolic masks through the net
         for pruned_layer_info in pruning_groups.get_all_nodes():
             node = graph.get_node_by_id(pruned_layer_info.nncf_node_id)
             node.attributes["output_mask"] = SymbolicMask(get_output_channels(node), node.node_id)

nncf/common/pruning/symbolic_mask.py

@@ -18,7 +18,7 @@
 
 class SymbolicMaskProducer:
     """
-    Container of information about a NNCFNode which is produsing a symbolic mask.
+    Container of information about a NNCFNode which is producing a symbolic mask.
     NNCFNode produced a (symbolic or not) mask means this mask was set as an output
     mask to this NNCFNode during (symbolic or not) mask propagation.
     """
@@ -152,7 +152,7 @@ def split(cls, tensor: SymbolicMask, output_shapes: List[int]) -> List[SymbolicM
         if any(shape <= 0 for shape in output_shapes) or tensor.shape[0] != sum(output_shapes):
             msg = (
                 "Symbolic mask split was called with"
-                f"invalid parammeters: input mask shape: {tensor.shape[0]}, output masks shapes: {output_shapes}"
+                f"invalid parameters: input mask shape: {tensor.shape[0]}, output masks shapes: {output_shapes}"
             )
             raise AssertionError(msg)
 

nncf/common/pruning/tensor_processor.py

@@ -56,11 +56,11 @@ def assert_allclose(cls, tensors: List[NNCFTensor]) -> None:
     @abstractmethod
     def repeat(cls, tensor: NNCFTensor, repeats: int) -> NNCFTensor:
         """
-        Successively repeat each element of given NNCFTesnor.
+        Successively repeat each element of given NNCFTensor.
 
         :param tensor: Given NNCFTensor.
         :param repeats: The number of repetitions for each element.
-        :return: NNCFTensor with repited elements.
+        :return: NNCFTensor with repeated elements.
         """
 
     @classmethod
@@ -78,7 +78,7 @@ def elementwise_mask_propagation(cls, input_masks: List[NNCFTensor]) -> NNCFTens
     @abstractmethod
     def split(cls, tensor: NNCFTensor, output_shapes: List[int]) -> List[NNCFTensor]:
         """
-        Split/chunk NNCFTensor into chunks along an exsiting dimension.
+        Split/chunk NNCFTensor into chunks along an existing dimension.
 
         :param tensor: Given NNCFTensor.
         :param output_shapes: Given shapes of the output masks

nncf/common/pruning/weights_flops_calculator.py

@@ -69,10 +69,10 @@ def count_flops_and_weights(
         :return number of FLOPs for the model
                 number of weights (params) in the model
         """
-        flops_pers_node, weights_per_node = self.count_flops_and_weights_per_node(
+        flops_per_node, weights_per_node = self.count_flops_and_weights_per_node(
             graph, output_shapes, input_channels, output_channels, kernel_sizes, op_addresses_to_skip
         )
-        return sum(flops_pers_node.values()), sum(weights_per_node.values())
+        return sum(flops_per_node.values()), sum(weights_per_node.values())
 
     def count_flops_and_weights_per_node(
         self,

nncf/common/tensor_statistics/statistic_point.py

@@ -21,7 +21,7 @@ class StatisticPoint:
     StatisticPoint stores information is necessary for statistics collection process:
     target_point from which statistics is collected: node_name and target_type determines the node edge.
     tensor_collector determines how to aggregate statistics in target_point
-    algorithm implies on what algorithm nedeed this statistics.
+    algorithm implies on what algorithm needed this statistics.
     """
 
     def __init__(self, target_point: TargetPoint, tensor_collector: TensorCollector, algorithm: str):

nncf/common/utils/patcher.py

@@ -36,7 +36,7 @@ def patch(  # noqa: C901
     ) -> None:
         """
         Apply patching
-        :param obj_cls: Function to be overriden.
+        :param obj_cls: Function to be overridden.
         :param wrapper: Wrapper function to override with.
         :param force: Whether to override previously applied patches or not.
         """

nncf/experimental/quantization/algorithms/range_estimator/algorithm.py

@@ -38,7 +38,7 @@ def __init__(
             for the given model.
         :param subset_size: Size of a subset to calculate activations statistics used
             for quantization, defaults to 300.
-        :param inplace_statistics: Defines wheather to calculate quantizers statistics
+        :param inplace_statistics: Defines whether to calculate quantizers statistics
             by backend graph operations or by default Python implementation, defaults
             to True.
         :param batchwise_statistics: Determines whether quantizer statistics should be calculated

nncf/experimental/tensorflow/context.py

@@ -51,7 +51,7 @@ def __init__(self, in_call: bool = False, wrap_ops: bool = False, model: Optiona
 
         if model is None and in_call:
             msg = (
-                f"Inconsisten values `{in_call}` and `{model}` for `in_call` and `model` parameters. "
+                f"Inconsistent values `{in_call}` and `{model}` for `in_call` and `model` parameters. "
                 "The `None` value is specified that model is undefined at this moment. This is only "
                 "possible when `in_call` is equal to `False`."
             )

nncf/experimental/tensorflow/graph/converter.py

@@ -69,7 +69,7 @@ def build(self, graph_optimizers: List[str]):
         # List of output tensors
         output_tensors = frozen_func.outputs
 
-        # Step 2: Run a Grappler pass to oprimize the TensorFlow graph.
+        # Step 2: Run a Grappler pass to optimize the TensorFlow graph.
 
         # Creates a ConfigProto for configuring Grappler
         grappler_config = _get_grappler_config(graph_optimizers)

nncf/experimental/tensorflow/nncf_network.py

@@ -41,7 +41,7 @@ def __init__(self, model: tf.keras.Model, input_signature: InputSignature, **kwa
         Initializes the NNCF network.
 
         :param model: Keras model.
-        :param input_signature: Input signature of the moodel.
+        :param input_signature: Input signature of the model.
         """
         super().__init__(**kwargs)
         self._model = model
@@ -98,7 +98,7 @@ def insert_at_point(self, point: TFTargetPoint, ops: List[NNCFOperation]) -> Non
         Inserts the list of the NNCF operations according to the target point.
 
         :param point: The location where operations should be inserted.
-        :param ops: List of the NNCF operarions.
+        :param ops: List of the NNCF operations.
         """
         ops_weights = {op.name: op.create_variables(self) for op in ops}
         hook = Hook(ops, point, ops_weights)

nncf/experimental/tensorflow/patch_tf.py

@@ -82,7 +82,7 @@ def get_operation_weights(self, op_name: str) -> Any:
         Returns weights of the operation with `op_name`.
 
         :param op_name: Name of the operation.
-        :return: Weihts of the operation.
+        :return: Weights of the operation.
         """
         return self._ops_weights[op_name]
 

nncf/experimental/torch/fx/constant_folding.py

@@ -69,7 +69,7 @@ def _is_const_source(node: torch.fx.Node) -> bool:
 
 class ConstantFolder(torch.fx.Interpreter):
     """
-    Finds constant subraphs and place it in node_replacement attribute.
+    Finds constant subgraphs and place it in node_replacement attribute.
     """
 
     def __init__(
@@ -216,10 +216,10 @@ def add_node_replacement(self, node: torch.fx.Node, tensor: torch.Tensor) -> Non
 
     def run(self) -> Any:  # type: ignore[override]
         env: Dict[torch.fx.Node, Any] = {}
-        self.insert_placerholder_values(env)
+        self.insert_placeholder_values(env)
         return super().run(initial_env=env)
 
-    def insert_placerholder_values(self, env: Dict[torch.fx.Node, Any]) -> None:
+    def insert_placeholder_values(self, env: Dict[torch.fx.Node, Any]) -> None:
         for n in self.module.graph.find_nodes(op="placeholder"):
             env[n] = self.unknown_value  # type: ignore[assignment]
 
@@ -242,10 +242,10 @@ def constant_fold(
     constraint_fn: Optional[Callable[[torch.fx.Node], bool]] = None,
 ) -> None:
     """
-    Calcualtes constant subgraphs values and replaces them with a constant node inplace.
+    Calculates constant subgraphs values and replaces them with a constant node inplace.
 
     :param gm: Given graph model.
-    :param constraint_fn: Constraint function which takes a node and returs the constraint:
+    :param constraint_fn: Constraint function which takes a node and returns the constraint:
         should the node be constant folded or not.
     """
     with torch.no_grad(), torch.utils._python_dispatch._disable_current_modes():

nncf/experimental/torch/fx/node_utils.py

@@ -22,7 +22,7 @@
 # torch version update (>= 2.4)
 def get_graph_node_by_name(graph: torch.fx.Graph, name: str) -> torch.fx.Node:
     """
-    Retrieves a node with the specified name from the grpah.
+    Retrieves a node with the specified name from the graph.
     Raises a runtime error if graph does not contain node with
     the given name.
 

nncf/experimental/torch/fx/quantization/quantize_model.py

@@ -97,8 +97,7 @@ def quantize_impl(
     else:
         fq_weights_transformation(quantized_model)
 
-    # Magic. Without this call compiled model
-    # is not preformant
+    # Magic. Without this call compiled model is not performant
     quantized_model = GraphModule(quantized_model, quantized_model.graph)
 
     quantized_model = _fold_conv_bn_qat(quantized_model)

nncf/experimental/torch/fx/quantization/quantize_pt2e.py

@@ -123,8 +123,7 @@ def quantize_pt2e(
     nncf_graph = NNCFGraphFactory.create(transformed_model)
     quantized_model = quantization_algorithm.apply(transformed_model, nncf_graph, dataset=calibration_dataset)
 
-    # Magic. Without this call compiled model
-    # is not preformant
+    # Magic. Without this call compiled model is not performant
     quantized_model = GraphModule(quantized_model, quantized_model.graph)
 
     if fold_quantize:

nncf/experimental/torch/fx/quantization/quantizer/openvino_quantizer.py

@@ -355,7 +355,7 @@ def transform_for_annotation(self, model: torch.fx.GraphModule) -> torch.fx.Grap
         For example quantizer can
         a) decompose a compound operator like scaled dot product attention,
         into bmm and softmax if quantizer knows how to quantize bmm/softmax but not sdpa
-        or b) transform scalars to tensor to allow quantizing scalares.
+        or b) transform scalars to tensor to allow quantizing scalars.
 
         Note: this is an optional method
 

nncf/experimental/torch/fx/quantization/quantizer/torch_ao_adapter.py

@@ -70,12 +70,12 @@ def get_quantization_setup(self, model: torch.fx.GraphModule, nncf_graph: NNCFGr
     def _get_quantization_points(
         from_node: torch.fx.Node,
         to_nodes: List[torch.fx.Node],
-        anotated_model: torch.fx.GraphModule,
+        annotated_model: torch.fx.GraphModule,
         qconfig: QuantizerConfig,
     ) -> List[QuantizationPointBase]:
         to_n = to_nodes[0]
         if from_node.op == "get_attr":
-            _, metatype = GraphConverter.get_node_type_and_metatype(to_n, anotated_model)
+            _, metatype = GraphConverter.get_node_type_and_metatype(to_n, annotated_model)
             # Check that the constant is placed on the actual weight port, as it is possible for
             # activations to be a constant as well.
             if TorchAOQuantizerAdapter._get_node_args(to_n).index(from_node) in metatype.weight_port_ids:
@@ -101,8 +101,8 @@ def _get_node_args(node: torch.fx.Node):
         return node.args
 
     @staticmethod
-    def get_quantizer_config_from_annotated_model(anotated_model: torch.fx.GraphModule) -> SingleConfigQuantizerSetup:
-        edge_or_node_to_qspec = _get_edge_or_node_to_qspec(anotated_model)
+    def get_quantizer_config_from_annotated_model(annotated_model: torch.fx.GraphModule) -> SingleConfigQuantizerSetup:
+        edge_or_node_to_qspec = _get_edge_or_node_to_qspec(annotated_model)
 
         q_map = defaultdict(list)
         for edge, qspec in edge_or_node_to_qspec.items():
@@ -133,7 +133,7 @@ def get_quantizer_config_from_annotated_model(anotated_model: torch.fx.GraphModu
                 )
                 qconfig = QuantizerConfig(mode=mode, signedness_to_force=signed, per_channel=per_channel)
 
-                qps = TorchAOQuantizerAdapter._get_quantization_points(from_n, to_nodes, anotated_model, qconfig)
+                qps = TorchAOQuantizerAdapter._get_quantization_points(from_n, to_nodes, annotated_model, qconfig)
                 for qp in qps:
                     q_setup.add_independent_quantization_point(qp)
 

nncf/experimental/torch/fx/statistics/aggregator.py

@@ -60,7 +60,7 @@ def collect_statistics(self, model: NNCFNetwork, graph: NNCFGraph) -> None:
         with torch.no_grad():
             super().collect_statistics(model, graph)
         # All statistics are collected as a dead code,
-        # so eliminate dead core removed statistcs collector
+        # so eliminate dead core removed statistics collector
         # from the target model. No additional code required
         # for that, horay!
         model.graph.eliminate_dead_code()
@@ -72,7 +72,7 @@ def _register_statistics(self, outputs: Dict[str, Tensor], statistic_points: Sta
     @staticmethod
     def _get_statistic_collector_name(tp: PTTargetPoint, module_to_insert: torch.nn.Module) -> str:
         """
-        Compouses unique statistic collector name according to given target point and module.
+        Composes unique statistic collector name according to given target point and module.
 
         :param tp: Given target point.
         :param module_to_insert: Given statistic collection module.
@@ -118,7 +118,7 @@ def _get_transformation_layout_extra_outputs(
     def _get_merged_statistic_points(
         statistic_points: StatisticPointsContainer, model: TModel, graph: NNCFGraph
     ) -> StatisticPointsContainer:
-        # TODO(dlyakhov): mirgate to experimental statistic collector and use common merging algorithm
+        # TODO(dlyakhov): migrate to experimental statistic collector and use common merging algorithm
         return statistic_points
 
     @staticmethod

nncf/experimental/torch/nas/bootstrapNAS/search/evaluator.py

@@ -100,7 +100,7 @@ def retrieve_from_cache(self, subnet_config_repr: Tuple[float, ...]) -> Tuple[bo
 
     def get_state(self) -> Dict[str, Any]:
         """
-        Returns state of the evaluatar
+        Returns state of the evaluator
 
         :return: Dict with the state of the evaluator
         """
@@ -180,7 +180,7 @@ def __init__(
         Initializes Accuracy operator
 
         :param eval_func: function used to validate a sub-network
-        :param val_loader: Datq loader used by the validation function
+        :param val_loader: Data loader used by the validation function
         :param is_top1: Whether is top 1 accuracy or top 5.
         :param ref_acc: Accuracy from a model that is used as input to BootstrapNAS
         """

nncf/experimental/torch/nas/bootstrapNAS/search/search.py

@@ -692,14 +692,14 @@ def __init__(self, search: BaseSearchAlgorithm):
         self._model = search._model
         self._lower_bound_acc = search.search_params.ref_acc - search.acc_delta
 
-    def _evaluate(self, x: List[float], out: Dict[str, Any], *args, **kargs) -> NoReturn:
+    def _evaluate(self, x: List[float], out: Dict[str, Any], *args, **kwargs) -> NoReturn:
         """
         Evaluates a population of sub-networks.
 
         :param x: set of sub-networks to evaluate.
         :param out: measurements obtained by evaluating sub-networks.
         :param args:
-        :param kargs:
+        :param kwargs:
         :return:
         """
         evaluators_arr = [[] for i in range(len(self._search.evaluator_handlers))]

nncf/experimental/torch/nas/bootstrapNAS/training/lr_scheduler.py

@@ -101,7 +101,7 @@ def __init__(
     @classmethod
     def from_dict(cls, lr_scheduler_config: Dict[str, Any]) -> "LRSchedulerParams":
         """
-        Initialize learning rate scheduler parameters storage clas from Dict.
+        Initialize learning rate scheduler parameters storage class from Dict.
         :param lr_scheduler_config: Dict with parameters of learning rate scheduler.
         :return:
         """