namespace internal {

void CompareNumericalAndAutodiffGradients(
    Model model, Model grad_model, AbstractContext* ctx,
    absl::Span<AbstractTensorHandle* const> inputs, bool use_function,
    double abs_error) {
  auto num_inputs = inputs.size();
  std::vector<AbstractTensorHandle*> outputs(num_inputs);
  auto s = RunModel(grad_model, ctx, inputs, absl::MakeSpan(outputs),
                    /*use_function=*/use_function);

### Breaking Changes


`tf.keras`:

            action()
        }
    }

    override fun <T : Any> loadOrCreateModel(creator: () -> T): T {
        if (isLoaded) {
            runLoadedSideEffects()
            return loadModel().uncheckedCast()
        }

        return runWorkThatContributesToCacheEntry {
            val model = creator()
            saveModel(model)
            model
        }
    }

    private

    std::vector<int>& used_tensors, bool quantized = false) {
  std::unique_ptr<ModelT> quant_model =
      CreateMutableModelFromFile(quantized_model);
  std::unique_ptr<ModelT> float_model =
      CreateMutableModelFromFile(expected_model);

  for (int i = 0; i < possible_tensors->size(); i++) {
    // Skip if the tensor is already used for match.