       _xla: XLATensor.cumsum(
         x.xlaTensor, Int64(axis.scalarized()),
         exclusive: exclusive, reverse: reverse))
+  }
+
+  /// DepthToSpace for tensors of type T.
+  ///
+  /// Rearranges data from depth into blocks of spatial data.
+  /// This is the reverse transformation of SpaceToDepth. More specifically,
+  /// this op outputs a copy of the input tensor where values from the `depth`
+  /// dimension are moved in spatial blocks to the `height` and `width` dimensions.
+  /// The attr `block_size` indicates the input block size and how the data is moved.
+  /// 
+  ///   * Chunks of data of size `block_size * block_size` from depth are rearranged
+  ///     into non-overlapping blocks of size `block_size x block_size`
+  ///   * The width the output tensor is `input_depth * block_size`, whereas the
+  ///     height is `input_height * block_size`.
+  ///   * The Y, X coordinates within each block of the output image are determined
+  ///     by the high order component of the input channel index.
+  ///   * The depth of the input tensor must be divisible by
+  ///     `block_size * block_size`.
+  /// 
+  /// The `data_format` attr specifies the layout of the input and output tensors
+  /// with the following options:
+  ///   "NHWC": `[ batch, height, width, channels ]`
+  ///   "NCHW": `[ batch, channels, height, width ]`
+  ///   "NCHW_VECT_C":
+  ///       `qint8 [ batch, channels / 4, height, width, 4 ]`
+  /// 
+  /// It is useful to consider the operation as transforming a 6-D Tensor.
+  /// e.g. for data_format = NHWC,
+  ///      Each element in the input tensor can be specified via 6 coordinates,
+  ///      ordered by decreasing memory layout significance as:
+  ///      n,iY,iX,bY,bX,oC  (where n=batch index, iX, iY means X or Y coordinates
+  ///                         within the input image, bX, bY means coordinates
+  ///                         within the output block, oC means output channels).
+  ///      The output would be the input transposed to the following layout:
+  ///      n,iY,bY,iX,bX,oC
+  /// 
+  /// This operation is useful for resizing the activations between convolutions
+  /// (but keeping all data), e.g. instead of pooling. It is also useful for training
+  /// purely convolutional models.
+  /// 
+  /// For example, given an input of shape `[1, 1, 1, 4]`, data_format = "NHWC" and
+  /// block_size = 2:
+  /// 
+  /// ```
+  /// x = [[[[1, 2, 3, 4]]]]
+  /// 
+  /// ```
+  /// 
+  /// This operation will output a tensor of shape `[1, 2, 2, 1]`:
+  /// 
+  /// ```
+  ///    [[[[1], [2]],
+  ///      [[3], [4]]]]
+  /// ```
+  /// 
+  /// Here, the input has a batch of 1 and each batch element has shape `[1, 1, 4]`,
+  /// the corresponding output will have 2x2 elements and will have a depth of
+  /// 1 channel (1 = `4 / (block_size * block_size)`).
+  /// The output element shape is `[2, 2, 1]`.
+  /// 
+  /// For an input tensor with larger depth, here of shape `[1, 1, 1, 12]`, e.g.
+  /// 
+  /// ```
+  /// x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
+  /// ```
+  /// 
+  /// This operation, for block size of 2, will return the following tensor of shape
+  /// `[1, 2, 2, 3]`
+  /// 
+  /// ```
+  ///    [[[[1, 2, 3], [4, 5, 6]],
+  ///      [[7, 8, 9], [10, 11, 12]]]]
+  /// 
+  /// ```
+  /// 
+  /// Similarly, for the following input of shape `[1 2 2 4]`, and a block size of 2:
+  /// 
+  /// ```
+  /// x =  [[[[1, 2, 3, 4],
+  ///        [5, 6, 7, 8]],
+  ///       [[9, 10, 11, 12],
+  ///        [13, 14, 15, 16]]]]
+  /// ```
+  /// 
+  /// the operator will return the following tensor of shape `[1 4 4 1]`:
+  /// 
+  /// ```
+  /// x = [[[ [1],   [2],  [5],  [6]],
+  ///       [ [3],   [4],  [7],  [8]],
+  ///       [ [9],  [10], [13],  [14]],
+  ///       [ [11], [12], [15],  [16]]]]
+  /// 
+  /// ```
+  ///
+  /// - Attr block_size: The size of the spatial block, same as in Space2Depth.
+  @inlinable @inline(__always)
+  public static func depthToSpace<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    blockSize: Int64,
+    dataFormat: DataFormat5 = .nhwc
+  ) -> Tensor<T> {
+    fatalError("implement depthToSpace")
   }
 
   /// Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors.

    checkSameDevice(gradients, features)
    checkSamePrecision(gradients, features)
    return _Raw.div(gradients, _Raw.square(_Raw.addV2(_Raw.abs(features), _Raw.onesLike(features))))
  }

  /// Computes softmax cross entropy cost and gradients to backpropagate.


  // @_frozen // SR-9739
  public enum DataFormat4 {
    case nchw
    case nchwVectC
    case nhwc

    @inlinable
    var cName: String {
      @inline(__always)
      get {
        switch self {
        case .nchw: return "NCHW"
        case .nchwVectC: return "NCHW_VECT_C"
        case .nhwc: return "NHWC"
        }
      }
    }
  }

  // @_frozen // SR-9739
  public enum DataFormat5 {
    case nchw
    case nchwVectC
    case nhwc
