Google I/O にご注目いただきありがとうございます。すべてのセッションをオンデマンドで表示オンデマンドで見る

関数

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

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

    宣言

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

    パラメーター

    predicted

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

    expected

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

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

    宣言

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

    パラメーター

    predicted

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

    expected

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

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

    宣言

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

    パラメーター

    predicted

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

    expected

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

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

    宣言

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

    パラメーター

    predicted

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

    expected

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

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

    宣言

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

    パラメーター

    predicted

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

    expected

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

  • 予測と期待の間の誤差の双曲線コサインの対数を返します。

    宣言

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

    パラメーター

    predicted

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

    expected

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

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

    宣言

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

    パラメーター

    predicted

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

    expected

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

  • 期待値と予測値の間のカルバックライブラーダイバージェンス（KLダイバージェンス）を返します。二つの分布を考える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

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

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

    宣言

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

    パラメーター

    logits

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

    labels

    正しい出力のインデックス（ゼロインデックス）。

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

    宣言

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

    パラメーター

    logits

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

    labels

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

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

    宣言

    @differentiable
public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

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

    宣言

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

    パラメーター

    context

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

    body

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

    戻り値

    戻り値があれば、 body閉鎖。

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

    宣言

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

    パラメーター

    learningPhase

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

    body

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

    戻り値

    戻り値があれば、 body閉鎖。

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

    宣言

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

    パラメーター

    randomSeed

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

    body

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

    戻り値

    戻り値があれば、 body閉鎖。

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

    宣言

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

    パラメーター

    randomNumberGenerator

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

    body

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

    戻り値

    戻り値があれば、 body閉鎖。

  • 宣言

    public func zip<T: TensorGroup, U: TensorGroup>(
  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
) -> Dataset<Zip2TensorGroup<T, U>>

  • LazyTensorBarrierは、すべてのライブテンソル（提供されている場合はデバイス上）がスケジュールされ、実行されていることを確認します。 waitがtrueに設定されている場合、この呼び出しは計算が完了するまでブロックされます。

    宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 宣言

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

  • 従来の自動微分では「チェックポインティング」と呼ばれる、プルバックで関数を再計算します。

    宣言

    public func withRecomputationInPullbacks<T, U>(
  _ body: @escaping @differentiable (T) -> U
) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable

  • ベクトルから微分可能関数を作成します-ヤコビアン積関数。

    宣言

    public func differentiableFunction<T : Differentiable, R : Differentiable>(
  from vjp: @escaping (T)
           -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
) -> @differentiable (T) -> R

  • ベクトルから微分可能関数を作成します-ヤコビアン積関数。

    宣言

    public func differentiableFunction<T, U, R>(
  from vjp: @escaping (T, U)
           -> (value: R, pullback: (R.TangentVector)
             -> (T.TangentVector, U.TangentVector))
) -> @differentiable (T, U) -> R

  • 戻り値は、 x恒等関数のように。文脈で使用される場合xで微分され、この関数は、で任意の誘導体を生じないx 。

    宣言

    @_semantics("autodiff.nonvarying")
public func withoutDerivative<T>(at x: T) -> T

  • 与えられた閉鎖適用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 / reply：0 / task：0 / device：GPU：1」：TensorFlowに表示されるマシンの2番目のGPUの完全修飾名。

    宣言

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

    パラメーター

    name

    装置名。

    body

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

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

    宣言

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

    パラメーター

    body

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

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

    前提条件

    画像は、ランク持っている必要があります3または4 。

    前提条件

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

    宣言

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

    パラメーター

    images

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

    size

    画像の新しいサイズ。

    method

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

    antialias

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

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

    前提条件

    画像は、ランク持っている必要があります3または4 。

    前提条件

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

    宣言

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

    パラメーター

    images

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

    size

    画像の新しいサイズ。

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

    前提条件

    input 、ランク持っている必要があります4 。

    前提条件

    filter 、ランク持っている必要があります3 。

    宣言

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

    パラメーター

    input

    入力。

    filter

    拡張フィルター。

    strides

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

    padding

    操作のためのパディング

    rates

    入力の各次元の膨張率。

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

    前提条件

    input 、ランク持っている必要があります4 。

    前提条件

    filter 、ランク3を持っている必要があります。

    宣言

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

    パラメーター

    input

    入力。

    filter

    侵食フィルター。

    strides

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

    padding

    操作のためのパディング

    rates

    入力の各次元の膨張率。

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

    宣言

    public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint

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

    宣言

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
  value: Scalar
) -> ParameterInitializer<Scalar>

  • 指定された値に初期化することによってテンソルを作成する関数を返します。提供された値の放送がサポートされていないことに注意してください。

    宣言

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
  value: Tensor<Scalar>
) -> ParameterInitializer<Scalar>

  • 戻りランダム間の一様分布からのスカラー値をサンプリングし、所定形状のためGlorot（ザビエル）均一な初期化を実行することによってテンソルを作成機能-limitとlimit限界があるデフォルトの乱数発生器によって生成され、 sqrt(6 / (fanIn + fanOut))及びfanIn / fanOut入力と出力の数を表し、存在する場合、受容野を乗じた特徴。

    宣言

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • ランダムに切断正規分布からのスカラー値をサンプリング戻りGlorot（ザビエル）所定形状のための通常の初期化を実行することによってテンソルを作成する機能を中心0標準偏差とsqrt(2 / (fanIn + fanOut))ここで、 fanIn / fanOut存在する場合は、入力および出力フィーチャの数に受容フィールドサイズを掛けたものを表します。

    宣言

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 戻りランダム間の一様分布からのスカラー値をサンプリングし、所定形状のために彼（Kaiming）均一な初期化を実行することによってテンソルを作成機能-limitとlimit限界があるデフォルトの乱数発生器によって生成され、 sqrt(6 / fanIn) 、及びfanIn存在する場合、受容野を乗じた入力特徴の数を表します。

    宣言

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • ランダムに切断正規分布からのスカラー値をサンプリング戻り所定形状のために彼（Kaiming）通常の初期化を実行することによってテンソルを作成する機能は、上に中心0標準偏差とsqrt(2 / fanIn) 、 fanIn入力フィーチャの数を表します。存在する場合は、受容フィールドサイズを掛けます。

    宣言

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 戻りランダム間の均一な分布からスカラー値をサンプリングし、所定形状のためLeCun均一な初期化を実行することによってテンソルを作成機能-limitとlimit限界があるデフォルトの乱数発生器によって生成され、 sqrt(3 / fanIn) 、およびfanIn存在する場合、受容野を乗じた入力特徴の数を表します。

    宣言

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • 戻り値は、ランダムに切断正規分布からのスカラー値をサンプリングし、所定形状のためLeCun通常の初期化を実行することによってテンソルを作成する機能は、上に中心0標準偏差とsqrt(1 / fanIn) 、 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]その最も内側の二次元正方行列を形成します。

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

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

    宣言

    @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

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

    rhs

    表す右辺値、 bでAx = b 。

    lower

    かどうかのmatrix下三角ある（ true ）または上三角（ false ）。デフォルト値はtrue 。

    adjoint

    場合はtrueの随伴を解決matrixの代わりに、 matrix 。デフォルト値はfalse 。

    戻り値

    溶液のx線形方程式のシステムには、で表されるAx = b 。 x同じ形状を有しb 。

  • 間のL1損失計算expectedとpredicted 。 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

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

  • 間のL2損失計算expectedとpredicted 。 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))

    ノート

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

    宣言

    @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つ以上のラベルクラスがある場合は、このクロスエントロピー損失関数を使用します。ラベルは整数として提供されることを期待しています。あるはず# classesのための機能ごとに浮動小数点値logitsためと機能ごとに単一の浮動小数点値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

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

  • 間Huber損失計算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

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

    reduction

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

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

    宣言

    @differentiable
public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar

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

    宣言

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

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

    宣言

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

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

    宣言

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

  • 戻り値の対数1 + x要素単位。

    宣言

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

  • 戻り値は、 log(1 - exp(x))数値的に安定したアプローチを使用します。

    ノート

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

    宣言

    @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

  • 指定されたテンソルの符号の表示を要素ごとに返します。具体的には、計算y = sign(x) = -1であればx < 0 0であればx == 0 。 1であればx > 0 。

    宣言

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

  • 指定されたテンソルのシグモイドを要素ごとに返します。具体的には、演算1 / (1 + exp(-x))

    宣言

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

  • 指定されたテンソルの対数シグモイドを要素ごとに返します。具体的には、 log(1 / (1 + exp(-x)))数値安定性のために、我々は使用-softplus(-x) 。

    宣言

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

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

    宣言

    @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

  • 指数線形単位を適用してテンソルを返します。具体的には、計算するexp(x) - 1であれば<0、 xそうでありません。参照指数線形単位（ELUs）により、高速かつ正確なディープ・ネットワークの学習を

    宣言

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

  • 指定されたテンソルのガウス誤差線形単位（GELU）アクティベーションを要素ごとに返します。

    具体的には、 gelu近似xP(X <= x)ここで、 P(X <= x)標準ガウス累積分布を計算することにより、ある：X * [0.5 *（1 + TANH [√（2 /π）*（X + 0.044715 * x ^ 3）]）]。

    参照してくださいガウスエラー線形単位を。

    宣言

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

  • ReLU活性化関数を指定されたテンソルに要素ごとに適用することにより、テンソルを返します。具体的には、計算max(0, x)

    宣言

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

  • リターン即ちReLU6活性化関数を適用することによってテンソル、 min(max(0, x), 6)

    宣言

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

  • 漏れのあるReLU活性化関数を指定されたテンソルに要素ごとに適用することにより、テンソルを返します。具体的には、計算max(x, x * alpha) 。

    宣言

    @differentiable(wrt: x)
public func leakyRelu<T: TensorFlowFloatingPoint>(
  _ x: Tensor<T>,
  alpha: Double = 0.2
) -> Tensor<T>

  • SELU活性化関数を適用することによって戻りテンソル、即ちscale * alpha * (exp(x) - 1)であればx < 0及びscale * xさもなければ。

    ノート

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

    宣言

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

  • スウィッシュ活性化関数、すなわち適用することによってテンソルを返すx * sigmoid(x) 。

    出典：（。ラマチャンドランら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の検索」（ハワードら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の検索」（ハワードら2019） https://arxiv.org/abs/1905.02244

    宣言

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

  • ミッシュ活性化関数、すなわち適用することによって戻りテンソルx * tanh(softplus(x)) 。

    出典：「ミッシュ：A自己正則非単調神経活性化関数」 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

    膨張係数。

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

    前提条件

    input 、ランク持っている必要があります4 。

    前提条件

    filter 、ランク4を持っている必要があります。

    宣言

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

    パラメーター

    input

    入力。

    filter

    畳み込みフィルター。

    strides

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

    padding

    操作のためのパディング

    dilations

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

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

    前提条件

    input 、ランク持っている必要があります4 。

    前提条件

    filter 、ランク4を持っている必要があります。

    宣言

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

    パラメーター

    input

    入力。

    shape

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

    filter

    畳み込みフィルター。

    strides

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

    padding

    操作のためのパディング

    dilations

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

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

    前提条件

    input 、ランク持っている必要があります5 。

    前提条件

    filter 、ランク5を持っている必要があります。

    宣言

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

    パラメーター

    input

    入力。

    filter

    畳み込みフィルター。

    strides

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

    padding

    操作のパディング。

    dilations

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

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

    前提条件

    input 、ランク4を持っている必要があります。

    前提条件

    filter 、ランク4を持っている必要があります。

    宣言

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

    パラメーター

    input

    入力。

    filter

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

    strides

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

    padding

    操作のパディング。

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

    宣言

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

    パラメーター

    input

    入力。

    filterSize

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

    strides

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

    padding

    操作のパディング。

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

    宣言

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

    パラメーター

    input

    入力。

    filterSize

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

    strides

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

    padding

    操作のパディング。

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

    宣言

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

    パラメーター

    input

    入力。

    filterSize

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

    strides

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

    padding

    操作のパディング。

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

    宣言

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

    パラメーター

    input

    入力。

    filterSize

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

    strides

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

    padding

    操作のパディング。

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

    注： fractionalMaxPool XLAの実装を持っていないため、パフォーマンスへの影響を有することができます。

    宣言

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

    パラメーター

    input

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

    poolingRatio

    リストDoubles 。各ディメンションの比率をプールinput 、現在のみ反転ROWおよび反転COL次元をサポートし、> = 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である）と4つのチャネルの深さを有することになる（1 * block_size * block_size）。出力素子形状である[1, 1, 4]

    ここで、形状のより大きな深さを有する入力テンソルのために[1, 2, 2, 3]例えば

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

    この操作は、2のBLOCK_SIZEのために、形状の次テンソル戻ります[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 。

    宣言

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

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

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

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

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

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

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

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

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

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

    Precondition

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

    Precondition

    The height of the input must be divisible by b .

    Precondition

    The width of the input must be divisible by b .

    宣言

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

  • Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    宣言

    public func makeLARS(
  learningRate: Float = 0.01,
  momentum: Float = 0.9,
  trustCoefficient: Float = 0.001,
  nesterov: Bool = false,
  epsilon: Float = 0.0,
  weightDecay: Float = 0.0
) -> ParameterGroupOptimizer

  • Builds a SGD based per-weight optimizer.

    宣言

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

  • Builds a per-weight optimizer for Adam with weight decay.

    Reference: “Adam - A Method for Stochastic Optimization”

    宣言

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

  • Generates a new random seed for TensorFlow.

    宣言

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed

  • Concatenates two values.

    宣言

    @differentiable
public func concatenate<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Adds two values and produces their sum.

    宣言

    @differentiable
public func sum<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Averages two values.

    宣言

    @differentiable
public func average<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Multiplies two values.

    宣言

    @differentiable
public func multiply<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Stack two values.

    宣言

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

  • 宣言

    public func PrintX10Metrics()

  • Creates a string summary of a list of training and testing stats.

    宣言

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

  • 宣言

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

  • Maps a function over n threads.

    宣言

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