このページは Cloud Translation API によって翻訳されました。

関数

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

l1Loss(予測:予想:)
予測と期待値の間の L1 損失を返します。
宣言
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l1Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
パラメータ
predicted
ニューラルネットワークからの予測出力。
expected
正しい出力に対応する期待値、つまりターゲット。
l2Loss(予測:期待:)
予測と期待値の間の 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
正しい出力に対応する期待値、つまりターゲット。
squaredHingeLoss(予測:期待:)
予測と期待値の間の二乗ヒンジ損失を返します。
宣言
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
パラメータ
predicted
ニューラルネットワークからの予測出力。
expected
正しい出力に対応する期待値、つまりターゲット。
categoricalHingeLoss(予測:期待:)
予測と期待の間のカテゴリカルヒンジ損失を返します。
宣言
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
パラメータ
predicted
ニューラルネットワークからの予測出力。
expected
正しい出力に対応する期待値、つまりターゲット。
logCoshLoss(予測:期待:)
予測と期待値の間の誤差の双曲線余弦の対数を返します。
宣言
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func logCoshLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
パラメータ
predicted
ニューラルネットワークからの予測出力。
expected
正しい出力に対応する期待値、つまりターゲット。
poissonLoss(予測:期待:)
予測と期待の間のポアソン損失を返します。
宣言
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func poissonLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
パラメータ
predicted
ニューラルネットワークからの予測出力。
expected
正しい出力に対応する期待値、つまりターゲット。
kullbackLeiblerDivergence(予測:期待:)
期待と予測の間のカルバック・ライブラー発散 (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
正しい出力のインデックス (ゼロから始まる)。
sigmoidCrossEntropy(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

withContext(_:_:)

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

宣言

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

パラメータ

`context`	クロージャが呼び出される前に設定され、クロージャが戻った後に復元されるコンテキスト。
`body`	ヌル閉包。クロージャに戻り値がある場合、その値は`withContext(_:_:)`関数の戻り値としても使用されます。

戻り値

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

withLearningPhase(_:_:)

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

宣言

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

パラメータ

`learningPhase`	クロージャが呼び出される前に設定され、クロージャが戻った後に復元される学習フェーズ。
`body`	ヌル閉包。クロージャーに戻り値がある場合、その値は`withLearningPhase(_:_:)`関数の戻り値としても使用されます。

戻り値

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

withRandomSeedForTensorFlow(_:_:)

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

宣言

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

パラメータ

`randomSeed`	クロージャが呼び出される前に設定され、クロージャが戻った後に復元されるランダムシード。
`body`	ヌル閉包。クロージャーに戻り値がある場合、その値は`withRandomSeedForTensorFlow(_:_:)`関数の戻り値としても使用されます。

戻り値

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

withRandomNumberGeneratorForTensorFlow(_:_:)

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

宣言

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(on:devices:wait:)
LazyTensorBarrier は、すべてのライブテンソル (提供されている場合はデバイス上) がスケジュールされ、実行されていることを保証します。 wait が true に設定されている場合、この呼び出しは計算が完了するまでブロックされます。
宣言
public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

valueWithGradient(at:in:)

宣言

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

valueWithGradient(at:_:in:)

宣言

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

valueWithGradient(at:_:_:in:)

宣言

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

valueWithGradient(:)

宣言

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

valueWithGradient(:)

宣言

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

valueWithGradient(:)

宣言

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

勾配(at:in:)

宣言

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

グラデーション(at:_:in:)

宣言

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

グラデーション(at:_:_:in:)

宣言

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

withRecomputationInPullbacks(_:)

従来の自動微分では「チェックポイント」として知られる、プルバックで関数を再計算します。

宣言

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

派生なし(at:)
恒等関数のようにxを返します。 xが微分されるコンテキストで使用される場合、この関数はxで微分を生成しません。
宣言
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
デリバティブなし(at:in:)
指定されたクロージャbody xに適用します。 xが微分されるコンテキストで使用される場合、この関数はxで微分を生成しません。
宣言
@_semantics("autodiff.nonvarying") public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R

withDevice(_:_:perform:)

クロージャを実行して、特定の種類のデバイス上で TensorFlow 操作を実行します。

宣言

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

パラメータ

`kind`	TensorFlow 操作を実行するためのデバイスの一種。
`index`	ops を実行するデバイス。
`body`	指定された種類のデバイス上で TensorFlow 操作が実行されるクロージャ。

withDevice(名前:実行:)
クロージャを実行し、特定の名前のデバイス上で 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 操作が実行されるクロージャ。
withDefaultDevice(実行:)
クロージャを実行して、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`場合、イメージをダウンサンプリングするときにアンチエイリアシングフィルターを使用します。

sizeArea(images:size:alignCorners:)
領域補間を使用して画像のサイズを変更します。
前提条件
画像のランクは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
画像の新しいサイズ。

dilation2D(_:フィルター:ストライド:レート:パディング:)

指定された入力、フィルター、ストライド、およびパディングを使用して 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`	入力の各次元の拡張率。

erosion2D(_:フィルター:ストライド:レート:パディング:)

指定された入力、フィルター、ストライド、およびパディングを使用して 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
constantInitializer(値:)
すべての値を指定された値に初期化してテンソルを作成する関数を返します。
宣言
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
constantInitializer(値:)
指定された値に初期化してテンソルを作成する関数を返します。提供された値のブロードキャストはサポートされていないことに注意してください。
宣言
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
glorotUniform(シード:)
指定された形状に対して Glorot (ザビエル) 一様初期化を実行し、デフォルトの乱数ジェネレーターによって生成され-limitとlimitの間の一様分布からスカラー値をランダムにサンプリングすることでテンソルを作成する関数を返します。ここで、limit はsqrt(6 / (fanIn + fanOut)) 、およびfanIn / fanOut 、入力機能と出力機能の数に、存在する場合は受容野を乗算した数を表します。
宣言
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
glorotNormal(シード:)
指定された形状に対して 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>
heNormal(シード:)
指定された形状に対して 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>
truncatedNormalInitializer(平均:標準偏差:シード:)
切り捨てられた正規分布からすべての値をランダムに初期化することによってテンソルを作成する関数を返します。生成された値は、平均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

eye(rowCount:columnCount:batchShape:on:)
単位行列または行列のバッチを返します。
宣言
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]のテンソル。

三角ソルブ(行列:rhs:下位:随伴:)

解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と同じ形状です。

l1Loss(予測:期待:削減:)

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`	計算された要素ごとの損失値に適用する削減。

l2Loss(予測:期待:削減:)

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`	計算された要素ごとの損失値に適用する削減。

meansAbsoluteError(予測:期待:)
ラベルと予測の間の絶対差の平均を計算します。 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
正しい出力に対応する期待値、つまりターゲット。
meansSquaredError(予測:期待:)
ラベルと予測の間の誤差の二乗平均を計算します。 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
正しい出力に対応する期待値、つまりターゲット。
meansSquaredLogarithmicError(予測:期待:)
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
正しい出力に対応する期待値、つまりターゲット。
meansAbsolutePercentageError(予測:期待:)
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`	計算された要素ごとの損失値に適用する削減。

squaredHingeLoss(予測:期待:削減:)

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`	計算された要素ごとの損失値に適用する削減。

categoricalHingeLoss(予測:期待:削減:)

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`	計算された要素ごとの損失値に適用する削減。

logCoshLoss(予測:期待:削減:)

予測誤差の双曲線余弦の対数を計算します。 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`	計算された要素ごとの損失値に適用する削減。

poissonLoss(予測:期待:削減:)

予測値と期待値の間のポアソン損失を計算します。ポアソン損失は、 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`	計算された要素ごとの損失値に適用する削減。

kullbackLeiblerDivergence(予測:期待:削減:)

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`	計算された要素ごとの損失値に適用する削減。

SoftmaxCrossEntropy(logits:labels: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`	計算された要素ごとの損失値に適用する削減。

SoftmaxCrossEntropy(ロジッツ:確率:リダクション:)

ロジットとラベル間のスパースソフトマックスクロスエントロピー (カテゴリクロスエントロピー) を計算します。ラベルクラスが 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`	計算された要素ごとの損失値に適用する削減。

sigmoidCrossEntropy(logits:labels: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`	計算された要素ごとの損失値に適用する削減。

HuberLoss(予測:期待:デルタ:減少:)

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

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

|x| <= δの場合0.5 * x^2 |x| <= δ 。
それ以外の場合は0.5 * δ^2 + δ * (|x| - δ) 。
出典:ウィキペディアの記事。

宣言

@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(_:)

指定されたテンソルの要素ごとの底 2 の対数を返します。

宣言

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

ログ10(_:)

指定されたテンソルの要素ごとの 10 を底とする対数を返します。

宣言

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

ログ1p(_:)

1 + xの対数を要素ごとに返します。

宣言

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

log1mexp(_:)
数値的に安定したアプローチを使用して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

cos(_:)

指定されたテンソルのコサインを要素ごとに返します。

宣言

@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

rsqrt(_:)

指定されたテンソルの逆平方根を要素ごとに返します。

宣言

@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

exp2(_:)

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

宣言

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

exp10(_:)

指定されたテンソルを要素ごとに乗じた 10 を返します。

宣言

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

expm1(_:)

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

logSoftmax(_:)

指定されたテンソルの要素ごとの 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
レル6(_:)
ReLU6 活性化関数、つまりmin(max(0, x), 6)を適用してテンソルを返します。
宣言
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
漏れるRelu(_:alpha:)
指定されたテンソルに要素ごとに 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>

cosineDistance(_:_:)

xとyの間のコサイン距離を返します。コサイン距離は1 - cosineSimilarity(x, y)として定義されます。

宣言

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

matmul(_:転置:_:転置:)

別のテンソルと行列の乗算を実行し、結果を生成します。

宣言

@differentiable
public func matmul<Scalar: Numeric>(
  _ lhs: Tensor<Scalar>,
  transposed transposeLhs: Bool = false,
  _ rhs: Tensor<Scalar>,
  transposed transposeRhs: Bool = false
) -> Tensor<Scalar>

conv1D(_:フィルター:ストライド:パディング:拡張:)
指定された入力、フィルター、ストライド、およびパディングを使用した 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
拡張係数。

conv2D(_:フィルター:ストライド:パディング:拡張:)

指定された入力、フィルター、ストライド、およびパディングを使用した 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`	入力の各次元の膨張係数。

transposedConv2D(_:shape: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`	入力の各次元の膨張係数。

conv3D(_:フィルター:ストライド:パディング:拡張:)

指定された入力、フィルター、ストライド、パディング、および拡張を使用した 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`	入力の各次元の膨張係数。

DepthwiseConv2D(_:フィルター:ストライド:パディング:)
指定された入力、フィルター、ストライド、パディングを使用した 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
操作のパディング。

maxPool2D(_:filterSize: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`	操作のパディング。

maxPool3D(_: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`	操作のパディング。

avgPool2D(_: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`	操作のパディング。

avgPool3D(_: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`	操作のパディング。

fractionalMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2:)

指定されたプーリング率を使用して、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 番目のシード。

DepthToSpace(_:blockSize:)
奥行き次元の値が空間ブロックで高さと幅の次元に移動された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
spaceToDepth(_:blockSize:)
高さと幅の寸法の値が奥行きの寸法に移動された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

Makelars（LearningRate：Momentum：TrustCoefficient：Nesterov：Epsilon：weightdecay :)

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

makegd（LearningRate：Momentum：weightdecay：nesterov :)

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

宣言

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

Makeadam（LearningRate：Beta1：Beta2：weightdecayrate：epsilon :)

体重減衰を伴うアダムの重量ごとのオプティマイザーを構築します。

参照：「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

randomseedfortensorflow（:)
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

printx10metrics（）
宣言
public func PrintX10Metrics()
formatstatistics（_ :)
トレーニングとテストの統計のリストの文字列概要を作成します。
宣言
public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

formatstatistics（トレーニング：テスト:)

宣言

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

runonnthreads（_：_ :)

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

宣言

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

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

`mean`	正規分布の平均。
`standardDeviation`	正規分布の標準偏差。

`rowCount`	各バッチ行列の行数。
`columnCount`	各バッチ行列の列の数。
`batchShape`	返されたテンソルの先頭のバッチディメンション。