¡Reserva! Google I / O regresa del 18 al 20 de mayo Regístrese ahora
Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Funciones

Las siguientes funciones están disponibles a nivel mundial.

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

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

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

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

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

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

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

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

  • 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 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 usa como el valor de retorno de la función withContext(_:_:) .

    Valor devuelto

    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 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 usa como el valor de retorno de la función withLearningPhase(_:_:) .

    Valor devuelto

    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 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 usa como el valor de retorno de la función withRandomSeedForTensorFlow(_:_:) .

    Valor devuelto

    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 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 vuelva el cierre.

    body

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

    Valor devuelto

    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 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)
  • 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, 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
  • 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 en el que x se está diferenciando 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 cierre dado x . Cuando se usa en un contexto en el que x se está diferenciando 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:

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

  • 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 a su 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 , use un filtro anti-aliasing cuando reduzca el muestreo de una imagen.

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

    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 acolchado 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 acolchado 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 al realizar la 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 multiplicado 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 al realizar 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 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>
  • Devuelve una función que crea un tensor realizando una inicialización uniforme de 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 multiplicado 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 al realizar 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 al realizar la inicialización uniforme 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 multiplicado 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 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 multiplicado por el 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 de desviación 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 devuelto

    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 inicial 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 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 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 la matrix es triangular inferior ( true ) o triangular superior ( false ). El valor predeterminado es true .

    adjoint

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

    Valor devuelto

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

  • Calcula la pérdida de L1 entre la expected y la 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • 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 a la salida correcta.

    reduction

    Reducción para aplicar sobre los valores calculados de pérdida por elemento.

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

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

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

    Nota

    Las entradas de tensor negativo se fijarán en 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 a la salida correcta.

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

  • Calcula la pérdida de bisagra entre lo predicted y lo expected . loss = reduction(max(0, 1 - predicted * expected)) expected valores esperados 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 a la salida correcta.

    reduction

    Reducción para aplicar sobre los valores calculados de pérdida por elemento.

  • Calcula la pérdida de bisagra al cuadrado entre lo predicted y lo expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected valores esperados 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 a la salida correcta.

    reduction

    Reducción para aplicar sobre los valores calculados de pérdida por elemento.

  • Calcula la pérdida de bisagra categórica entre lo predicted y lo 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • 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 a la salida correcta.

    reduction

    Reducción para aplicar sobre los valores calculados de pérdida por elemento.

  • Calcula la pérdida de Poisson entre la predicción y la esperada 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • Calcula la pérdida de divergencia de Kullback-Leibler entre lo expected y lo 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • 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. Debe haber # classes valores de punto flotante por característica para logits y un único valor de punto flotante por característica para la 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • 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 en una representación one_hot . Debe haber # classes valores de punto 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • Calcula la entropía cruzada sigmoidea (entropía cruzada binaria) entre logits y etiquetas. Utilice esta pérdida de entropía cruzada cuando solo hay 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • Calcula la pérdida de Huber entre la predicted y la 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 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 para aplicar sobre los valores calculados de pérdida por elemento.

  • 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
  • Devuelve el logaritmo natural del elemento tensor especificado.

    Declaración

    @differentiable
    public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • 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
  • Devuelve el logaritmo de 1 + x elementos.

    Declaración

    @differentiable
    public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve log(1 - exp(x)) utilizando 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 elemento tensor especificado.

    Declaración

    @differentiable
    public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve el coseno del elemento tensor especificado.

    Declaración

    @differentiable
    public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve la tangente del elemento tensor especificado.

    Declaración

    @differentiable
    public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve el seno hiperbólico del elemento tensor especificado.

    Declaración

    @differentiable
    public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve el coseno hiperbólico del elemento tensor especificado.

    Declaración

    @differentiable
    public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve la tangente hiperbólica del elemento tensor especificado.

    Declaración

    @differentiable
    public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve el coseno inverso del elemento tensor especificado.

    Declaración

    @differentiable
    public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve el seno inverso del elemento tensor especificado.

    Declaración

    @differentiable
    public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve la tangente inversa del elemento tensor especificado.

    Declaración

    @differentiable
    public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • 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
  • 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
  • Devuelve la raíz cuadrada del elemento tensor especificado.

    Declaración

    @differentiable
    public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • Devuelve el exponencial del elemento tensor especificado.

    Declaración

    @differentiable
    public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • Devuelve diez elevado a la potencia del elemento tensorial especificado.

    Declaración

    @differentiable
    public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve el exponencial de x - 1 elemento.

    Declaración

    @differentiable
    public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • Devuelve el techo del elemento tensor especificado.

    Declaración

    @differentiable
    public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devuelve el suelo del elemento tensor especificado.

    Declaración

    @differentiable
    public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • 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
  • Devuelve el log-sigmoide del elemento tensor especificado. Específicamente, log(1 / (1 + exp(-x))) . Para la 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 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
  • 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
  • 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 elemento tensor especificado.

    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 caso contrario. Vea el aprendizaje en red profundo rápido y preciso por 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 elemento tensor especificado.

    Específicamente, gelu aproxima a 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)])].

    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 de 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
  • Devuelve un tensor aplicando la función de activación de ReLU6, a saber, 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 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>
  • Devuelve un tensor aplicando la función de activación SeLU, a saber, scale * alpha * (exp(x) - 1) si x < 0 , y scale * x caso contrario.

    Nota

    Está diseñado para utilizarse junto con los inicializadores de la capa de escala de varianza. Consulte Redes neuronales autonormalizadas 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 de swish, a saber, 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 dura, a saber, Relu6(x+3)/6 .

    Fuente: "Searching for 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 swish fuerte, a saber, x * Relu6(x+3)/6 .

    Fuente: "Searching for 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, a saber, x * tanh(softplus(x)) .

    Fuente: "Mish: una función de activación neuronal no monotónica auto regularizada" 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 de elementos del tensor.

    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 devuelto

    (x - y) ^ 2 .

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

    Nota

    max admite la radiodifusió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 radiodifusió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 el coseno similitud entre x e y .

    Declaración

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Devuelve el coseno distancia 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

    El paso del filtro deslizante.

    padding

    El acolchado 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 acolchado 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 acolchado 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 acolchado para la operación.

    dilations

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

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

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

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 3-D max pooling, with the specified filter sizes, strides, and padding.

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 2-D average pooling, with the specified filter sizes, strides, and padding.

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 3-D average pooling, with the specified filter sizes, strides, and padding.

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 2-D fractional max pooling, with the specified pooling ratios.

    Note: fractionalMaxPool does not have an XLA implementation, and thus may have performance implications.

    Declaration

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

    Parameters

    input

    A Tensor. 4-D with shape [batch, height, width, channels] .

    poolingRatio

    A list of Doubles . Pooling ratio for each dimension of input , currently only supports row and col dimension and should be >= 1.0.

    pseudoRandom

    An optional Bool . Defaults to false . When set to true , generates the pooling sequence in a pseudorandom fashion, otherwise, in a random fashion.

    overlapping

    An optional Bool . Defaults to false . When set to true , it means when pooling, the values at the boundary of adjacent pooling cells are used by both cells.

    deterministic

    An Optional Bool . When set to true , a fixed pooling region will be used when iterating over a fractionalMaxPool2D node in the computation graph.

    seed

    An optional Int64 . Defaults to 0 . If set to be non-zero, the random number generator is seeded by the given seed.

    seed2

    An optional Int64 . Defaults to 0 . A second seed to avoid seed collision.

  • Returns a copy of input where values from the depth dimension are moved in spatial blocks to the height and width dimensions.

    For example, given an input of shape [1, 2, 2, 1] , data_format = “NHWC” and block_size = 2:

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

    This operation will output a tensor of shape [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 number of the features must be divisible by square of b .

    Declaration

    @differentiable(wrt: input)
    public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Returns a copy of input where values from the height and width dimensions are moved to the depth dimension.

    For example, given an input of shape [1, 2, 2, 1] , data_format = “NHWC” and block_size = 2:

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

    This operation will output a tensor of shape [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 .

    Declaration

    @differentiable(wrt: input)
    public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    Declaration

    public func makeLARS(
      learningRate: Float = 0.01,
      momentum: Float = 0.9,
      trustCoefficient: Float = 0.001,
      nesterov: Bool = false,
      epsilon: Float = 0.0,
      weightDecay: Float = 0.0
    ) -> ParameterGroupOptimizer
  • Builds a SGD based per-weight optimizer.

    Declaration

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • Builds a per-weight optimizer for Adam with weight decay.

    Reference: “Adam - A Method for Stochastic Optimization”

    Declaration

    public func makeAdam(
      learningRate: Float = 0.01,
      beta1: Float = 0.9,
      beta2: Float = 0.999,
      weightDecayRate: Float = 0.01,
      epsilon: Float = 1e-6
    ) -> ParameterGroupOptimizer
  • Generates a new random seed for TensorFlow.

    Declaration

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    Declaration

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    Declaration

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    Declaration

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    Declaration

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    Declaration

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

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    Declaration

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

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    Declaration

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