関数

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

  • 予測と期待値の間の 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

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

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

    宣言

    @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 つの分布pおよびqが与えられると、KL 発散は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

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

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

    宣言

    @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

  • 指定されたクロージャbodyをxに適用します。 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/replica: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

    形状[batch, height, width, channels]の 4 次元Tensor 、または形状[height, width, channels]の 3 次元Tensor 。

    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

    形状[batch, height, width, channels]の 4 次元Tensor 、または形状[height, width, channels]の 3 次元Tensor 。

    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

    入力の各次元の拡張率。

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

    前提条件

    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 (ザビエル) 一様初期化を実行し、デフォルトの乱数ジェネレーターによって生成された-limitとlimitの間の一様分布からスカラー値をランダムにサンプリングすることでテンソルを作成する関数を返します。ここで、limit はsqrt(6 / (fanIn + fanOut)) 、および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) 一様初期化を実行し、デフォルトの乱数ジェネレーターによって生成された-limitとlimitの間の一様分布からスカラー値をランダムにサンプリングすることにより、テンソルを作成する関数を返します。ここで、limit はsqrt(6 / fanIn) 、 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 一様初期化を実行し、デフォルトの乱数ジェネレーターによって生成された-limitとlimitの間の一様分布からスカラー値をランダムにサンプリングすることによってテンソルを作成する関数を返します。ここで、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>

  • 切り捨てられた正規分布からすべての値をランダムに初期化することによってテンソルを作成する関数を返します。生成された値は、 meanと標準偏差standardDeviationを含む正規分布に従います。ただし、大きさが平均値から 2 標準偏差を超える値は削除され、再サンプリングされます。

    宣言

    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]のテンソル。

  • 解x Ax = bで表される線形方程式系に返します。

    前提条件

    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

    Ax = bのbを表す右側の値。

    lower

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

    adjoint

    trueの場合、 matrixの代わりにmatrixの随伴を使用して解決します。デフォルト値はfalseです。

    戻り値

    Ax = bで表される連立一次方程式の解x 。 xはbと同じ形状です。

  • expectedとpredictedの間の L1 損失を計算します。 loss = 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

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

  • expectedとpredictedの間の L2 損失を計算します。 loss = 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損失とexpected損失の間の平均二乗対数誤差を計算しますloss = square(log(expected) - log(predicted))

    注記

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

    宣言

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

    パラメーター

    predicted

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

    expected

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

  • predictedとexpectedの間の平均絶対パーセント誤差を計算します。 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

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

  • predictedとexpectedの間のヒンジ損失を計算します。 loss = 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

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

  • predictedとexpectedの間の二乗ヒンジ損失を計算します。 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

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

  • predictedとexpectedの間のカテゴリカル ヒンジ損失を計算します。 loss = 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誤差です。

    宣言

    @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

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

  • 予測値と期待値の間のポアソン損失を計算します。 ポアソン損失は、 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

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

  • expectedとpredictedの間のカルバック・ライブラー発散損失を計算します。 loss = 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の場合は特徴ごとに単一の浮動小数点値が必要です。

    宣言

    @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

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

  • predictedとexpectedの間のフーバー損失を計算します。

    各値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

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

    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))を返します。

    注記

    このアプローチは、 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の場合は 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

  • 指定されたテンソルのソフトプラスを要素ごとに返します。具体的には、 log(exp(features) + 1)を計算します。

    宣言

    @differentiable
public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • 指定されたテンソルのソフトサインを要素ごとに返します。具体的には、 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

  • 指数線形単位を適用してテンソルを返します。具体的には、< 0 の場合はexp(x) - 1 、それ以外の場合は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

  • 指定されたテンソルに要素ごとに Leaky 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

  • swish 活性化関数、つまりx * sigmoid(x)を適用してテンソルを返します。

    出典: 「活性化関数の探索」 (Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941

    宣言

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

  • ハード シグモイド活性化関数、つまりRelu6(x+3)/6を適用してテンソルを返します。

    出典: 「MobileNetV3 の検索」 (Howard et al. 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を適用してテンソルを返します。

    出典: 「MobileNetV3 の検索」 (Howard et al. 2019) https://arxiv.org/abs/1905.02244

    宣言

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

  • mish 活性化関数、つまり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

  • xとyの差の二乗を返します。

    宣言

    @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

  • xとyの間のコサイン類似度を返します。

    宣言

    @differentiable
public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

  • xとyの間のコサイン距離を返します。コサイン距離は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

    操作のパディング。

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

    宣言

    @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

    操作のパディング。

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

    宣言

    @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]の 4-D。

    poolingRatio

    Doublesのリスト。 inputの各次元のプーリング率は、現在行次元と列次元のみをサポートしており、1.0 以上である必要があります。

    pseudoRandom

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

    overlapping

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

    deterministic

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

    seed

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

    seed2

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

  • 奥行き次元の値が空間ブロックで高さと幅の次元に移動されたinputのコピーを返します。

    たとえば、形状[1, 2, 2, 1]の入力、 data_format = “NHWC” および block_size = 2 の場合、次のようになります。

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

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

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

    ここで、入力には 1 のバッチがあり、各バッチ要素の形状は[2, 2, 1]です。対応する出力は 1 つの要素 (つまり、幅と高さは両方とも 1) を持ち、深さは 4 チャネル (1) になります。 * ブロックサイズ * ブロックサイズ)。出力要素の形状は[1, 1, 4]です。

    より深い深さの入力テンソルの場合、ここでは[1, 2, 2, 3]の形状になります。

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

    この操作は、block_size が 2 の場合、次の形状[1, 1, 1, 12]のテンソルを返します。

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

    同様に、形状[1 4 4 1] 、ブロック サイズ 2 の次の入力の場合:

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

    演算子は、次の形状[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 。

    前提条件

    特徴の数はbの 2 乗で割り切れる必要があります。

    宣言

    @differentiable(wrt: input)
public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • 高さと幅の寸法の値が奥行きの寸法に移動されたinputのコピーを返します。

    たとえば、形状[1, 2, 2, 1]の入力、 data_format = “NHWC” および block_size = 2 の場合、次のようになります。

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

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

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

    ここで、入力には 1 のバッチがあり、各バッチ要素の形状は[2, 2, 1]です。対応する出力は 1 つの要素 (つまり、幅と高さは両方とも 1) を持ち、深さは 4 チャネル (1) になります。 * ブロックサイズ * ブロックサイズ)。出力要素の形状は[1, 1, 4]です。

    より深い深さの入力テンソルの場合、ここでは[1, 2, 2, 3]の形状になります。

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

    この操作は、block_size が 2 の場合、次の形状[1, 1, 1, 12]のテンソルを返します。

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

    同様に、形状[1 4 4 1] 、ブロック サイズ 2 の次の入力の場合:

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

    演算子は、次の形状[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 。

    前提条件

    入力の高さはbで割り切れる必要があります。

    前提条件

    入力の幅はbで割り切れる必要があります。

    宣言

    @differentiable(wrt: input)
public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • 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

  • SGD ベースの重みごとのオプティマイザーを構築します。

    宣言

    public func makeSGD(
  learningRate: Float = 0.01,
  momentum: Float = 0,
  weightDecay: Float = 0,
  nesterov: Bool = false
) -> ParameterGroupOptimizer

  • 重み減衰を使用して Adam の重みごとのオプティマイザーを構築します。

    参考文献： 「Adam - 確率的最適化の手法」

    宣言

    public func makeAdam(
  learningRate: Float = 0.01,
  beta1: Float = 0.9,
  beta2: Float = 0.999,
  weightDecayRate: Float = 0.01,
  epsilon: Float = 1e-6
) -> ParameterGroupOptimizer

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

  • トレーニングとテストの統計のリストの文字列概要を作成します。

    宣言

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

  • 宣言

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
  -> String

  • nスレッド上の関数をマップします。

    宣言

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