テンソル

@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

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

汎用パラメーターScalarは、テンソル内のスカラーのタイプ( Int32Floatなど)を記述します。

  • 基になるTensorHandle

    注意

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

    宣言

    public let handle: TensorHandle<Scalar>
  • 宣言

    public init(handle: TensorHandle<Scalar>)
  • ランクRテンソルの指定された次元を複数のランク(R-1)テンソルに展開します。 Nは、このテンソルの形状から推測されるaxis次元に沿ってチッピングすることにより、このテンソルからNテンソルを解凍します。たとえば、形状が[A, B, C, D]テンソルがあるとし[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は提供されたテンソルのランクです。

    宣言

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

    パラメーター

    axis

    スタックを解除する次元。負の値は折り返されます。

    戻り値

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

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

    例えば:

    // '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は提供されたテンソルのランクです。

    宣言

    @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の値は、 sizesして寸法axis sizes必要があります。

    前提条件

    axis[-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]回複製されmultiples[i] 。たとえば、 [abcd][2]でタイリングすると、 [abcdabcd]生成されます。

    前提条件

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

    前提条件

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

    前提条件

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

    宣言

    @differentiable(wrt: self)
    public func tiled(multiples: [Int]) -> Tensor
  • このテンソルをタイリングすることによって構築された、タイル化されたテンソルを返します。

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

    前提条件

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

    前提条件

    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
  • Tensor順序で、1次元テンソルに折りたたまれたテンソルのコピーを返します。

    宣言

    @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次元(ベクトル) 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] 、ここで[i1, ..., iK]は、 mask i番目のtrueエントリです(行[i1, ..., iK]順位)。

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

    前提条件

    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-D整数テンソル。ここで、 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 axes示していることを確認し、そうでない場合は診断でプログラムを停止します。

    宣言

    func ensureValid(
      axes: Tensor<Int32>,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • axes各要素がself axes示していることを確認し、そうでない場合は診断でプログラムを停止します。

    宣言

    func ensureValid(
      axes: [Int],
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • kself軸を示していることを確認し、そうでない場合は診断でプログラムを停止します。

    宣言

    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電流テンソルとの各テンソルより上位一つに新しいテンソルに寸法、 tensors

    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は提供されたテンソルのランクです。

    宣言

    @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:)使用を検討してTensor.init(stacking:alongAxis:)

    前提条件

    すべてのテンソルは同じランクである必要があり、 axisを除くすべての寸法は等しくなければなりません。

    前提条件

    axis[-rank, rank)範囲内にある必要があります。ここで、 rankは提供されたテンソルのランクです。

    宣言

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

    パラメーター

    tensors

    連結するテンソル。

    axis

    連結する次元。負の値は折り返されます。

    戻り値

    連結テンソル。

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

    前提条件

    selfotherは同じ形でなければなりません。 selfotherがスカラーの場合、 maskもスカラーである必要があります。 selfotherランクが1以上の場合、 maskselfと同じ形状であるか、 mask.scalarCount == self.shape[0]ような1-D Tensor必要があります。

    宣言

    @differentiable(wrt: (self, other)
    ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
  • 物理スカラー型の精度が低下している場合はtrueを返します。

    現在、低精度の物理スカラー型にはBFloat16のみが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真実であると要素数が二回超えedgeElementCount

    宣言

    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の要素とほぼ等しいかどうかを示すブール値のテンソルを返します。

    前提条件

    selfotherは同じ形でなければなりません。

    宣言

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

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

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

    前提条件

    selfotherは同じ形でなければなりません。

    宣言

    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`で利用可能

  • すべてのスカラーがゼロに設定されたテンソルを作成します。

    宣言

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

    パラメーター

    shape

    テンソルの形状。

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

    宣言

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

    パラメーター

    shape

    テンソルの形状。

  • 提供されたテンソルと同じ形状とタイプを持つ、すべてのスカラーがゼロに設定されたテンソルを作成します。

    宣言

    public init(zerosLike other: Tensor)

    パラメーター

    other

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

  • 提供されたテンソルと同じ形状とタイプを持つものに設定されたすべてのスカラーでテンソルを作成します。

    宣言

    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軸== 0の場合は深さx特徴

    indicesが形状[batch, features]行列(バッチ)の場合、出力形状は次のようになります。 、axis == 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次元テンソルを作成します。

    前提条件

    startto 、およびcountは、単一のスカラー値を含むテンソルである必要があります。

    宣言

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

    パラメーター

    start

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

    end

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

    count

    結果のシーケンスの値の数。 countは正でなければなりません。

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

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

    宣言

    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`で利用可能

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

    宣言

    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)の均一初期化を実行して、指定した形状のテンソルを作成します。

    これは、デフォルトの乱数ジェネレーターによって生成された-limitlimit間の一様分布からランダムなサンプルを抽出します。ここで、 limitsqrt(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)均一初期化を実行して、指定した形状のテンソルを作成します。

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

    参考: 「整流器を深く掘り下げる:ImageNet分類で人間レベルのパフォーマンスを超える」

    宣言

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

    パラメーター

    shape

    テンソルの寸法。

    seed

    シード値。

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

    デフォルトの乱数ジェネレーターによって生成された標準偏差sqrt(2 / fanIn))使用して、 0を中心とする切断正規分布からランダムサンプルを抽出します。ここで、 fanInは、入力フィーチャの数に受容フィールドサイズを掛けたものを表します。

    参考: 「整流器を深く掘り下げる:ImageNet分類で人間レベルのパフォーマンスを超える」

    宣言

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

    パラメーター

    shape

    テンソルの寸法。

    seed

    シード値。

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

    これは、デフォルトの乱数ジェネレーターによって生成された-limitlimit間の一様分布からランダムなサンプルを抽出します。ここで、 limitsqrt(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]ここで、 Kmin(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`で利用可能

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

    宣言

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

    パラメーター

    fullMatrices

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

  • selfがオプションでバッチ処理された行列である場合、 self特異値分解を返します。

    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()`
    

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

    前提条件

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

    宣言

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

    パラメーター

    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.

    戻り値

    • 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.
  • 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.

    宣言

    @differentiable
    public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
  • The cosine of x , interpreted as an angle in radians.

    宣言

    @differentiable
    public static func cos(_ x: `Self`) -> Tensor<Scalar>
  • The sine of x , interpreted as an angle in radians.

    宣言

    @differentiable
    public static func sin(_ x: `Self`) -> Tensor<Scalar>
  • The tangent of x , interpreted as an angle in radians.

    宣言

    @differentiable
    public static func tan(_ x: `Self`) -> Tensor<Scalar>
  • The inverse cosine of x in radians.

    宣言

    @differentiable
    public static func acos(_ x: `Self`) -> Tensor<Scalar>
  • The inverse sine of x in radians.

    宣言

    @differentiable
    public static func asin(_ x: `Self`) -> Tensor<Scalar>
  • The inverse tangent of x in radians.

    宣言

    @differentiable
    public static func atan(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic cosine of x .

    宣言

    @differentiable
    public static func cosh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic sine of x .

    宣言

    @differentiable
    public static func sinh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic tangent of x .

    宣言

    @differentiable
    public static func tanh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic cosine of x .

    宣言

    @differentiable
    public static func acosh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic sine of x .

    宣言

    @differentiable
    public static func asinh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic tangent of x .

    宣言

    @differentiable
    public static func atanh(_ x: `Self`) -> Tensor<Scalar>
  • The exponential function applied to x , or e**x .

    宣言

    @differentiable
    public static func exp(_ x: `Self`) -> Tensor<Scalar>
  • Two raised to to power x .

    宣言

    @differentiable
    public static func exp2(_ x: `Self`) -> Tensor<Scalar>
  • Ten raised to to power x .

    宣言

    @differentiable
    public static func exp10(_ x: `Self`) -> Tensor<Scalar>
  • exp(x) - 1 evaluated so as to preserve accuracy close to zero.

    宣言

    @differentiable
    public static func expm1(_ x: `Self`) -> Tensor<Scalar>
  • The natural logarithm of x .

    宣言

    @differentiable
    public static func log(_ x: `Self`) -> Tensor<Scalar>
  • The base-two logarithm of x .

    宣言

    @differentiable
    public static func log2(_ x: `Self`) -> Tensor<Scalar>
  • The base-ten logarithm of x .

    宣言

    @differentiable
    public static func log10(_ x: `Self`) -> Tensor<Scalar>
  • log(1 + x) evaluated so as to preserve accuracy close to zero.

    宣言

    @differentiable
    public static func log1p(_ x: `Self`) -> Tensor<Scalar>
  • 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.

    宣言

    @differentiable
    public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
  • x raised to the n th power.

    The product of n copies of x .

    宣言

    @differentiable
    public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • The n th 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.

    宣言

    @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>

Available where `Scalar`: `Numeric`

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

    宣言

    @differentiable
    public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
  • Adds the scalar to every scalar of the tensor and produces the sum.

    宣言

    @differentiable
    public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference.

    宣言

    @differentiable
    public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference

    宣言

    @differentiable
    public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
  • Adds two tensors and stores the result in the left-hand-side variable.

    注意

    += supports broadcasting.

    宣言

    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.

    宣言

    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.

    注意

    -= supports broadcasting.

    宣言

    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.

    宣言

    public static func -= (lhs: inout Tensor, rhs: Scalar)
  • Returns the tensor produced by multiplying the two tensors.

    注意

    * supports broadcasting.

    宣言

    @differentiable
    public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the tensor by multiplying it with every scalar of the tensor.

    宣言

    @differentiable
    public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
  • Multiplies the scalar with every scalar of the tensor and produces the product.

    宣言

    @differentiable
    public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
  • Multiplies two tensors and stores the result in the left-hand-side variable.

    注意

    *= supports broadcasting.

    宣言

    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.

    宣言

    public static func *= (lhs: inout Tensor, rhs: Scalar)
  • Returns the quotient of dividing the first tensor by the second.

    注意

    / supports broadcasting.

    宣言

    @differentiable
    public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the scalar by the tensor, broadcasting the scalar.

    宣言

    @differentiable
    public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the tensor by the scalar, broadcasting the scalar.

    宣言

    @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.

    宣言

    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.

    宣言

    public static func /= (lhs: inout Tensor, rhs: Scalar)
  • Returns the remainder of dividing the first tensor by the second.

    注意

    % supports broadcasting.

    宣言

    public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the remainder of dividing the tensor by the scalar, broadcasting the scalar.

    宣言

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
  • Returns the remainder of dividing the scalar by the tensor, broadcasting the scalar.

    宣言

    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.

    宣言

    public static func %= (lhs: inout Tensor, rhs: Tensor)
  • Divides the tensor by the scalar and stores the remainder in the left-hand-side variable.

    宣言

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

Available where `Scalar` == `Bool`

  • Returns !self element-wise.

    宣言

    public func elementsLogicalNot() -> Tensor
  • Returns self && other element-wise.

    注意

    && supports broadcasting.

    宣言

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor
  • Returns self && other element-wise, broadcasting other .

    宣言

    public func elementsLogicalAnd(_ other: Scalar) -> Tensor
  • Returns self || other element-wise.

    宣言

    public func elementsLogicalOr(_ other: Tensor) -> Tensor
  • Returns self || other element-wise, broadcasting other .

    宣言

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

Available where `Scalar`: `TensorFlowNumeric`

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

    宣言

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

    宣言

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

    宣言

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

    宣言

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

Available where `Scalar`: `SignedNumeric`

  • Returns the negation of the specified tensor element-wise.

    宣言

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

Available where `Scalar`: `Numeric`

  • 宣言

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

Available where `Scalar`: `TensorFlowFloatingPoint`

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

    宣言

    public var isFinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are infinite.

    宣言

    public var isInfinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are NaN-valued.

    宣言

    public var isNaN: Tensor<Bool> { get }

Available where `Scalar` == `Bool`

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

    宣言

    public func all() -> Bool
  • Returns true if any scalars are equal to true . Otherwise, returns false .

    宣言

    public func any() -> Bool
  • Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

Available where `Scalar`: `Numeric` & `Comparable`

  • 宣言

    @differentiable
    public func min() -> Tensor
  • 宣言

    @differentiable
    public func max() -> Tensor
  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    宣言

    public func argmax() -> Tensor<Int32>
  • Returns the index of the minimum value of the flattened scalars.

    宣言

    public func argmin() -> Tensor<Int32>

Available where `Scalar`: `Numeric`

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 宣言

    @differentiable(wrt: self)
    public func sum() -> Tensor
  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 宣言

    @differentiable(wrt: self)
    public func product() -> Tensor
  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 宣言

    @differentiable(wrt: self)
    public func mean() -> Tensor
  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 宣言

    @differentiable(wrt: self)
    public func variance() -> Tensor
  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    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.

    戻り値

    Result of the cumulative sum operation.

  • 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.

    前提条件

    axis.rank must be 0 .

    前提条件

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

    宣言

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

    パラメーター

    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.

    戻り値

    Result of the cumulative sum operation.

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    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.

    戻り値

    Result of the cumulative product operation.

  • 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.

    前提条件

    axis must have rank 0 .

    前提条件

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

    宣言

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

    パラメーター

    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.

    戻り値

    Result of the cumulative product operation.

Available where `Scalar`: `TensorFlowFloatingPoint`

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

    @differentiable(wrt: self)
    public func standardDeviation() -> Tensor
  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    宣言

    @differentiable(wrt: self)
    public func logSumExp() -> Tensor
  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • 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.

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

    axes must have rank 1 .

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

  • Returns the mean and variance of this tensor's elements.

    宣言

    @differentiable(wrt: self)
    public func moments() -> Moments<Scalar>
  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    前提条件

    axes must have rank 1 .

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

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

    前提条件

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

    宣言

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

    パラメーター

    axes

    縮小する寸法。

Available where `Scalar`: `Numeric`

  • Performs matrix multiplication between two tensors and produces the result.

    宣言

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • 宣言

    static func vjpInitDeviceAndPrecisionLike(
      _ value: Scalar,
      deviceAndPrecisionLike tensor: Tensor
    ) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))
  • 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 .

    宣言

    @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

    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.

  • Concatenates two tensors along last axis.

    宣言

    @differentiable
    public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Adds two values and produces their sum.

    宣言

    @differentiable
    public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Averages two values.

    宣言

    @differentiable
    public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Multiplies two values.

    宣言

    @differentiable
    public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Stack two values.

    宣言

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

    @derivative
    init(shape: scalars)

Available where `Scalar`: `Equatable`

  • 宣言

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

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

Available where `Scalar`: `Codable`

  • 宣言

    public func encode(to encoder: Encoder) throws
  • 宣言

    public init(from decoder: Decoder) throws

Available where `Scalar`: `Numeric`

  • The scalar zero tensor.

  • 宣言

    public static var zero: Tensor { get }
  • Adds two tensors and produces their sum.

    注意

    + supports broadcasting.

    宣言

    @differentiable
    public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
  • Subtracts one tensor from another and produces their difference.

    注意

    - supports broadcasting.

    宣言

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

    The scalar one tensor.

    宣言

    public static var one: Tensor { get }
  • Returns the element-wise reciprocal of self .

    宣言

    public var reciprocal: Tensor { get }
  • Multiplies two tensors element-wise and produces their product.

    注意

    .* supports broadcasting.

    宣言

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • 宣言

    public typealias TangentVector = Tensor
  • 宣言

    public var zeroTangentVectorInitializer: () -> TangentVector { get }
  • Adds an annotation.

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

    宣言

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

    パラメーター

    annotation

    The annotation to be added.

    戻り値

    The annotated tensor.

  • 宣言

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