AddProcessNchwTensorPasses(pm);

  pm.addPass(CreateLiftQuantizableSpotsAsFunctionsPass(quantization_specs));
  if (debugger_config.debugger_type() !=
      DebuggerConfig::DEBUGGER_TYPE_UNSPECIFIED) {
    pm.addPass(CreateAddDumpTensorOpPass(debugger_config.debugger_type(),
                                         debugger_config.log_dir_path()));
  }
  pm.addNestedPass<func::FuncOp>(
      CreateInsertCustomAggregationOpsPass(calibration_options));

    OpPassManager& pm,
    const ::stablehlo::quantization::CalibrationOptions& calibration_options,
    const ::stablehlo::quantization::QuantizationSpecs& specs,
    const ::stablehlo::quantization::DebuggerConfig& debugger_config);

// Adds passes for static-range quantization post-calibration. Utilizes tensor
// statistics collected from the calibration step and performs quantization.
void AddPostCalibrationPasses(
    OpPassManager& pm,

  // both quantized and unquantized tensors and compare them offline.
  if (quantization_options.has_debugger_config() &&
      quantization_options.debugger_config().debugger_type() ==
          DebuggerConfig::DEBUGGER_TYPE_WHOLE_MODEL) {
    TF_ASSIGN_OR_RETURN(
        ExportedModel debugging_exported_model,
        ExportDebuggingModel(*module_ref, context.get(), quantization_options,

  if quantization_options.HasField('debugger_config'):
    if not quantization_options.debugger_config.log_dir_path:
      quantization_options.debugger_config.log_dir_path = '/tmp/dumps'

    if (
        quantization_options.debugger_config.debugger_type
        == stablehlo_quant_config_pb2.DebuggerConfig.DebuggerType.DEBUGGER_TYPE_UNSPECIFIED
    ):
      raise ValueError(

  TF_RETURN_IF_ERROR(RunPasses(
      kName, /*add_passes_func=*/
      [&config](PassManager& pm) {
        AddPreCalibrationPasses(pm, config.calibration_options(),
                                config.specs(), config.debugger_config());
      },
      *ctx_, module_op));
  return module_op;
}

                GetReportFilePath(config)));

        AddWeightOnlyQuantizationPasses(pm, config.specs(),
                                        config.pipeline_config(),
                                        config.debugger_config());
      },
      *ctx_, module_op));
  return module_op;
}

absl::Status QuantizeWeightOnlyPtq(
    const absl::string_view src_saved_model_path,
    const absl::string_view dst_saved_model_path,

  if (quantization_options.has_debugger_config()) {
    pm.addPass(mlir::quant::CreateAddDumpTensorOpPass(
        quantization_options.debugger_config().debugger_type(),
        quantization_options.debugger_config().log_dir_path()));
  }
  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::quant::CreateInsertCustomAggregationOpsPass(
          quantization_options.calibration_options()));
}

  // method is set to MIN_MAX by default.
  stablehlo.quantization.CalibrationOptions calibration_options = 15;

  // Configuration related to quantization debugger.
  stablehlo.quantization.DebuggerConfig debugger_config = 16;

  reserved 3;

  // Configures the graph transformation pipeline for quantization.
  PipelineConfig pipeline_config = 3;

  QuantizationSpecs specs = 4;

  // Configures the quantization debugger.
  DebuggerConfig debugger_config = 5;

  // Defines calibration options for quantization. This option is only used for
  // activation of static range quantization (SRQ). Quantization calibration
  // method is set to MIN_MAX by default.

        quantization_method=quant_opts_pb2.QuantizationMethod(
            preset_method=_PresetMethod.METHOD_STATIC_RANGE_INT8
        ),
        op_set=quant_opts_pb2.XLA,
        debugger_config=_DebuggerConfig(
            debugger_type=_DebuggerConfig.DebuggerType.DEBUGGER_TYPE_WHOLE_MODEL,
            unquantized_dump_model_path=unquantized_dump_model_path,
            log_dir_path=log_dir_path,
        ),
        tags=tags,