Funciones

Las siguientes funciones están disponibles globalmente.

  • 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 al resultado correcto.

  • 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 al resultado correcto.

  • Devuelve la pérdida 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 al resultado correcto.

  • Devuelve la pérdida 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 al resultado correcto.

  • 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 al resultado correcto.

  • 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 al resultado correcto.

  • 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 al resultado correcto.

  • Devuelve la divergencia Kullback-Leibler (divergencia KL) entre expectativas y predicciones. Dadas dos distribuciones p y q , la divergencia KL 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 al resultado correcto.

  • 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.

  • 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.

  • 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

  • Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto 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 regrese el cierre.

    body

    Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se usa como valor de retorno de la función withContext(_:_:) .

    Valor de retorno

    El valor de retorno, si lo hay, del cierre del body .

  • Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto 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 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 usa como valor de retorno de la función withLearningPhase(_:_:) .

    Valor de retorno

    El valor de retorno, si lo hay, del cierre del body .

  • Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto 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 usa como valor de retorno de la función withRandomSeedForTensorFlow(_:_:) .

    Valor de retorno

    El valor de retorno, si lo hay, del cierre del body .

  • Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto 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 usa como valor de retorno de la función withRandomNumberGeneratorForTensorFlow(_:_:) .

    Valor de retorno

    El valor de retorno, si lo hay, del cierre del body .

  • Declaración

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

  • LazyTensorBarrier garantiza que todos los tensores activos (en el dispositivo, si se proporciona) estén programados y en ejecución. Si la espera se establece en verdadero, 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)

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • Declaración

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

  • 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

  • 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

  • Declaración

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

  • 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

  • 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

  • Hacer que una función se vuelva a calcular en su retroceso, lo que se conoce como "puntos 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

  • Cree una función diferenciable a partir de una función de productos vectoriales jacobianos.

    Declaración

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

  • Cree una función diferenciable a partir de una función de productos vectoriales 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

  • Devuelve x como una función de identidad. Cuando se usa en un contexto donde x se diferencia con respecto a, esta función no producirá ninguna derivada en x .

    Declaración

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

  • Aplica el body de cierre dado a x . Cuando se usa en un contexto donde x se diferencia con respecto a, esta función no producirá ninguna derivada en x .

    Declaración

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

  • 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.

  • 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:

    • “/device: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 su 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.

  • 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.

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

    Condición previa

    Las imágenes deben tener rango 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

    Tensor de forma 4-D [batch, height, width, channels] o Tensor de forma 3-D [height, width, channels] .

    size

    El nuevo tamaño de las imágenes.

    method

    El método de cambio de tamaño. El valor predeterminado es .bilinear .

    antialias

    Si es true , utilice un filtro antialiasing al reducir la resolución de una imagen.

  • Cambie el tamaño de las imágenes al tamaño mediante interpolación de área.

    Condición previa

    Las imágenes deben tener rango 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

    Tensor de forma 4-D [batch, height, width, channels] o Tensor de forma 3-D [height, width, channels] .

    size

    El nuevo tamaño de las imágenes.

  • 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 relleno para la operación.

    rates

    Las tasas de dilatación para cada dimensión de la entrada.

  • 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 relleno para la operación.

    rates

    Las tasas de dilatación para cada dimensión de la entrada.

  • 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

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

  • Devuelve una función que crea un tensor inicializándolo con el valor proporcionado. Tenga en cuenta que no se admite la transmisión del valor proporcionado.

    Declaración

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

  • Devuelve una función que crea un tensor realizando una inicialización uniforme de Glorot (Xavier) para la forma especificada, muestreando aleatoriamente valores escalares de una distribución uniforme entre -limit y limit , generada por el generador de números aleatorios predeterminado, donde limit es sqrt(6 / (fanIn + fanOut)) y fanIn / fanOut representan el número de características de entrada y salida multiplicadas por el campo receptivo, si está presente.

    Declaración

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

  • Devuelve una función que crea un tensor realizando la inicialización normal de Glorot (Xavier) para la forma especificada, muestreando aleatoriamente valores escalares de una distribución normal truncada centrada 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 multiplicadas por el tamaño del campo receptivo, si está presente.

    Declaración

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

  • Devuelve una función que crea un tensor realizando una inicialización uniforme He (Kaiming) para la forma especificada, muestreando aleatoriamente valores escalares de una distribución uniforme entre -limit y limit , generada por el generador de números aleatorios predeterminado, donde limit es sqrt(6 / fanIn) y fanIn representa el número de características de entrada multiplicadas por el campo receptivo, si está presente.

    Declaración

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

  • Devuelve una función que crea un tensor realizando la inicialización normal He (Kaiming) para la forma especificada, muestreando aleatoriamente valores escalares de una distribución normal truncada centrada en 0 con 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>

  • Devuelve una función que crea un tensor realizando una inicialización uniforme de LeCun para la forma especificada, muestreando aleatoriamente valores escalares de una distribución uniforme entre -limit y limit , generada por el generador de números aleatorios predeterminado, donde limit es sqrt(3 / fanIn) y fanIn representa el número de características de entrada multiplicadas por el campo receptivo, si está presente.

    Declaración

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

  • Devuelve una función que crea un tensor realizando la inicialización normal de LeCun para la forma especificada, muestreando aleatoriamente valores escalares de una distribución normal truncada centrada en 0 con desviación estándar sqrt(1 / fanIn) , donde fanIn representa el número de características de entrada multiplicadas por tamaño del campo receptivo, si está presente.

    Declaración

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

  • 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 eliminan y se vuelven a muestrear.

    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 de retorno

    Una función inicializadora de parámetros normal truncada.

  • Declaración

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

  • 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 principal del tensor devuelto.

  • 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 [..., M, N] . La salida es un tensor con forma [...] .

    Condición previa

    matrix debe ser un tensor con forma [..., 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 forma [..., M, N] .

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

    La entrada es un tensor de forma [..., M, M] cuyas 2 dimensiones más internas forman matrices cuadradas.

    La entrada tiene que ser simétrica y positiva definida. Para esta operación sólo se utilizará la parte triangular inferior de la entrada. La parte triangular superior no se leerá.

    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 forma [..., M, M] .

  • Devuelve la solución x al sistema de ecuaciones lineales representado por Ax = b .

    Condición previa

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

    Condición previa

    rhs debe ser un tensor con 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 matriz de coeficientes triangulares de entrada, que representa A en Ax = b .

    rhs

    Valores del lado derecho, que representan b en Ax = b .

    lower

    Si matrix es triangular inferior ( true ) o triangular superior ( false ). El valor por defecto es true .

    adjoint

    Si es true , resuelva con el adjunto de matrix en lugar de matrix . El valor predeterminado es false .

    Valor de retorno

    La solución x al sistema de ecuaciones lineales representado por Ax = b . x tiene la misma forma que b .

  • 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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • Calcula la pérdida 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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • 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 al resultado correcto.

  • Calcula la media de los cuadrados de los 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 al resultado correcto.

  • Calcula el error logarítmico cuadrático medio entre la pérdida predicted y expected loss = square(log(expected) - log(predicted))

    Nota

    Las entradas del tensor negativo se limitarán a 0 para evitar un comportamiento logarítmico indefinido, ya que log(_:) no está definido 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 al resultado correcto.

  • 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 al resultado correcto.

  • Calcula la pérdida de bisagra entre predicted y expected . loss = reduction(max(0, 1 - predicted * expected)) Se espera que los valores expected sean -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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • Calcula la pérdida de bisagra al cuadrado entre predicted y expected . loss = reduction(square(max(0, 1 - predicted * expected))) se espera que los valores expected sean -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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • 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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • Calcula el logaritmo del coseno hiperbólico del error de predicción. logcosh = log((exp(x) + exp(-x))/2) , donde x es 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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • Calcula la pérdida de Poisson entre lo previsto y lo esperado. 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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • Calcula la pérdida de 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 al resultado correcto.

    reduction

    Reducción que se aplicará a los valores de pérdida por elementos calculados.

  • Calcula la entropía cruzada dispersa 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. Debe haber # classes de valores de punto flotante por característica para logits y un único valor de punto flotante por característica para 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 de pérdida por elementos calculados.

  • Calcula la entropía cruzada dispersa 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 en una representación one_hot . Debe haber # classes valores de coma flotante por característica.

    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 de pérdida por elementos calculados.

  • 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, debe 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 de pérdida por elementos calculados.

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

    Para cada valor x en error = expected - predicted :

    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 al resultado correcto.

    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 de pérdida por elementos calculados.

  • Devuelve el valor absoluto del tensor especificado por elementos.

    Declaración

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

  • Devuelve el logaritmo natural del tensor especificado por elementos.

    Declaración

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

  • Devuelve el logaritmo de base dos del tensor especificado por elementos.

    Declaración

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

  • Devuelve el logaritmo de base diez del tensor especificado por elementos.

    Declaración

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

  • Devuelve el logaritmo de 1 + x por elementos.

    Declaración

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

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

    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

  • Devuelve el seno del tensor especificado por elementos.

    Declaración

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

  • Devuelve el coseno del tensor especificado por elementos.

    Declaración

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

  • Devuelve la tangente del tensor especificado por elementos.

    Declaración

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

  • Devuelve el seno hiperbólico del tensor especificado por elementos.

    Declaración

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

  • Devuelve el coseno hiperbólico del tensor especificado por elementos.

    Declaración

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

  • Devuelve la tangente hiperbólica del tensor especificado por elementos.

    Declaración

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

  • Devuelve el coseno inverso del tensor especificado por elementos.

    Declaración

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

  • Devuelve el seno inverso del tensor especificado por elementos.

    Declaración

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

  • Devuelve la tangente inversa del tensor especificado por elementos.

    Declaración

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

  • Devuelve el coseno hiperbólico inverso del tensor especificado por elementos.

    Declaración

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

  • Devuelve el seno hiperbólico inverso del tensor especificado por elementos.

    Declaración

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

  • Devuelve la tangente hiperbólica inversa del tensor especificado por elementos.

    Declaración

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

  • Devuelve la raíz cuadrada del tensor especificado por elementos.

    Declaración

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

  • Devuelve la raíz cuadrada inversa del tensor especificado por elementos.

    Declaración

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

  • Devuelve el exponencial del tensor especificado por elementos.

    Declaración

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

  • Devuelve dos elevados a la potencia del tensor especificado por elementos.

    Declaración

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

  • Devuelve diez elevado a la potencia del tensor especificado por elementos.

    Declaración

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

  • Devuelve el exponencial de x - 1 por elementos.

    Declaración

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

  • Devuelve los valores del tensor especificado redondeados al entero más cercano, por elementos.

    Declaración

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

  • Devuelve el techo del tensor especificado por elementos.

    Declaración

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

  • Devuelve el piso del tensor especificado por elementos.

    Declaración

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

  • Devuelve una indicación del signo del tensor especificado por elementos. 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

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

    Declaración

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

  • Devuelve el log-sigmoide del tensor especificado por elementos. Específicamente, log(1 / (1 + exp(-x))) . Para estabilidad numérica, usamos -softplus(-x) .

    Declaración

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

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

    Declaración

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

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

    Declaración

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

  • 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

  • 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

  • Devuelve el log-softmax del tensor especificado por elementos.

    Declaración

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

  • Devuelve un tensor aplicando una unidad lineal exponencial. Específicamente, calcula exp(x) - 1 si < 0, x en caso contrario. Consulte Aprendizaje de red profundo, rápido y preciso mediante unidades lineales exponenciales (ELU)

    Declaración

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

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

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

    Consulte Unidades lineales de error gaussiano .

    Declaración

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

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

    Declaración

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

  • Devuelve un tensor aplicando la función de activación ReLU6, es decir min(max(0, x), 6) .

    Declaración

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

  • Devuelve un tensor aplicando la función de activación 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>

  • Devuelve un tensor aplicando la función de activación SeLU, es decir scale * alpha * (exp(x) - 1) si x < 0 y scale * x en caso contrario.

    Nota

    Esto está diseñado para usarse junto con los inicializadores de la capa de escala de varianza. Consulte Redes neuronales de normalización automática para obtener más información.

    Declaración

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

  • Devuelve un tensor aplicando la función de activación swish, es decir x * sigmoid(x) .

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

    Declaración

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

  • Devuelve un tensor aplicando la función de activación sigmoidea estricta, es decir, Relu6(x+3)/6 .

    Fuente: “Buscando 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

  • Devuelve un tensor aplicando la función de activación de golpe fuerte, es decir x * Relu6(x+3)/6 .

    Fuente: “Buscando 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

  • Devuelve un tensor aplicando la función de activación Mish, es decir x * tanh(softplus(x)) .

    Fuente: "Mish: una función de activación neuronal no monótona y autorregulada" https://arxiv.org/abs/1908.08681

    Declaración

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

  • 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

  • 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

  • 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

  • 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

  • Devuelve la raíz n -ésima del tensor por elementos.

    Declaración

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

  • 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 de retorno

    (x - y) ^ 2 .

  • Devuelve el máximo por elementos de dos tensores.

    Nota

    max admite la transmisión.

    Declaración

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

  • 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

  • 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

  • Devuelve el mínimo de dos tensores por elementos.

    Nota

    min admite la transmisión.

    Declaración

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

  • Devuelve el mínimo de 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

  • Devuelve el mínimo de 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

  • Devuelve la similitud del coseno entre x e y .

    Declaración

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

  • Devuelve la distancia del coseno entre x e y . La distancia del coseno se define como 1 - cosineSimilarity(x, y) .

    Declaración

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

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

  • 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

    La zancada del filtro deslizante.

    padding

    El relleno para la operación.

    dilation

    El factor de dilatación.

  • 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 relleno para la operación.

    dilations

    El factor de dilatación para cada dimensión de la entrada.

  • 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 relleno para la operación.

    dilations

    El factor de dilatación para cada dimensión de la entrada.

  • 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 relleno para la operación.

    dilations

    El factor de dilatación para cada dimensión de la entrada.

  • Devuelve una convolución profunda 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 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 relleno para la operación.

  • Devuelve una agrupación máxima 2-D, con los tamaños de filtro, zancadas y 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 relleno para la operación.

  • Devuelve una agrupación máxima en 3D, con los tamaños de filtro, zancadas y 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 relleno para la operación.

  • Devuelve una agrupación promedio 2-D, con los tamaños de filtro, zancadas y 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 relleno para la operación.

  • Devuelve una agrupación promedio 3D, con los tamaños de filtro, zancadas y 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 relleno para la operación.

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

    Nota: fractionalMaxPool no tiene una implementación XLA y, por lo tanto, puede tener implicaciones 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 [batch, height, width, channels] .

    poolingRatio

    Una lista de Doubles . La proporción de agrupación para cada dimensión de input , actualmente solo admite dimensiones de fila y columna y debe ser >= 1,0.

    pseudoRandom

    Un Bool opcional. El valor predeterminado es false . Cuando se establece en true , genera la secuencia de agrupación de forma pseudoaleatoria; de lo contrario, de forma aleatoria.

    overlapping

    Un Bool opcional. El valor predeterminado es false . Cuando se establece en true , significa que al realizar la agrupación, ambas celdas utilizan los valores en el límite de las celdas de agrupación adyacentes.

    deterministic

    Un Bool opcional. Cuando se establece en true , se utilizará una región de agrupación fija al iterar sobre un nodo fraccionalMaxPool2D en el gráfico de cálculo.

    seed

    Un Int64 opcional. El valor predeterminado es 0 . Si se establece en un valor distinto de cero, el generador de números aleatorios se siembra con la semilla dada.

    seed2

    Un Int64 opcional. El valor predeterminado es 0 . Una segunda semilla para evitar la colisión de semillas.

  • Devuelve una copia de input donde los valores de la dimensión de profundidad se mueven en bloques espaciales a las dimensiones de alto y ancho.

    Por ejemplo, dada una entrada de forma [1, 2, 2, 1] , formato_datos = “NHWC” y tamaño_bloque = 2:

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

    Esta operación generará un tensor de forma [1, 1, 1, 4] :

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

    Aquí, la entrada tiene un lote de 1 y cada elemento del lote tiene forma [2, 2, 1] , la salida correspondiente tendrá un solo elemento (es decir, el ancho y el alto son ambos 1) y tendrá una profundidad de 4 canales (1 * tamaño_bloque * tamaño_bloque). La forma del elemento de salida es [1, 1, 4] .

    Para un tensor de entrada con mayor profundidad, 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, para block_size de 2, devolverá el siguiente tensor de forma [1, 1, 1, 12]

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

    De manera similar, para la siguiente entrada de 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 devolverá el siguiente tensor de 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 características debe ser divisible por el cuadrado de b .

    Declaración

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

  • Devuelve una copia de input donde los valores de las dimensiones de alto y ancho se mueven a la dimensión de profundidad.

    Por ejemplo, dada una entrada de forma [1, 2, 2, 1] , formato_datos = “NHWC” y tamaño_bloque = 2:

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

    Esta operación generará un tensor de forma [1, 1, 1, 4] :

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

    Aquí, la entrada tiene un lote de 1 y cada elemento del lote tiene forma [2, 2, 1] , la salida correspondiente tendrá un solo elemento (es decir, el ancho y el alto son ambos 1) y tendrá una profundidad de 4 canales (1 * tamaño_bloque * tamaño_bloque). La forma del elemento de salida es [1, 1, 4] .

    Para un tensor de entrada con mayor profundidad, 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, para block_size de 2, devolverá el siguiente tensor de forma [1, 1, 1, 12]

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

    De manera similar, para la siguiente entrada de 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 devolverá el siguiente tensor de 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

    La altura de la entrada debe ser divisible por b .

    Condición previa

    El ancho de la entrada debe ser divisible por b .

    Declaración

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

  • Crea un optimizador por peso para 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

  • Crea un optimizador por peso basado en SGD.

    Declaración

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

  • Crea un optimizador por peso para Adam con disminución de peso.

    Referencia: "Adam: un método para la optimización estocástica"

    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

  • Genera una nueva semilla aleatoria para TensorFlow.

    Declaración

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

  • Concatena dos valores.

    Declaración

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

  • Suma dos valores y produce su suma.

    Declaración

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

  • Promedia dos valores.

    Declaración

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

  • Multiplica dos valores.

    Declaración

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

  • Apila dos valores.

    Declaración

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

  • Declaración

    public func PrintX10Metrics()

  • Crea un resumen de cadena de una lista de estadísticas de capacitación y prueba.

    Declaración

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

  • Declaración

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

  • Mapea una función sobre n hilos.

    Declaración

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