Funciones

Las siguientes funciones están disponibles a nivel mundial.

• l1Loss (predicho: esperado :)

  Devuelve la pérdida L1 entre predicciones y expectativas.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• l2Loss (predicho: esperado :)

  Devuelve la pérdida L2 entre predicciones y expectativas.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• hingeLoss (predicho: esperado :)

  Devuelve la pérdida de bisagra entre predicciones y expectativas.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• squaredHingeLoss (predicho: esperado :)

  Devuelve la pérdida de bisagra al cuadrado entre predicciones y expectativas.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• categoricalHingeLoss (predicho: esperado :)

  Devuelve la pérdida de bisagra categórica entre predicciones y expectativas.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• logCoshLoss (predicho: esperado :)

  Devuelve el logaritmo del coseno hiperbólico del error entre predicciones y expectativas.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• poissonLoss (predicho: esperado :)

  Devuelve la pérdida de Poisson entre predicciones y expectativas.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• kullbackLeiblerDivergence (predicho: esperado :)

  Devuelve la divergencia Kullback-Leibler (divergencia KL) entre expectativas y predicciones. Dadas dos distribuciones de p y q , KL divergencia calcula p * log(p / q) .

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• softmaxCrossEntropy (logits: probabilidades :)

  Devuelve la entropía cruzada softmax (entropía cruzada categórica) entre logits y etiquetas.

  Declaración

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

  Parámetros

  logits	Salidas codificadas en caliente de una red neuronal.
  labels	Índices (indexados a cero) de las salidas correctas.

• sigmoidCrossEntropy (logits: etiquetas :)

  Devuelve la entropía cruzada sigmoidea (entropía cruzada binaria) entre logits y etiquetas.

  Declaración

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

  Parámetros

  logits	La salida sin escala de una red neuronal.
  labels	Valores enteros que corresponden a la salida correcta.

• identidad(_:)

  Devuelve un tensor con la misma forma y escalares que el tensor especificado.

  Declaración

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

• withContext (_: _ :)

  Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto por la fase de aprendizaje dada.

  Declaración

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

  Parámetros

  context	Un contexto que se establecerá antes de que se llame al cierre y se restaurará después de que vuelva el cierre.
  body	Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se utiliza como valor de retorno de la withContext(_:_:) función.

  Valor devuelto

  El valor de retorno, en su caso, del body cierre.

• withLearningPhase (_: _ :)

  Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto por la fase de aprendizaje dada.

  Declaración

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

  Parámetros

  learningPhase	Una fase de aprendizaje que se establecerá antes de que se llame al cierre y se restablecerá después de que vuelva el cierre.
  body	Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se utiliza como valor de retorno de la withLearningPhase(_:_:) función.

  Valor devuelto

  El valor de retorno, en su caso, del body cierre.

• withRandomSeedForTensorFlow (_: _ :)

  Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto por la semilla aleatoria dada.

  Declaración

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

  Parámetros

  randomSeed	Una semilla aleatoria que se establecerá antes de que se llame al cierre y se restaurará después de que regrese el cierre.
  body	Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se utiliza como valor de retorno de la withRandomSeedForTensorFlow(_:_:) función.

  Valor devuelto

  El valor de retorno, en su caso, del body cierre.

• withRandomNumberGeneratorForTensorFlow (_: _ :)

  Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto por el generador de números aleatorios dado.

  Declaración

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

  Parámetros

  randomNumberGenerator	Un generador de números aleatorios que se configurará antes de que se llame al cierre y se restaurará después de que regrese el cierre.
  body	Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se utiliza como valor de retorno de la withRandomNumberGeneratorForTensorFlow(_:_:) función.

  Valor devuelto

  El valor de retorno, en su caso, del body cierre.

• Código Postal(_:_:)

  Declaración

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

• LazyTensorBarrier (en: dispositivos: espere :)

  LazyTensorBarrier garantiza que todos los tensores activos (en el dispositivo, si se proporcionan) estén programados y funcionando. Si wait se establece en true, esta llamada se bloquea hasta que se completa el cálculo.

  Declaración

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

• valueWithGradient (en: en :)

  Declaración

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

  Declaración

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

  Declaración

  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 (de :)

  Declaración

  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 (de :)

  Declaración

  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 (de :)

  Declaración

  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

• gradiente (en: en :)

  Declaración

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

• gradiente (en: _: en :)

  Declaración

  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

• gradiente (en: _: _: en :)

  Declaración

  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

• gradiente (de :)

  Declaración

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

• gradiente (de :)

  Declaración

  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

• gradiente (de :)

  Declaración

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

  Hacer que una función se vuelva a calcular en su retroceso, conocido como "punto de control" en la diferenciación automática tradicional.

  Declaración

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

• función diferenciable (de :)

  Cree una función diferenciable a partir de una función de productos vector-jacobianos.

  Declaración

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

• función diferenciable (de :)

  Cree una función diferenciable a partir de una función de productos vector-jacobianos.

  Declaración

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

• withoutDerivative (en :)

  Devuelve x como una función de identidad. Cuando se utiliza en un contexto donde x está siendo diferenciado con respecto a, esta función no producirá ningún derivada en x .

  Declaración

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

• withoutDerivative (en: en :)

  Se aplica el cierre dado body a x . Cuando se utiliza en un contexto donde x está siendo diferenciado con respecto a, esta función no producirá ningún derivada en x .

  Declaración

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

• withDevice (_: _: realizar :)

  Ejecuta un cierre, lo que hace que las operaciones de TensorFlow se ejecuten en un tipo específico de dispositivo.

  Declaración

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

  Parámetros

  kind	Una especie de dispositivo para ejecutar operaciones de TensorFlow.
  index	El dispositivo para ejecutar las operaciones.
  body	Un cierre cuyas operaciones de TensorFlow se ejecutarán en el tipo de dispositivo especificado.

• withDevice (llamado: realizar :)

  Ejecuta un cierre, lo que hace que las operaciones de TensorFlow se ejecuten en un dispositivo con un nombre específico.

  Algunos ejemplos de nombres de dispositivos:

  • “/ Dispositivo: CPU: 0”: la CPU de su máquina.
  • "/ GPU: 0": notación abreviada para la primera GPU de su máquina que es visible para TensorFlow
  • “/ Job: localhost / replica: 0 / task: 0 / device: GPU: 1”: nombre completo de la segunda GPU de tu máquina que es visible para TensorFlow.

  Declaración

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

  Parámetros

  name	Nombre del dispositivo.
  body	Un cierre cuyas operaciones de TensorFlow se ejecutarán en el tipo de dispositivo especificado.

• withDefaultDevice (realizar :)

  Ejecuta un cierre, lo que permite a TensorFlow colocar operaciones de TensorFlow en cualquier dispositivo. Esto debería restaurar el comportamiento de ubicación predeterminado.

  Declaración

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

  Parámetros

  body	Un cierre cuyas operaciones de TensorFlow se ejecutarán en el tipo de dispositivo especificado.

• cambiar el tamaño (imágenes: tamaño: método: antialias :)

  Cambie el tamaño de las imágenes a su tamaño utilizando el método especificado.

  Condición previa

  Las imágenes deben tener rango de 3 o 4 .

  Condición previa

  El tamaño debe ser positivo.

  Declaración

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

  Parámetros

  images	4-D Tensor de forma [batch, height, width, channels] o 3-D Tensor de forma [height, width, channels] .
  size	El nuevo tamaño de las imágenes.
  method	El método de cambio de tamaño. El valor por defecto es .bilinear .
  antialias	Iff true , utilizar un filtro anti-aliasing cuando la disminución de resolución de una imagen.

• resizeArea (imágenes: tamaño: alignCorners :)

  Cambie el tamaño de las imágenes mediante la interpolación de áreas.

  Condición previa

  Las imágenes deben tener rango de 3 o 4 .

  Condición previa

  El tamaño debe ser positivo.

  Declaración

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

  Parámetros

  images	4-D Tensor de forma [batch, height, width, channels] o 3-D Tensor de forma [height, width, channels] .
  size	El nuevo tamaño de las imágenes.

• dilation2D (_: filter: strides: rates: padding :)

  Devuelve una dilatación 2-D con la entrada, el filtro, los pasos y el relleno especificados.

  Condición previa

  input debe tener rango 4 .

  Condición previa

  filter debe tener rango 3 .

  Declaración

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

  Parámetros

  input	La entrada.
  filter	El filtro de dilatación.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación
  rates	Las tasas de dilatación para cada dimensión de la entrada.

• erosion2D (_: filter: strides: rates: padding :)

  Devuelve una erosión 2-D con la entrada, el filtro, las zancadas y el relleno especificados.

  Condición previa

  input debe tener rango 4 .

  Condición previa

  filter debe tener rango 3.

  Declaración

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

  Parámetros

  input	La entrada.
  filter	El filtro de erosión.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación
  rates	Las tasas de dilatación para cada dimensión de la entrada.

• ceros ()

  Devuelve una función que crea un tensor inicializando todos sus valores a ceros.

  Declaración

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

• constantInitializer (valor :)

  Devuelve una función que crea un tensor inicializando todos sus valores al valor proporcionado.

  Declaración

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

• constantInitializer (valor :)

  Devuelve una función que crea un tensor inicializándolo con el valor proporcionado. Tenga en cuenta que la difusión del valor proporcionado no es compatible.

  Declaración

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

• glorotUniform (semilla :)

  Devuelve una función que crea un tensor mediante la realización de Glorot (Xavier) inicialización uniforme para la forma especificada, el muestreo al azar valores escalares de una distribución uniforme entre -limit y limit , generada por el generador de números aleatorios por defecto, donde límite es sqrt(6 / (fanIn + fanOut)) , y fanIn / fanOut representan el número de entrada y salida características multiplican por el campo receptivo, si está presente.

  Declaración

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

• glorotNormal (semilla :)

  Devuelve una función que crea un tensor mediante la realización de Glorot (Xavier) de inicialización normal para la forma especificada, el muestreo al azar valores escalares a partir de una distribución normal truncada centradas en 0 con desviación estándar sqrt(2 / (fanIn + fanOut)) , donde fanIn / fanOut representan el número de características de entrada y salida multiplicado por el tamaño del campo receptivo, si está presente.

  Declaración

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

• heUniform (semilla :)

  Devuelve una función que crea un tensor mediante la realización de He (Kaiming) inicialización uniforme para la forma especificada, el muestreo al azar valores escalares de una distribución uniforme entre -limit y limit , generada por el generador de números aleatorios por defecto, donde límite es sqrt(6 / fanIn) , y fanIn representa el número de características de entrada multiplicada por el campo receptivo, si está presente.

  Declaración

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

• heNormal (semilla :)

  Devuelve una función que crea un tensor mediante la realización de He (Kaiming) de inicialización normal para la forma especificada, el muestreo al azar valores escalares a partir de una distribución normal truncada centradas en 0 con una desviación estándar sqrt(2 / fanIn) , donde fanIn representa el número de características de entrada multiplicado por el tamaño del campo receptivo, si está presente.

  Declaración

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

• leCunUniform (semilla :)

  Devuelve una función que crea un tensor mediante la realización de LeCun inicialización uniforme para la forma especificada, el muestreo al azar valores escalares de una distribución uniforme entre -limit y limit , generada por el generador de números aleatorios por defecto, donde límite es sqrt(3 / fanIn) , y fanIn representa el número de características de entrada multiplicada por el campo receptivo, si está presente.

  Declaración

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

• leCunNormal (semilla :)

  Devuelve una función que crea un tensor mediante la realización de LeCun inicialización normal para la forma especificada, el muestreo al azar valores escalares a partir de una distribución normal truncada centradas en 0 con una desviación estándar sqrt(1 / fanIn) , donde fanIn representa el número de entidades de entrada multiplicada por el tamaño del campo receptivo, si está presente.

  Declaración

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

• truncatedNormalInitializer (media: desviación estándar: semilla :)

  Devuelve una función que crea un tensor inicializando todos sus valores aleatoriamente a partir de una distribución Normal truncada. Los valores generados siguen una distribución normal con media mean y desviación estándar standardDeviation , excepto que los valores cuya magnitud es más de dos desviaciones estándar de la media se dejan caer y un nuevo muestreo.

  Declaración

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

  Parámetros

  mean	Media de la distribución normal.
  standardDeviation	Desviación estándar de la distribución normal.

  Valor devuelto

  Una función de inicializador de parámetro normal truncada.

• == (_: _ :)

  Declaración

  public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool

• ojo (rowCount: columnCount: batchShape: on :)

  Devuelve una matriz de identidad o un lote de matrices.

  Declaración

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

  Parámetros

  rowCount	El número de filas en cada matriz de lote.
  columnCount	El número de columnas en cada matriz de lote.
  batchShape	Las dimensiones del lote inicial del tensor devuelto.

• rastro(_:)

  Calcula la traza de una matriz por lotes opcional. La traza es la suma a lo largo de la diagonal principal de cada matriz más interna.

  La entrada es un tensor con forma de [..., M, N] . La salida es un tensor con la forma [...] .

  Condición previa

  matrix debe ser un tensor con forma de [..., M, N] .

  Declaración

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

  Parámetros

  matrix

  Un tensor de la forma de [..., M, N] .

• cholesky (_ :)

  Devuelve la descomposición de Cholesky de una o más matrices cuadradas.

  La entrada es un tensor de la forma de [..., M, M] cuya 2 dimensiones-mayoría interior formar matrices cuadradas.

  La entrada tiene que ser simétrica y definida positiva. Solo la parte triangular inferior de la entrada se utilizará para esta operación. No se leerá la parte triangular superior.

  La salida es un tensor de la misma forma que la entrada que contiene las descomposiciones de Cholesky para todas las submatrices de entrada [..., :, :] .

  Declaración

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

  Parámetros

  input

  Un tensor de la forma [..., M, M] .

• triangularSolve (matriz: rhs: lower: adjoint :)

  Devuelve la solución x en el sistema de ecuaciones lineales representadas por Ax = b .

  Condición previa

  matrix debe ser un tensor con forma de [..., M, M] .

  Condición previa

  rhs debe ser un tensor con la forma [..., M, K] .

  Declaración

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

  Parámetros

  matrix	La entrada triangular coeficiente de la matriz, representando A en Ax = b .
  rhs	Valores lado derecho, representando b en Ax = b .
  lower	Ya sea matrix es triangular inferior ( true ) o triangular superior ( false ). El valor por defecto es true .
  adjoint	Si true , resolver con el adjunto de la matrix en lugar de matrix . El valor por defecto es false .

  Valor devuelto

  La solución de x para el sistema de ecuaciones lineales representada por Ax = b . x tiene la misma forma como b .

• l1Loss (predicho: esperado: reducción :)

  Calcula la pérdida L1 entre expected y predicted . loss = reduction(abs(expected - predicted))

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• l2Loss (predicho: esperado: reducción :)

  Calcula la pérdida de L2 entre expected y predicted . loss = reduction(square(expected - predicted))

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• meanAbsoluteError (predicho: esperado :)

  Calcula la media de la diferencia absoluta entre etiquetas y predicciones. loss = mean(abs(expected - predicted))

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• meanSquaredError (predicho: esperado :)

  Calcula la media de cuadrados de errores entre etiquetas y predicciones. loss = mean(square(expected - predicted))

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• meanSquaredLogarithmicError (predicho: esperado :)

  Calcula el error cuadrático medio entre logarítmica predicted y expected loss = square(log(expected) - log(predicted))

  Nota

  Entradas tensor negativa serán sujetados en 0 para evitar un comportamiento logarítmico indefinido, como log(_:) está definida para reales negativos.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• meanAbsolutePercentageError (predicho: esperado :)

  Calcula el error porcentual absoluto medio entre predicted y expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.

• hingeLoss (predicho: esperado: reducción :)

  Calcula la pérdida de bisagra entre predicted y expected . loss = reduction(max(0, 1 - predicted * expected)) expected se espera que los valores a ser -1 o 1.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• squaredHingeLoss (predicho: esperado: reducción :)

  Calcula la pérdida de bisagra al cuadrado entre predicted y expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected Se espera que los valores a ser -1 o 1.

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• categoricalHingeLoss (predicho: esperado: reducción :)

  Calcula la pérdida de bisagra categórica entre predicted y expected . loss = maximum(negative - positive + 1, 0) , donde negative = max((1 - expected) * predicted) y positive = sum(predicted * expected)

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• logCoshLoss (predicho: esperado: reducción :)

  Calcula el logaritmo del coseno hiperbólico del error de predicción. logcosh = log((exp(x) + exp(-x))/2) , donde es X el error predicted - expected

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• poissonLoss (predicho: esperado: reducción :)

  Calcula la pérdida de Poisson entre predicho y espera que la pérdida de Poisson es la media de los elementos del Tensor predicted - expected * log(predicted) .

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• kullbackLeiblerDivergence (predicho: esperado: reducción :)

  Calcula la pérdida de la divergencia de Kullback-Leibler entre expected y predicted . loss = reduction(expected * log(expected / predicted))

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• softmaxCrossEntropy (logits: etiquetas: reducción :)

  Calcula la entropía cruzada escasa de softmax (entropía cruzada categórica) entre logits y etiquetas. Utilice esta función de pérdida de entropía cruzada cuando haya dos o más clases de etiquetas. Esperamos que las etiquetas se proporcionen como números enteros. No debe haber # classes valores de punto flotante por función de logits y un único valor de punto flotante por función de expected .

  Declaración

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

  Parámetros

  logits	Salidas codificadas en caliente de una red neuronal.
  labels	Índices (indexados a cero) de las salidas correctas.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• softmaxCrossEntropy (logits: probabilidades: reducción :)

  Calcula la entropía cruzada escasa de softmax (entropía cruzada categórica) entre logits y etiquetas. Utilice esta función de pérdida de entropía cruzada cuando haya dos o más clases de etiquetas. Esperamos que las etiquetas que se deben proporcionar proporcionado en un one_hot representación. No debe haber # classes valores de punto flotante por función.

  Declaración

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

  Parámetros

  logits	Probabilidades de registro sin escala de una red neuronal.
  probabilities	Valores de probabilidad que corresponden a la salida correcta. Cada fila debe ser una distribución de probabilidad válida.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• sigmoidCrossEntropy (logits: etiquetas: reducción :)

  Calcula la entropía cruzada sigmoidea (entropía cruzada binaria) entre logits y etiquetas. Utilice esta pérdida de entropía cruzada cuando solo haya dos clases de etiquetas (se supone que son 0 y 1). Para cada ejemplo, debería haber un único valor de punto flotante por predicción.

  Declaración

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

  Parámetros

  logits	La salida sin escala de una red neuronal.
  labels	Valores enteros que corresponden a la salida correcta.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• huberLoss (predicho: esperado: delta: reducción :)

  Calcula la pérdida de Huber entre predicted y expected .

  Para cada valor de x en error = expected - predicted :

  • 0.5 * x^2 si |x| <= δ .

  • 0.5 * δ^2 + δ * (|x| - δ) de otro modo.

  • Fuente: artículo de Wikipedia .

  Declaración

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

  Parámetros

  predicted	Salidas previstas de una red neuronal.
  expected	Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
  delta	Un escalar de coma flotante que representa el punto donde la función de pérdida de Huber cambia de cuadrática a lineal.
  reduction	Reducción que se aplicará a los valores calculados de pérdida por elemento.

• abdominales(_:)

  Devuelve el valor absoluto del elemento tensor especificado.

  Declaración

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

• Iniciar sesión(_:)

  Devuelve el logaritmo natural del elemento tensor especificado.

  Declaración

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

• log2 (_ :)

  Devuelve el logaritmo en base dos del elemento tensor especificado.

  Declaración

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

• log10 (_ :)

  Devuelve el logaritmo en base diez del elemento tensor especificado.

  Declaración

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

• log1p (_ :)

  Devuelve el logaritmo de 1 + x elemento a elemento.

  Declaración

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

• log1mexp (_ :)

  Devuelve log(1 - exp(x)) usando un enfoque estable numéricamente.

  Nota

  El enfoque se muestra en la Ecuación 7 de: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

  Declaración

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

• pecado(_:)

  Devuelve el seno del elemento tensor especificado.

  Declaración

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

• cos (_ :)

  Devuelve el coseno del elemento tensor especificado.

  Declaración

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

• broncearse(_:)

  Devuelve la tangente del elemento tensor especificado.

  Declaración

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

• sinh (_ :)

  Devuelve el seno hiperbólico del elemento tensor especificado.

  Declaración

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

• aporrear(_:)

  Devuelve el coseno hiperbólico del elemento tensor especificado.

  Declaración

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

• tanh (_ :)

  Devuelve la tangente hiperbólica del elemento tensor especificado.

  Declaración

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

• acos (_ :)

  Devuelve el coseno inverso del elemento tensor especificado.

  Declaración

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

• como en(_:)

  Devuelve el seno inverso del elemento tensor especificado.

  Declaración

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

• un bronceado(_:)

  Devuelve la tangente inversa del elemento tensor especificado.

  Declaración

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

• acosh (_ :)

  Devuelve el coseno hiperbólico inverso del elemento tensor especificado.

  Declaración

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

• asinh (_ :)

  Devuelve el seno hiperbólico inverso del elemento tensor especificado.

  Declaración

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

• atanh (_ :)

  Devuelve la tangente hiperbólica inversa del elemento tensor especificado.

  Declaración

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

• sqrt (_ :)

  Devuelve la raíz cuadrada del elemento tensor especificado.

  Declaración

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

• rsqrt (_ :)

  Devuelve la raíz cuadrada inversa del elemento tensor especificado.

  Declaración

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

• Exp(_:)

  Devuelve el exponencial del elemento tensorial especificado.

  Declaración

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

• exp2 (_ :)

  Devuelve dos elevados a la potencia del elemento tensor especificado.

  Declaración

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

• exp10 (_ :)

  Devuelve diez elevado a la potencia del elemento tensor especificado.

  Declaración

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

• expm1 (_ :)

  Devuelve el exponencial de x - 1 elemento a elemento.

  Declaración

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

• ronda(_:)

  Devuelve los valores del tensor especificado redondeados al número entero más cercano, por elemento.

  Declaración

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

• hacer techo(_:)

  Devuelve el techo del elemento tensor especificado.

  Declaración

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

• suelo(_:)

  Devuelve el suelo del elemento tensor especificado.

  Declaración

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

• firmar(_:)

  Devuelve una indicación del signo del elemento tensor especificado. Específicamente, calcula y = sign(x) = -1 si x < 0 ; 0 si x == 0 ; 1 si x > 0 .

  Declaración

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

• sigmoideo(_:)

  Devuelve el sigmoide del elemento tensor especificado. Específicamente, calcula 1 / (1 + exp(-x)) .

  Declaración

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

• logSigmoid (_ :)

  Devuelve el log-sigmoide del elemento tensor especificado. Específicamente, log(1 / (1 + exp(-x))) . Para la estabilidad numérica, utilizamos -softplus(-x) .

  Declaración

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

• softplus (_ :)

  Devuelve el softplus del elemento tensor especificado. Específicamente, calcula log(exp(features) + 1) .

  Declaración

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

• softsign (_ :)

  Devuelve el signo suave del elemento tensor especificado. Específicamente, calcula features/ (abs(features) + 1) .

  Declaración

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

• softmax (_ :)

  Devuelve el softmax del tensor especificado a lo largo del último eje. Específicamente, calcula exp(x) / exp(x).sum(alongAxes: -1) .

  Declaración

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

• softmax (_: AlongAxis :)

  Devuelve el softmax del tensor especificado a lo largo del eje especificado. Específicamente, calcula exp(x) / exp(x).sum(alongAxes: axis) .

  Declaración

  @differentiable
  public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

• logSoftmax (_ :)

  Devuelve el log-softmax del elemento tensor especificado.

  Declaración

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

• elu (_ :)

  Devuelve un tensor aplicando una unidad lineal exponencial. Específicamente, calcula exp(x) - 1 si <0, x lo contrario. Ver profundo rápido y preciso red de aprendizaje por unidades lineales Exponencial (ELUs)

  Declaración

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

• gelu (_ :)

  Devuelve las activaciones de la unidad lineal de error gaussiano (GELU) del elemento tensor especificado.

  Específicamente, gelu aproxima xP(X <= x) , donde P(X <= x) es la distribución acumulativa estándar gaussiana, calculando: x * [0,5 * (1 + tanh [√ (2 / π) * (x + 0,044715 * x ^ 3)])].

  Ver unidades lineales de Gauss error .

  Declaración

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

• relu (_ :)

  Devuelve un tensor aplicando la función de activación ReLU al elemento tensor especificado. Específicamente, calcula max(0, x) .

  Declaración

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

• relu6 (_ :)

  Devuelve un tensor mediante la aplicación de la función de activación ReLU6, a saber min(max(0, x), 6) .

  Declaración

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

• fugasRelu (_: alpha :)

  Devuelve un tensor aplicando la función de activación de ReLU con fugas al elemento tensor especificado. Específicamente, calcula max(x, x * alpha) .

  Declaración

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

• selu (_ :)

  Devuelve un tensor mediante la aplicación de la función de activación Selu, a saber scale * alpha * (exp(x) - 1) si x < 0 , y scale * x lo contrario.

  Nota

  Está diseñado para usarse junto con los inicializadores de la capa de escala de varianza. Por favor refiérase a la auto-La normalización de redes neuronales para más información.

  Declaración

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

• silbido(_:)

  Devuelve un tensor mediante la aplicación de la función de activación chasquido, a saber, x * sigmoid(x) .

  Fuente: (. Ramachandran et al 2017) y “Búsqueda de funciones de activación” https://arxiv.org/abs/1710.05941

  Declaración

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

• hardSigmoid (_ :)

  Devuelve un tensor mediante la aplicación de la función de activación sigmoide duro, a saber Relu6(x+3)/6 .

  Fuente: “Búsqueda de MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244

  Declaración

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

• hardSwish (_ :)

  Devuelve un tensor mediante la aplicación de la función de activación chasquido duro, a saber, x * Relu6(x+3)/6 .

  Fuente: “Búsqueda de MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244

  Declaración

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

• mish (_ :)

  Devuelve un tensor mediante la aplicación de la función de activación Mish, a saber, x * tanh(softplus(x)) .

  Fuente: “Mish: Función Un Auto regularizada no monótona neuronal Activación” https://arxiv.org/abs/1908.08681

  Declaración

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

• pow (_: _ :)

  Devuelve la potencia del primer tensor al segundo tensor.

  Declaración

  @differentiable
  public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

• pow (_: _ :)

  Devuelve la potencia del escalar al tensor, transmitiendo el escalar.

  Declaración

  @differentiable(wrt: rhs)
  public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

• pow (_: _ :)

  Devuelve la potencia del tensor al escalar, transmitiendo el escalar.

  Declaración

  @differentiable(wrt: lhs)
  public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint

• pow (_: _ :)

  Devuelve la potencia del tensor al escalar, transmitiendo el escalar.

  Declaración

  @differentiable
  public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

• raíz(_:_:)

  Devuelve el elemento a elemento n º raíz del tensor.

  Declaración

  @differentiable
  public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

• squareDifference (_: _ :)

  Devuelve la diferencia al cuadrado entre x e y .

  Declaración

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

  Valor devuelto

  (x - y) ^ 2 .

• max (_: _ :)

  Devuelve el máximo por elementos de dos tensores.

  Nota

  max soportes de radiodifusión.

  Declaración

  @differentiable
  public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• max (_: _ :)

  Devuelve el máximo por elementos del escalar y el tensor, transmitiendo el escalar.

  Declaración

  @differentiable(wrt: rhs)
  public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• max (_: _ :)

  Devuelve el máximo por elementos del escalar y el tensor, transmitiendo el escalar.

  Declaración

  @differentiable(wrt: lhs)
  public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• min (_: _ :)

  Devuelve el mínimo por elementos de dos tensores.

  Nota

  min apoya radiodifusión.

  Declaración

  @differentiable
  public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• min (_: _ :)

  Devuelve el mínimo por elementos del escalar y el tensor, transmitiendo el escalar.

  Declaración

  @differentiable(wrt: rhs)
  public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• min (_: _ :)

  Devuelve el mínimo por elementos del escalar y el tensor, transmitiendo el escalar.

  Declaración

  @differentiable(wrt: lhs)
  public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• cosenoSimilaridad (_: _ :)

  Devuelve el coseno similitud entre x e y .

  Declaración

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

• cosineDistance (_: _ :)

  Devuelve el coseno distancia entre x e y . Distancia coseno se define como 1 - cosineSimilarity(x, y) .

  Declaración

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

• matmul (_: transposed: _: transposed :)

  Realiza la multiplicación de matrices con otro tensor y produce el resultado.

  Declaración

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

• conv1D (_: filter: stride: padding: dilatación :)

  Devuelve una convolución 1-D con la entrada, el filtro, el paso y el relleno especificados.

  Condición previa

  input debe tener rango 3 .

  Condición previa

  filter debe tener rango 3.

  Declaración

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

  Parámetros

  input	La entrada.
  filter	El filtro de convolución.
  stride	El paso del filtro deslizante.
  padding	El acolchado para la operación.
  dilation	El factor de dilatación.

• conv2D (_: filter: strides: padding: dilations :)

  Devuelve una convolución 2-D con la entrada, el filtro, los pasos y el relleno especificados.

  Condición previa

  input debe tener rango 4 .

  Condición previa

  filter debe tener rango 4.

  Declaración

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

  Parámetros

  input	La entrada.
  filter	El filtro de convolución.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación
  dilations	El factor de dilatación para cada dimensión de la entrada.

• transposedConv2D (_: shape: filter: strides: padding: dilations :)

  Devuelve una convolución transpuesta 2-D con la entrada, el filtro, los pasos y el relleno especificados.

  Condición previa

  input debe tener rango 4 .

  Condición previa

  filter debe tener rango 4.

  Declaración

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

  Parámetros

  input	La entrada.
  shape	La forma de salida de la operación de deconvolución.
  filter	El filtro de convolución.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación
  dilations	El factor de dilatación para cada dimensión de la entrada.

• conv3D (_: filter: strides: padding: dilations :)

  Devuelve una convolución 3-D con la entrada, el filtro, los pasos, el relleno y las dilataciones especificados.

  Condición previa

  input debe tener rango 5 .

  Condición previa

  filter debe tener rango 5.

  Declaración

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

  Parámetros

  input	La entrada.
  filter	El filtro de convolución.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación.
  dilations	El factor de dilatación para cada dimensión de la entrada.

• depthwiseConv2D (_: filter: strides: padding :)

  Devuelve una convolución en profundidad 2-D con la entrada, el filtro, las zancadas y el relleno especificados.

  Condición previa

  input debe tener rango 4.

  Condición previa

  filter debe tener rango 4.

  Declaración

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

  Parámetros

  input	La entrada.
  filter	El filtro de convolución en profundidad.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación.

• maxPool2D (_: filterSize: strides: padding :)

  Devuelve una agrupación máxima 2-D, con los tamaños de filtro, los pasos y el relleno especificados.

  Declaración

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

  Parámetros

  input	La entrada.
  filterSize	Las dimensiones del núcleo de agrupación.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación.

• maxPool3D (_: filterSize: strides: padding :)

  Devuelve una agrupación máxima en 3D, con los tamaños de filtro, los pasos y el relleno especificados.

  Declaración

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

  Parámetros

  input	La entrada.
  filterSize	Las dimensiones del núcleo de agrupación.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación.

• avgPool2D (_: filterSize: strides: padding :)

  Devuelve una agrupación promedio 2-D, con los tamaños de filtro, los pasos y el relleno especificados.

  Declaración

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

  Parámetros

  input	La entrada.
  filterSize	Las dimensiones del núcleo de agrupación.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación.

• avgPool3D (_: filterSize: strides: padding :)

  Devuelve una agrupación promedio en 3D, con los tamaños de filtro, los pasos y el relleno especificados.

  Declaración

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

  Parámetros

  input	La entrada.
  filterSize	Las dimensiones del núcleo de agrupación.
  strides	Los pasos del filtro deslizante para cada dimensión de la entrada.
  padding	El acolchado para la operación.

• fraccionalMaxPool2D (_: poolingRatio: pseudoRandom: superposición: determinista: semilla: semilla2 :)

  Devuelve una agrupación máxima fraccional 2-D, con las proporciones de agrupación especificadas.

  Nota: fractionalMaxPool no tiene una aplicación XLA, y por lo tanto puede tener consecuencias en el rendimiento.

  Declaración

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

  Parámetros

  input	Un tensor. 4-D con forma de [batch, height, width, channels] .
  poolingRatio	Una lista de Doubles . El agrupamiento de relación para cada dimensión de la input , en la actualidad sólo es compatible fila y col dimensión y debe ser> = 1,0.
  pseudoRandom	Un opcional Bool . Por defecto es false . Cuando se establece en true , genera la secuencia de puesta en común de una manera pseudoaleatoria, de lo contrario, de una manera aleatoria.
  overlapping	Un opcional Bool . Por defecto es false . Cuando se establece en true , que significa cuando la puesta en común, los valores en el límite de las células de agrupación adyacentes son utilizadas por ambas células.
  deterministic	Un opcional Bool . Cuando se establece en true , una región agrupación fija se utilizará cuando iterar sobre un nodo fractionalMaxPool2D en el gráfico de cálculo.
  seed	Un opcional Int64 . El valor predeterminado es 0 . Si se establece en un valor distinto de cero, el generador de números aleatorios es sembrado por la semilla dada.
  seed2	Un opcional Int64 . El valor predeterminado es 0 . Una segunda semilla para evitar la colisión de semillas.

• depthToSpace (_: blockSize :)

  Devuelve una copia de input donde los valores de la dimensión de profundidad se mueven en bloques espaciales a la altura y dimensiones de anchura.

  Por ejemplo, dada una entrada de forma [1, 2, 2, 1] , data_format = “NHWC” y block_size = 2:

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

  Esta salida de operación voluntad un tensor de la forma de [1, 1, 1, 4] :

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

  Aquí, la entrada tiene un lote de 1 y cada elemento de proceso por lotes tiene forma [2, 2, 1] , la salida correspondiente tendrá un único elemento (es decir, anchura y altura son ambos 1) y tendrá una profundidad de 4 canales (1 * tamaño_bloque * tamaño_bloque). La forma elemento de salida es [1, 1, 4] .

  Para un tensor de entrada con la profundidad más grande, aquí de forma [1, 2, 2, 3] , por ejemplo,

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

  Esta operación, por block_size de 2, devolverá el siguiente tensor de la forma de [1, 1, 1, 12]

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

  Del mismo modo, para la siguiente entrada de la forma [1 4 4 1] , y un tamaño de bloque de 2:

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

  el operador volverá la siguiente tensor de la forma [1 2 2 4] :

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

  Condición previa

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

  Condición previa

  El número de las características debe ser divisible por cuadrado de b .

  Declaración

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

• spaceToDepth (_: blockSize :)

  Devuelve una copia de input donde los valores de la altura y dimensiones de anchura se mueven a la dimensión de profundidad.

  Por ejemplo, dada una entrada de forma [1, 2, 2, 1] , data_format = “NHWC” y block_size = 2:

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

  Esta salida de operación voluntad un tensor de la forma de [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 .

  Declaración

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

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

  Declaración

  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

• makeSGD(learningRate:momentum:weightDecay:nesterov:)

  Builds a SGD based per-weight optimizer.

  Declaración

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

• makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon:)

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

  Reference: “Adam - A Method for Stochastic Optimization”

  Declaración

  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(using:)

  Generates a new random seed for TensorFlow.

  Declaración

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

• concatenate(_:_:)

  Concatenates two values.

  Declaración

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

• sum(_:_:)

  Adds two values and produces their sum.

  Declaración

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

• average(_:_:)

  Averages two values.

  Declaración

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

• multiply(_:_:)

  Multiplies two values.

  Declaración

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

• stack(_:_:)

  Stack two values.

  Declaración

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

• PrintX10Metrics()

  Declaración

  public func PrintX10Metrics()

• formatStatistics(_:)

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

  Declaración

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

• formatStatistics(train:test:)

  Declaración

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

• runOnNThreads(_:_:)

  Maps a function over n threads.

  Declaración

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