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

ベクトルと行列を潜在的に高次元に一般化した要素の多次元配列。

ジェネリック パラメーターScalarテンソル内のスカラーのタイプ ( Int32 、 Floatなど) を記述します。

  • 基礎となるTensorHandle 。

    注記

    handleユーザー定義の操作を許可するためにパブリックですが、通常は使用しないでください。

    宣言

    public let handle: TensorHandle<Scalar>

  • 宣言

    public init(handle: TensorHandle<Scalar>)

  • ランクRテンソルの指定された次元を複数のランク(R-1)テンソルにアンパックします。このテンソルをaxis次元に沿ってチッピングすることにより、このテンソルからNテンソルをアンパックします。ここで、 Nこのテンソルの形状から推測されます。たとえば、形状[A, B, C, D]のテンソルがあるとします。

    • axis == 0の場合、返される配列のi番目のテンソルはスライスself[i, :, :, :]であり、その配列内の各テンソルの形状は[B, C, D]になります。 ( Tensor.split(numSplits:alongAxis)やTensor.split(sizes:alongAxis)とは異なり、アンパックされた次元はなくなっていることに注意してください)。
    • axis == 1の場合、返される配列のi番目のテンソルはスライスvalue[:, i, :, :]であり、その配列内の各テンソルの形状は[A, C, D]になります。
    • 等。

    これはTensor.init(stacking:alongAxis:)の逆です。

    前提条件

    axis [-rank, rank)の範囲内になければなりません。rank rank指定されたテンソルのランクです。

    宣言

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

    パラメータ

    axis

    積み重ねを解除する寸法。負の値はラップアラウンドします。

    戻り値

    スタックされていないテンソルを含む配列。

  • テンソルを複数のテンソルに分割します。テンソルは次元axisに沿ってcountの小さなテンソルに分割されます。これには、 count shape[axis]を均等に分割する必要があります。

    例えば： 

    // '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[0] // has shape [5, 10]
parts[1] // has shape [5, 10]
parts[2] // has shape [5, 10]

    前提条件

    count寸法axisのサイズを均等に分割する必要があります。

    前提条件

    axis [-rank, rank)の範囲内になければなりません。rank rank指定されたテンソルのランクです。

    宣言

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

    パラメータ

    count

    作成する分割の数。

    axis

    このテンソルを分割する次元。負の値はラップアラウンドします。

    戻り値

    テンソル部分を含む配列。

  • テンソルを複数のテンソルに分割します。テンソルはsizes.shape[0]部分に分割されます。 i番目の部分の形状は、サイズがsizes[i]である次元axisに沿った点を除いて、このテンソルと同じ形状になります。

    例えば： 

    // '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[0] // has shape [5, 4]
parts[1] // has shape [5, 15]
parts[2] // has shape [5, 11]

    前提条件

    sizesの値は、合計が寸法axisのサイズに達する必要があります。

    前提条件

    axis [-rank, rank)の範囲内になければなりません。rank rank指定されたテンソルのランクです。

    宣言

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

    パラメータ

    sizes

    各分割のサイズを含む 1 次元テンソル。

    axis

    このテンソルを分割する次元。負の値はラップアラウンドします。

    戻り値

    テンソル部分を含む配列。

  • 宣言

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

  • このテンソルをタイル化することによって構築された、タイル化されたテンソルを返します。

    このコンストラクターは、このテンソルをmultiples回複製することで新しいテンソルを作成します。構築されたテンソルのi番目の次元にはself.shape[i] * multiples[i]要素があり、このテンソルの値はi番目の次元に沿ってmultiples[i]回複製されます。たとえば、 [abcd]を[2]でタイリングすると[abcdabcd]が生成されます。

    前提条件

    期待される倍数のrank 1でなければなりません。

    前提条件

    multiplesの形状は[tensor.rank]でなければなりません。

    前提条件

    multiples内のすべてのスカラーは非負でなければなりません。

    宣言

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

  • このテンソルをタイル化することによって構築された、タイル化されたテンソルを返します。

    このコンストラクターは、このテンソルをmultiples回複製することで新しいテンソルを作成します。構築されたテンソルのi番目の次元にはself.shape[i] * multiples[i]要素があり、このテンソルの値はi番目の次元に沿ってmultiples[i]回複製されます。たとえば、 [abcd]を[2]でタイリングすると[abcdabcd]が生成されます。

    前提条件

    期待される倍数のrank 1でなければなりません。

    前提条件

    multiplesの形状は[tensor.rank]でなければなりません。

    宣言

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

  • 指定されたTensorの形状に変形します。

    前提条件

    スカラーの数は新しい形状と一致します。

    宣言

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

  • 指定された形状に整形します。

    前提条件

    スカラーの数は新しい形状と一致します。

    宣言

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

  • 形状を表す指定されたTensorに変形します。

    前提条件

    スカラーの数は新しい形状と一致します。

    宣言

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

  • 1-D Tensorに折りたたまれたテンソルのコピーを行優先の順序で返します。

    宣言

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

  • 指定された形状インデックスに挿入された次元 1 を持つ、形状拡張されたTensorを返します。

    宣言

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

  • 指定された形状インデックスに挿入された次元 1 を持つ、形状拡張されたTensorを返します。

    宣言

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

  • 先頭次元が 1 のランクリフトされたTensorを返します。

    宣言

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

  • サイズ 1 の指定された次元をテンソルのシェイプから削除します。寸法が指定されていない場合は、サイズ 1 のすべての寸法が削除されます。

    宣言

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

  • サイズ 1 の指定された次元をテンソルのシェイプから削除します。寸法が指定されていない場合は、サイズ 1 のすべての寸法が削除されます。

    宣言

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

  • 指定された順序で次元を並べ替えた、転置されたテンソルを返します。

    宣言

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

  • 指定された順序で次元を並べ替えた、転置されたテンソルを返します。

    宣言

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

  • 指定された順序で次元を並べ替えた、転置されたテンソルを返します。

    宣言

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

  • 指定された順序で次元を並べ替えた、転置されたテンソルを返します。

    宣言

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

  • 指定された順序で次元を並べ替えた、転置されたテンソルを返します。

    宣言

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

  • 指定された順序で次元を並べ替えた、転置されたテンソルを返します。

    宣言

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

  • 次元を逆順に並べ替えた、転置されたテンソルを返します。

    宣言

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

  • 指定された次元を反転したテンソルを返します。

    前提条件

    axesの各値は-rank..<rank範囲内である必要があります。

    前提条件

    axesに重複があってはなりません。

    宣言

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

  • 指定された次元を反転したテンソルを返します。

    前提条件

    axesの各値は-rank..<rank範囲内である必要があります。

    前提条件

    axesに重複があってはなりません。

    宣言

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

  • 指定された次元を反転したテンソルを返します。

    前提条件

    axesの各値は-rank..<rank範囲内である必要があります。

    前提条件

    axesに重複があってはなりません。

    宣言

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

  • 指定された軸に沿って連結されたテンソルを返します。

    前提条件

    テンソルは、指定された軸を除き、同じ次元を持つ必要があります。

    前提条件

    軸は-rank..<rank範囲内にある必要があります。

    宣言

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

  • 連結演算子。

    注記

    ++ 、Swift には存在しないカスタム演算子ですが、Haskell/Scala には存在します。この追加は言語の重要な変更ではなく、物議を醸す可能性があります。 ++の存在と名前については、後の API 設計フェーズで説明します。

    宣言

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

  • axis次元に沿ったindicesで入力のスライスを収集することによってテンソルを返します。

    0-D (スカラー) 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}]

    1-D (ベクトル) 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}]

    一般的なケースでは、次のような結果のテンソルが生成されます。 

    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}]

    ここで、 N = self.rankおよびM = indices.rankです。

    結果として得られるテンソルの形状は、 self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...]となります。

    注記

    CPU では、範囲外のインデックスが見つかった場合、エラーがスローされます。 GPU では、範囲外のインデックスが見つかった場合、対応する出力値に 0 が格納されます。

    前提条件

    axis [-rank, rank)の範囲内にある必要があります。

    宣言

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

    パラメータ

    indices

    収集するインデックスが含まれます。

    axis

    集まる次元。負の値はラップアラウンドします。

    戻り値

    集められたテンソル。

  • バッチ次元に対応する最初のbatchDimensionCount次元を無視して、 axis次元に沿ったindicesでこのテンソルのスライスを返します。収集は、最初の非バッチ次元に沿って実行されます。

    結果のテンソル形状がshape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...]になることを除いて、 gatheringと同様の機能を実行します。

    前提条件

    axis -rank..<rankの範囲内である必要があり、また、 batchDimensionCount以上である必要があります。

    前提条件

    batchDimensionCount 、 indices.rankより小さくなければなりません。

    宣言

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

    パラメータ

    indices

    収集するインデックスが含まれます。

    axis

    集まる次元。負の値はラップアラウンドします。

    batchDimensionCount

    無視する先頭のバッチ次元の数。

    戻り値

    集められたテンソル。

  • 提供されたブール マスクを入力に適用した後に値を収集することにより、テンソルを返します。

    例えば： 

    // 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]]

    一般に、 0 < mask.rank = K <= tensor.rank 、 maskの形状は、 tensorの形状の最初の K 次元と一致する必要があります。次にtensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , where [i1, ..., iK]は、 maskのi番目のtrueエントリ (行優先順) です。

    axisをmaskとともに使用して、マスクする軸を示すことができます。その場合、 axis + mask.rank <= tensor.rank 、 mask 's shape must match the first 、テンソルの形状dimensions of theと一致する必要があります。

    前提条件

    maskスカラーにすることはできません ( mask.rank != 0 。

    宣言

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

    パラメータ

    mask

    KD ブールテンソル、ここでK <= self.rank 。

    axis

    マスクするselfの軸を表す 0 次元の整数テンソル。ここで、 K + axis <= self.rank 。

    戻り値

    (self.rank - K + 1)次元テンソル。 maskのtrue値に対応するこのテンソルのエントリによって設定されます。

  • このテンソル内の非ゼロ/真の値の位置を返します。

    座標は 2 次元テンソルで返されます。最初の次元 (行) は非ゼロ要素の数を表し、2 番目の次元 (列) は非ゼロ要素の座標を表します。出力テンソルの形状は、このテンソルに存在する真の値の数に応じて変化する可能性があることに注意してください。インデックスは行優先の順序で出力されます。

    例えば： 

    // '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]]

    宣言

    public func nonZeroIndices() -> Tensor<Int64>

    戻り値

    形状(num_true, rank(condition))のテンソル。

  • 宣言

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

  • 宣言

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

  • 指定されたTensorと同じ形状にブロードキャストします。

    前提条件

    指定された形状はブロードキャストに対応している必要があります。

    宣言

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

  • 宣言

    public static func .= (lhs: inout Tensor, rhs: Tensor)

  • 各次元の下限と上限によって定義されたテンソルからスライスを抽出します。

    宣言

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

    パラメータ

    lowerBounds

    各次元の下限。

    upperBounds

    各次元の上限。

  • 宣言

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

  • 宣言

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

  • 宣言

    @differentiable(wrt: self)
public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }

  • axesの各要素がselfの軸を示しているかどうかを確認し、そうでない場合は診断を行ってプログラムを停止します。

    宣言

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

  • axesの各要素がselfの軸を示しているかどうかを確認し、そうでない場合は診断を行ってプログラムを停止します。

    宣言

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

  • k selfの軸を示しているかどうかを確認し、それ以外の場合は診断を行ってプログラムを停止します。

    宣言

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

  • 宣言

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

  • 指定されたDevice上にotherのコピーを作成します。

    宣言

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

  • 指定された形状と単一の繰り返しスカラー値を持つテンソルを作成します。

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    repeatedValue

    繰り返すスカラー値。

  • 指定された形状と単一の繰り返しスカラー値を持つテンソルを作成します。

    宣言

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

    パラメータ

    repeatedValue

    繰り返すスカラー値。

    shape

    テンソルの次元。

  • すべての次元が 1 である指定されたスカラーを指定されたランクにブロードキャストすることにより、テンソルを作成します。

    宣言

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

  • テンソルの配列 (それ自体がスカラーである場合もあります) からテンソルを作成します。

    宣言

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

  • tensors axis次元に沿って、現在の tensor およびtensors内の各 tensor よりランク 1 高い新しい tensor にスタックします。

    tensorsすべて[A, B, C]の形状を持ち、 tensors.count = Nあるとすると、次のようになります。

    • axis == 0の場合、結果として得られるテンソルの形状は[N, A, B, C]になります。
    • axis == 1の場合、結果のテンソルの形状は[A, N, B, C]になります。
    • 等

    例えば： 

    // '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]]

    これはTensor.unstacked(alongAxis:)の逆です。

    前提条件

    すべてのテンソルは同じ形状でなければなりません。

    前提条件

    axis [-rank, rank)の範囲内になければなりません。rank rank指定されたテンソルのランクです。

    宣言

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

    パラメータ

    tensors

    スタックするテンソル。

    axis

    積み重ねる寸法。負の値はラップアラウンドします。

    戻り値

    積み上げテンソル。

  • axis次元に沿ってtensorsを連結します。

    tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn]とすると、連結された結果の形状は[D0, D1, ... Raxis, ...Dn]になります。ここでRaxis = sum(Daxis(i)) 。つまり、入力テンソルからのデータはaxis次元に沿って結合されます。

    例えば： 

    // 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]

    注記

    新しい軸に沿って連結する場合はTensor.init(stacking:alongAxis:)の使用を検討してください。

    前提条件

    すべてのテンソルは同じランクを持つ必要があり、 axisを除くすべての次元が等しい必要があります。

    前提条件

    axis [-rank, rank)の範囲内である必要があります。rank rank指定されたテンソルのランクです。

    宣言

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

    パラメータ

    tensors

    連結するテンソル。

    axis

    連結する次元。負の値はラップアラウンドします。

    戻り値

    連結されたテンソル。

  • このテンソルの要素を、 maskがtrueであるレーン内のother要素に置き換えます。

    前提条件

    selfとother同じ形でなければなりません。 selfとotherスカラーの場合、 maskもスカラーでなければなりません。 selfとotherランクが1以上の場合、 mask selfと同じ形状を持つか、またはmask.scalarCount == self.shape[0]となる 1 次元Tensorなければなりません。

    宣言

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

  • 物理スカラー型の精度が低い場合は true を返します。

    現在、精度の低い物理スカラー型にはBFloat16のみが含まれます。

    宣言

    public var isReducedPrecision: Bool { get }

  • 指定されたテンソルと同じデバイスと精度でスカラーをテンソルにプロモートします。

    宣言

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

  • BFloat16物理スカラー型に変換されたselfのコピーを返します。

    宣言

    public var toReducedPrecision: `Self` { get }

  • Scalar物理スカラー型に変換されたselfのコピーを返します。

    宣言

    public var toFullPrecision: `Self` { get }

  • Tensorの次元数。

    宣言

    public var rank: Int { get }

  • Tensorの形状。

    宣言

    public var shape: TensorShape { get }

  • Tensor内のスカラーの数。

  • 宣言

    public var scalarCount: Int { get }

  • テンソルのランク。 Tensor<Int32>として表されます。

    宣言

    public var rankTensor: Tensor<Int32> { get }

  • テンソルの次元。 Tensor<Int32>として表されます。

    宣言

    public var shapeTensor: Tensor<Int32> { get }

  • テンソル内のスカラーの数。 Tensor<Int32>として表されます。

    宣言

    public var scalarCountTensor: Tensor<Int32> { get }

  • rankが 0 に等しい場合はtrue返し、それ以外の場合はfalse返します。

    宣言

    public var isScalar: Bool { get }

  • rankが 0 に等しい場合は単一のスカラー要素を返し、それ以外の場合はnil返します。

    宣言

    public var scalar: Scalar? { get }

  • スカラーに変形します。

    前提条件

    テンソルにはスカラーが 1 つだけあります。

    宣言

    @differentiable
public func scalarized() -> Scalar

  • 宣言

    public var array: ShapedArray<Scalar> { get }

  • 宣言

    @differentiable
public var scalars: [Scalar] { get }

  • スカラー値から 0 次元のテンソルを作成します。

    宣言

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

  • スカラーから 1D テンソルを作成します。

    宣言

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

  • スカラーから 1D テンソルを作成します。

    宣言

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

  • 指定された形状と連続したスカラーを持つテンソルを行優先の順序で作成します。

    前提条件

    形状の寸法の積は、スカラーの数と等しくなければなりません。

    宣言

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

    パラメータ

    shape

    テンソルの形状。

    scalars

    テンソルのスカラー内容。

  • 指定された形状と連続したスカラーを持つテンソルを行優先の順序で作成します。

    前提条件

    形状の寸法の積は、スカラーの数と等しくなければなりません。

    宣言

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

    パラメータ

    shape

    テンソルの形状。

    scalars

    テンソルのスカラー内容。

  • 指定された形状と連続したスカラーを持つテンソルを行優先の順序で作成します。

    前提条件

    形状の寸法の積は、スカラーの数と等しくなければなりません。

  • 指定された形状と連続したスカラーを持つテンソルを行優先の順序で作成します。

    前提条件

    形状の寸法の積は、スカラーの数と等しくなければなりません。

    宣言

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

    パラメータ

    shape

    テンソルの形状。

    scalars

    テンソルのスカラー内容。

  • 配列リテラルの要素の型。

    宣言

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

  • 指定された要素で初期化されたテンソルを作成します。

    宣言

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

  • テンソルのテキスト表現。

    注記

    すべてのスカラーを表示する、美しく印刷されない説明には、 fullDescriptionを使用します。

    宣言

    public var description: String { get }

  • テンソルのテキスト表現。 summarizeが true で、要素数がedgeElementCount 2 倍を超える場合、要約された説明を返します。

    宣言

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

    パラメータ

    lineWidth

    印刷時の最大線幅。 1 行あたりに出力するスカラーの数を決定するために使用されます。

    edgeElementCount

    省略記号 ( ... ) による要約の前後に出力する要素の最大数。

    summarizing

    true の場合、要素数がedgeElementCount 2倍を超えた場合に説明を要約します。

  • すべてのスカラーを示す、テンソルの完全な、美しく印刷されていないテキスト表現。

    宣言

    public var fullDescription: String { get }

  • 宣言

    public var playgroundDescription: Any { get }

  • 宣言

    public var customMirror: Mirror { get }

  • このテンソルを説明するアノテーション。

    宣言

    public var annotations: String { get }

  • 注釈のエイリアス。

    宣言

    public var summary: String { get }

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

    init(_xla: XLATensor)

  • 宣言

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

  • 宣言

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

  • 宣言

    var xlaTensor: XLATensor { get }
`Scalar`: `Numeric` の場合に利用可能

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • テンソルをパディングする方法を決定するモード。

    宣言

    public enum PaddingMode

  • 指定されたパディング サイズに従って定数でパディングされたテンソルを返します。

    宣言

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

  • 指定されたパディング サイズとモードに従ってパディングされたテンソルを返します。

    宣言

    @differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor
`Scalar`: `Numeric` & `Comparable` で利用可能

  • lhs < rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    宣言

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

  • lhs <= rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    宣言

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

  • lhs > rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    宣言

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

  • lhs >= rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    宣言

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

  • lhs < rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .<ブロードキャストをサポートします。

    宣言

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

  • lhs <= rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .<=ブロードキャストをサポートします。

    宣言

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

  • lhs > rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .>ブロードキャストをサポートします。

    宣言

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

  • lhs >= rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .>=ブロードキャストをサポートします。

    宣言

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

  • lhs < rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .<ブロードキャストをサポートします。

    宣言

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

  • lhs <= rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .<=ブロードキャストをサポートします。

    宣言

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

  • lhs > rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .>ブロードキャストをサポートします。

    宣言

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

  • lhs >= rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .>=ブロードキャストをサポートします。

    宣言

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
`Scalar`: `Equatable` で利用可能

  • lhs == rhs要素ごとに計算することにより、ブール スカラーのテンソルを返します。

    注記

    .==ブロードキャストをサポートします。

    宣言

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

  • lhs != rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .!=ブロードキャストをサポートします。

    宣言

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

  • lhs == rhs要素ごとに計算することにより、ブール スカラーのテンソルを返します。

    注記

    .==ブロードキャストをサポートします。

    宣言

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

  • lhs != rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .!=ブロードキャストをサポートします。

    宣言

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

  • lhs == rhs要素ごとに計算することにより、ブール スカラーのテンソルを返します。

    注記

    .==ブロードキャストをサポートします。

    宣言

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

  • lhs != rhs要素ごとに計算して、ブール スカラーのテンソルを返します。

    注記

    .!=ブロードキャストをサポートします。

    宣言

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
`Scalar`: `TensorFlowFloatingPoint` および `Equatable` で利用可能

  • selfの要素がotherの要素とほぼ等しいかどうかを示すブール値のテンソルを返します。

    前提条件

    selfとother同じ形でなければなりません。

    宣言

    public func elementsAlmostEqual(
  _ other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Tensor<Bool>
`Scalar`: `TensorFlowFloatingPoint` で利用可能

  • selfのすべての要素がotherの要素とほぼ等しい場合、 true返します。

    前提条件

    selfとother同じ形でなければなりません。

    宣言

    public func isAlmostEqual(
  to other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
`Scalar`: `TensorFlowNumeric` で利用可能

  • このテンソルのクロスレプリカ合計を実行します。同じ相互レプリカの合計が、合計に参加している他の各デバイスでも発生する必要があります。

    宣言

    public mutating mutating func crossReplicaSum(_ scale: Double)
`Scalar`: `TensorFlowFloatingPoint` で利用可能
`Scalar`: `Numeric` の場合に利用可能

  • Boolテンソルから要素ごとの型変換を実行します。

    宣言

    public init(_ other: Tensor<Bool>)

  • 別のTensorから要素ごとの変換を実行します。

    宣言

    @differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
`Scalar`: `TensorFlowFloatingPoint` で利用可能
`Scalar`: `Numeric` の場合に利用可能

  • すべてのスカラーを 0 に設定してテンソルを作成します。

    宣言

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

    パラメータ

    shape

    テンソルの形状。

  • すべてのスカラーを 1 に設定してテンソルを作成します。

    宣言

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

    パラメータ

    shape

    テンソルの形状。

  • すべてのスカラーが 0 に設定され、指定されたテンソルと同じ形状と型を持つテンソルを作成します。

    宣言

    public init(zerosLike other: Tensor)

    パラメータ

    other

    使用する形状とデータ型のテンソル。

  • すべてのスカラーが、指定されたテンソルと同じ形状と型を持つ 1 つに設定されたテンソルを作成します。

    宣言

    public init(onesLike other: Tensor)

    パラメータ

    other

    使用する形状とデータ型のテンソル。

  • 開始値から終了値までのシーケンスを表す 1 次元テンソルを作成します (指定された量ずつステップ)。

    宣言

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

    パラメータ

    start

    シーケンスに使用する開始値。シーケンスに値が含まれている場合、最初の値はstartです。

    end

    シーケンスを制限する終了値。 end結果のシーケンスの要素になることはありません。

    stride

    各反復でステップバイする量。 stride正の値でなければなりません。

  • 開始値から終了値までのシーケンスを表す 1 次元テンソルを作成します (指定された量ずつステップ)。

    宣言

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

    パラメータ

    start

    シーケンスに使用する開始値。シーケンスに値が含まれている場合、最初の値はstartです。

    end

    シーケンスを制限する終了値。 end結果のシーケンスの要素になることはありません。

    stride

    各反復でステップバイする量。 stride正の値でなければなりません。

  • 指定されたインデックスでワンホット テンソルを作成します。 indicesで表される位置は値onValue (デフォルトでは1 ) をとり、他のすべての位置は値offValue (デフォルトでは0 ) をとります。入力indicesがランクnの場合、新しいテンソルのランクはn+1になります。新しい軸はディメンションaxisに作成されます (デフォルトでは、新しい軸は最後に追加されます)。

    indicesがスカラーの場合、新しいテンソルの形状は長さdepthのベクトルになります。

    indices長さのfeaturesのベクトルである場合、出力形状は次のようになります: 特徴 x 深さ (軸 == -1 の場合) 深さ x 特徴 (軸 == 0 の場合)

    indicesが形状[batch, features]の行列 (バッチ) の場合、出力形状は次のようになります: バッチ x 特徴 x 深さ (軸 == -1 の場合) バッチ x 深さ x 特徴 (軸 == 1 深さ x バッチ x 特徴の場合) 、軸 == 0 の場合

    宣言

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

    パラメータ

    indices

    インデックスのTensor 。

    depth

    1 つのホット ディメンションの深さを定義するスカラー。

    onValue

    indices内の一部のインデックスによって参照される位置の値を定義するスカラー。

    offValue

    indices内のどのインデックスからも参照されない位置の値を定義するスカラー。

    axis

    塗りつぶす軸。デフォルトは-1で、新しい最も内側の軸です。

`Scalar`: `TensorFlowFloatingPoint` で利用可能

  • 開始値から終了値までのシーケンスを表す 1 次元テンソルを等間隔で作成し、指定された数の値を生成します。

    宣言

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

    パラメータ

    start

    シーケンスに使用する開始値。シーケンスに値が含まれている場合、最初の値はstartです。

    end

    シーケンスを制限する終了値。 end 、結果のシーケンスの最後の要素です。

    count

    結果として得られるシーケンス内の値の数。 count正の値でなければなりません。

  • 開始値から終了値までのシーケンスを表す 1 次元テンソルを等間隔で作成し、指定された数の値を生成します。

    前提条件

    start 、 to 、 count 、単一のスカラー値を含む Tensor である必要があります。

    宣言

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

    パラメータ

    start

    シーケンスに使用する開始値。シーケンスに値が含まれている場合、最初の値はstartです。

    end

    シーケンスを制限する終了値。 end 、結果のシーケンスの最後の要素です。

    count

    結果として得られるシーケンス内の値の数。 count正の値でなければなりません。

`Scalar`: `TensorFlowIndex` で利用可能

  • lowerBoundとupperBoundの間の一様分布からスカラー値をランダムにサンプリングして、指定された形状のテンソルを作成します。

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    lowerBound

    分布の下限。

    upperBound

    分布の上限。

    seed

    シード値。

`Scalar`: `TensorFlowFloatingPoint` で利用可能

  • lowerBoundとupperBoundの間の一様分布からスカラー値をランダムにサンプリングして、指定された形状のテンソルを作成します。

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    lowerBound

    分布の下限。

    upperBound

    分布の上限。

    seed

    シード値。

  • 正規分布からスカラー値をランダムにサンプリングして、指定された形状のテンソルを作成します。

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    mean

    分布の平均。

    standardDeviation

    分布の標準偏差。

    seed

    シード値。

  • 切り詰められた正規分布からスカラー値をランダムにサンプリングして、指定された形状のテンソルを作成します。

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    mean

    分布の平均。

    standardDeviation

    分布の標準偏差。

    seed

    シード値。

`Scalar`: `TensorFlowIndex` で利用可能

  • カテゴリ分布からサンプルを抽出してテンソルを作成します。

    宣言

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

    パラメータ

    randomCategorialLogits

    形状[batchSize, classCount]の 2 次元テンソル。各スライス[i, :]すべてのクラスの非正規化対数確率を表します。

    sampleCount

    0-D。各行スライスに対して描画する独立したサンプルの数。

    seed

    シード値。

    戻り値

    形状[batchSize, sampleCount]の 2 次元テンソル。各スライス[i, :]範囲[0, classCount)の描画されたクラス ラベルが含まれています。

`Scalar`: `TensorFlowFloatingPoint` で利用可能

  • Glorot (Xavier) 均一初期化を実行して、指定された形状のテンソルを作成します。

    これは、デフォルトの乱数ジェネレーターによって生成された-limitとlimitの間の一様分布からランダムなサンプルを抽出します。ここで、 limitはsqrt(6 / (fanIn + fanOut))であり、 fanIn / fanOut入力および出力特徴の数と受容機能を乗算した数を表します。フィールドサイズ。

    参考： 「ディープフィードフォワードニューラルネットワークの学習の難しさを理解する」

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    seed

    シード値。

  • Glorot (Xavier) 法線初期化を実行して、指定された形状のテンソルを作成します。

    デフォルトの乱数ジェネレーターによって生成された標準偏差sqrt(2 / (fanIn + fanOut))をもつ、 0を中心とする切り捨て正規分布からランダム サンプルを抽出します。ここで、 fanIn / fanOut 、入力および出力の特徴の数と受容野の積を表します。サイズ。

    参考： 「ディープフィードフォワードニューラルネットワークの学習の難しさを理解する」

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    seed

    シード値。

  • He (Kaiming) 均一初期化を実行して、指定された形状のテンソルを作成します。

    これは、デフォルトの乱数ジェネレーターによって生成された-limitとlimitの間の一様分布からランダムなサンプルを抽出します。ここで、 limitはsqrt(6 / fanIn)であり、 fanIn入力特徴の数と受容野サイズを乗算したものを表します。

    参考資料: 「整流器の詳細: ImageNet 分類における人間レベルのパフォーマンスを超える」

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    seed

    シード値。

  • He (Kaiming) 法線初期化を実行して、指定された形状のテンソルを作成します。

    デフォルトの乱数ジェネレーターによって生成された、 0を中心とした標準偏差sqrt(2 / fanIn))の切り捨て正規分布からランダム サンプルを抽出します。ここで、 fanIn入力特徴の数と受容野サイズを乗算したものを表します。

    参考資料: 「整流器の詳細: ImageNet 分類における人間レベルのパフォーマンスを超える」

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    seed

    シード値。

  • LeCun 均一初期化を実行して、指定された形状のテンソルを作成します。

    これは、デフォルトの乱数ジェネレーターによって生成された-limitとlimitの間の一様分布からランダムなサンプルを抽出します。ここで、 limitはsqrt(3 / fanIn)であり、 fanIn入力特徴の数と受容野サイズを乗算したものを表します。

    参考： 「効率的なBackProp」

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    seed

    シード値。

  • LeCun 法線初期化を実行して、指定された形状のテンソルを作成します。

    これは、デフォルトの乱数ジェネレーターによって生成された標準偏差sqrt(1 / fanIn)を持つ0を中心とする切り捨て正規分布からランダム サンプルを抽出します。ここで、 fanIn入力特徴の数と受容野サイズを乗算したものを表します。

    参考： 「効率的なBackProp」

    宣言

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

    パラメータ

    shape

    テンソルの次元。

    seed

    シード値。

  • 直交行列またはテンソルを作成します。

    初期化するテンソルの形状が 2 次元の場合、正規分布から抽出された乱数行列の QR 分解から得られる直交行列で初期化されます。行列の行数が列数よりも少ない場合、出力には直交する行が含まれます。それ以外の場合、出力には直交する列が含まれます。

    初期化するテンソルの形状が 2 次元以上の場合、形状[shape[0] * ... * shape[rank - 2], shape[rank - 1]]行列が初期化されます。その後、行列は再形成されて、目的の形状のテンソルが得られます。

    宣言

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

    パラメータ

    shape

    テンソルの形状。

    gain

    直交テンソルに適用する乗算係数。

    seed

    乱数ジェネレーターのシードとなる 2 つの整数のタプル。

`Scalar`: `TensorFlowNumeric` で利用可能

  • [バッチ化された] テンソルの [バッチ化された] 対角部分を返します。形状[..., M, N]のテンソル インスタンスの場合、出力は形状[..., K]のテンソルです。ここで、 K min(N, M)に等しいです。

    例えば： 

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

    宣言

    @differentiable
public func diagonalPart() -> Tensor

  • [バッチ化された]対角配列を構築します。形状[..., M]のテンソル インスタンスの場合、出力は形状[..., M, M]のテンソルです。

    例えば： 

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

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

    宣言

    @differentiable
public func diagonal() -> Tensor

  • selfオプションでバッチ化された行列である場合、新しい対角値を含むselfを返します。

    返されるテンソルの形状と値はselfと同じですが、最も内側の行列の指定された対角がdiagonalの値によって上書きされます。

    パラメータ 対角線: 新しい対角線の値を表すランクrank - 1のテンソル。

    宣言

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

  • 宣言

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

  • 中央のバンド境界によって定義された最も内側のテンソルのコピーを返します。出力は、インスタンス[..., :, :]と同じ形状のテンソルです。

    例えば： 

    // '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]]

    宣言

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

    パラメータ

    subdiagonalCount

    保持する下対角線の数。負の場合は、下三角全体を保持します。

    superdiagonalCount

    保持する上対角線の数。負の場合は、上三角全体を保持します。

`Scalar`: `TensorFlowFloatingPoint` で利用可能

  • テンソルの各内部行列、内部直交行列qをもつテンソル、および内部上三角行列rをもつテンソルの QR 分解を返します。テンソルはmatmul(q, r)と等しくなります。

    宣言

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

    パラメータ

    fullMatrices

    trueの場合、フルサイズのqとrを計算します。それ以外の場合は、 qの先頭のmin(shape[rank - 1], shape[rank - 2])列のみを計算します。

  • selfオプションでバッチ化された行列であると仮定して、 selfの特異値分解を返します。

    オプションでバッチ化された行列selfの特異値分解 (SVD) は、次のような値s 、 u 、およびvになります。 

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

    self は […, M, N] must be a tensor with shape . Let K = min(M, N)` . Let 。

    前提条件

    self 、形状[..., M, N]のテンソルでなければなりません。

    宣言

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

    パラメータ

    computeUV

    trueの場合、左および右の特異ベクトルが計算され、それぞれuおよびvとして返されます。 false場合、 uおよびvとしてnil値が返されます。

    fullMatrices

    trueの場合、 uとvそれぞれ[..., M, M]と[..., N, N]の形状を持ちます。 false場合、 uとvそれぞれ[..., M, K]と[..., K, N]の形状を持ちます。 computeUVが false の場合は無視されます。

    戻り値

    • s: [..., K]の形状を持つ特異値。各ベクトル内で、特異値は降順に並べ替えられます。
    • u: 左特異ベクトル。
    • v: 右特異ベクトル。

  • xの平方根。

    実数型の場合、 xが負の場合、結果は.nanになります。複合型の場合、負の実軸に分岐カットがあります。

    宣言

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

  • xの余弦。ラジアン単位の角度として解釈されます。

    宣言

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

  • xのサイン。ラジアン単位の角度として解釈されます。

    宣言

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

  • xのタンジェント。ラジアン単位の角度として解釈されます。

    宣言

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

  • xの逆余弦 (ラジアン単位)。

    宣言

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

  • xの逆サイン (ラジアン単位)。

    宣言

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

  • xの逆タンジェント (ラジアン単位)。

    宣言

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

  • xの双曲線余弦。

    宣言

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

  • xの双曲線正弦。

    宣言

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

  • xの双曲線正接。

    宣言

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

  • xの逆双曲線余弦。

    宣言

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

  • xの逆双曲線正弦。

    宣言

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

  • xの逆双曲線正接。

    宣言

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

  • xまたはe**xに適用される指数関数。

    宣言

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

  • 2 のx乗。

    宣言

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

  • 10 のx乗です。

    宣言

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

  • exp(x) - 1ゼロに近い精度を維持するように評価されます。

    宣言

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

  • xの自然対数。

    宣言

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

  • xの底 2 の対数。

    宣言

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

  • xの 10 を底とする対数。

    宣言

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

  • log(1 + x)ゼロに近い精度を維持するように評価されます。

    宣言

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

  • exp(y log(x))中間精度を失うことなく計算されます。

    実数型の場合、 xが負の場合、 y整数値であっても結果は NaN になります。複合型の場合、負の実軸に分岐カットがあります。

    宣言

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

  • xのn乗。

    xのnコピーの積。

    宣言

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

  • xのn乗根。

    実数型の場合、 xが負でnが偶数の場合、結果は NaN になります。複合型の場合、負の実軸に沿って分岐が存在します。

    宣言

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

  • 宣言

    public typealias VectorSpaceScalar = Float

  • 宣言

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

  • 宣言

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

  • 宣言

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
`Scalar`: `Numeric` の場合に利用可能

  • スカラーをテンソルのすべてのスカラーに加算し、合計を生成します。

    宣言

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

  • スカラーをテンソルのすべてのスカラーに加算し、合計を生成します。

    宣言

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

  • テンソルのすべてのスカラーからスカラーを減算し、差を生成します。

    宣言

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

  • テンソルのすべてのスカラーからスカラーを減算し、差を生成します。

    宣言

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

  • 2つのテンソルを追加し、結果を左側の変数に保存します。

    注記

    +=放送をサポートします。

    宣言

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

  • テンソルのすべてのスカラーにスカラーを追加し、結果を左側の変数に保存します。

    宣言

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

  • 最初のテンソルを最初から減算し、結果を左側の変数に保存します。

    注記

    -=放送をサポートします。

    宣言

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

  • テンソルのすべてのスカラーからスカラーを減算し、結果を左側の変数に保存します。

    宣言

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

  • 2つのテンソルを掛けることで生成されたテンソルを返します。

    注記

    *放送をサポートします。

    宣言

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

  • テンソルをテンソルのすべてのスカラーに掛けることにより、テンソルを返します。

    宣言

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

  • スカラーにテンソルのすべてのスカラーを掛け、製品を生成します。

    宣言

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

  • 2つのテンソルを掛け、結果を左側の変数に保存します。

    注記

    *=放送をサポートします。

    宣言

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

  • テンソルにスカラーを掛け、スカラーをブロードキャストし、結果を左側の変数に保存します。

    宣言

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

  • 最初のテンソルを2番目のテンソルで除算する商の商を返します。

    注記

    /放送をサポートします。

    宣言

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

  • スカラーをテンソルで除算する商の商を返し、スカラーをブロードキャストします。

    宣言

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

  • テンソルをスカラーで除算する商の商を返し、スカラーをブロードキャストします。

    宣言

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

  • 最初のテンソルを2番目のテンソルを分割し、商を左側の変数に格納します。

    宣言

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

  • テンソルをスカラーで分割し、スカラーをブロードキャストし、商を左側の変数に格納します。

    宣言

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

  • 最初のテンソルを2番目のテンソルで割る残りの部分を返します。

    注記

    %放送をサポートしています。

    宣言

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

  • テンソルをスカラーで分割する残りの部分を返し、スカラーをブロードキャストします。

    宣言

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

  • スカラーをテンソルで分割する残りの部分を返し、スカラーをブロードキャストします。

    宣言

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

  • 最初のテンソルを2番目のテンソルを分割し、残りを左側の変数に保存します。

    宣言

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

  • テンソルをスカラーで分割し、残りを左側の変数に保存します。

    宣言

    public static func %= (lhs: inout Tensor, rhs: Scalar)
「scalar」== `bool`で利用可能

  • 返品!self要素の面で。

    宣言

    public func elementsLogicalNot() -> Tensor

  • self && other要素ごとに返します。

    注記

    &&放送をサポートしています。

    宣言

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

  • self && other要素ごとに返品し、 other放送を放送します。

    宣言

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

  • self || otherを返しますself || other要素に関して。

    宣言

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

  • self || otherを返しますself || other要素に関しては、 other放送。

    宣言

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
「scalar」で利用可能： `tensorflownumeric`

  • max(min(self, max), min)を返します。

    宣言

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

  • max(min(self, max), min)を返します。

    宣言

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

  • max(min(self, max), min)を返します。

    宣言

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

  • max(min(self, max), min)を返します。

    宣言

    @differentiable(wrt: self)
public func clipped(min: Scalar, max: Scalar) -> Tensor
「scalar」： `signednumeric`で利用可能

  • 指定されたテンソル要素の否定を返します。

    宣言

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
「scalar」：「numeric」で利用可能

  • 宣言

    @differentiable(wrt: self)
public func squared() -> Tensor
「scalar」で利用可能： `tensorflowfloatingpoint`

  • xのどの要素が有限であるかを示すブールテンソルを返します。

    宣言

    public var isFinite: Tensor<Bool> { get }

  • xのどの要素が無限であるかを示すブールテンソルを返します。

    宣言

    public var isInfinite: Tensor<Bool> { get }

  • xのどの要素がNAN値であるかを示すブールテンソルを返します。

    宣言

    public var isNaN: Tensor<Bool> { get }
「scalar」== `bool`で利用可能

  • すべてのスカラーがtrueに等しい場合、 true返します。それ以外の場合は、 falseを返します。

    宣言

    public func all() -> Bool

  • スカラーがtrueに等しい場合、 true返します。それ以外の場合は、 falseを返します。

    宣言

    public func any() -> Bool

  • 指定された軸に沿って論理と動作を実行します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って論理と動作を実行します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って論理と動作を実行します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って論理または操作を実行します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

「scalar」で利用可能：「numeric」＆ `comparable`

  • 宣言

    @differentiable
public func min() -> Tensor

  • 宣言

    @differentiable
public func max() -> Tensor

  • 指定された軸に沿って最大値を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最大値を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最大値を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最大値のインデックスを返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値のインデックスを返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って最小値を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 平坦化されたスカラーの最大値のインデックスを返します。

    宣言

    public func argmax() -> Tensor<Int32>

  • 平坦化されたスカラーの最小値のインデックスを返します。

    宣言

    public func argmin() -> Tensor<Int32>
「scalar」：「numeric」で利用可能

  • 指定された軸に沿って合計を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って合計を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って合計を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 宣言

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

  • 指定された軸に沿って合計を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って合計を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って合計を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って製品を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って製品を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って製品を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 宣言

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

  • 指定された軸に沿って製品を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って製品を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って製品を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って算術平均を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って算術平均を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って算術平均を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank...rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 宣言

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

  • 指定された軸に沿って算術平均を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って算術平均を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って算術平均を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って分散を返します。縮小寸法が削除されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って分散を返します。縮小寸法が削除されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って分散を返します。縮小寸法は値1で保持されます。ベッセルの補正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 宣言

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

  • 指定された軸に沿って分散を返します。縮小寸法は値1で保持されます。ベッセルの補正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って分散を返します。縮小寸法は値1で保持されます。ベッセルの補正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って分散を返します。縮小寸法は値1で保持されます。ベッセルの補正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿って、このテンソルの累積合計を返します。デフォルトでは、この関数は、入力の最初の要素が出力の最初の要素と同一であることを意味します。 

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

    exclusive引数をtrueに設定することにより、代わりに排他的な累積合計が実行されます。 

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

    reverse引数をtrueに設定することにより、累積合計は反対方向に実行されます。 

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

    これは、結果のテンソルを個別に逆転させるよりも効率的です。

    前提条件

    axis範囲にある必要があります-rank..<rank 。

    宣言

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

    パラメータ

    axis

    累積合計操作を実行する軸。

    exclusive

    排他的な累積合計を実行するかどうかを示します。

    reverse

    反転した順序で累積合計を実行するかどうかを示します。

    戻り値

    累積合計操作の結果。

  • 指定された軸に沿って、このテンソルの累積合計を返します。デフォルトでは、この関数は、入力の最初の要素が出力の最初の要素と同一であることを意味します。 

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

    exclusive引数をtrueに設定することにより、代わりに排他的な累積合計が実行されます。 

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

    reverse引数をtrueに設定することにより、累積合計は反対方向に実行されます。 

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

    これは、結果のテンソルを個別に逆転させるよりも効率的です。

    前提条件

    axis.rank 0でなければなりません。

    前提条件

    axis範囲にある必要があります-rank..<rank 。

    宣言

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

    パラメータ

    axis

    累積合計操作を実行する軸。

    exclusive

    排他的な累積合計を実行するかどうかを示します。

    reverse

    反転した順序で累積合計を実行するかどうかを示します。

    戻り値

    累積合計操作の結果。

  • 指定された軸に沿って、このテンソルの累積積を返します。デフォルトでは、この関数は、入力の最初の要素が出力の最初の要素と同一であることを意味します。 

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

    exclusive引数をtrueに設定することにより、代わりに排他的な累積製品が実行されます。 

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

    reverse引数をtrueに設定することにより、累積製品は反対方向に実行されます。 

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

    これは、結果のテンソルを個別に逆転させるよりも効率的です。

    前提条件

    axis範囲にある必要があります-rank..<rank 。

    宣言

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

    パラメータ

    axis

    累積製品操作を実行する軸。

    exclusive

    排他的な累積製品を実行するかどうかを示します。

    reverse

    累積製品を逆順に実行するかどうかを示します。

    戻り値

    累積製品操作の結果。

  • 指定された軸に沿って、このテンソルの累積積を返します。デフォルトでは、この関数は、入力の最初の要素が出力の最初の要素と同一であることを意味します。 

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

    exclusive引数をtrueに設定することにより、代わりに排他的な累積製品が実行されます。 

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

    reverse引数をtrueに設定することにより、累積製品は反対方向に実行されます。 

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

    これは、結果のテンソルを個別に逆転させるよりも効率的です。

    前提条件

    axisにはランク0が必要です。

    前提条件

    axis範囲にある必要があります-rank..<rank 。

    宣言

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

    パラメータ

    axis

    累積製品操作を実行する軸。

    exclusive

    排他的な累積製品を実行するかどうかを示します。

    reverse

    累積製品を逆順に実行するかどうかを示します。

    戻り値

    累積製品操作の結果。

「scalar」で利用可能： `tensorflowfloatingpoint`

  • 指定された軸に沿った要素の標準偏差を返します。縮小寸法は値1で保持されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿った要素の標準偏差を返します。縮小寸法は値1で保持されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿った要素の標準偏差を返します。縮小寸法は値1で保持されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • このテンソルのすべての要素の標準偏差を返します。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

  • 指定された軸に沿った要素の標準偏差を返します。縮小寸法は値1で保持されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿った要素の標準偏差を返します。縮小寸法は値1で保持されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿った要素の標準偏差を返します。縮小寸法は値1で保持されます。 Besselの修正は適用されません。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • log(exp(self).sum(squeezingAxes: axes))を返します。縮小寸法が削除されます。

    この関数はlog(exp(self).sum(squeezingAxes: axes))直接計算するよりも数値的に安定しています。それは、小さな入力のlog計算することによって引き起こされる大きな入力とアンダーフローのexpを計算することによって引き起こされるオーバーフローを回避します。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • log(exp(self).sum(squeezingAxes: axes))を返します。縮小寸法が削除されます。

    この関数はlog(exp(self).sum(squeezingAxes: axes))直接計算するよりも数値的に安定しています。それは、小さな入力のlog計算することによって引き起こされる大きな入力とアンダーフローのexpを計算することによって引き起こされるオーバーフローを回避します。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • log(exp(self).sum(squeezingAxes: axes))を返します。縮小寸法が削除されます。

    この関数はlog(exp(self).sum(squeezingAxes: axes))直接計算するよりも数値的に安定しています。それは、小さな入力のlog計算することによって引き起こされる大きな入力とアンダーフローのexpを計算することによって引き起こされるオーバーフローを回避します。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • log(exp(self).sum())を返します。結果はスカラーです。

    この関数はlog(exp(self).sum())直接計算するよりも数値的に安定しています。それは、小さな入力のlog計算することによって引き起こされる大きな入力とアンダーフローのexpを計算することによって引き起こされるオーバーフローを回避します。

    宣言

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

  • log(exp(self).sum(alongAxes: axes))を返します。縮小寸法は値1で保持されます。

    この関数はlog(exp(self).sum(alongAxes: axes))直接計算するよりも数値的に安定しています。それは、小さな入力のlog計算することによって引き起こされる大きな入力とアンダーフローのexpを計算することによって引き起こされるオーバーフローを回避します。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • log(exp(self).sum(alongAxes: axes))を返します。縮小寸法は値1で保持されます。

    この関数はlog(exp(self).sum(alongAxes: axes))直接計算するよりも数値的に安定しています。それは、小さな入力のlog計算することによって引き起こされる大きな入力とアンダーフローのexpを計算することによって引き起こされるオーバーフローを回避します。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • log(exp(self).sum(alongAxes: axes))を返します。縮小寸法は値1で保持されます。

    この関数はlog(exp(self).sum(alongAxes: axes))直接計算するよりも数値的に安定しています。それは、小さな入力のlog計算することによって引き起こされる大きな入力とアンダーフローのexpを計算することによって引き起こされるオーバーフローを回避します。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿ってこのテンソルの平均と分散を返します。縮小寸法が削除されます。

    前提条件

    axesにはランク1が必要です。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿ってこのテンソルの平均と分散を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿ってこのテンソルの平均と分散を返します。縮小寸法が削除されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • このテンソルの要素の平均と分散を返します。

    宣言

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

  • 指定された軸に沿ってこのテンソルの平均と分散を返します。縮小寸法は値1で保持されます。

    前提条件

    axesにはランク1が必要です。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿ってこのテンソルの平均と分散を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲にある必要があります-rank..<rank 。

    宣言

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

    パラメータ

    axes

    減少する寸法。

  • 指定された軸に沿ってこのテンソルの平均と分散を返します。縮小寸法は値1で保持されます。

    前提条件

    axes内の各値は、範囲-rank..<rankにある必要があります。

    宣言

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

    パラメータ

    axes

    減少する寸法。

「scalar」：「numeric」で利用可能

  • 2つのテンソル間でマトリックスの乗算を実行し、結果を生成します。

    宣言

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
「scalar」で利用可能： `tensorflowfloatingpoint`

  • 宣言

    static func vjpInitDeviceAndPrecisionLike(
  _ value: Scalar,
  deviceAndPrecisionLike tensor: Tensor
) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))

  • 指定された軸に沿って入力を正規化するバッチから計算されたテンソルを返します。

    具体的には、return (self - mu) / (var + epsilon) * gamma + betaで、 muとvarそれぞれaxisに沿ったselfの平均と分散です。

    宣言

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

    パラメータ

    axis

    バッチディメンション。

    offset

    ベータとも呼ばれるオフセット。

    scale

    ガンマとも呼ばれるスケール。

    epsilon

    数値の安定性のために分母に追加される小さな値。

  • 最後の軸に沿って2つのテンソルを連結します。

    宣言

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

  • 2つの値を追加し、合計を生成します。

    宣言

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

  • 平均2つの値。

    宣言

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

  • 2つの値を掛けます。

    宣言

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

  • 2つの値をスタックします。

    宣言

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

  • 宣言

    @derivative
init(shape: scalars)
`Scalar`: `Equatable` で利用可能

  • 宣言

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

  • 宣言

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
`Scalar`: `Codable` で利用可能
「scalar」：「numeric」で利用可能

  • スカラーゼロテンソル。

  • 宣言

    public static var zero: Tensor { get }

  • 2つのテンソルを追加し、合計を生成します。

    注記

    +放送をサポートします。

    宣言

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

  • あるテンソルを別のテンソルから減算し、その違いを生成します。

    注記

    -放送をサポートします。

    宣言

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

  • スカラー1テンソル。

    宣言

    public static var one: Tensor { get }

  • selfの要素ごとの相互に戻ります。

    宣言

    public var reciprocal: Tensor { get }

  • エレメントごとに2つのテンソルを掛けて、製品を生産します。

    注記

    .*放送をサポートします。

    宣言

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
「scalar」で利用可能： `tensorflowfloatingpoint`

  • 宣言

    public typealias TangentVector = Tensor

  • 宣言

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

  • 注釈を追加します。

    注：X10のみがサポートされています。他のバックエンドの場合、Umodified selfが返されます。

    宣言

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

    パラメータ

    annotation

    追加する注釈。

    戻り値

    注釈付きテンソル。

  • 宣言

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