#include "tensorflow/c/experimental/gradients/not_differentiable.h"

namespace tensorflow {
namespace gradients {
Status NotDifferentiableGradientFunction::Compute(
    AbstractContext* ctx, absl::Span<AbstractTensorHandle* const> grad_outputs,
    absl::Span<AbstractTensorHandle*> grad_inputs) {
  for (int i = 0; i < grad_inputs.size(); i++) {
    grad_inputs[i] = nullptr;
  }
  return absl::OkStatus();
}

  if (attr_.full_type() == "list(string)") {
    return "absl::Span<string const>";
  }

  // Normal path: translate base type to C++ ...
  string c_base_type = attr_.base_type();
  if (attr_.base_type() == "type") {
    c_base_type = "DataType";
  } else if (attr_.base_type() == "shape") {
    c_base_type = "const PartialTensorShape";
  }

  // ... and wrap in a Span<> if it's a list.
  if (attr_.is_list()) {

  }
};

class PassThroughGradientFunction : public GradientFunction {
 public:
  Status Compute(AbstractContext* ctx,
                 absl::Span<AbstractTensorHandle* const> grad_outputs,
                 absl::Span<AbstractTensorHandle*> grad_inputs) override {
    CHECK_EQ(grad_outputs.size(), 1);
    CHECK_EQ(grad_inputs.size(), 1);
    grad_inputs[0] = grad_outputs[0];
    if (grad_inputs[0]) {

string ArgTypeView::TypeName() const {
  if (arg_type_.is_read_only()) {
    if (arg_type_.is_list()) {
      return "absl::Span<AbstractTensorHandle* const>";
    } else {
      return "AbstractTensorHandle* const";
    }
  } else {
    if (arg_type_.is_list()) {
      return "absl::Span<AbstractTensorHandle*>";
    } else {
      return "AbstractTensorHandle**";
    }
  }
}

}  // namespace cpp

#define TENSORFLOW_COMPILER_MLIR_QUANTIZATION_TENSORFLOW_CALIBRATOR_CALIBRATION_STATISTICS_COLLECTOR_BASE_H_

#include <cstdint>
#include <optional>

#include "absl/types/span.h"
#include "tensorflow/compiler/mlir/quantization/tensorflow/calibrator/calibration_statistics.pb.h"

namespace tensorflow {
namespace calibrator {

// Abstract base class for CalibrationStatisticsCollcetor such as

  std::optional<AttrKeyValuePair> attr_;
};

::testing::Matcher<const Node*> NodeWith(
    absl::Span<const NodeMatcherProperties> props);

impl::NodeMatcherProperties Inputs(
    absl::Span<const ::testing::Matcher<OutEdge>> inputs);

impl::NodeMatcherProperties CtrlDeps(
    absl::Span<const ::testing::Matcher<const Node*>> control_deps);

impl::NodeMatcherProperties Attr(std::pair<string, AttrValue> attrs);

  Status ComputeGradient(
      const VSpace<Gradient, BackwardFunction, TapeTensor>& vspace,
      const absl::Span<const int64_t> target_tensor_ids,
      const absl::Span<const int64_t> source_tensor_ids,
      const std::unordered_map<int64, TapeTensor>& sources_that_are_targets,
      gtl::ArraySlice<Gradient*> output_gradients, absl::Span<Gradient*> result,
      bool build_default_zeros_grads = true);

  }
}

// Runs model as is if output is a scalar,
// else sums the output tensor before returning.
Status RunAndMaybeSum(AbstractContext* ctx, Model forward,
                      absl::Span<AbstractTensorHandle* const> inputs,
                      absl::Span<AbstractTensorHandle*> outputs,
                      bool use_function) {
  AbstractTensorHandle* model_outputs[1];

  // Run the model.
  TF_RETURN_IF_ERROR(

    params->emplace_back(handle);
  }
  return absl::OkStatus();
}

// Runs `model` maybe wrapped in a function.
Status RunModel(Model model, AbstractContext* ctx,
                absl::Span<AbstractTensorHandle* const> inputs,
                absl::Span<AbstractTensorHandle*> outputs, bool use_function) {
  if (use_function) {
    const char* fn_name = "test_fn";
    core::RefCountPtr<AbstractFunction> scoped_func;

### 实时文档

在本地开发时，可以使用该脚本构建站点并检查所做的任何更改，并实时重载：

<div class="termy">

```console
$ python ./scripts/docs.py live

<span style="color: green;">[INFO]</span> Serving on http://127.0.0.1:8008
<span style="color: green;">[INFO]</span> Start watching changes
<span style="color: green;">[INFO]</span> Start detecting changes
```

</div>

文档服务将运行在 `http://127.0.0.1:8008`。

这样，你可以编辑文档 / 源文件并实时查看更改。

!!! tip