}
  if (enable_float16_quantization_) {
    quant_specs.inference_type = tensorflow::DT_HALF;
  }

  const quant::QuantPassSpec quant_params = {
      {quant_specs.verify_numeric, error_tolerance_,
       quant_specs.whole_model_verify, enable_log_if_failed_},
      quant_specs};

  populateWithGenerated(patterns);

  if (quant_specs.weight_quantization || quant_specs.use_fake_quant_num_bits ||

  ];

  let options = [
      Option<"enable_numeric_verify_", "numeric-verify",
             "bool", "false",
             "Whether verify numericals at runtime.">,
      Option<"error_tolerance_", "error-tolerance",
             "float", "5.0f",
             "Error tolerance for numeric verify. Valid when `-numeric-verify` is set.">,
      Option<"enable_whole_model_verify_", "whole-model-verify",

})mlir";
  TF_ASSERT_OK_AND_ASSIGN(auto arg0, CreateRandomF32Literal({10}));
  // error_tolerance is set to be slightly > scale because different rounding
  // implementations for UniformQuantize in TF kernel and the lowering passes
  // may cause +/-1 differences.
  ExecuteAndCompareResultsWithTfKernel(
      kProgram, {&arg0}, /*tf_program=*/std::nullopt, /*error_tolerance=*/0.35);
}

  bool verify_numeric = false;

  // Tolerance level from the quantized value for verification. If the tolerance
  // is very small(<0.1), only the stats of the diff is displayed.
  float error_tolerance = 5.0f;

  // Whether to verify numerical correctness layer by layer or by whole model
  bool whole_model_verify = false;

  // Whether to enable log for failures
  bool log_if_failed_flag = false;
};

  auto func = getOperation();
  auto* ctx = func.getContext();

  quant_specs_.weight_quantization = weight_quantization_;
  const QuantPassSpec quant_params = {
      {quant_specs_.verify_numeric, /*error_tolerance=*/5.0f,
       quant_specs_.whole_model_verify, /*enable_log_if_failed=*/false},
      quant_specs_};

  if (quant_specs_.weight_quantization) {
    patterns.add<TFDynamicRangeQuantization>(ctx, quant_params);