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
yq
, KL divergencia calculap * 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 utiliza como valor de retorno de la
withContext(_:_:)
función.Valor devuelto
El valor de retorno, en su caso, del
body
cierre.Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto por la fase de aprendizaje dada.
Declaración
public func withLearningPhase<R>( _ learningPhase: LearningPhase, _ body: () throws -> R ) rethrows -> R
Parámetros
learningPhase
Una fase de aprendizaje que se establecerá antes de que se llame al cierre y se restablecerá después de que vuelva el cierre.
body
Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se utiliza como valor de retorno de la
withLearningPhase(_:_:)
función.Valor devuelto
El valor de retorno, en su caso, del
body
cierre.Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto por la semilla aleatoria dada.
Declaración
public func withRandomSeedForTensorFlow<R>( _ randomSeed: TensorFlowSeed, _ body: () throws -> R ) rethrows -> R
Parámetros
randomSeed
Una semilla aleatoria que se establecerá antes de que se llame al cierre y se restaurará después de que regrese el cierre.
body
Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se utiliza como valor de retorno de la
withRandomSeedForTensorFlow(_:_:)
función.Valor devuelto
El valor de retorno, en su caso, del
body
cierre.Llama al cierre dado dentro de un contexto que tiene todo idéntico al contexto actual excepto por el generador de números aleatorios dado.
Declaración
public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>( _ randomNumberGenerator: inout G, _ body: () throws -> R ) rethrows -> R
Parámetros
randomNumberGenerator
Un generador de números aleatorios que se configurará antes de que se llame al cierre y se restaurará después de que regrese el cierre.
body
Un cierre nular. Si el cierre tiene un valor de retorno, ese valor también se utiliza como valor de retorno de la
withRandomNumberGeneratorForTensorFlow(_:_:)
función.Valor devuelto
El valor de retorno, en su caso, del
body
cierre.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 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 vector-jacobianos.
Declaración
public func differentiableFunction<T : Differentiable, R : Differentiable>( from vjp: @escaping (T) -> (value: R, pullback: (R.TangentVector) -> T.TangentVector) ) -> @differentiable (T) -> R
Cree una función diferenciable a partir de una función de productos vector-jacobianos.
Declaración
public func differentiableFunction<T, U, R>( from vjp: @escaping (T, U) -> (value: R, pullback: (R.TangentVector) -> (T.TangentVector, U.TangentVector)) ) -> @differentiable (T, U) -> R
Devuelve
x
como una función de identidad. Cuando se utiliza en un contexto dondex
está siendo diferenciado con respecto a, esta función no producirá ningún derivada enx
.Declaración
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
Se aplica el cierre dado
body
ax
. Cuando se utiliza en un contexto dondex
está siendo diferenciado con respecto a, esta función no producirá ningún derivada enx
.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 de3
o4
.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
size
El nuevo tamaño de las imágenes.
method
El método de cambio de tamaño. El valor por defecto es
.bilinear
.antialias
Iff
true
, utilizar un filtro anti-aliasing cuando la disminución de resolución de una imagen.Cambie el tamaño de las imágenes mediante la interpolación de áreas.
Condición previa
Las imágenes deben tener rango de3
o4
.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>
Devuelve una dilatación 2-D con la entrada, el filtro, los pasos y el relleno especificados.
Condición previa
input
debe tener rango4
.Condición previa
filter
debe tener rango3
.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 rango4
.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 la difusión del valor proporcionado no es compatible.
Declaración
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
Devuelve una función que crea un tensor mediante la realización de Glorot (Xavier) inicialización uniforme para la forma especificada, el muestreo al azar valores escalares de una distribución uniforme entre
-limit
ylimit
, generada por el generador de números aleatorios por defecto, donde límite essqrt(6 / (fanIn + fanOut))
, yfanIn
/fanOut
representan el número de entrada y salida características multiplican por el campo receptivo, si está presente.Declaración
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Devuelve una función que crea un tensor mediante la realización de Glorot (Xavier) de inicialización normal para la forma especificada, el muestreo al azar valores escalares a partir de una distribución normal truncada centradas en
0
con desviación estándarsqrt(2 / (fanIn + fanOut))
, dondefanIn
/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 mediante la realización de He (Kaiming) inicialización uniforme para la forma especificada, el muestreo al azar valores escalares de una distribución uniforme entre
-limit
ylimit
, generada por el generador de números aleatorios por defecto, donde límite essqrt(6 / fanIn)
, yfanIn
representa el número de características de entrada multiplicada por el campo receptivo, si está presente.Declaración
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Devuelve una función que crea un tensor mediante la realización de He (Kaiming) de inicialización normal para la forma especificada, el muestreo al azar valores escalares a partir de una distribución normal truncada centradas en
0
con una desviación estándarsqrt(2 / fanIn)
, dondefanIn
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 mediante la realización de LeCun inicialización uniforme para la forma especificada, el muestreo al azar valores escalares de una distribución uniforme entre
-limit
ylimit
, generada por el generador de números aleatorios por defecto, donde límite essqrt(3 / fanIn)
, yfanIn
representa el número de características de entrada multiplicada por el campo receptivo, si está presente.Declaración
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Devuelve una función que crea un tensor mediante la realización de LeCun inicialización normal para la forma especificada, el muestreo al azar valores escalares a partir de una distribución normal truncada centradas en
0
con una desviación estándarsqrt(1 / fanIn)
, dondefanIn
representa el número de entidades de entrada multiplicada por el tamaño del campo receptivo, si está presente.Declaración
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
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ándarstandardDeviation
, excepto que los valores cuya magnitud es más de dos desviaciones estándar de la media se dejan caer y un nuevo muestreo.Declaración
public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>( mean: Tensor<Scalar> = Tensor<Scalar>(0), standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1), seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Parámetros
mean
Media de la distribución normal.
standardDeviation
Desviación estándar de la distribución normal.
Valor devuelto
Una función de inicializador de parámetro normal truncada.
Declaración
public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
Devuelve una matriz de identidad o un lote de matrices.
Declaración
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 de
[..., M, N]
. La salida es un tensor con la forma[...]
.Condición previa
matrix
debe ser un tensor con forma de[..., M, N]
.Declaración
@differentiable(wrt: matrix) public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
Parámetros
matrix
Un tensor de la forma de
[..., M, N]
.Devuelve la descomposición de Cholesky de una o más matrices cuadradas.
La entrada es un tensor de la forma de
[..., M, M]
cuya 2 dimensiones-mayoría interior formar matrices cuadradas.La entrada tiene que ser simétrica y definida positiva. Solo la parte triangular inferior de la entrada se utilizará para esta operación. No se leerá la parte triangular superior.
La salida es un tensor de la misma forma que la entrada que contiene las descomposiciones de Cholesky para todas las submatrices de entrada
[..., :, :]
.Declaración
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Parámetros
input
Un tensor de la forma
[..., M, M]
.Devuelve la solución
x
en el sistema de ecuaciones lineales representadas porAx = b
.Condición previa
matrix
debe ser un tensor con forma de[..., M, M]
.Condición previa
rhs
debe ser un tensor con la forma[..., M, K]
.Declaración
@differentiable public func triangularSolve<T: TensorFlowFloatingPoint>( matrix: Tensor<T>, rhs: Tensor<T>, lower: Bool = true, adjoint: Bool = false ) -> Tensor<T>
Parámetros
matrix
La entrada triangular coeficiente de la matriz, representando
A
enAx = b
.rhs
Valores lado derecho, representando
b
enAx = b
.lower
Ya sea
matrix
es triangular inferior (true
) o triangular superior (false
). El valor por defecto estrue
.adjoint
Si
true
, resolver con el adjunto de lamatrix
en lugar dematrix
. El valor por defecto esfalse
.Valor devuelto
La solución de
x
para el sistema de ecuaciones lineales representada porAx = b
.x
tiene la misma forma comob
.Calcula la pérdida L1 entre
expected
ypredicted
.loss = reduction(abs(expected - predicted))
Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la pérdida de L2 entre
expected
ypredicted
.loss = reduction(square(expected - predicted))
Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
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 cuadrático medio entre logarítmica
predicted
yexpected
loss = square(log(expected) - log(predicted))
Nota
Entradas tensor negativa serán sujetados en
0
para evitar un comportamiento logarítmico indefinido, comolog(_:)
está definida para reales negativos.Declaración
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
Calcula el error porcentual absoluto medio entre
predicted
yexpected
.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
predicted
yexpected
.loss = reduction(max(0, 1 - predicted * expected))
expected
se espera que los valores a ser -1 o 1.Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la pérdida de bisagra al cuadrado entre
predicted
yexpected
.loss = reduction(square(max(0, 1 - predicted * expected)))
expected
Se espera que los valores a ser -1 o 1.Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la pérdida de bisagra categórica entre
predicted
yexpected
.loss = maximum(negative - positive + 1, 0)
, dondenegative = max((1 - expected) * predicted)
ypositive = sum(predicted * expected)
Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula el logaritmo del coseno hiperbólico del error de predicción.
logcosh = log((exp(x) + exp(-x))/2)
, donde es X el errorpredicted - expected
Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la pérdida de Poisson entre predicho y espera que la pérdida de Poisson es la media de los elementos del
Tensor
predicted - expected * log(predicted)
.Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la pérdida de la divergencia de Kullback-Leibler entre
expected
ypredicted
.loss = reduction(expected * log(expected / predicted))
Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la entropía cruzada escasa de softmax (entropía cruzada categórica) entre logits y etiquetas. Utilice esta función de pérdida de entropía cruzada cuando haya dos o más clases de etiquetas. Esperamos que las etiquetas se proporcionen como números enteros. No debe haber
# classes
valores de punto flotante por función delogits
y un único valor de punto flotante por función deexpected
.Declaración
Parámetros
logits
Salidas codificadas en caliente de una red neuronal.
labels
Índices (indexados a cero) de las salidas correctas.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la entropía cruzada escasa de softmax (entropía cruzada categórica) entre logits y etiquetas. Utilice esta función de pérdida de entropía cruzada cuando haya dos o más clases de etiquetas. Esperamos que las etiquetas que se deben proporcionar proporcionado en un
one_hot
representación. No debe haber# classes
valores de punto flotante por función.Declaración
Parámetros
logits
Probabilidades de registro sin escala de una red neuronal.
probabilities
Valores de probabilidad que corresponden a la salida correcta. Cada fila debe ser una distribución de probabilidad válida.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la entropía cruzada sigmoidea (entropía cruzada binaria) entre logits y etiquetas. Utilice esta pérdida de entropía cruzada cuando solo haya dos clases de etiquetas (se supone que son 0 y 1). Para cada ejemplo, debería haber un único valor de punto flotante por predicción.
Declaración
Parámetros
logits
La salida sin escala de una red neuronal.
labels
Valores enteros que corresponden a la salida correcta.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
Calcula la pérdida de Huber entre
predicted
yexpected
.Para cada valor de
x
enerror = expected - predicted
:-
0.5 * x^2
si|x| <= δ
. 0.5 * δ^2 + δ * (|x| - δ)
de otro modo.Fuente: artículo de Wikipedia .
Declaración
Parámetros
predicted
Salidas previstas de una red neuronal.
expected
Valores esperados, es decir, objetivos, que corresponden a la salida correcta.
delta
Un escalar de coma flotante que representa el punto donde la función de pérdida de Huber cambia de cuadrática a lineal.
reduction
Reducción que se aplicará a los valores calculados de pérdida por elemento.
-
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
elemento a elemento.Declaración
@differentiable public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve
log(1 - exp(x))
usando un enfoque estable numéricamente.Nota
El enfoque se muestra en la Ecuación 7 de: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .Declaración
@differentiable public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
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 tensorial 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 tensor especificado.
Declaración
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve el exponencial de
x - 1
elemento a 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
six < 0
; 0 six == 0
; 1 six > 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, utilizamos-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
lo contrario. Ver profundo rápido y preciso red de aprendizaje por unidades lineales Exponencial (ELUs)Declaración
@differentiable public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve las activaciones de la unidad lineal de error gaussiano (GELU) del elemento tensor especificado.
Específicamente,
gelu
aproximaxP(X <= x)
, dondeP(X <= x)
es la distribución acumulativa estándar gaussiana, calculando: x * [0,5 * (1 + tanh [√ (2 / π) * (x + 0,044715 * x ^ 3)])].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 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 mediante la aplicación de la función de activación ReLU6, a saber
min(max(0, x), 6)
.Declaración
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
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 mediante la aplicación de la función de activación Selu, a saber
scale * alpha * (exp(x) - 1)
six < 0
, yscale * x
lo contrario.Nota
Está diseñado para usarse junto con los inicializadores de la capa de escala de varianza. Por favor refiérase a la auto-La normalización de redes neuronales para más información.Declaración
@differentiable public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve un tensor mediante la aplicación de la función de activación chasquido, a saber,
x * sigmoid(x)
.Fuente: (. Ramachandran et al 2017) y “Búsqueda de funciones de activación” https://arxiv.org/abs/1710.05941
Declaración
@differentiable public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve un tensor mediante la aplicación de la función de activación sigmoide duro, a saber
Relu6(x+3)/6
.Fuente: “Búsqueda de MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244
Declaración
@differentiable public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve un tensor mediante la aplicación de la función de activación chasquido duro, a saber,
x * Relu6(x+3)/6
.Fuente: “Búsqueda de MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244
Declaración
@differentiable public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve un tensor mediante la aplicación de la función de activación Mish, a saber,
x * tanh(softplus(x))
.Fuente: “Mish: Función Un Auto regularizada no monótona neuronal Activación” https://arxiv.org/abs/1908.08681
Declaración
@differentiable public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
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 el elemento a elemento
n
º raíz del tensor.Declaración
@differentiable public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
Devuelve la diferencia al cuadrado entre
x
ey
.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
soportes de radiodifusión.Declaración
@differentiable public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
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 por elementos de dos tensores.
Nota
min
apoya radiodifusión.Declaración
@differentiable public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Devuelve el mínimo por elementos del escalar y el tensor, transmitiendo el escalar.
Declaración
@differentiable(wrt: rhs) public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Devuelve el mínimo por elementos del escalar y el tensor, transmitiendo el escalar.
Declaración
@differentiable(wrt: lhs) public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Devuelve el coseno similitud entre
x
ey
.Declaración
@differentiable public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
Devuelve el coseno distancia entre
x
ey
. Distancia coseno se define como1 - cosineSimilarity(x, y)
.Declaración
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> 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 rango3
.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 rango4
.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 rango4
.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 rango5
.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, los pasos y el relleno especificados.
Declaración
@differentiable(wrt: input) public func maxPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Parámetros
input
La entrada.
filterSize
Las dimensiones del núcleo de agrupación.
strides
Los pasos del filtro deslizante para cada dimensión de la entrada.
padding
El acolchado para la operación.
Devuelve una agrupación máxima en 3D, con los tamaños de filtro, los pasos y el relleno especificados.
Declaración
@differentiable(wrt: input) public func maxPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Parámetros
input
La entrada.
filterSize
Las dimensiones del núcleo de agrupación.
strides
Los pasos del filtro deslizante para cada dimensión de la entrada.
padding
El acolchado para la operación.
Devuelve una agrupación promedio 2-D, con los tamaños de filtro, los pasos y el relleno especificados.
Declaración
@differentiable(wrt: input) public func avgPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Parámetros
input
La entrada.
filterSize
Las dimensiones del núcleo de agrupación.
strides
Los pasos del filtro deslizante para cada dimensión de la entrada.
padding
El acolchado para la operación.
Devuelve una agrupación promedio en 3D, con los tamaños de filtro, los pasos y el relleno especificados.
Declaración
@differentiable(wrt: input) public func avgPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Parámetros
input
La entrada.
filterSize
Las dimensiones del núcleo de agrupación.
strides
Los pasos del filtro deslizante para cada dimensión de la entrada.
padding
El acolchado para la operación.
fraccionalMaxPool2D (_: poolingRatio: pseudoRandom: superposición: determinista: semilla: semilla2 :)
Devuelve una agrupación máxima fraccional 2-D, con las proporciones de agrupación especificadas.
Nota:
fractionalMaxPool
no tiene una aplicación XLA, y por lo tanto puede tener consecuencias en el rendimiento.Declaración
@differentiable(wrt: input) public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, poolingRatio: (Double, Double, Double, Double), pseudoRandom: Bool = false, overlapping: Bool = false, deterministic: Bool = false, seed: Int64 = 0, seed2: Int64 = 0 ) -> Tensor<Scalar>
Parámetros
input
Un tensor. 4-D con forma de
[batch, height, width, channels]
.poolingRatio
Una lista de
Doubles
. El agrupamiento de relación para cada dimensión de lainput
, en la actualidad sólo es compatible fila y col dimensión y debe ser> = 1,0.pseudoRandom
Un opcional
Bool
. Por defecto esfalse
. Cuando se establece entrue
, genera la secuencia de puesta en común de una manera pseudoaleatoria, de lo contrario, de una manera aleatoria.overlapping
Un opcional
Bool
. Por defecto esfalse
. Cuando se establece entrue
, que significa cuando la puesta en común, los valores en el límite de las células de agrupación adyacentes son utilizadas por ambas células.deterministic
Un opcional
Bool
. Cuando se establece entrue
, una región agrupación fija se utilizará cuando iterar sobre un nodo fractionalMaxPool2D en el gráfico de cálculo.seed
Un opcional
Int64
. El valor predeterminado es0
. Si se establece en un valor distinto de cero, el generador de números aleatorios es sembrado por la semilla dada.seed2
Un opcional
Int64
. El valor predeterminado es0
. 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 la altura y dimensiones de anchura.Por ejemplo, dada una entrada de forma
[1, 2, 2, 1]
, data_format = “NHWC” y block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
Esta salida de operación voluntad un tensor de la forma de
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
Aquí, la entrada tiene un lote de 1 y cada elemento de proceso por lotes tiene forma
[2, 2, 1]
, la salida correspondiente tendrá un único elemento (es decir, anchura y altura son ambos 1) y tendrá una profundidad de 4 canales (1 * tamaño_bloque * tamaño_bloque). La forma elemento de salida es[1, 1, 4]
.Para un tensor de entrada con la profundidad más grande, aquí de forma
[1, 2, 2, 3]
, por ejemplo,x = [[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]]
Esta operación, por block_size de 2, devolverá el siguiente tensor de la forma de
[1, 1, 1, 12]
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
Del mismo modo, para la siguiente entrada de la forma
[1 4 4 1]
, y un tamaño de bloque de 2:x = [[[[1], [2], [5], [6]], [[3], [4], [7], [8]], [[9], [10], [13], [14]], [[11], [12], [15], [16]]]]
el operador volverá la siguiente tensor de la forma
[1 2 2 4]
:x = [[[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]]]
Condición previa
input.rank == 4 && b >= 2
.Condición previa
El número de las características debe ser divisible por cuadrado deb
.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 la altura y dimensiones de anchura se mueven a la dimensión de profundidad.Por ejemplo, dada una entrada de forma
[1, 2, 2, 1]
, data_format = “NHWC” y block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
Esta salida de operación voluntad un tensor de la forma de
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
Here, the input has a batch of 1 and each batch element has shape
[2, 2, 1]
, the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is[1, 1, 4]
.For an input tensor with larger depth, here of shape
[1, 2, 2, 3]
, egx = [[[[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 byb
.Precondition
The width of the input must be divisible byb
.Declaración
@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 ).
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
Builds a SGD based per-weight optimizer.
Declaración
public func makeSGD( learningRate: Float = 0.01, momentum: Float = 0, weightDecay: Float = 0, nesterov: Bool = false ) -> ParameterGroupOptimizer
Builds a per-weight optimizer for Adam with weight decay.
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
Generates a new random seed for TensorFlow.
Declaración
public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
Concatenates two values.
Declaración
@differentiable public func concatenate<T: Mergeable>( _ first: T, _ second: T ) -> T
Adds two values and produces their sum.
Declaración
@differentiable public func sum<T: Mergeable>( _ first: T, _ second: T ) -> T
Averages two values.
Declaración
@differentiable public func average<T: Mergeable>( _ first: T, _ second: T ) -> T
Multiplies two values.
Declaración
@differentiable public func multiply<T: Mergeable>( _ first: T, _ second: T ) -> T
Stack two values.
Declaración
@differentiable public func stack<T: Mergeable>( _ first: T, _ second: T ) -> T
Declaración
public func PrintX10Metrics()
Creates a string summary of a list of training and testing stats.
Declaración
public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
Declaración
public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics) -> String
Maps a function over n threads.
Declaración
public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]