Method Compare

tensorflow/core/kernels/lrn_op_test.cc:55–92

  }

  bool Compare() {
    const auto& input = GetInput(0);
    const int64 batch_size = input.dim_size(0);
    const int64 rows = input.dim_size(1);
    const int64 cols = input.dim_size(2);
    const int64 depth = input.dim_size(3);
    const int64 rest = cols * rows * batch_size;

    const int64 depth_radius = GetIntAttr("depth_radius");
    const float bias = GetFloatAttr("bias");
    const float alpha = GetFloatAttr("alpha");
    const float beta = GetFloatAttr("beta");

    Eigen::Tensor<float, 4, Eigen::RowMajor> expected(batch_size, rows, cols,
                                                      depth);
    auto out = expected.reshape(Eigen::DSizes<int64, 2>{rest, depth});
    auto in = input.shaped<float, 2>({rest, depth});

    for (int64 i = 0; i < rest; ++i) {
      Eigen::Tensor<float, 1, Eigen::RowMajor> out_col(depth);
      for (int64 d = 0; d < depth; ++d) {
        float denom = 0.0f;
        for (int64 r = std::max(int64{0}, d - depth_radius);
             r < std::min(depth, d + depth_radius + 1); ++r) {
          denom += in(i, r) * in(i, r);
        }
        denom = std::pow(denom * alpha + bias, beta);
        out_col(d) = in(i, d) / denom;
      }
      out.chip<0>(i) = out_col;
    }
    auto actual = GetOutput(0)->tensor<float, 4>();
    Eigen::Tensor<float, 0, Eigen::RowMajor> sum =
        ((expected - actual).abs() > actual.constant(tol_))
            .select(actual.constant(1), actual.constant(0))
            .sum();
    return sum() == 0;
  }

  random::PhiloxRandom philox_;
  random::SimplePhilox rand_;