関数

以下の機能はグローバルに利用できます。

  • 予測と期待の間のL1損失を返します。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func l1Loss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 予測と期待の間のL2損失を返します。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func l2Loss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 予測と期待の間のヒンジ損失を返します。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 予測と期待の間のヒンジ損失の2乗を返します。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 予測と期待の間のカテゴリのヒンジ損失を返します。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 予測と期待の間の誤差の双曲線余弦の対数を返します。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 予測と期待の間のポアソン損失を返します。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 期待値と予測値の間のカルバックライブラーダイバージェンス(KLダイバージェンス)を返します。 2つの分布pq与えられると、KL発散はp * log(p / q)計算しp * log(p / q)

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • ロジットとラベルの間のsoftmaxクロスエントロピー(カテゴリクロスエントロピー)を返します。

    宣言

    @differentiable(wrt: logits)
    public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
      logits: Tensor<Scalar>,
      probabilities: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    logits

    ニューラルネットワークからのワンホットエンコード出力。

    labels

    正しい出力のインデックス(ゼロインデックス)。

  • ロジットとラベルの間のシグモイドクロスエントロピー(バイナリクロスエントロピー)を返します。

    宣言

    @differentiable(wrt: logits)
    @differentiable(wrt: (logits, labels)
    public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
      logits: Tensor<Scalar>,
      labels: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    logits

    ニューラルネットワークのスケーリングされていない出力。

    labels

    正しい出力に対応する整数値。

  • 指定されたテンソルと同じ形状とスカラーを持つテンソルを返します。

    宣言

    @differentiable
    public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • 指定された学習フェーズを除いて、現在のコンテキストとすべて同じであるコンテキスト内で指定されたクロージャーを呼び出します。

    宣言

    public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R

    パラメーター

    context

    クロージャーが呼び出される前に設定され、クロージャーが戻った後に復元されるコンテキスト。

    body

    無効な閉鎖。クロージャに戻り値がある場合、その値はwithContext(_:_:)関数の戻り値としても使用されます。

    戻り値

    bodyクロージャーの戻り値(ある場合)。

  • 指定された学習フェーズを除いて、現在のコンテキストとすべて同じであるコンテキスト内で指定されたクロージャーを呼び出します。

    宣言

    public func withLearningPhase<R>(
      _ learningPhase: LearningPhase,
      _ body: () throws -> R
    ) rethrows -> R

    パラメーター

    learningPhase

    クロージャーが呼び出される前に設定され、クロージャーが戻った後に復元される学習フェーズ。

    body

    無効な閉鎖。クロージャに戻り値がある場合、その値はwithLearningPhase(_:_:)関数の戻り値としても使用されます。

    戻り値

    bodyクロージャーの戻り値(ある場合)。

  • 指定されたランダムシードを除いて、現在のコンテキストとすべて同じであるコンテキスト内で指定されたクロージャーを呼び出します。

    宣言

    public func withRandomSeedForTensorFlow<R>(
      _ randomSeed: TensorFlowSeed,
      _ body: () throws -> R
    ) rethrows -> R

    パラメーター

    randomSeed

    クロージャーが呼び出される前に設定され、クロージャーが戻った後に復元されるランダムシード。

    body

    無効な閉鎖。クロージャに戻り値がある場合、その値はwithRandomSeedForTensorFlow(_:_:)関数の戻り値としても使用されます。

    戻り値

    bodyクロージャーの戻り値(ある場合)。

  • 指定された乱数ジェネレーターを除いて、現在のコンテキストとすべて同じであるコンテキスト内で指定されたクロージャーを呼び出します。

    宣言

    public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>(
      _ randomNumberGenerator: inout G,
      _ body: () throws -> R
    ) rethrows -> R

    パラメーター

    randomNumberGenerator

    クロージャーが呼び出される前に設定され、クロージャーが戻った後に復元される乱数ジェネレーター。

    body

    無効な閉鎖。クロージャに戻り値がある場合、その値はwithRandomNumberGeneratorForTensorFlow(_:_:)関数の戻り値としても使用されます。

    戻り値

    bodyクロージャーの戻り値(ある場合)。

  • 宣言

    public func zip<T: TensorGroup, U: TensorGroup>(
      _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
    ) -> Dataset<Zip2TensorGroup<T, U>>
  • LazyTensorBarrierは、すべてのライブテンソル(提供されている場合はデバイス上)がスケジュールされ、実行されていることを確認します。 waitがtrueに設定されている場合、この呼び出しは計算が完了するまでブロックされます。

    宣言

    public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)
  • 宣言

    public func valueWithGradient<T, R>(
      at x: T,
      in f: @differentiable (T) -> Tensor<R>
    ) -> (value: Tensor<R>, gradient: T.TangentVector)
    where T: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func valueWithGradient<T, U, R>(
      at x: T,
      _ y: U,
      in f: @differentiable (T, U) -> Tensor<R>
    ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
    where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func valueWithGradient<T, U, V, R>(
      at x: T,
      _ y: U,
      _ z: V,
      in f: @differentiable (T, U, V) -> Tensor<R>
    ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
    where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func valueWithGradient<T, R>(
      of f: @escaping @differentiable (T) -> Tensor<R>
    ) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
    where T: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func valueWithGradient<T, U, R>(
      of f: @escaping @differentiable (T, U) -> Tensor<R>
    ) -> (T, U) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
    where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func valueWithGradient<T, U, V, R>(
      of f: @escaping @differentiable (T, U, V) -> Tensor<R>
    ) -> (T, U, V) -> (
      value: Tensor<R>,
      gradient: (T.TangentVector, U.TangentVector, V.TangentVector)
    )
    where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func gradient<T, R>(
      at x: T,
      in f: @differentiable (T) -> Tensor<R>
    ) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func gradient<T, U, R>(
      at x: T,
      _ y: U,
      in f: @differentiable (T, U) -> Tensor<R>
    ) -> (T.TangentVector, U.TangentVector)
    where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func gradient<T, U, V, R>(
      at x: T,
      _ y: U,
      _ z: V,
      in f: @differentiable (T, U, V) -> Tensor<R>
    ) -> (T.TangentVector, U.TangentVector, V.TangentVector)
    where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func gradient<T, R>(
      of f: @escaping @differentiable (T) -> Tensor<R>
    ) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func gradient<T, U, R>(
      of f: @escaping @differentiable (T, U) -> Tensor<R>
    ) -> (T, U) -> (T.TangentVector, U.TangentVector)
    where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
  • 宣言

    public func gradient<T, U, V, R>(
      of f: @escaping @differentiable (T, U, V) -> Tensor<R>
    ) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector)
    where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
  • 従来の自動微分では「チェックポイント」と呼ばれる、プルバックで関数を再計算します。

    宣言

    public func withRecomputationInPullbacks<T, U>(
      _ body: @escaping @differentiable (T) -> U
    ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable
  • ベクトルから微分可能関数を作成します-ヤコビアン積関数。

    宣言

    public func differentiableFunction<T : Differentiable, R : Differentiable>(
      from vjp: @escaping (T)
               -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
    ) -> @differentiable (T) -> R
  • ベクトルから微分可能関数を作成します-ヤコビアン積関数。

    宣言

    public func differentiableFunction<T, U, R>(
      from vjp: @escaping (T, U)
               -> (value: R, pullback: (R.TangentVector)
                 -> (T.TangentVector, U.TangentVector))
    ) -> @differentiable (T, U) -> R
  • 恒等関数のようにx返します。 xがに関して微分されているコンテキストで使用される場合、この関数はx導関数を生成しません。

    宣言

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T>(at x: T) -> T
  • 指定されたクロージャbodyx適用します。 xがに関して微分されているコンテキストで使用される場合、この関数はx導関数を生成しません。

    宣言

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R
  • クロージャーを実行し、TensorFlow操作を特定の種類のデバイスで実行します。

    宣言

    public func withDevice<R>(
      _ kind: DeviceKind,
      _ index: UInt = 0,
      perform body: () throws -> R
    ) rethrows -> R

    パラメーター

    kind

    TensorFlow操作を実行するための一種のデバイス。

    index

    opsを実行するデバイス。

    body

    指定された種類のデバイスでTensorFlow操作が実行されるクロージャ。

  • クロージャーを実行し、特定の名前のデバイスでTensorFlow操作を実行します。

    デバイス名の例:

    • 「/ device:CPU:0」:マシンのCPU。
    • 「/ GPU:0」:TensorFlowに表示されるマシンの最初のGPUの省略表記
    • 「/ job:localhost / reply:0 / task:0 / device:GPU:1」:TensorFlowに表示されるマシンの2番目のGPUの完全修飾名。

    宣言

    public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R

    パラメーター

    name

    装置名。

    body

    指定された種類のデバイスでTensorFlow操作が実行されるクロージャ。

  • クロージャを実行し、TensorFlowが任意のデバイスにTensorFlow操作を配置できるようにします。これにより、デフォルトの配置動作が復元されます。

    宣言

    public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R

    パラメーター

    body

    指定された種類のデバイスでTensorFlow操作が実行されるクロージャ。

  • 指定された方法を使用して、画像のサイズをサイズ変更します。

    前提条件

    画像のランクは3または4必要があります。

    前提条件

    サイズは正でなければなりません。

    宣言

    @differentiable(wrt: images)
    public func resize(
      images: Tensor<Float>,
      size: (newHeight: Int, newWidth: Int),
      method: ResizeMethod = .bilinear,
      antialias: Bool = false
    ) -> Tensor<Float>

    パラメーター

    images

    形状の4D Tensor [batch, height, width, channels]または形状の3D Tensor [height, width, channels]

    size

    画像の新しいサイズ。

    method

    サイズ変更方法。デフォルト値は.bilinearです。

    antialias

    true場合、画像をダウンサンプリングするときにアンチエイリアシングフィルターを使用します。

  • エリア補間を使用して、画像のサイズをサイズに変更します。

    前提条件

    画像のランクは3または4必要があります。

    前提条件

    サイズは正でなければなりません。

    宣言

    public func resizeArea<Scalar: TensorFlowNumeric>(
      images: Tensor<Scalar>,
      size: (newHeight: Int, newWidth: Int),
      alignCorners: Bool = false
    ) -> Tensor<Float>

    パラメーター

    images

    形状の4D Tensor [batch, height, width, channels]または形状の3D Tensor [height, width, channels]

    size

    画像の新しいサイズ。

  • 指定された入力、フィルター、ストライド、およびパディングを使用して2次元膨張を返します。

    前提条件

    inputはランク4必要があります。

    前提条件

    filterランクは3必要があります。

    宣言

    @differentiable(wrt: (input, filter)
    public func dilation2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
      rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
      padding: Padding = .valid
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filter

    拡張フィルター。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のためのパディング

    rates

    入力の各次元の膨張率。

  • 指定された入力、フィルター、ストライド、およびパディングを使用して2D侵食を返します。

    前提条件

    inputはランク4必要があります。

    前提条件

    filterランクは3である必要があります。

    宣言

    @differentiable(wrt: (input, filter)
    public func erosion2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
      rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
      padding: Padding = .valid
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filter

    侵食フィルター。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のためのパディング

    rates

    入力の各次元の膨張率。

  • すべての値をゼロに初期化することによってテンソルを作成する関数を返します。

    宣言

    public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
  • すべての値を指定された値に初期化することによってテンソルを作成する関数を返します。

    宣言

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Scalar
    ) -> ParameterInitializer<Scalar>
  • 指定された値に初期化することによってテンソルを作成する関数を返します。提供された値のブロードキャストはサポートされていないことに注意してください。

    宣言

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Tensor<Scalar>
    ) -> ParameterInitializer<Scalar>
  • 指定された形状に対してGlorot(Xavier)の一様初期化を実行し、デフォルトの乱数ジェネレーターによって生成された-limitlimit間の一様分布からスカラー値をランダムにサンプリングすることにより、テンソルを作成する関数を返します。ここで、limitはsqrt(6 / (fanIn + fanOut)) 、およびfanIn / fanOutは、入力および出力機能の数に受容フィールドを掛けたもの(存在する場合sqrt(6 / (fanIn + fanOut))表します。

    宣言

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 指定された形状に対してGlorot(Xavier)正規初期化を実行し、標準偏差sqrt(2 / (fanIn + fanOut))0を中心とする切断正規分布からスカラー値をランダムにサンプリングすることにより、テンソルを作成する関数を返します。ここで、 fanIn / fanOut存在する場合は、入力および出力フィーチャの数に受容フィールドサイズを掛けたものを表します。

    宣言

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 指定された形状に対してHe(Kaiming)一様初期化を実行し、デフォルトの乱数ジェネレーターによって生成された-limitlimit間の一様分布からスカラー値をランダムにサンプリングすることにより、テンソルを作成する関数を返します。ここで、limitはsqrt(6 / fanIn) 、およびfanInは、入力フィーチャの数に受容フィールドを掛けたもの(存在する場合sqrt(6 / fanIn)表します。

    宣言

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 指定された形状に対してHe(Kaiming)正規初期化を実行し、標準偏差sqrt(2 / fanIn)0を中心とする切断正規分布からスカラー値をランダムにサンプリングすることにより、テンソルを作成する関数を返します。ここで、 fanInは入力特徴の数を表します。存在する場合は、受容フィールドサイズを掛けます。

    宣言

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 指定された形状に対してLeCun一様初期化を実行し、デフォルトの乱数ジェネレーターによって生成された-limitlimit間の一様分布からスカラー値をランダムにサンプリングすることによってテンソルを作成する関数を返します。ここで、limitはsqrt(3 / fanIn)であり、 fanInは、入力フィーチャの数に受容フィールドを掛けたものを表します(存在する場合)。

    宣言

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 指定された形状に対してLeCun正規初期化を実行し、標準偏差sqrt(1 / fanIn)を使用して0を中心とする切断正規分布からスカラー値をランダムにサンプリングすることにより、テンソルを作成する関数を返します。ここで、 fanInは入力フィーチャの数に受容フィールドサイズ(存在する場合)。

    宣言

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • 切断正規分布からすべての値をランダムに初期化することによってテンソルを作成する関数を返します。生成された値は、平均から2標準偏差を超える大きさの値が削除されて再サンプリングされることを除いて、平均meanと標準偏差standardDeviation正規分布に従います。

    宣言

    public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>(
      mean: Tensor<Scalar> = Tensor<Scalar>(0),
      standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1),
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>

    パラメーター

    mean

    正規分布の平均。

    standardDeviation

    正規分布の標準偏差。

    戻り値

    切り捨てられた正規パラメーター初期化関数。

  • 宣言

    public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
  • 単位行列または行列のバッチを返します。

    宣言

    public func eye<Scalar: Numeric>(
      rowCount: Int,
      columnCount: Int? = nil,
      batchShape: [Int] = [],
      on device: Device = .default
    ) -> Tensor<Scalar>

    パラメーター

    rowCount

    各バッチマトリックスの行数。

    columnCount

    各バッチマトリックスの列数。

    batchShape

    返されたテンソルの主要なバッチ次元。

  • オプションでバッチ処理された行列のトレースを計算します。トレースは、各最も内側のマトリックスの主対角線に沿った合計です。

    入力は形状[..., M, N]テンソルです。出力は形状[...]テンソル[...]

    前提条件

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

    宣言

    @differentiable(wrt: matrix)
    public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    パラメーター

    matrix

    形状のテンソル[..., M, N]

  • 1つ以上の正方行列のコレスキー分解を返します。

    入力は形状[..., M, M]テンソルであり、その最も内側の2次元は正方行列を形成します。

    入力は対称で正定値である必要があります。この操作には、入力の下三角部分のみが使用されます。上三角部分は読み込まれません。

    出力は、すべての入力部分行列[..., :, :]のコレスキー分解を含む入力と同じ形状のテンソルです。

    宣言

    @differentiable
    public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

    パラメーター

    input

    形状のテンソル[..., M, M]

  • Ax = b表される連立一次方程式の解xを返します。

    前提条件

    matrixは形状[..., M, M]テンソルでなければなりません。

    前提条件

    rhsは、形状[..., M, K]テンソルでなければなりません。

    宣言

    @differentiable
    public func triangularSolve<T: TensorFlowFloatingPoint>(
      matrix: Tensor<T>,
      rhs: Tensor<T>,
      lower: Bool = true,
      adjoint: Bool = false
    ) -> Tensor<T>

    パラメーター

    matrix

    Ax = b Aを表す入力三角係数行列。

    rhs

    表す右辺値、 bAx = b

    lower

    matrixが下三角( true )であるか上三角( false )であるか。デフォルト値はtrueです。

    adjoint

    true場合、 matrix代わりにmatrix随伴作用素で解きます。デフォルト値はfalseです。

    戻り値

    Ax = b表される連立一次方程式の解xxbと同じ形をしています。

  • 間のL1損失計算expectedpredictedloss = reduction(abs(expected - predicted))

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func l1Loss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • 間のL2損失計算expectedpredictedloss = reduction(square(expected - predicted))

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func l2Loss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • ラベルと予測の間の絶対差の平均を計算します。 loss = mean(abs(expected - predicted))

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • ラベルと予測の間の誤差の二乗の平均を計算します。 loss = mean(square(expected - predicted))

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanSquaredError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • predicted loss = square(log(expected) - log(predicted))expected loss = square(log(expected) - log(predicted))間の平均二乗対数誤差を計算しloss = square(log(expected) - log(predicted))

    注意

    log(_:)は負の実数に対して未定義であるため、負のテンソルエントリは、未定義の対数動作を回避するために0にクランプされlog(_:)

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • predictedexpected間の平均絶対パーセント誤差を計算します。 loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

  • 間のヒンジ損失計算predictedexpectedloss = reduction(max(0, 1 - predicted * expected)) expected値は-1または1であると予想されます。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • predictedexpected間のヒンジ損失の2乗を計算します。 loss = reduction(square(max(0, 1 - predicted * expected))) expected値は-1または1であると予想されます。

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • 間のカテゴリヒンジ損失計算predictedexpectedloss = maximum(negative - positive + 1, 0)ここで、 negative = max((1 - expected) * predicted)およびpositive = sum(predicted * expected)

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • 予測誤差の双曲線余弦の対数を計算します。 logcosh = log((exp(x) + exp(-x))/2) 、ここでxはpredicted - expectedたエラーですpredicted - expected

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • 予測値と予測値の間のポアソン損失を計算します。ポアソン損失は、 predicted - expected * log(predicted)Tensorの要素の平均ですpredicted - expected * log(predicted)

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • 間を計算カルバック・ライブラー情報量の損失expectedpredictedloss = reduction(expected * log(expected / predicted))

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • ロジットとラベルの間のスパースソフトマックスクロスエントロピー(カテゴリクロスエントロピー)を計算します。 2つ以上のラベルクラスがある場合は、このクロスエントロピー損失関数を使用します。ラベルは整数として提供されることを期待しています。 logits場合は機能ごとに# classes浮動小数点値があり、 expected場合は機能ごとに1つの浮動小数点値が必要expected

    宣言

    @differentiable(wrt: logits)
    public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
      logits: Tensor<Scalar>,
      labels: Tensor<Int32>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    logits

    ニューラルネットワークからのワンホットエンコード出力。

    labels

    正しい出力のインデックス(ゼロインデックス)。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • ロジットとラベルの間のスパースソフトマックスクロスエントロピー(カテゴリクロスエントロピー)を計算します。 2つ以上のラベルクラスがある場合は、このクロスエントロピー損失関数を使用します。ラベルはone_hot表現で提供されることを期待しています。機能ごとに# classes浮動小数点値が必要です。

    宣言

    @differentiable(wrt: logits)
    public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
      logits: Tensor<Scalar>,
      probabilities: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    logits

    ニューラルネットワークからのスケーリングされていない対数確率。

    probabilities

    正しい出力に対応する確率値。各行は、有効な確率分布である必要があります。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • ロジットとラベルの間のシグモイドクロスエントロピー(バイナリクロスエントロピー)を計算します。ラベルクラスが2つしかない場合(0と1と想定)、このクロスエントロピー損失を使用します。例ごとに、予測ごとに1つの浮動小数点値が必要です。

    宣言

    @differentiable(wrt: logits)
    @differentiable(wrt: (logits, labels)
    public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
      logits: Tensor<Scalar>,
      labels: Tensor<Scalar>,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
    ) -> Tensor<Scalar>

    パラメーター

    logits

    ニューラルネットワークのスケーリングされていない出力。

    labels

    正しい出力に対応する整数値。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • predictedexpected間のHuber損失を計算します。

    error = expected - predicted各値xについてerror = expected - predicted

    宣言

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func huberLoss<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>,
      delta: Scalar,
      reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
    ) -> Tensor<Scalar>

    パラメーター

    predicted

    ニューラルネットワークからの予測出力。

    expected

    正しい出力に対応する期待値、つまりターゲット。

    delta

    Huber損失関数が2次から線形に変化する点を表す浮動小数点スカラー。

    reduction

    計算された要素ごとの損失値に適用する削減。

  • 指定されたテンソルの絶対値を要素ごとに返します。

    宣言

    @differentiable
    public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
  • 指定されたテンソルの自然対数を要素ごとに返します。

    宣言

    @differentiable
    public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの基数2の対数を要素ごとに返します。

    宣言

    @differentiable
    public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの10を底とする対数を要素ごとに返します。

    宣言

    @differentiable
    public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 1 + x対数を要素ごとに返します。

    宣言

    @differentiable
    public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 数値的に安定したアプローチを使用してlog(1 - exp(x))を返しlog(1 - exp(x))

    注意

    このアプローチは、 https//cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdfの式7に示されています

    宣言

    @differentiable
    public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの正弦を要素ごとに返します。

    宣言

    @differentiable
    public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルのコサインを要素ごとに返します。

    宣言

    @differentiable
    public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの接線を要素ごとに返します。

    宣言

    @differentiable
    public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの双曲線正弦を要素ごとに返します。

    宣言

    @differentiable
    public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの双曲線余弦を要素ごとに返します。

    宣言

    @differentiable
    public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの双曲線正接を要素ごとに返します。

    宣言

    @differentiable
    public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの逆余弦を要素ごとに返します。

    宣言

    @differentiable
    public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの逆正弦を要素ごとに返します。

    宣言

    @differentiable
    public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの逆正接を要素ごとに返します。

    宣言

    @differentiable
    public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの逆双曲線余弦を要素ごとに返します。

    宣言

    @differentiable
    public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの逆双曲線正弦を要素ごとに返します。

    宣言

    @differentiable
    public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの逆双曲線正接を要素ごとに返します。

    宣言

    @differentiable
    public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの平方根を要素ごとに返します。

    宣言

    @differentiable
    public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの逆平方根を要素ごとに返します。

    宣言

    @differentiable
    public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの指数を要素ごとに返します。

    宣言

    @differentiable
    public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 要素ごとに、指定されたテンソルの累乗の2を返します。

    宣言

    @differentiable
    public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 要素ごとに、指定されたテンソルの累乗で10を返します。

    宣言

    @differentiable
    public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • x - 1指数を要素ごとに返します。

    宣言

    @differentiable
    public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 要素ごとに、最も近い整数に丸められた指定されたテンソルの値を返します。

    宣言

    @differentiable
    public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの上限を要素ごとに返します。

    宣言

    @differentiable
    public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの床を要素ごとに返します。

    宣言

    @differentiable
    public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの符号の表示を要素ごとに返します。具体的には、 x < 0場合、 y = sign(x) = -1計算します。 x == 0 0の場合はx == 0 ; x > 0場合は1。

    宣言

    @differentiable
    public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
  • 指定されたテンソルのシグモイドを要素ごとに返します。具体的には、 1 / (1 + exp(-x))計算します。

    宣言

    @differentiable
    public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルの対数シグモイドを要素ごとに返します。具体的には、 log(1 / (1 + exp(-x))) 。数値安定性のために、 -softplus(-x)を使用します。

    宣言

    @differentiable
    public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルのsoftplusを要素ごとに返します。具体的には、 log(exp(features) + 1)計算しlog(exp(features) + 1)

    宣言

    @differentiable
    public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルのソフトサインを要素ごとに返します。具体的には、 features/ (abs(features) + 1)計算しfeatures/ (abs(features) + 1)

    宣言

    @differentiable
    public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 最後の軸に沿って指定されたテンソルのソフトマックスを返します。具体的には、 exp(x) / exp(x).sum(alongAxes: -1)

    宣言

    @differentiable
    public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定された軸に沿った指定されたテンソルのソフトマックスを返します。具体的には、 exp(x) / exp(x).sum(alongAxes: axis)

    宣言

    @differentiable
    public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルのlog-softmaxを要素ごとに返します。

    宣言

    @differentiable
    public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指数線形単位を適用してテンソルを返します。具体的には、計算するexp(x) - 1であれば<0、 xそうでありません。指数線形単位(ELU)による高速で正確なディープネットワーク学習を参照してください。

    宣言

    @differentiable
    public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 指定されたテンソルのガウス誤差線形単位(GELU)アクティベーションを要素ごとに返します。

    具体的には、 gelu xP(X <= x)近似します。ここで、 P(X <= x)は、次の計算によって標準ガウス累積分布です。x* [0.5 *(1 + tanh [√(2 /π)*(x + 0.044715 * x ^ 3)])]。

    ガウス誤差線形単位を参照してください。

    宣言

    @differentiable
    public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ReLU活性化関数を指定されたテンソルに要素ごとに適用することにより、テンソルを返します。具体的には、 max(0, x)計算します。

    宣言

    @differentiable
    public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ReLU6活性化関数、つまりmin(max(0, x), 6)適用して、テンソルを返します。

    宣言

    @differentiable
    public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 漏れのあるReLU活性化関数を指定されたテンソルに要素ごとに適用することにより、テンソルを返します。具体的には、 max(x, x * alpha)計算します。

    宣言

    @differentiable(wrt: x)
    public func leakyRelu<T: TensorFlowFloatingPoint>(
      _ x: Tensor<T>,
      alpha: Double = 0.2
    ) -> Tensor<T>
  • SeLU活性化関数を適用してテンソルを返します。つまり、 x < 0場合はscale * alpha * (exp(x) - 1) 、それ以外の場合はscale * xです。

    注意

    これは、分散スケーリングレイヤー初期化子と一緒に使用するように設計されています。詳細については、自己正規化ニューラルネットワークを参照してください。

    宣言

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • スウィッシュ活性化関数、つまりx * sigmoid(x)適用してテンソルを返します。

    出典:「活性化関数の検索」(Ramachandran etal。2017) https://arxiv.org/abs/1710.05941

    宣言

    @differentiable
    public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ハードシグモイド活性化関数、つまりRelu6(x+3)/6適用して、テンソルを返します。

    出典:「Searchingfor MobileNetV3」(Howard etal。2019) https://arxiv.org/abs/1905.02244

    宣言

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ハードスウィッシュ活性化関数、つまりx * Relu6(x+3)/6適用してテンソルを返します。

    出典:「Searchingfor MobileNetV3」(Howard etal。2019) https://arxiv.org/abs/1905.02244

    宣言

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • ミッシュ活性化関数、つまりx * tanh(softplus(x))適用してテンソルを返します。

    出典:「Mish:自己正則化された非単調ニューラル活性化関数」 https://arxiv.org/abs/1908.08681

    宣言

    @differentiable
    public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 最初のテンソルのパワーを2番目のテンソルに返します。

    宣言

    @differentiable
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • スカラーのパワーをテンソルに返し、スカラーをブロードキャストします。

    宣言

    @differentiable(wrt: rhs)
    public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • テンソルのパワーをスカラーに返し、スカラーをブロードキャストします。

    宣言

    @differentiable(wrt: lhs)
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
  • テンソルのパワーをスカラーに返し、スカラーをブロードキャストします。

    宣言

    @differentiable
    public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • テンソルの要素ごとのn乗根を返します。

    宣言

    @differentiable
    public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • xy差の2乗を返します。

    宣言

    @differentiable
    public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    戻り値

    (x - y) ^ 2

  • 要素ごとの最大2つのテンソルを返します。

    注意

    maxはブロードキャストをサポートします。

    宣言

    @differentiable
    public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • スカラーとテンソルの要素ごとの最大値を返し、スカラーをブロードキャストします。

    宣言

    @differentiable(wrt: rhs)
    public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • スカラーとテンソルの要素ごとの最大値を返し、スカラーをブロードキャストします。

    宣言

    @differentiable(wrt: lhs)
    public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • 2つのテンソルの要素ごとの最小値を返します。

    注意

    minはブロードキャストをサポートします。

    宣言

    @differentiable
    public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • スカラーとテンソルの要素ごとの最小値を返し、スカラーをブロードキャストします。

    宣言

    @differentiable(wrt: rhs)
    public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • スカラーとテンソルの要素ごとの最小値を返し、スカラーをブロードキャストします。

    宣言

    @differentiable(wrt: lhs)
    public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • xy間のコサイン類似度を返します。

    宣言

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • xy間のコサイン距離を返します。コサイン距離は1 - cosineSimilarity(x, y)として定義されます。

    宣言

    @differentiable
    public func cosineDistance<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • 別のテンソルで行列乗算を実行し、結果を生成します。

    宣言

    @differentiable
    public func matmul<Scalar: Numeric>(
      _ lhs: Tensor<Scalar>,
      transposed transposeLhs: Bool = false,
      _ rhs: Tensor<Scalar>,
      transposed transposeRhs: Bool = false
    ) -> Tensor<Scalar>
  • 指定された入力、フィルター、ストライド、およびパディングを使用した1次元畳み込みを返します。

    前提条件

    inputはランク3必要があります。

    前提条件

    filterランクは3である必要があります。

    宣言

    @differentiable(wrt: (input, filter)
    public func conv1D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      stride: Int = 1,
      padding: Padding = .valid,
      dilation: Int = 1
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filter

    畳み込みフィルター。

    stride

    スライディングフィルターのストライド。

    padding

    操作のパディング。

    dilation

    膨張係数。

  • 指定された入力、フィルター、ストライド、およびパディングを使用した2次元畳み込みを返します。

    前提条件

    inputはランク4必要があります。

    前提条件

    filterランクは4である必要があります。

    宣言

    @differentiable(wrt: (input, filter)
    public func conv2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
      padding: Padding = .valid,
      dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filter

    畳み込みフィルター。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のためのパディング

    dilations

    入力の各次元の膨張係数。

  • 指定された入力、フィルター、ストライド、およびパディングを使用して2次元転置畳み込みを返します。

    前提条件

    inputはランク4必要があります。

    前提条件

    filterランクは4である必要があります。

    宣言

    @differentiable(wrt: (input, filter)
    public func transposedConv2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      shape: [Int64],
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
      padding: Padding = .valid,
      dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    shape

    デコンボリューション操作の出力形状。

    filter

    畳み込みフィルター。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のためのパディング

    dilations

    入力の各次元の膨張係数。

  • 指定された入力、フィルター、ストライド、パディング、および拡張を使用した3D畳み込みを返します。

    前提条件

    inputはランク5必要があります。

    前提条件

    filterランクは5である必要があります。

    宣言

    @differentiable(wrt: (input, filter)
    public func conv3D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1),
      padding: Padding = .valid,
      dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1)
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filter

    畳み込みフィルター。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のパディング。

    dilations

    入力の各次元の膨張係数。

  • 指定された入力、フィルター、ストライド、およびパディングを使用して、2次元の深さ方向の畳み込みを返します。

    前提条件

    inputはランク4でなければなりません。

    前提条件

    filterランクは4である必要があります。

    宣言

    @differentiable(wrt: (input, filter)
    public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filter

    深さ方向の畳み込みフィルター。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のパディング。

  • 指定されたフィルターサイズ、ストライド、およびパディングを使用して、2次元の最大プーリングを返します。

    宣言

    @differentiable(wrt: input)
    public func maxPool2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int),
      strides: (Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filterSize

    プーリングカーネルの次元。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のパディング。

  • 指定されたフィルタサイズ、ストライド、およびパディングを使用して、3D最大プーリングを返します。

    宣言

    @differentiable(wrt: input)
    public func maxPool3D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int, Int),
      strides: (Int, Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filterSize

    プーリングカーネルの次元。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のパディング。

  • 指定されたフィルターサイズ、ストライド、およびパディングを使用して、2次元平均プーリングを返します。

    宣言

    @differentiable(wrt: input)
    public func avgPool2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int),
      strides: (Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filterSize

    プーリングカーネルの次元。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のパディング。

  • 指定されたフィルターサイズ、ストライド、およびパディングを使用して、3D平均プーリングを返します。

    宣言

    @differentiable(wrt: input)
    public func avgPool3D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int, Int),
      strides: (Int, Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    パラメーター

    input

    入力。

    filterSize

    プーリングカーネルの次元。

    strides

    入力の各次元のスライディングフィルターのストライド。

    padding

    操作のパディング。

  • 指定されたプーリング比で、2次元の小数最大プーリングを返します。

    注: fractionalMaxPoolはXLA実装がないため、パフォーマンスに影響を与える可能性があります。

    宣言

    @differentiable(wrt: input)
    public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      poolingRatio: (Double, Double, Double, Double),
      pseudoRandom: Bool = false,
      overlapping: Bool = false,
      deterministic: Bool = false,
      seed: Int64 = 0,
      seed2: Int64 = 0
    ) -> Tensor<Scalar>

    パラメーター

    input

    テンソル。形状[batch, height, width, channels] 4D。

    poolingRatio

    Doublesのリスト。 input各ディメンションのプール率。現在、行と列のディメンションのみがサポートされており、1.0以上である必要があります。

    pseudoRandom

    オプションのBool 。デフォルトはfalseです。 trueに設定すると、疑似ランダム方式でプーリングシーケンスが生成されtrue 。それ以外の場合は、ランダム方式で生成されtrue

    overlapping

    オプションのBool 。デフォルトはfalseです。 trueに設定すると、プール時に、隣接するプールセルの境界の値が両方のセルで使用されることを意味します。

    deterministic

    オプションのBooltrueに設定すると、計算グラフのfractionalMaxPool2Dノードを反復処理するときに、固定プーリング領域が使用されます。

    seed

    オプションのInt64 。デフォルトは0です。ゼロ以外に設定されている場合、乱数ジェネレーターは指定されたシードによってシードされます。

    seed2

    オプションのInt64 。デフォルトは0です。シードの衝突を回避するための2番目のシード。

  • 深さディメンションの値が空間ブロックで高さと幅のディメンションに移動さinputコピーを返します。

    たとえば、形状[1, 2, 2, 1] 1、2、2、1 [1, 2, 2, 1]入力が与えられた場合、data_format =“ NHWC”およびblock_size = 2:

    x = [[[[1], [2]],
          [[3], [4]]]]
    

    この操作は、形状[1, 1, 1, 4] 1、1、1、4]のテンソルを出力します。

    [[[[1, 2, 3, 4]]]]
    

    ここで、入力は1のバッチを持ち、各バッチ要素は形状[2, 2, 1] 2、2、1 [2, 2, 1]を持ち、対応する出力は単一の要素を持ち(つまり、幅と高さは両方とも1)、深さは4チャネル(1 * block_size * block_size)。出力要素の形状は[1, 1, 4]です。

    For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

    x = [[[[1, 2, 3], [4, 5, 6]],
          [[7, 8, 9], [10, 11, 12]]]]
    

    This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

    [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
    

    Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

    x = [[[[1],   [2],  [5],  [6]],
          [[3],   [4],  [7],  [8]],
          [[9],  [10], [13],  [14]],
          [[11], [12], [15],  [16]]]]
    

    the operator will return the following tensor of shape [1 2 2 4] :

    x = [[[[1, 2, 3, 4],
           [5, 6, 7, 8]],
          [[9, 10, 11, 12],
           [13, 14, 15, 16]]]]
    

    前提条件

    input.rank == 4 && b >= 2 .

    前提条件

    The number of the features must be divisible by square of b .

    宣言

    @differentiable(wrt: input)
    public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Returns a copy of input where values from the height and width dimensions are moved to the depth dimension.

    For example, given an input of shape [1, 2, 2, 1] , data_format = “NHWC” and block_size = 2:

    x = [[[[1], [2]],
          [[3], [4]]]]
    

    This operation will output a tensor of shape [1, 1, 1, 4] :

    [[[[1, 2, 3, 4]]]]
    

    Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

    For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

    x = [[[[1, 2, 3], [4, 5, 6]],
          [[7, 8, 9], [10, 11, 12]]]]
    

    This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

    [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
    

    Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

    x = [[[[1],   [2],  [5],  [6]],
          [[3],   [4],  [7],  [8]],
          [[9],  [10], [13],  [14]],
          [[11], [12], [15],  [16]]]]
    

    the operator will return the following tensor of shape [1 2 2 4] :

    x = [[[[1, 2, 3, 4],
           [5, 6, 7, 8]],
          [[9, 10, 11, 12],
           [13, 14, 15, 16]]]]
    

    前提条件

    input.rank == 4 && b >= 2 .

    前提条件

    The height of the input must be divisible by b .

    前提条件

    The width of the input must be divisible by b .

    宣言

    @differentiable(wrt: input)
    public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    宣言

    public func makeLARS(
      learningRate: Float = 0.01,
      momentum: Float = 0.9,
      trustCoefficient: Float = 0.001,
      nesterov: Bool = false,
      epsilon: Float = 0.0,
      weightDecay: Float = 0.0
    ) -> ParameterGroupOptimizer
  • Builds a SGD based per-weight optimizer.

    宣言

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • Builds a per-weight optimizer for Adam with weight decay.

    Reference: “Adam - A Method for Stochastic Optimization”

    宣言

    public func makeAdam(
      learningRate: Float = 0.01,
      beta1: Float = 0.9,
      beta2: Float = 0.999,
      weightDecayRate: Float = 0.01,
      epsilon: Float = 1e-6
    ) -> ParameterGroupOptimizer
  • Generates a new random seed for TensorFlow.

    宣言

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • 2つの値を連結します。

    宣言

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • 2つの値を加算し、それらの合計を生成します。

    宣言

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • 2つの値を平均します。

    宣言

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • 2つの値を乗算します。

    宣言

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • 2つの値をスタックします。

    宣言

    @differentiable
    public func stack<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • 宣言

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    宣言

    public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
  • 宣言

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    宣言

    public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]