def step(
        self,
        inputs,
        activation_stats_dict,
        intermediate_output_names=None,
        compute_units=ct.ComputeUnit.CPU_ONLY,
        op_group_size=-1,
    ):
        """
        During activation quantization, to get activations, all intermediate tensors will be added to model's outputs
        to form a temperary model. Then the temp model's output will be recorded for quantization.

        inputs: Inputs to the model for running `model.predict`.
        activation_stats_dict: Dictionary to store the min/max of the activation statistics.
        intermediate_output_names: The output names of the intermediate tensors.
        compute_units: The compute units to use for temperary model's prediction.
        op_group_size: If the model is very large, it could lead to the temperary model having thousands of outputs,
            which may lead to model hanging forever during model loading. To work around this issue, intermediate
            outputs are grouped into smaller groups, where each time a temperary model will only have `op_group_size`
            outputs. By default (op_group_size = -1), op_group_size is equal to the number of valid intermediate ops.
        """
        if intermediate_output_names is None:
            intermediate_output_names = self.get_intermediate_output_names()
        if len(intermediate_output_names) == 0:
            return
        if op_group_size == -1:
            op_group_size = len(intermediate_output_names)

        model_output_names = [output.name for output in self.__model_outputs]
        model_outputs = dict()

        for output_names in tqdm(
            self.batch(intermediate_output_names, op_group_size),
            desc="Running linear_quantize_activations on intermediate tensors batch-by-batch",
            unit=" batches",
        ):
            outputs = self.predict_intermediate_outputs(inputs, output_names, compute_units)

            model_outputs.update(
                {key: value for key, value in outputs.items() if key in model_output_names}
            )
            intermediate_outputs = {
                key: value for key, value in outputs.items() if key not in model_output_names
            }

            for output_name, output_value in intermediate_outputs.items():
                self.record_intermediate_output(output_value, output_name, activation_stats_dict)

        During activation quantization, to get activations, all intermediate tensors will be added to model's outputs
        to form a temperary model. Then the temp model's output will be recorded for quantization.

        inputs: Inputs to the model for running `model.predict`.
        activation_stats_dict: Dictionary to store the min/max of the activation statistics.
        intermediate_output_names: The output names of the intermediate tensors.
        compute_units: The compute units to use for temperary model's prediction.
        op_group_size: If the model is very large, it could lead to the temperary model having thousands of outputs,
            which may lead to model hanging forever during model loading. To work around this issue, intermediate
            outputs are grouped into smaller groups, where each time a temperary model will only have `op_group_size`
            outputs. By default (op_group_size = -1), op_group_size is equal to the number of valid intermediate ops.
        
coremltools/optimize/coreml/experimental/_model_debugger.py