Help protect the Great Barrier Reef with TensorFlow on Kaggle

Tensor

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
extension Tensor: TensorProtocol
extension Tensor: TensorGroup
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: Codable where Scalar: Codable
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

A multidimensional array of elements that is a generalization of vectors and matrices to potentially higher dimensions.

The generic parameter Scalar describes the type of scalars in the tensor (such as Int32, Float, etc).

• handle

The underlying TensorHandle.

Note

handle is public to allow user defined ops, but should not normally be used.

Declaration

public let handle: TensorHandle<Scalar>
• init(handle:)

Declaration

public init(handle: TensorHandle<Scalar>)
• unstacked(alongAxis:)

Unpacks the given dimension of a rank-R tensor into multiple rank-(R-1) tensors. Unpacks N tensors from this tensor by chipping it along the axis dimension, where N is inferred from this tensor’s shape. For example, given a tensor with shape [A, B, C, D]:

• If axis == 0 then the i-th tensor in the returned array is the slice self[i, :, :, :] and each tensor in that array will have shape [B, C, D]. (Note that the dimension unpacked along is gone, unlike Tensor.split(numSplits:alongAxis), or Tensor.split(sizes:alongAxis)).
• If axis == 1 then the i-th tensor in the returned array is the slice value[:, i, :, :] and each tensor in that array will have shape [A, C, D].
• Etc.

This is the opposite of Tensor.init(stacking:alongAxis:).

Precondition

axis must be in the range [-rank, rank), where rank is the rank of the provided tensors.

Declaration

@differentiable
public func unstacked(alongAxis axis: Int = 0) -> [Tensor]

Parameters

 axis Dimension along which to unstack. Negative values wrap around.

Return Value

Array containing the unstacked tensors.

• split(count:alongAxis:)

Splits a tensor into multiple tensors. The tensor is split along dimension axis into count smaller tensors. This requires that count evenly divides shape[axis].

For example:

// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors along dimension 1:
let parts = value.split(count: 3, alongAxis: 1)
parts // has shape [5, 10]
parts // has shape [5, 10]
parts // has shape [5, 10]

Precondition

count must divide the size of dimension axis evenly.

Precondition

axis must be in the range [-rank, rank), where rank is the rank of the provided tensors.

Declaration

@differentiable
public func split(count: Int, alongAxis axis: Int = 0) -> [Tensor]

Parameters

 count Number of splits to create. axis The dimension along which to split this tensor. Negative values wrap around.

Return Value

An array containing the tensors part.

• split(sizes:alongAxis:)

Splits a tensor into multiple tensors. The tensor is split into sizes.shape pieces. The shape of the i-th piece has the same shape as this tensor except along dimension axis where the size is sizes[i].

For example:

// 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors with sizes [4, 15, 11] along dimension 1:
let parts = value.split(sizes: Tensor<Int32>([4, 15, 11]), alongAxis: 1)
parts // has shape [5, 4]
parts // has shape [5, 15]
parts // has shape [5, 11]

Precondition

The values in sizes must add up to the size of dimension axis.

Precondition

axis must be in the range [-rank, rank), where rank is the rank of the provided tensors.

Declaration

@differentiable(wrt: self)
public func split(sizes: Tensor<Int32>, alongAxis axis: Int = 0) -> [Tensor]

Parameters

 sizes 1-D tensor containing the size of each split. axis Dimension along which to split this tensor. Negative values wrap around.

Return Value

Array containing the tensors parts.

• split(sizes:alongAxis:)

Declaration

@differentiable(wrt: self)
public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]
• tiled(multiples:)

Returns a tiled tensor, constructed by tiling this tensor.

This constructor creates a new tensor by replicating this tensor multiples times. The constructed tensor’s i‘th dimension has self.shape[i] * multiples[i] elements, and the values of this tensor are replicated multiples[i] times along the i'th dimension. For example, tiling [a b c d] by  produces [a b c d a b c d].

Precondition

The expected rank of multiples must be 1.

Precondition

The shape of multiples must be [tensor.rank].

Precondition

All scalars in multiples must be non-negative.

Declaration

@differentiable(wrt: self)
public func tiled(multiples: [Int]) -> Tensor
• tiled(multiples:)

Returns a tiled tensor, constructed by tiling this tensor.

This constructor creates a new tensor by replicating this tensor multiples times. The constructed tensor’s i‘th dimension has self.shape[i] * multiples[i] elements, and the values of this tensor are replicated multiples[i] times along the i'th dimension. For example, tiling [a b c d] by  produces [a b c d a b c d].

Precondition

The expected rank of multiples must be 1.

Precondition

The shape of multiples must be [tensor.rank].

Declaration

@differentiable(wrt: self)
public func tiled(multiples: Tensor<Int32>) -> Tensor
• reshaped(like:)

Reshape to the shape of the specified Tensor.

Precondition

The number of scalars matches the new shape.

Declaration

@differentiable(wrt: self)
public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar
• reshaped(to:)

Reshape to the specified shape.

Precondition

The number of scalars matches the new shape.

Declaration

@differentiable(wrt: self)
public func reshaped(to newShape: TensorShape) -> Tensor
• reshaped(toShape:)

Reshape to the specified Tensor representing a shape.

Precondition

The number of scalars matches the new shape.

Declaration

@differentiable(wrt: self)
public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor
• flattened()

Return a copy of the tensor collapsed into a 1-D Tensor, in row-major order.

Declaration

@differentiable(wrt: self)
public func flattened() -> Tensor
• expandingShape(at:)

Returns a shape-expanded Tensor, with a dimension of 1 inserted at the specified shape indices.

Declaration

@differentiable(wrt: self)
public func expandingShape(at axes: Int...) -> Tensor
• expandingShape(at:)

Returns a shape-expanded Tensor, with a dimension of 1 inserted at the specified shape indices.

Declaration

@differentiable(wrt: self)
public func expandingShape(at axes: [Int]) -> Tensor
• rankLifted()

Returns a rank-lifted Tensor with a leading dimension of 1.

Declaration

@differentiable(wrt: self)
public func rankLifted() -> Tensor
• squeezingShape(at:)

Removes the specified dimensions of size 1 from the shape of a tensor. If no dimensions are specified, then all dimensions of size 1 will be removed.

Declaration

@differentiable(wrt: self)
public func squeezingShape(at axes: Int...) -> Tensor
• squeezingShape(at:)

Removes the specified dimensions of size 1 from the shape of a tensor. If no dimensions are specified, then all dimensions of size 1 will be removed.

Declaration

@differentiable(wrt: self)
public func squeezingShape(at axes: [Int]) -> Tensor
• transposed(permutation:)

Returns a transposed tensor, with dimensions permuted in the specified order.

Declaration

@differentiable(wrt: self)
public func transposed(permutation: Tensor<Int32>) -> Tensor
• transposed(withPermutations:)

Returns a transposed tensor, with dimensions permuted in the specified order.

Declaration

@available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor
• transposed(permutation:)

Returns a transposed tensor, with dimensions permuted in the specified order.

Declaration

@differentiable(wrt: self)
public func transposed(permutation: [Int]) -> Tensor
• transposed(withPermutations:)

Returns a transposed tensor, with dimensions permuted in the specified order.

Declaration

@available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: [Int]) -> Tensor
• transposed(permutation:)

Returns a transposed tensor, with dimensions permuted in the specified order.

Declaration

@differentiable(wrt: self)
public func transposed(permutation: Int...) -> Tensor
• transposed(withPermutations:)

Returns a transposed tensor, with dimensions permuted in the specified order.

Declaration

@available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Int...) -> Tensor
• transposed()

Returns a transposed tensor, with dimensions permuted in reverse order.

Declaration

@differentiable(wrt: self)
public func transposed() -> Tensor
• reversed(inAxes:)

Returns a tensor with specified dimensions reversed.

Precondition

Each value in axes must be in the range -rank..<rank.

Precondition

There must be no duplication in axes.

Declaration

@differentiable(wrt: self)
public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
• reversed(inAxes:)

Returns a tensor with specified dimensions reversed.

Precondition

Each value in axes must be in the range -rank..<rank.

Precondition

There must be no duplication in axes.

Declaration

@differentiable(wrt: self)
public func reversed(inAxes axes: [Int]) -> Tensor
• reversed(inAxes:)

Returns a tensor with specified dimensions reversed.

Precondition

Each value in axes must be in the range -rank..<rank.

Precondition

There must be no duplication in axes.

Declaration

@differentiable(wrt: self)
public func reversed(inAxes axes: Int...) -> Tensor
• concatenated(with:alongAxis:)

Returns a concatenated tensor along the specified axis.

Precondition

The tensors must have the same dimensions, except for the specified axis.

Precondition

The axis must be in the range -rank..<rank.

Declaration

@differentiable
public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor
• ++(_:_:)

Concatenation operator.

Note

++ is a custom operator that does not exist in Swift, but does in Haskell/Scala. Its addition is not an insignificant language change and may be controversial. The existence/naming of ++ will be discussed during a later API design phase.

Declaration

@differentiable
public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor
• gathering(atIndices:alongAxis:)

Returns a tensor by gathering slices of the input at indices along the axis dimension

For 0-D (scalar) indices:

result[p_0,          ..., p_{axis-1},
p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
indices,
p_{axis + 1}, ..., p_{N-1}]

For 1-D (vector) indices:

result[p_0,          ..., p_{axis-1},
i,
p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
indices[i],
p_{axis + 1}, ..., p_{N-1}]

In the general case, produces a resulting tensor where:

result[p_0,             ..., p_{axis-1},
i_{batch\_dims}, ..., i_{M-1},
p_{axis + 1},    ..., p_{N-1}] =
self[p_0,             ..., p_{axis-1},
indices[i_0,     ..., i_{M-1}],
p_{axis + 1},    ..., p_{N-1}]

where N = self.rank and M = indices.rank.

The shape of the resulting tensor is: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...].

Note

On CPU, if an out-of-range index is found, an error is thrown. On GPU, if an out-of-range index is found, a 0 is stored in the corresponding output values.

Precondition

axis must be in the range [-rank, rank).

Declaration

@differentiable(wrt: self)
public func gathering<Index: TensorFlowIndex>(
atIndices indices: Tensor<Index>,
alongAxis axis: Int = 0
) -> Tensor

Parameters

 indices Contains the indices to gather at. axis Dimension along which to gather. Negative values wrap around.

Return Value

The gathered tensor.

• batchGathering(atIndices:alongAxis:batchDimensionCount:)

Returns slices of this tensor at indices along the axis dimension, while ignoring the first batchDimensionCount dimensions that correspond to batch dimensions. The gather is performed along the first non-batch dimension.

Performs similar functionality to gathering, except that the resulting tensor shape is now shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...].

Precondition

axis must be in the range -rank..<rank, while also being greater than or equal to batchDimensionCount.

Precondition

batchDimensionCount must be less than indices.rank.

Declaration

@differentiable(wrt: self)
public func batchGathering<Index: TensorFlowIndex>(
atIndices indices: Tensor<Index>,
alongAxis axis: Int = 1,
batchDimensionCount: Int = 1
) -> Tensor

Parameters

 indices Contains the indices to gather. axis Dimension along which to gather. Negative values wrap around. batchDimensionCount Number of leading batch dimensions to ignore.

Return Value

The gathered tensor.

• gathering(where:alongAxis:)

Returns a tensor by gathering the values after applying the provided boolean mask to the input.

For example:

// 1-D example
// tensor is [0, 1, 2, 3]
// mask is [true, false, true, false]
tensor.gathering(where: mask) // is [0, 2]

// 2-D example
// tensor is [[1, 2], [3, 4], [5, 6]]
// mask is [true, false, true]
tensor.gathering(where: mask) // is [[1, 2], [5, 6]]

In general, 0 < mask.rank = K <= tensor.rank, and the mask‘s shape must match the first K dimensions of the tensor’s shape. We then have: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd], where [i1, ..., iK] is the ith true entry of mask (row-major order).

The axis could be used with mask to indicate the axis to mask from. In that case, axis + mask.rank <= tensor.rank and the mask's shape must match the first axis + mask.rankdimensions of thetensor`’s shape.

Precondition

Declaration

@differentiable(wrt: self)
public func gathering(where mask: Tensor<Bool>, alongAxis axis: Int = 0) -> Tensor

Parameters

 mask K-D boolean tensor, where K <= self.rank. axis 0-D integer tensor representing the axis in self to mask from, where K + axis <= self.rank.

Return Value

(self.rank - K + 1)-dimensional tensor populated by entries in this tensor corresponding to true values in mask.

• nonZeroIndices()

Returns the locations of non-zero / true values in this tensor.

The coordinates are returned in a 2-D tensor where the first dimension (rows) represents the number of non-zero elements, and the second dimension (columns) represents the coordinates of the non-zero elements. Keep in mind that the shape of the output tensor can vary depending on how many true values there are in this tensor. Indices are output in row-major order.

For example:

// 'input' is [[true, false], [true, false]]
// 'input' has 2 true values and so the output has 2 rows.
// 'input' has rank of 2, and so the second dimension of the output has size 2.
input.nonZeroIndices() // is [[0, 0], [1, 0]]

// 'input' is [[[ true, false], [ true, false]],
//             [[false,  true], [false,  true]],
//             [[false, false], [false,  true]]]
// 'input' has 5 true values and so the output has 5 rows.
// 'input' has rank 3, and so the second dimension of the output has size 3.
input.nonZeroIndices() // is [[0, 0, 0],
//     [0, 1, 0],
//     [1, 0, 1],
//     [1, 1, 1],
//     [2, 1, 1]]

Declaration

public func nonZeroIndices() -> Tensor<Int64>

Return Value

A tensor with shape (num_true, rank(condition)).

Declaration

@differentiable(wrt: self)
public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor

Declaration

@differentiable(wrt: self)
public func broadcasted(to shape: TensorShape) -> Tensor

Broadcast to the same shape as the specified Tensor.

Precondition

The specified shape must be compatible for broadcasting.

Declaration

@differentiable(wrt: self)
public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
• .=(_:_:)

Declaration

public static func .= (lhs: inout Tensor, rhs: Tensor)
• slice(lowerBounds:upperBounds:)

Extracts a slice from the tensor defined by lower and upper bounds for each dimension.

Declaration

@differentiable(wrt: self)
public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor

Parameters

 lowerBounds The lower bounds at each dimension. upperBounds The upper bounds at each dimension.
• slice(lowerBounds:sizes:)

Declaration

@differentiable(wrt: self)
public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor
• slice(lowerBounds:sizes:)

Declaration

@differentiable(wrt: self)
public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor
• subscript(_:)

Declaration

@differentiable(wrt: self)
public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }
• ensureValid(axes:function:file:line:)

Checks that each element of axes denotes an axis of self, and stops the program with a diagnostic otherwise.

Declaration

func ensureValid(
axes: Tensor<Int32>,
function: StaticString = #function,
file: StaticString = #file,
line: UInt = #line
)
• ensureValid(axes:function:file:line:)

Checks that each element of axes denotes an axis of self, and stops the program with a diagnostic otherwise.

Declaration

func ensureValid(
axes: [Int],
function: StaticString = #function,
file: StaticString = #file,
line: UInt = #line
)
• ensureValid(axis:function:file:line:)

Checks that k denotes an axis of self, and stops the program with a diagnostic otherwise.

Declaration

func ensureValid(
axis k: Int,
function: StaticString = #function,
file: StaticString = #file,
line: UInt = #line
)
• init(collating:)

Declaration

public init<BatchSamples: Collection>(collating samples: BatchSamples)
where BatchSamples.Element == Self
• init(copying:to:)

Creates a copy of other on the given Device.

Declaration

public init(copying other: Tensor, to device: Device)
• init(shape:repeating:)

Creates a tensor with the specified shape and a single, repeated scalar value.

Declaration

@available(*, deprecated, renamed: "init(repeating:shape:﹚")
public init(shape: TensorShape, repeating repeatedValue: Scalar)

Parameters

 shape The dimensions of the tensor. repeatedValue The scalar value to repeat.
• init(repeating:shape:on:)

Creates a tensor with the specified shape and a single, repeated scalar value.

Declaration

@differentiable
public init(
repeating repeatedValue: Scalar, shape: TensorShape,
on device: Device = .default
)

Parameters

 repeatedValue The scalar value to repeat. shape The dimensions of the tensor.

Creates a tensor by broadcasting the given scalar to a given rank with all dimensions being 1.

Declaration

public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
• init(_:)

Creates a tensor from an array of tensors (which may themselves be scalars).

Declaration

@differentiable
public init(_ elements: [Tensor])
• init(stacking:alongAxis:)

Stacks tensors, along the axis dimension, into a new tensor with rank one higher than the current tensor and each tensor in tensors.

Given that tensors all have shape [A, B, C], and tensors.count = N, then:

• if axis == 0 then the resulting tensor will have the shape [N, A, B, C].
• if axis == 1 then the resulting tensor will have the shape [A, N, B, C].
• etc.

For example:

// 'x' is [1, 4]
// 'y' is [2, 5]
// 'z' is [3, 6]
Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]

This is the opposite of Tensor.unstacked(alongAxis:).

Precondition

All tensors must have the same shape.

Precondition

axis must be in the range [-rank, rank), where rank is the rank of the provided tensors.

Declaration

@differentiable
public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)

Parameters

 tensors Tensors to stack. axis Dimension along which to stack. Negative values wrap around.

Return Value

The stacked tensor.

• init(concatenating:alongAxis:)

Concatenates tensors along the axis dimension.

Given that tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn], then the concatenated result has shape [D0, D1, ... Raxis, ...Dn], where Raxis = sum(Daxis(i)). That is, the data from the input tensors is joined along the axis dimension.

For example:

// t1 is [[1, 2, 3], [4, 5, 6]]
// t2 is [[7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

// t3 has shape [2, 3]
// t4 has shape [2, 3]
Tensor(concatenating: [t3, t4]) // has shape [4, 3]
Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]

Note

If you are concatenating along a new axis consider using Tensor.init(stacking:alongAxis:).

Precondition

All tensors must have the same rank and all dimensions except axis must be equal.

Precondition

axis must be in the range [-rank, rank), where rank is the rank of the provided tensors.

Declaration

@differentiable
public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)

Parameters

 tensors Tensors to concatenate. axis Dimension along which to concatenate. Negative values wrap around.

Return Value

The concatenated tensor.

• replacing(with:where:)

Replaces elements of this tensor with other in the lanes where mask is true.

Precondition

self and other must have the same shape. If self and other are scalar, then mask must also be scalar. If self and other have rank greater than or equal to 1, then mask must be either have the same shape as self or be a 1-D Tensor such that mask.scalarCount == self.shape.

Declaration

@differentiable(wrt: (self, other)
) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
• isReducedPrecision

Returns true if the physical scalar type is reduced precision.

Currently, reduced precision physical scalar types include only BFloat16.

Declaration

public var isReducedPrecision: Bool { get }
• init(_:deviceAndPrecisionLike:)

Promotes a scalar to a tensor with the same device and precision as the given tensor.

Declaration

@differentiable
public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
• toReducedPrecision

Returns a copy of self converted to BFloat16 physical scalar type.

Declaration

public var toReducedPrecision: `Self` { get }
• toFullPrecision

Returns a copy of self converted to Scalar physical scalar type.

Declaration

public var toFullPrecision: `Self` { get }
• rank

The number of dimensions of the Tensor.

Declaration

public var rank: Int { get }
• shape

The shape of the Tensor.

Declaration

public var shape: TensorShape { get }
• scalarCount

The number of scalars in the Tensor.

• scalarCount

Declaration

public var scalarCount: Int { get }
• rankTensor

The rank of the tensor, represented as a Tensor<Int32>.

Declaration

public var rankTensor: Tensor<Int32> { get }
• shapeTensor

The dimensions of the tensor, represented as a Tensor<Int32>.

Declaration

public var shapeTensor: Tensor<Int32> { get }
• scalarCountTensor

The number of scalars in the tensor, represented as a Tensor<Int32>.

Declaration

public var scalarCountTensor: Tensor<Int32> { get }
• isScalar

Returns true if rank is equal to 0 and false otherwise.

Declaration

public var isScalar: Bool { get }
• scalar

Returns the single scalar element if rank is equal to 0 and nil otherwise.

Declaration

public var scalar: Scalar? { get }
• scalarized()

Reshape to scalar.

Precondition

The tensor has exactly one scalar.

Declaration

@differentiable
public func scalarized() -> Scalar
• array

Declaration

public var array: ShapedArray<Scalar> { get }
• scalars

Declaration

@differentiable
public var scalars: [Scalar] { get }
• init(_:on:)

Creates a 0-D tensor from a scalar value.

Declaration

@differentiable
public init(_ value: Scalar, on device: Device = .default)
• init(_:on:)

Creates a 1D tensor from scalars.

Declaration

@differentiable
public init(_ scalars: [Scalar], on device: Device = .default)
• init(_:on:)

Creates a 1D tensor from scalars.

Declaration

public init<C: Collection>(
_ vector: C, on device: Device = .default
) where C.Element == Scalar
• init(shape:scalars:on:)

Creates a tensor with the specified shape and contiguous scalars in row-major order.

Precondition

The product of the dimensions of the shape must equal the number of scalars.

Declaration

@differentiable
public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)

Parameters

 shape The shape of the tensor. scalars The scalar contents of the tensor.
• init(shape:scalars:on:)

Creates a tensor with the specified shape and contiguous scalars in row-major order.

Precondition

The product of the dimensions of the shape must equal the number of scalars.

Declaration

public init(
shape: TensorShape,
scalars: UnsafeBufferPointer<Scalar>,
on device: Device = .default
)

Parameters

 shape The shape of the tensor. scalars The scalar contents of the tensor.
• init(shape:scalars:toReducedPrecision:directlyOn:)

Creates a tensor with the specified shape and contiguous scalars in row-major order.

Precondition

The product of the dimensions of the shape must equal the number of scalars.
• init(shape:scalars:on:)

Creates a tensor with the specified shape and contiguous scalars in row-major order.

Precondition

The product of the dimensions of the shape must equal the number of scalars.

Declaration

public init<C: Collection>(
shape: TensorShape, scalars: C, on device: Device = .default
) where C.Element == Scalar

Parameters

 shape The shape of the tensor. scalars The scalar contents of the tensor.
• ArrayLiteralElement

The type of the elements of an array literal.

Declaration

public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
• init(arrayLiteral:)

Creates a tensor initialized with the given elements.

Declaration

public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
• description

A textual representation of the tensor.

Note

use fullDescription for a non-pretty-printed description showing all scalars.

Declaration

public var description: String { get }
• description(lineWidth:edgeElementCount:summarizing:)

A textual representation of the tensor. Returns a summarized description if summarize is true and the element count exceeds twice the edgeElementCount.

Declaration

public func description(
lineWidth: Int = 80,
edgeElementCount: Int = 3,
summarizing: Bool = false
) -> String

Parameters

 lineWidth The max line width for printing. Used to determine number of scalars to print per line. edgeElementCount The maximum number of elements to print before and after summarization via ellipses (...). summarizing If true, summarize description if element count exceeds twice edgeElementCount.
• fullDescription

A full, non-pretty-printed textual representation of the tensor, showing all scalars.

Declaration

public var fullDescription: String { get }

• playgroundDescription

Declaration

public var playgroundDescription: Any { get }
• customMirror

Declaration

public var customMirror: Mirror { get }
• annotations

The annotations describing this tensor.

Declaration

public var annotations: String { get }
• summary

An alias for annotations.

Declaration

public var summary: String { get }
• init(_owning:)

Declaration

public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
• init(_handles:)

Declaration

public init<C: RandomAccessCollection>(
_handles: C
) where C.Element: _AnyTensorHandle
• init(_:on:)

Declaration

public init(_ array: ShapedArray<Scalar>, on device: Device = .default)
• init(_xla:)

Declaration

init(_xla: XLATensor)
• init(_xlaHandle:)

Declaration

init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)
• xlaHandle

Declaration

var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }
• xlaTensor

Declaration

var xlaTensor: XLATensor { get }

Declaration

@differentiable(wrt: self)
public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor

Declaration

@differentiable(wrt: self)
public func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar

Declaration

@differentiable(wrt: self)
public func unbroadcasted(to shape: TensorShape) -> Tensor

A mode that dictates how a tensor is padded.

Declaration

Returns a tensor padded with constant according to the specified padding sizes.

Declaration

@differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
-> Tensor

Returns a padded tensor according to the specified padding sizes and mode.

Declaration

@differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor
• .<(_:_:)

Returns a tensor of Boolean scalars by computing lhs < rhs element-wise.

Declaration

public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
• .<=(_:_:)

Returns a tensor of Boolean scalars by computing lhs <= rhs element-wise.

Declaration

public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
• .>(_:_:)

Returns a tensor of Boolean scalars by computing lhs > rhs element-wise.

Declaration

public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
• .>=(_:_:)

Returns a tensor of Boolean scalars by computing lhs >= rhs element-wise.

Declaration

public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
• .<(_:_:)

Returns a tensor of Boolean scalars by computing lhs < rhs element-wise.

Note

Declaration

public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
• .<=(_:_:)

Returns a tensor of Boolean scalars by computing lhs <= rhs element-wise.

Note

Declaration

public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
• .>(_:_:)

Returns a tensor of Boolean scalars by computing lhs > rhs element-wise.

Note

Declaration

public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
• .>=(_:_:)

Returns a tensor of Boolean scalars by computing lhs >= rhs element-wise.

Note

Declaration

public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
• .<(_:_:)

Returns a tensor of Boolean scalars by computing lhs < rhs element-wise.

Note

Declaration

public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
• .<=(_:_:)

Returns a tensor of Boolean scalars by computing lhs <= rhs element-wise.

Note

Declaration

public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
• .>(_:_:)

Returns a tensor of Boolean scalars by computing lhs > rhs element-wise.

Note

Declaration

public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
• .>=(_:_:)

Returns a tensor of Boolean scalars by computing lhs >= rhs element-wise.

Note

Declaration

public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
• .==(_:_:)

Returns a tensor of Boolean scalars by computing lhs == rhs element-wise.

Note

Declaration

public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
• .!=(_:_:)

Returns a tensor of Boolean scalars by computing lhs != rhs element-wise.

Note

Declaration

public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
• .==(_:_:)

Returns a tensor of Boolean scalars by computing lhs == rhs element-wise.

Note

Declaration

public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
• .!=(_:_:)

Returns a tensor of Boolean scalars by computing lhs != rhs element-wise.

Note

Declaration

public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
• .==(_:_:)

Returns a tensor of Boolean scalars by computing lhs == rhs element-wise.

Note

Declaration

public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
• .!=(_:_:)

Returns a tensor of Boolean scalars by computing lhs != rhs element-wise.

Note

Declaration

public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
• elementsAlmostEqual(_:tolerance:)

Returns a tensor of Boolean values indicating whether the elements of self are approximately equal to those of other.

Precondition

self and other must be of the same shape.

Declaration

public func elementsAlmostEqual(
_ other: Tensor,
tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Tensor<Bool>
• isAlmostEqual(to:tolerance:)

Returns true if all elements of self are approximately equal to those of other.

Precondition

self and other must be of the same shape.

Declaration

public func isAlmostEqual(
to other: Tensor,
tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
• crossReplicaSum(_:)

Runs a cross replica sum for this tensor. The same cross replica sum must happen on each of the other devices participating in the sum.

Declaration

public mutating mutating func crossReplicaSum(_ scale: Double)
• init(repeating:)

Declaration

@derivative
init(repeating: shape)
• init(_:)

Perform an element-wise type conversion from a Bool tensor.

Declaration

public init(_ other: Tensor<Bool>)
• init(_:)

Perform an element-wise conversion from another Tensor.

Declaration

@differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
• init(_:)

Declaration

@derivative
init(_: <<error type>>)
• init(stacking:)

Declaration

@derivative
init(stacking: alongAxis)
• init(concatenating:)

Declaration

@derivative
init(concatenating: alongAxis)
• init(zeros:on:)

Creates a tensor with all scalars set to zero.

Declaration

public init(zeros shape: TensorShape, on device: Device = .default)

Parameters

 shape Shape of the tensor.
• init(ones:on:)

Creates a tensor with all scalars set to one.

Declaration

public init(ones shape: TensorShape, on device: Device = .default)

Parameters

 shape Shape of the tensor.
• init(zerosLike:)

Creates a tensor with all scalars set to zero that has the same shape and type as the provided tensor.

Declaration

public init(zerosLike other: Tensor)

Parameters

 other Tensor whose shape and data type to use.
• init(onesLike:)

Creates a tensor with all scalars set to one that has the same shape and type as the provided tensor.

Declaration

public init(onesLike other: Tensor)

Parameters

 other Tensor whose shape and data type to use.
• init(rangeFrom:to:stride:on:)

Creates a 1-D tensor representing a sequence from a starting value to, but not including, an end value, stepping by the specified amount.

Declaration

public init(
rangeFrom start: Scalar, to end: Scalar, stride: Scalar,
on device: Device = .default
)

Parameters

 start The starting value to use for the sequence. If the sequence contains any values, the first one is start. end An end value to limit the sequence. end is never an element of the resulting sequence. stride The amount to step by with each iteration. stride must be positive.
• init(rangeFrom:to:stride:)

Creates a 1-D tensor representing a sequence from a starting value to, but not including, an end value, stepping by the specified amount.

Declaration

public init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>)

Parameters

 start The starting value to use for the sequence. If the sequence contains any values, the first one is start. end An end value to limit the sequence. end is never an element of the resulting sequence. stride The amount to step by with each iteration. stride must be positive.
• init(oneHotAtIndices:depth:onValue:offValue:axis:)

Creates a one-hot tensor at given indices. The locations represented by indices take value onValue (1 by default), while all other locations take value offValue (0 by default). If the input indices is rank n, the new tensor will have rank n+1. The new axis is created at dimension axis (by default, the new axis is appended at the end).

If indices is a scalar, the new tensor’s shape will be a vector of length depth.

If indices is a vector of length features, the output shape will be: features x depth, if axis == -1 depth x features, if axis == 0

If indices is a matrix (batch) with shape [batch, features], the output shape will be: batch x features x depth, if axis == -1 batch x depth x features, if axis == 1 depth x batch x features, if axis == 0

Declaration

public init(
oneHotAtIndices indices: Tensor<Int32>,
depth: Int,
onValue: Scalar = 1,
offValue: Scalar = 0,
axis: Int = -1
)

Parameters

 indices A Tensor of indices. depth A scalar defining the depth of the one hot dimension. onValue A scalar defining the value at the location referred to by some index in indices. offValue A scalar defining the value at a location that is not referred to by any index in indices. axis The axis to fill. The default is -1, a new inner-most axis.
• init(linearSpaceFrom:to:count:on:)

Creates a 1-D tensor representing a sequence from a starting value, up to and including an end value, spaced evenly to generate the number of values specified.

Declaration

public init(
linearSpaceFrom start: Scalar, to end: Scalar, count: Int, on device: Device = .default
)

Parameters

 start The starting value to use for the sequence. If the sequence contains any values, the first one is start. end An end value to limit the sequence. end is the last element of the resulting sequence. count The number of values in the resulting sequence. count must be positive.
• init(linearSpaceFrom:to:count:)

Creates a 1-D tensor representing a sequence from a starting value, up to and including an end value, spaced evenly to generate the number of values specified.

Precondition

start, to, and count must be Tensors containing a single Scalar value.

Declaration

public init(linearSpaceFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, count: Tensor<Int32>)

Parameters

 start The starting value to use for the sequence. If the sequence contains any values, the first one is start. end An end value to limit the sequence. end is the last element of the resulting sequence. count The number of values in the resulting sequence. count must be positive.
• init(randomUniform:lowerBound:upperBound:seed:on:)

Creates a tensor with the specified shape, randomly sampling scalar values from a uniform distribution between lowerBound and upperBound.

Declaration

public init(
randomUniform shape: TensorShape,
lowerBound: Tensor<Scalar>? = nil,
upperBound: Tensor<Scalar>? = nil,
seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. lowerBound The lower bound of the distribution. upperBound The upper bound of the distribution. seed The seed value.
• init(randomUniform:lowerBound:upperBound:seed:on:)

Creates a tensor with the specified shape, randomly sampling scalar values from a uniform distribution between lowerBound and upperBound.

Declaration

public init(
randomUniform shape: TensorShape,
lowerBound: Tensor<Scalar>? = nil,
upperBound: Tensor<Scalar>? = nil,
seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. lowerBound The lower bound of the distribution. upperBound The upper bound of the distribution. seed The seed value.
• init(randomNormal:mean:standardDeviation:seed:on:)

Creates a tensor with the specified shape, randomly sampling scalar values from a normal distribution.

Declaration

public init(
randomNormal shape: TensorShape,
mean: Tensor<Scalar>? = nil,
standardDeviation: Tensor<Scalar>? = nil,
seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. mean The mean of the distribution. standardDeviation The standard deviation of the distribution. seed The seed value.
• init(randomTruncatedNormal:mean:standardDeviation:seed:on:)

Creates a tensor with the specified shape, randomly sampling scalar values from a truncated Normal distribution.

Declaration

public init(
randomTruncatedNormal shape: TensorShape,
mean: Tensor<Scalar>? = nil,
standardDeviation: Tensor<Scalar>? = nil,
seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. mean The mean of the distribution. standardDeviation The standard deviation of the distribution. seed The seed value.
• init(randomCategorialLogits:sampleCount:seed:)

Creates a tensor by drawing samples from a categorical distribution.

Declaration

public init<T: TensorFlowFloatingPoint>(
randomCategorialLogits: Tensor<T>,
sampleCount: Int32,
seed: TensorFlowSeed = Context.local.randomSeed
)

Parameters

 randomCategorialLogits 2-D Tensor with shape [batchSize, classCount]. Each slice [i, :] represents the unnormalized log probabilities for all classes. sampleCount 0-D. Number of independent samples to draw for each row slice. seed The seed value.

Return Value

2-D Tensor with shape [batchSize, sampleCount]. Each slice [i, :] contains the drawn class labels with range [0, classCount).

• init(glorotUniform:seed:on:)

Creates a tensor with the specified shape by performing Glorot (Xavier) uniform initialization.

It draws random samples from a uniform distribution between -limit and limit generated by the default random number generator, where limit is sqrt(6 / (fanIn + fanOut)) and fanIn/fanOut represent the number of input and output features multiplied by the receptive field size.

Declaration

public init(
glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. seed The seed value.
• init(glorotNormal:seed:on:)

Creates a tensor with the specified shape by performing Glorot (Xavier) normal initialization.

It draws random samples from a truncated normal distribution centered on 0 with standard deviation sqrt(2 / (fanIn + fanOut)) generated by the default random number generator, where fanIn/fanOut represent the number of input and output features multiplied by the receptive field size.

Declaration

public init(
glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. seed The seed value.
• init(heUniform:seed:on:)

Creates a tensor with the specified shape by performing He (Kaiming) uniform initialization.

It draws random samples from a uniform distribution between -limit and limit generated by the default random number generator, where limit is sqrt(6 / fanIn) and fanIn represents the number of input features multiplied by the receptive field size.

Declaration

public init(
heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. seed The seed value.
• init(heNormal:seed:on:)

Creates a tensor with the specified shape by performing He (Kaiming) normal initialization.

It draws random samples from a truncated normal distribution centered on 0 with standard deviation sqrt(2 / fanIn)) generated by the default random number generator, where fanIn represents the number of input features multiplied by the receptive field size.

Declaration

public init(
heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. seed The seed value.
• init(leCunUniform:seed:on:)

Creates a tensor with the specified shape by performing LeCun uniform initialization.

It draws random samples from a uniform distribution between -limit and limit generated by the default random number generator, where limit is sqrt(3 / fanIn) and fanIn represents the number of input features multiplied by the receptive field size.

Reference: “Efficient BackProp”

Declaration

public init(
leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. seed The seed value.
• init(leCunNormal:seed:on:)

Creates a tensor with the specified shape by performing LeCun normal initialization.

It draws random samples from a truncated normal distribution centered on 0 with standard deviation sqrt(1 / fanIn) generated by the default random number generator, where fanIn represents the number of input features multiplied by the receptive field size.

Reference: “Efficient BackProp”

Declaration

public init(
leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
on device: Device = .default
)

Parameters

 shape The dimensions of the tensor. seed The seed value.
• init(orthogonal:gain:seed:)

Creates an orthogonal matrix or tensor.

If the shape of the tensor to initialize is two-dimensional, it is initialized with an orthogonal matrix obtained from the QR decomposition of a matrix of random numbers drawn from a normal distribution. If the matrix has fewer rows than columns then the output will have orthogonal rows. Otherwise, the output will have orthogonal columns.

If the shape of the tensor to initialize is more than two-dimensional, a matrix of shape [shape * ... * shape[rank - 2], shape[rank - 1]] is initialized. The matrix is subsequently reshaped to give a tensor of the desired shape.

Declaration

public init(
orthogonal shape: TensorShape,
gain: Tensor<Scalar> = Tensor<Scalar>(1),
seed: TensorFlowSeed = Context.local.randomSeed
)

Parameters

 shape The shape of the tensor. gain A multiplicative factor to apply to the orthogonal tensor. seed A tuple of two integers to seed the random number generator.
• diagonalPart()

Returns the [batched] diagonal part of a [batched] tensor. For the tensor instance of the shape [..., M, N], the output is a tensor of the shape [..., K], where K equals min(N, M).

For example:

// 't' is [[1, 0, 0, 0]
//         [0, 2, 0, 0]
//         [0, 0, 3, 0]
//         [0, 0, 0, 4]]
t.diagonalPart()
// [1, 2, 3, 4]

Declaration

@differentiable
public func diagonalPart() -> Tensor
• diagonal()

Constructs a [batched] diagonal array. For the tensor instance of the shape [..., M], the output is a tensor of the shape [..., M, M].

For example:

// 't' is [1, 2, 3, 4]

t.diagonal()
// [[1, 0, 0, 0]
//  [0, 2, 0, 0]
//  [0, 0, 3, 0]
//  [0, 0, 0, 4]]

Declaration

@differentiable
public func diagonal() -> Tensor
• withDiagonal(_:)

Returns self with new diagonal values, given that self is an optionally batched matrix.

The returned tensor has the same shape and values as self, except for the specified diagonals of the innermost matrices which are overwritten by the values in diagonal.

Parameter diagonal: A tensor with rank rank - 1 representing the new diagonal values.

Declaration

public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor
• bandPart(_:_:)

Declaration

@differentiable(wrt: self)
public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor
• bandPart(subdiagonalCount:superdiagonalCount:)

Returns a copy of a innermost tensor defined by a central band boundaries. The output is a tensor of the same shape as the instance [..., :, :].

For example:

// 't' is [[ 0,  1,  2, 3]
//         [-1,  0,  1, 2]
//         [-2, -1,  0, 1]
//         [-3, -2, -1, 0]]

t.bandPart(1, -1)
// [[ 0,  1,  2, 3]
//  [-1,  0,  1, 2]
//  [ 0, -1,  0, 1]
//  [ 0,  0, -1, 0]]

t.bandPart(2, 1)
// [[ 0,  1,  0, 0]
//  [-1,  0,  1, 0]
//  [-2, -1,  0, 1]
//  [ 0, -2, -1, 0]]

Declaration

@differentiable
public func bandPart(subdiagonalCount: Int, superdiagonalCount: Int) -> Tensor

Parameters

 subdiagonalCount The number of subdiagonals to keep. If negative, keep entire lower triangle. superdiagonalCount The number of superdiagonals to keep. If negative, keep entire upper triangle.
• qrDecomposition(fullMatrices:)

Returns the QR decomposition of each inner matrix in the tensor, a tensor with inner orthogonal matrices q and a tensor with inner upper triangular matrices r, such that the tensor is equal to matmul(q, r).

Declaration

public func qrDecomposition(fullMatrices: Bool = false) -> (
q: Tensor<Scalar>, r: Tensor<Scalar>
)

Parameters

 fullMatrices If true, compute full-sized q and r. Otherwise compute only the leading min(shape[rank - 1], shape[rank - 2]) columns of q.
• svd(computeUV:fullMatrices:)

Returns the singular value decomposition of self, given that self is an optionally batched matrix.

The singular value decomposition (SVD) of the optionally batched matrix self is values s, u, and v, such that:

self[..., :, :] = u[..., :, :]  s[..., :, :].diagonal()  v[..., :, :].transposed()`

selfmust be a tensor with shape[…, M, N]. LetK = min(M, N)`.

Precondition

self must be a tensor with shape [..., M, N].

Declaration

public func svd(computeUV: Bool = true, fullMatrices: Bool = false) -> (
s: Tensor<Scalar>, u: Tensor<Scalar>?, v: Tensor<Scalar>?
)

Parameters

 computeUV If true, the left and right singular vectors are computed and returned as u and v, respectively. If false, nil values are returned as u and v. fullMatrices If true, u and v respectively have shapes [..., M, M] and [..., N, N]. If false, u and v respectively have shapes [..., M, K] and [..., K, N]. Ignored when computeUV is false.

Return Value

• s: The singular values, with shape [..., K]. Within each vector, the singular values are sorted in descending order.
• u: The left singular vectors.
• v: The right singular vectors.
• sqrt(_:)

The square root of x.

For real types, if x is negative the result is .nan. For complex types there is a branch cut on the negative real axis.

Declaration

@differentiable
public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
• cos(_:)

The cosine of x, interpreted as an angle in radians.

Declaration

@differentiable
public static func cos(_ x: `Self`) -> Tensor<Scalar>
• sin(_:)

The sine of x, interpreted as an angle in radians.

Declaration

@differentiable
public static func sin(_ x: `Self`) -> Tensor<Scalar>
• tan(_:)

The tangent of x, interpreted as an angle in radians.

Declaration

@differentiable
public static func tan(_ x: `Self`) -> Tensor<Scalar>
• acos(_:)

The inverse cosine of x in radians.

Declaration

@differentiable
public static func acos(_ x: `Self`) -> Tensor<Scalar>
• asin(_:)

The inverse sine of x in radians.

Declaration

@differentiable
public static func asin(_ x: `Self`) -> Tensor<Scalar>
• atan(_:)

The inverse tangent of x in radians.

Declaration

@differentiable
public static func atan(_ x: `Self`) -> Tensor<Scalar>
• cosh(_:)

The hyperbolic cosine of x.

Declaration

@differentiable
public static func cosh(_ x: `Self`) -> Tensor<Scalar>
• sinh(_:)

The hyperbolic sine of x.

Declaration

@differentiable
public static func sinh(_ x: `Self`) -> Tensor<Scalar>
• tanh(_:)

The hyperbolic tangent of x.

Declaration

@differentiable
public static func tanh(_ x: `Self`) -> Tensor<Scalar>
• acosh(_:)

The inverse hyperbolic cosine of x.

Declaration

@differentiable
public static func acosh(_ x: `Self`) -> Tensor<Scalar>
• asinh(_:)

The inverse hyperbolic sine of x.

Declaration

@differentiable
public static func asinh(_ x: `Self`) -> Tensor<Scalar>
• atanh(_:)

The inverse hyperbolic tangent of x.

Declaration

@differentiable
public static func atanh(_ x: `Self`) -> Tensor<Scalar>
• exp(_:)

The exponential function applied to x, or e**x.

Declaration

@differentiable
public static func exp(_ x: `Self`) -> Tensor<Scalar>
• exp2(_:)

Two raised to to power x.

Declaration

@differentiable
public static func exp2(_ x: `Self`) -> Tensor<Scalar>
• exp10(_:)

Ten raised to to power x.

Declaration

@differentiable
public static func exp10(_ x: `Self`) -> Tensor<Scalar>
• expm1(_:)

exp(x) - 1 evaluated so as to preserve accuracy close to zero.

Declaration

@differentiable
public static func expm1(_ x: `Self`) -> Tensor<Scalar>
• log(_:)

The natural logarithm of x.

Declaration

@differentiable
public static func log(_ x: `Self`) -> Tensor<Scalar>
• log2(_:)

The base-two logarithm of x.

Declaration

@differentiable
public static func log2(_ x: `Self`) -> Tensor<Scalar>
• log10(_:)

The base-ten logarithm of x.

Declaration

@differentiable
public static func log10(_ x: `Self`) -> Tensor<Scalar>
• log1p(_:)

log(1 + x) evaluated so as to preserve accuracy close to zero.

Declaration

@differentiable
public static func log1p(_ x: `Self`) -> Tensor<Scalar>
• pow(_:_:)

exp(y log(x)) computed without loss of intermediate precision.

For real types, if x is negative the result is NaN, even if y has an integral value. For complex types, there is a branch cut on the negative real axis.

Declaration

@differentiable
public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
• pow(_:_:)

x raised to the nth power.

The product of n copies of x.

Declaration

@differentiable
public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
• root(_:_:)

The nth root of x.

For real types, if x is negative and n is even, the result is NaN. For complex types, there is a branch cut along the negative real axis.

Declaration

@differentiable
public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
• VectorSpaceScalar

Declaration

public typealias VectorSpaceScalar = Float
• scaled(by:)

Declaration

public func scaled(by scale: Float) -> Tensor<Scalar>

Declaration

public func adding(_ scalar: Float) -> Tensor<Scalar>
• subtracting(_:)

Declaration

public func subtracting(_ scalar: Float) -> Tensor<Scalar>
• +(_:_:)

Adds the scalar to every scalar of the tensor and produces the sum.

Declaration

@differentiable
public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
• +(_:_:)

Adds the scalar to every scalar of the tensor and produces the sum.

Declaration

@differentiable
public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
• -(_:_:)

Subtracts the scalar from every scalar of the tensor and produces the difference.

Declaration

@differentiable
public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
• -(_:_:)

Subtracts the scalar from every scalar of the tensor and produces the difference

Declaration

@differentiable
public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
• +=(_:_:)

Adds two tensors and stores the result in the left-hand-side variable.

Note

Declaration

public static func += (lhs: inout Tensor, rhs: Tensor)
• +=(_:_:)

Adds the scalar to every scalar of the tensor and stores the result in the left-hand-side variable.

Declaration

public static func += (lhs: inout Tensor, rhs: Scalar)
• -=(_:_:)

Subtracts the second tensor from the first and stores the result in the left-hand-side variable.

Note

Declaration

public static func -= (lhs: inout Tensor, rhs: Tensor)
• -=(_:_:)

Subtracts the scalar from every scalar of the tensor and stores the result in the left-hand-side variable.

Declaration

public static func -= (lhs: inout Tensor, rhs: Scalar)
• *(_:_:)

Returns the tensor produced by multiplying the two tensors.

Note

Declaration

@differentiable
public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
• *(_:_:)

Returns the tensor by multiplying it with every scalar of the tensor.

Declaration

@differentiable
public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
• *(_:_:)

Multiplies the scalar with every scalar of the tensor and produces the product.

Declaration

@differentiable
public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
• *=(_:_:)

Multiplies two tensors and stores the result in the left-hand-side variable.

Note

Declaration

public static func *= (lhs: inout Tensor, rhs: Tensor)
• *=(_:_:)

Multiplies the tensor with the scalar, broadcasting the scalar, and stores the result in the left-hand-side variable.

Declaration

public static func *= (lhs: inout Tensor, rhs: Scalar)
• /(_:_:)

Returns the quotient of dividing the first tensor by the second.

Note

Declaration

@differentiable
public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
• /(_:_:)

Returns the quotient of dividing the scalar by the tensor, broadcasting the scalar.

Declaration

@differentiable
public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
• /(_:_:)

Returns the quotient of dividing the tensor by the scalar, broadcasting the scalar.

Declaration

@differentiable
public static func / (lhs: Tensor, rhs: Scalar) -> Tensor
• /=(_:_:)

Divides the first tensor by the second and stores the quotient in the left-hand-side variable.

Declaration

public static func /= (lhs: inout Tensor, rhs: Tensor)
• /=(_:_:)

Divides the tensor by the scalar, broadcasting the scalar, and stores the quotient in the left-hand-side variable.

Declaration

public static func /= (lhs: inout Tensor, rhs: Scalar)
• %(_:_:)

Returns the remainder of dividing the first tensor by the second.

Note

Declaration

public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
• %(_:_:)

Returns the remainder of dividing the tensor by the scalar, broadcasting the scalar.

Declaration

public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
• %(_:_:)

Returns the remainder of dividing the scalar by the tensor, broadcasting the scalar.

Declaration

public static func % (lhs: Scalar, rhs: Tensor) -> Tensor
• %=(_:_:)

Divides the first tensor by the second and stores the remainder in the left-hand-side variable.

Declaration

public static func %= (lhs: inout Tensor, rhs: Tensor)
• %=(_:_:)

Divides the tensor by the scalar and stores the remainder in the left-hand-side variable.

Declaration

public static func %= (lhs: inout Tensor, rhs: Scalar)
• elementsLogicalNot()

Returns !self element-wise.

Declaration

public func elementsLogicalNot() -> Tensor
• elementsLogicalAnd(_:)

Returns self && other element-wise.

Note

Declaration

public func elementsLogicalAnd(_ other: Tensor) -> Tensor
• elementsLogicalAnd(_:)

Returns self && other element-wise, broadcasting other.

Declaration

public func elementsLogicalAnd(_ other: Scalar) -> Tensor
• elementsLogicalOr(_:)

Returns self || other element-wise.

Declaration

public func elementsLogicalOr(_ other: Tensor) -> Tensor
• elementsLogicalOr(_:)

Returns self || other element-wise, broadcasting other.

Declaration

public func elementsLogicalOr(_ other: Scalar) -> Tensor
• clipped(min:max:)

Returns max(min(self, max), min).

Declaration

@differentiable
public func clipped(min: Tensor, max: Tensor) -> Tensor
• clipped(min:max:)

Returns max(min(self, max), min).

Declaration

@differentiable(wrt: (self, min)
) public func clipped(min: Tensor, max: Scalar) -> Tensor
• clipped(min:max:)

Returns max(min(self, max), min).

Declaration

@differentiable(wrt: (self, max)
) public func clipped(min: Scalar, max: Tensor) -> Tensor
• clipped(min:max:)

Returns max(min(self, max), min).

Declaration

@differentiable(wrt: self)
public func clipped(min: Scalar, max: Scalar) -> Tensor
• -(_:)

Returns the negation of the specified tensor element-wise.

Declaration

@differentiable
public prefix static func - (rhs: Tensor) -> Tensor
• squared()

Declaration

@differentiable(wrt: self)
public func squared() -> Tensor
• isFinite

Returns a boolean tensor indicating which elements of x are finite.

Declaration

public var isFinite: Tensor<Bool> { get }
• isInfinite

Returns a boolean tensor indicating which elements of x are infinite.

Declaration

public var isInfinite: Tensor<Bool> { get }
• isNaN

Returns a boolean tensor indicating which elements of x are NaN-valued.

Declaration

public var isNaN: Tensor<Bool> { get }
• all()

Returns true if all scalars are equal to true. Otherwise, returns false.

Declaration

public func all() -> Bool
• any()

Returns true if any scalars are equal to true. Otherwise, returns false.

Declaration

public func any() -> Bool
• all(squeezingAxes:)

Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func all(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• any(squeezingAxes:)

Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func any(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• all(alongAxes:)

Performs a logical AND operation along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func all(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• any(alongAxes:)

Performs a logical OR operation along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func any(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• min()

Declaration

@differentiable
public func min() -> Tensor
• max()

Declaration

@differentiable
public func max() -> Tensor
• max(squeezingAxes:)

Returns the maximum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• max(squeezingAxes:)

Returns the maximum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func max(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• max(squeezingAxes:)

Returns the maximum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func max(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• min(squeezingAxes:)

Returns the minimum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• min(squeezingAxes:)

Returns the minimum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func min(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• min(squeezingAxes:)

Returns the minimum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func min(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• argmax(squeezingAxis:)

Returns the indices of the maximum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>

Parameters

 axes The dimensions to reduce.
• argmin(squeezingAxis:)

Returns the indices of the minimum values along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>

Parameters

 axes The dimensions to reduce.
• min(alongAxes:)

Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func min(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• min(alongAxes:)

Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func min(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• min(alongAxes:)

Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func min(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• max(alongAxes:)

Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func max(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• max(alongAxes:)

Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func max(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• max(alongAxes:)

Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func max(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• argmax()

Returns the index of the maximum value of the flattened scalars.

Declaration

public func argmax() -> Tensor<Int32>
• argmin()

Returns the index of the minimum value of the flattened scalars.

Declaration

public func argmin() -> Tensor<Int32>
• sum(squeezingAxes:)

Returns the sum along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• sum(squeezingAxes:)

Returns the sum along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func sum(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• sum(squeezingAxes:)

Returns the sum along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func sum(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• sum()

Declaration

@differentiable(wrt: self)
public func sum() -> Tensor
• sum(alongAxes:)

Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func sum(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• sum(alongAxes:)

Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func sum(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• sum(alongAxes:)

Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func sum(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• product(squeezingAxes:)

Returns the product along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• product(squeezingAxes:)

Returns the product along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func product(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• product(squeezingAxes:)

Returns the product along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func product(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• product()

Declaration

@differentiable(wrt: self)
public func product() -> Tensor
• product(alongAxes:)

Returns the product along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func product(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• product(alongAxes:)

Returns the product along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func product(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• product(alongAxes:)

Returns the product along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

public func product(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• mean(squeezingAxes:)

Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• mean(squeezingAxes:)

Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func mean(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• mean(squeezingAxes:)

Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank...rank.

Declaration

@differentiable(wrt: self)
public func mean(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• mean()

Declaration

@differentiable(wrt: self)
public func mean() -> Tensor
• mean(alongAxes:)

Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func mean(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• mean(alongAxes:)

Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func mean(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• mean(alongAxes:)

Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func mean(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• variance(squeezingAxes:)

Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• variance(squeezingAxes:)

Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func variance(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• variance(squeezingAxes:)

Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func variance(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• variance()

Declaration

@differentiable(wrt: self)
public func variance() -> Tensor
• variance(alongAxes:)

Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func variance(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• variance(alongAxes:)

Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func variance(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• variance(alongAxes:)

Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func variance(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• cumulativeSum(alongAxis:exclusive:reverse:)

Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])

By setting the exclusive argument to true, an exclusive cumulative sum is performed instead:

Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])

By setting the reverse argument to true, the cumulative sum is performed in the opposite direction:

Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
Tensor<Float>([a + b + c, a + b, a])

This is more efficient than separately reversing the resulting tensor.

Precondition

axis must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func cumulativeSum(
alongAxis axis: Int,
exclusive: Bool = false,
reverse: Bool = false
) -> Tensor

Parameters

 axis Axis along which to perform the cumulative sum operation. exclusive Indicates whether to perform an exclusive cumulative sum. reverse Indicates whether to perform the cumulative sum in reversed order.

Return Value

Result of the cumulative sum operation.

• cumulativeSum(alongAxis:exclusive:reverse:)

Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])

By setting the exclusive argument to true, an exclusive cumulative sum is performed instead:

Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])

By setting the reverse argument to true, the cumulative sum is performed in the opposite direction:

Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
Tensor<Float>([a + b + c, a + b, a])

This is more efficient than separately reversing the resulting tensor.

Precondition

axis.rank must be 0.

Precondition

axis must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func cumulativeSum(
alongAxis axis: Tensor<Int32>,
exclusive: Bool = false,
reverse: Bool = false
) -> Tensor

Parameters

 axis Axis along which to perform the cumulative sum operation. exclusive Indicates whether to perform an exclusive cumulative sum. reverse Indicates whether to perform the cumulative sum in reversed order.

Return Value

Result of the cumulative sum operation.

• cumulativeProduct(alongAxis:exclusive:reverse:)

Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])

By setting the exclusive argument to true, an exclusive cumulative product is performed instead:

Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])

By setting the reverse argument to true, the cumulative product is performed in the opposite direction:

Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
Tensor<Float>([a * b * c, a * b, a])

This is more efficient than separately reversing the resulting tensor.

Precondition

axis must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func cumulativeProduct(
alongAxis axis: Int,
exclusive: Bool = false,
reverse: Bool = false
) -> Tensor

Parameters

 axis Axis along which to perform the cumulative product operation. exclusive Indicates whether to perform an exclusive cumulative product. reverse Indicates whether to perform the cumulative product in reversed order.

Return Value

Result of the cumulative product operation.

• cumulativeProduct(alongAxis:exclusive:reverse:)

Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])

By setting the exclusive argument to true, an exclusive cumulative product is performed instead:

Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])

By setting the reverse argument to true, the cumulative product is performed in the opposite direction:

Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
Tensor<Float>([a * b * c, a * b, a])

This is more efficient than separately reversing the resulting tensor.

Precondition

axis must have rank 0.

Precondition

axis must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func cumulativeProduct(
alongAxis axis: Tensor<Int32>,
exclusive: Bool = false,
reverse: Bool = false
) -> Tensor

Parameters

 axis Axis along which to perform the cumulative product operation. exclusive Indicates whether to perform an exclusive cumulative product. reverse Indicates whether to perform the cumulative product in reversed order.

Return Value

Result of the cumulative product operation.

• standardDeviation(squeezingAxes:)

Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• standardDeviation(squeezingAxes:)

Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• standardDeviation(squeezingAxes:)

Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• standardDeviation()

Returns the standard deviation of all elements in this tensor. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func standardDeviation() -> Tensor
• standardDeviation(alongAxes:)

Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• standardDeviation(alongAxes:)

Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func standardDeviation(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• standardDeviation(alongAxes:)

Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel’s correction.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func standardDeviation(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• logSumExp(squeezingAxes:)

Returns log(exp(self).sum(squeezingAxes: axes)). The reduced dimensions are removed.

This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• logSumExp(squeezingAxes:)

Returns log(exp(self).sum(squeezingAxes: axes)). The reduced dimensions are removed.

This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• logSumExp(squeezingAxes:)

Returns log(exp(self).sum(squeezingAxes: axes)). The reduced dimensions are removed.

This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• logSumExp()

Returns log(exp(self).sum()). The result is a scalar.

This function is more numerically stable than computing log(exp(self).sum()) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

Declaration

@differentiable(wrt: self)
public func logSumExp() -> Tensor
• logSumExp(alongAxes:)

Returns log(exp(self).sum(alongAxes: axes)). The reduced dimensions are retained with value 1.

This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor

Parameters

 axes The dimensions to reduce.
• logSumExp(alongAxes:)

Returns log(exp(self).sum(alongAxes: axes)). The reduced dimensions are retained with value 1.

This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func logSumExp(alongAxes axes: [Int]) -> Tensor

Parameters

 axes The dimensions to reduce.
• logSumExp(alongAxes:)

Returns log(exp(self).sum(alongAxes: axes)). The reduced dimensions are retained with value 1.

This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func logSumExp(alongAxes axes: Int...) -> Tensor

Parameters

 axes The dimensions to reduce.
• moments(squeezingAxes:)

Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

Precondition

axes must have rank 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>

Parameters

 axes The dimensions to reduce.
• moments(squeezingAxes:)

Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

Parameters

 axes The dimensions to reduce.
• moments(squeezingAxes:)

Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

Parameters

 axes The dimensions to reduce.
• moments()

Returns the mean and variance of this tensor’s elements.

Declaration

@differentiable(wrt: self)
public func moments() -> Moments<Scalar>
• moments(alongAxes:)

Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1.

Precondition

axes must have rank 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>

Parameters

 axes The dimensions to reduce.
• moments(alongAxes:)

Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

Parameters

 axes The dimensions to reduce.
• moments(alongAxes:)

Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1.

Precondition

Each value in axes must be in the range -rank..<rank.

Declaration

@differentiable(wrt: self)
public func moments(alongAxes axes: Int...) -> Moments<Scalar>

Parameters

 axes The dimensions to reduce.
• •(_:_:)

Performs matrix multiplication between two tensors and produces the result.

Declaration

@differentiable
public static func  (lhs: Tensor, rhs: Tensor) -> Tensor
• vjpInitDeviceAndPrecisionLike(_:deviceAndPrecisionLike:)

Declaration

static func vjpInitDeviceAndPrecisionLike(
_ value: Scalar,
deviceAndPrecisionLike tensor: Tensor
) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))
• batchNormalized(alongAxis:offset:scale:epsilon:)

Returns a tensor computed from batch-normalizing the input along the specified axis.

Specifically, returns (self - mu) / (var + epsilon) * gamma + beta where mu and var are respectively the mean and variance of self along axis.

Declaration

@differentiable(wrt: (self, offset, scale)
public func batchNormalized(
alongAxis axis: Int,
offset: Tensor = Tensor(0),
scale: Tensor = Tensor(1),
epsilon: Scalar = 0.001
) -> Tensor

Parameters

 axis The batch dimension. offset The offset, also known as beta. scale The scale, also known as gamma. epsilon A small value added to the denominator for numerical stability.
• concatenate(_:_:)

Concatenates two tensors along last axis.

Declaration

@differentiable
public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
• sum(_:_:)

Adds two values and produces their sum.

Declaration

@differentiable
public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
• average(_:_:)

Averages two values.

Declaration

@differentiable
public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
• multiply(_:_:)

Multiplies two values.

Declaration

@differentiable
public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
• stack(_:_:)

Stack two values.

Declaration

@differentiable
public static func stack(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
• init(shape:)

Declaration

@derivative
init(shape: scalars)
• ==(_:_:)

Declaration

public static func == (lhs: Tensor, rhs: Tensor) -> Bool
• !=(_:_:)

Declaration

public static func != (lhs: Tensor, rhs: Tensor) -> Bool
• encode(to:)

Declaration

public func encode(to encoder: Encoder) throws
• init(from:)

Declaration

public init(from decoder: Decoder) throws
• zero

The scalar zero tensor.

• zero

Declaration

public static var zero: Tensor { get }
• +(_:_:)

Adds two tensors and produces their sum.

Note

Declaration

@differentiable
public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
• -(_:_:)

Subtracts one tensor from another and produces their difference.

Note

Declaration

@differentiable
public static func - (lhs: Tensor, rhs: Tensor) -> Tensor
• one

The scalar one tensor.

Declaration

public static var one: Tensor { get }
• reciprocal

Returns the element-wise reciprocal of self.

Declaration

public var reciprocal: Tensor { get }
• .*(_:_:)

Multiplies two tensors element-wise and produces their product.

Note

Declaration

public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
• TangentVector

Declaration

public typealias TangentVector = Tensor
• zeroTangentVectorInitializer

Declaration

public var zeroTangentVectorInitializer: () -> TangentVector { get }
• annotate(_:)

Note: Only X10 is supported. For other backends, umodified self is returned.

Declaration

@differentiable(wrt: self)
public func annotate(_ annotation: String) -> Tensor<Scalar>

Parameters

 annotation The annotation to be added.

Return Value

The annotated tensor.

• vjpAnnotate(_:)

Declaration

@derivative
func vjpAnnotate(_ annotation: String) -> (
value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar>
)
[]
[]