As funções a seguir estão disponíveis globalmente.
Retorna a perda de L1 entre previsões e expectativas.
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l1Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna a perda L2 entre previsões e expectativas.
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l2Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna a perda de dobradiça entre previsões e expectativas.
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func hingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna a perda de dobradiça quadrada entre previsões e expectativas.
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna a perda de dobradiça categórica entre previsões e expectativas.
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna o logaritmo do cosseno hiperbólico do erro entre as previsões e as expectativas.
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func logCoshLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna a perda de Poisson entre previsões e expectativas.
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func poissonLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna a divergência de Kullback-Leibler (divergência KL) entre as expectativas e as previsões. Dadas duas distribuições de
p
eq
, KL divergência calculap * log(p / q)
.Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Retorna a entropia cruzada softmax (entropia cruzada categórica) entre logits e rótulos.
Declaração
@differentiable(wrt: logits) public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, probabilities: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
logits
Saídas codificadas one-hot de uma rede neural.
labels
Índices (indexados a zero) das saídas corretas.
Retorna a entropia cruzada sigmóide (entropia cruzada binária) entre logits e rótulos.
Declaração
@differentiable(wrt: logits) @differentiable(wrt: (logits, labels) public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, labels: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
logits
A saída fora de escala de uma rede neural.
labels
Valores inteiros que correspondem à saída correta.
Retorna um tensor com a mesma forma e escalares do tensor especificado.
Declaração
@differentiable public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar
Chama o encerramento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto para a fase de aprendizagem fornecida.
Declaração
public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R
Parâmetros
context
Um contexto que será definido antes que o encerramento seja chamado e restaurado após o retorno do encerramento.
body
Um fechamento nulo. Se o fechamento tem um valor de retorno, esse valor também é usado como o valor de retorno do
withContext(_:_:)
função.Valor de retorno
O valor de retorno, se houver, do
body
de fecho.Chama o encerramento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto para a fase de aprendizagem fornecida.
Declaração
public func withLearningPhase<R>( _ learningPhase: LearningPhase, _ body: () throws -> R ) rethrows -> R
Parâmetros
learningPhase
Uma fase de aprendizado que será definida antes que o fechamento seja chamado e restaurada após o retorno do fechamento.
body
Um fechamento nulo. Se o fechamento tem um valor de retorno, esse valor também é usado como o valor de retorno do
withLearningPhase(_:_:)
função.Valor de retorno
O valor de retorno, se houver, do
body
de fecho.Chama o fechamento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto para a semente aleatória fornecida.
Declaração
public func withRandomSeedForTensorFlow<R>( _ randomSeed: TensorFlowSeed, _ body: () throws -> R ) rethrows -> R
Parâmetros
randomSeed
Uma semente aleatória que será definida antes que o encerramento seja chamado e restaurado após o retorno do encerramento.
body
Um fechamento nulo. Se o fechamento tem um valor de retorno, esse valor também é usado como o valor de retorno do
withRandomSeedForTensorFlow(_:_:)
função.Valor de retorno
O valor de retorno, se houver, do
body
de fecho.Chama o encerramento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto para o gerador de número aleatório fornecido.
Declaração
public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>( _ randomNumberGenerator: inout G, _ body: () throws -> R ) rethrows -> R
Parâmetros
randomNumberGenerator
Um gerador de números aleatórios que será definido antes que o encerramento seja chamado e restaurado após o retorno do encerramento.
body
Um fechamento nulo. Se o fechamento tem um valor de retorno, esse valor também é usado como o valor de retorno do
withRandomNumberGeneratorForTensorFlow(_:_:)
função.Valor de retorno
O valor de retorno, se houver, do
body
de fecho.Declaração
public func zip<T: TensorGroup, U: TensorGroup>( _ dataset1: Dataset<T>, _ dataset2: Dataset<U> ) -> Dataset<Zip2TensorGroup<T, U>>
LazyTensorBarrier garante que todos os tensores ativos (no dispositivo, se fornecido) estejam agendados e em execução. Se esperar for definido como verdadeiro, essa chamada será bloqueada até que o cálculo seja concluído.
Declaração
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
Declaração
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
Declaração
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
Declaração
public func valueWithGradient<T, R>( of f: @escaping @differentiable (T) -> Tensor<R> ) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector) where T: Differentiable, R: TensorFlowFloatingPoint
Declaração
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
Declaração
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
Declaração
public func gradient<T, R>( at x: T, in f: @differentiable (T) -> Tensor<R> ) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
Declaração
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
Declaração
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
Declaração
public func gradient<T, R>( of f: @escaping @differentiable (T) -> Tensor<R> ) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
Declaração
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
Declaração
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
Faça uma função ser recomputada em seu retrocesso, conhecido como “checkpointing” na diferenciação automática tradicional.
Declaração
public func withRecomputationInPullbacks<T, U>( _ body: @escaping @differentiable (T) -> U ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable
Crie uma função diferenciável a partir de uma função de produtos vetoriais Jacobiana.
Declaração
public func differentiableFunction<T : Differentiable, R : Differentiable>( from vjp: @escaping (T) -> (value: R, pullback: (R.TangentVector) -> T.TangentVector) ) -> @differentiable (T) -> R
Crie uma função diferenciável a partir de uma função de produtos vetoriais Jacobiana.
Declaração
public func differentiableFunction<T, U, R>( from vjp: @escaping (T, U) -> (value: R, pullback: (R.TangentVector) -> (T.TangentVector, U.TangentVector)) ) -> @differentiable (T, U) -> R
Retorna
x
como uma função de identidade. Quando utilizada num contexto em quex
está a ser diferenciados no que diz respeito a, esta função não produzirá qualquer derivado emx
.Declaração
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
Aplica-se o dado de fecho
body
dex
. Quando utilizada num contexto em quex
está a ser diferenciados no que diz respeito a, esta função não produzirá qualquer derivado emx
.Declaração
@_semantics("autodiff.nonvarying") public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R
Executa um fechamento, fazendo com que as operações do TensorFlow sejam executadas em um tipo específico de dispositivo.
Declaração
public func withDevice<R>( _ kind: DeviceKind, _ index: UInt = 0, perform body: () throws -> R ) rethrows -> R
Parâmetros
kind
Um tipo de dispositivo para executar operações do TensorFlow.
index
O dispositivo para executar as operações.
body
Um fechamento cujas operações do TensorFlow devem ser executadas no tipo de dispositivo especificado.
Executa um fechamento, fazendo com que as operações do TensorFlow sejam executadas em um dispositivo com um nome específico.
Alguns exemplos de nomes de dispositivos:
- “/ Dispositivo: CPU: 0”: A CPU da sua máquina.
- “/ GPU: 0”: notação abreviada para a primeira GPU da sua máquina que é visível para o TensorFlow
- “/ Job: localhost / replica: 0 / task: 0 / device: GPU: 1”: nome totalmente qualificado da segunda GPU de sua máquina que é visível para o TensorFlow.
Declaração
public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R
Parâmetros
name
Nome do dispositivo.
body
Um fechamento cujas operações do TensorFlow devem ser executadas no tipo de dispositivo especificado.
Executa um fechamento, permitindo que o TensorFlow coloque operações do TensorFlow em qualquer dispositivo. Isso deve restaurar o comportamento de posicionamento padrão.
Declaração
public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R
Parâmetros
body
Um fechamento cujas operações do TensorFlow devem ser executadas no tipo de dispositivo especificado.
Redimensione imagens para o tamanho usando o método especificado.
Condição prévia
As imagens devem ter grau3
ou4
.Condição prévia
O tamanho deve ser positivo.Declaração
@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
O novo tamanho das imagens.
method
O método de redimensionamento. O valor padrão é
.bilinear
.antialias
Iff
true
, usar um filtro anti-aliasing quando downsampling uma imagem.Redimensione imagens para o tamanho usando interpolação de área.
Condição prévia
As imagens devem ter grau3
ou4
.Condição prévia
O tamanho deve ser positivo.Declaração
public func resizeArea<Scalar: TensorFlowNumeric>( images: Tensor<Scalar>, size: (newHeight: Int, newWidth: Int), alignCorners: Bool = false ) -> Tensor<Float>
Retorna uma dilatação 2-D com a entrada, filtro, passos e preenchimento especificados.
Condição prévia
input
deve ter posto4
.Condição prévia
filter
deve ter posto3
.Declaração
@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
A entrada.
filter
O filtro de dilatação.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação
rates
As taxas de dilatação para cada dimensão da entrada.
Retorna uma erosão 2-D com a entrada, filtro, passadas e preenchimento especificados.
Condição prévia
input
deve ter posto4
.Condição prévia
filter
deve ter posto 3.Declaração
@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
A entrada.
filter
O filtro de erosão.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação
rates
As taxas de dilatação para cada dimensão da entrada.
Retorna uma função que cria um tensor inicializando todos os seus valores para zeros.
Declaração
public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
Retorna uma função que cria um tensor inicializando todos os seus valores com o valor fornecido.
Declaração
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
Retorna uma função que cria um tensor inicializando-o com o valor fornecido. Note-se que a transmissão do valor fornecido não é suportado.
Declaração
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
Retorna uma função que gera um tensor efectuando Glorot (Xavier) inicialização uniforme para a forma especificado, a amostragem de valores escalares aleatoriamente a partir de uma distribuição uniforme entre
-limit
elimit
, gerado pelo gerador de números aleatórios padrão, onde o limite ésqrt(6 / (fanIn + fanOut))
, efanIn
/fanOut
representam o número de entrada e de saída possui multiplicado pelo campo receptivo, se presente.Declaração
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Retorna uma função que gera um tensor efectuando Glorot (Xavier) inicialização normal para a forma especificada, a amostragem de forma aleatória valores escalares de uma distribuição normal truncada centrado em
0
com desvio padrãosqrt(2 / (fanIn + fanOut))
, ondefanIn
/fanOut
representam o número de recursos de entrada e saída multiplicados pelo tamanho do campo receptivo, se houver.Declaração
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Retorna uma função que gera um tensor efectuando Ele (Kaiming) inicialização uniforme para a forma especificada, a amostragem de valores escalares aleatoriamente a partir de uma distribuição uniforme entre
-limit
elimit
, gerado pelo gerador de números aleatórios padrão, onde o limite ésqrt(6 / fanIn)
, efanIn
representa o número de recursos de entrada multiplicado pelo campo receptivo, se presente.Declaração
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Retorna uma função que gera um tensor efectuando Ele (Kaiming) inicialização normal para a forma especificado, a amostragem de forma aleatória valores escalares de uma distribuição normal truncada centrado em
0
com um desvio padrãosqrt(2 / fanIn)
, ondefanIn
representa o número de recursos de entrada multiplicado pelo tamanho do campo receptivo, se presente.Declaração
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Retorna uma função que gera um tensor efectuando LeCun inicialização uniforme para a forma especificada, a amostragem de valores escalares aleatoriamente a partir de uma distribuição uniforme entre
-limit
elimit
, gerado pelo gerador de números aleatórios padrão, onde o limite ésqrt(3 / fanIn)
, efanIn
representa o número de recursos de entrada multiplicado pelo campo receptivo, se presente.Declaração
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Retorna uma função que gera um tensor efectuando LeCun inicialização normal para a forma especificada, a amostragem de forma aleatória valores escalares de uma distribuição normal truncada centrado em
0
com um desvio padrãosqrt(1 / fanIn)
, ondefanIn
representa o número de entrada possui multiplicado pela tamanho do campo receptivo, se presente.Declaração
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Retorna uma função que cria um tensor inicializando todos os seus valores aleatoriamente a partir de uma distribuição Normal truncada. Os valores gerados seguem uma distribuição normal com média
mean
e desvio padrãostandardDeviation
, exceto que os valores cuja magnitude é mais do que dois desvios-padrão da média são descartados e refeita.Declaração
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
Média da distribuição normal.
standardDeviation
Desvio padrão da distribuição normal.
Valor de retorno
Uma função inicializadora de parâmetro normal truncada.
Declaração
public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
Retorna uma matriz de identidade ou um lote de matrizes.
Declaração
Parâmetros
rowCount
O número de linhas em cada matriz de lote.
columnCount
O número de colunas em cada matriz de lote.
batchShape
As dimensões principais do lote do tensor retornado.
Calcula o traço de uma matriz opcionalmente em lote. O traço é a soma ao longo da diagonal principal de cada matriz mais interna.
A entrada é um tensor com a forma
[..., M, N]
. A saída é um tensor com forma[...]
.Condição prévia
matrix
deve ser um tensor com a forma[..., M, N]
.Declaração
@differentiable(wrt: matrix) public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
Parâmetros
matrix
Um tensor de forma
[..., M, N]
.Retorna a decomposição de Cholesky de uma ou mais matrizes quadradas.
A entrada é um tensor de forma
[..., M, M]
, cuja maior parte dos 2-dimensões interior formar matrizes quadradas.A entrada deve ser simétrica e definida positivamente. Apenas a parte triangular inferior da entrada será usada para esta operação. A parte triangular superior não será lida.
A saída é um tensor da mesma forma que a entrada contendo as decomposições Cholesky para todas as submatrizes de entrada
[..., :, :]
.Declaração
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Parâmetros
input
Um tensor de forma
[..., M, M]
.Retorna a solução
x
para o sistema de equações lineares representado porAx = b
.Condição prévia
matrix
deve ser um tensor com forma[..., M, M]
.Condição prévia
rhs
deve ser um tensor com forma[..., M, K]
.Declaração
@differentiable public func triangularSolve<T: TensorFlowFloatingPoint>( matrix: Tensor<T>, rhs: Tensor<T>, lower: Bool = true, adjoint: Bool = false ) -> Tensor<T>
Parâmetros
matrix
A entrada triangular coeficiente de matriz, representando
A
emAx = b
.rhs
Valores Lado direito, representando
b
emAx = b
.lower
Se
matrix
é triangular inferior (true
) ou triangular superior (false
). O valor padrão étrue
.adjoint
Se
true
, resolver com o adjunto damatrix
em vez dematrix
. O valor padrão éfalse
.Valor de retorno
A solução de
x
para o sistema de equações lineares representado porAx = b
.x
tem a mesma forma queb
.Calcula a perda L1 entre
expected
epredicted
.loss = reduction(abs(expected - predicted))
Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a perda L2 entre
expected
epredicted
.loss = reduction(square(expected - predicted))
Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a média da diferença absoluta entre rótulos e previsões.
loss = mean(abs(expected - predicted))
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Calcula a média dos quadrados dos erros entre rótulos e previsões.
loss = mean(square(expected - predicted))
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Calcula o erro logarítmica quadrado médio entre
predicted
eexpected
loss = square(log(expected) - log(predicted))
Observação
Entradas tensor negativos será fixada em
0
a evitar comportamentos logarítmica indefinido, comolog(_:)
é indefinido para reais negativos.Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Calcula o erro médio absoluto percentual entre
predicted
eexpected
.loss = 100 * mean(abs((expected - predicted) / abs(expected)))
Declaração
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
Calcula a perda de charneira entre
predicted
eexpected
.loss = reduction(max(0, 1 - predicted * expected))
expected
valores deverão ser -1 ou 1.Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a perda dobradiça quadrados entre
predicted
eexpected
.loss = reduction(square(max(0, 1 - predicted * expected)))
expected
valores deverão ser -1 ou 1.Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a perda dobradiça categórica entre
predicted
eexpected
.loss = maximum(negative - positive + 1, 0)
, ondenegative = max((1 - expected) * predicted)
epositive = sum(predicted * expected)
Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula o logaritmo do cosseno hiperbólico do erro de previsão.
logcosh = log((exp(x) + exp(-x))/2)
, em que x é o erropredicted - expected
Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a perda de Poisson entre o previsto e esperado que a perda de Poisson é a média dos elementos do
Tensor
predicted - expected * log(predicted)
.Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula Kullback-Leibler perda de divergência entre
expected
epredicted
.loss = reduction(expected * log(expected / predicted))
Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a entropia cruzada softmax esparsa (entropia cruzada categórica) entre logits e rótulos. Use esta função de perda de entrecropia cruzada quando houver duas ou mais classes de rótulo. Esperamos que os rótulos sejam fornecidos como inteiros. Deve haver
# classes
valores de ponto por recurso flutuante paralogits
e um único valor de ponto flutuante por recurso para oexpected
.Declaração
Parâmetros
logits
Saídas codificadas one-hot de uma rede neural.
labels
Índices (indexados a zero) das saídas corretas.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a entropia cruzada softmax esparsa (entropia cruzada categórica) entre logits e rótulos. Use esta função de perda de entrecropia cruzada quando houver duas ou mais classes de rótulo. Esperamos rótulos a serem fornecidos fornecido em um
one_hot
representação. Deve haver# classes
Valores de ponto flutuante por função.Declaração
Parâmetros
logits
Probabilidades de registro não escalonadas de uma rede neural.
probabilities
Valores de probabilidade que correspondem à saída correta. Cada linha deve ser uma distribuição de probabilidade válida.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a entropia cruzada sigmóide (entropia cruzada binária) entre logits e rótulos. Use esta perda de entropia cruzada quando houver apenas duas classes de rótulo (assumidas como 0 e 1). Para cada exemplo, deve haver um único valor de ponto flutuante por predição.
Declaração
Parâmetros
logits
A saída fora de escala de uma rede neural.
labels
Valores inteiros que correspondem à saída correta.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
Calcula a perda Huber entre
predicted
eexpected
.Para cada valor de
x
emerror = expected - predicted
:-
0.5 * x^2
se|x| <= δ
. 0.5 * δ^2 + δ * (|x| - δ)
de outra forma.Fonte: Wikipedia .
Declaração
Parâmetros
predicted
Saídas previstas de uma rede neural.
expected
Valores esperados, ou seja, metas, que correspondem à saída correta.
delta
Um escalar de ponto flutuante que representa o ponto onde a função de perda de Huber muda de quadrática para linear.
reduction
Redução a ser aplicada aos valores de perda calculados por elemento.
-
Retorna o valor absoluto do tensor especificado em termos de elemento.
Declaração
@differentiable public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
Retorna o logaritmo natural do tensor especificado em termos de elemento.
Declaração
@differentiable public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o logaritmo de base dois do tensor especificado em termos de elemento.
Declaração
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o logaritmo de base dez do tensor especificado em termos de elemento.
Declaração
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o logaritmo de
1 + x
elemento-wise.Declaração
@differentiable public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Devoluções
log(1 - exp(x))
usando uma abordagem numericamente estável.Observação
A abordagem é mostrada na Equação 7 de: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .Declaração
@differentiable public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o seno do tensor especificado em termos de elemento.
Declaração
@differentiable public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o cosseno do tensor especificado em termos de elemento.
Declaração
@differentiable public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a tangente do tensor especificado em termos de elemento.
Declaração
@differentiable public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o seno hiperbólico do tensor especificado em termos de elemento.
Declaração
@differentiable public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o cosseno hiperbólico do tensor especificado em termos de elemento.
Declaração
@differentiable public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a tangente hiperbólica do tensor especificado em termos de elemento.
Declaração
@differentiable public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o cosseno inverso do tensor especificado em termos de elemento.
Declaração
@differentiable public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o seno inverso do tensor especificado em termos de elemento.
Declaração
@differentiable public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a tangente inversa do tensor especificado em termos de elemento.
Declaração
@differentiable public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o cosseno hiperbólico inverso do tensor especificado em termos de elemento.
Declaração
@differentiable public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o seno hiperbólico inverso do tensor especificado em termos de elemento.
Declaração
@differentiable public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a tangente hiperbólica inversa do tensor especificado em termos de elemento.
Declaração
@differentiable public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a raiz quadrada do tensor especificado em termos de elemento.
Declaração
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a raiz quadrada inversa do tensor especificado em termos de elemento.
Declaração
@differentiable public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o exponencial do tensor especificado em termos de elemento.
Declaração
@differentiable public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna dois elevados à potência do tensor especificado em termos de elemento.
Declaração
@differentiable public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna dez elevado à potência do tensor especificado em termos de elemento.
Declaração
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o exponencial de
x - 1
elemento-wise.Declaração
@differentiable public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna os valores do tensor especificado, arredondados para o inteiro mais próximo, elemento a elemento.
Declaração
@differentiable public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o teto do tensor especificado em termos de elemento.
Declaração
@differentiable public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o piso do tensor especificado em termos de elemento.
Declaração
@differentiable public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna uma indicação do sinal do tensor especificado em termos de elemento. Especificamente, calcula
y = sign(x) = -1
sex < 0
; 0 sex == 0
; 1 sex > 0
.Declaração
@differentiable public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
Retorna o sigmóide do tensor especificado em termos de elemento. Especificamente, calcula
1 / (1 + exp(-x))
.Declaração
@differentiable public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o log-sigmóide do tensor especificado em termos de elemento. Especificamente,
log(1 / (1 + exp(-x)))
. Para estabilidade numérica, usamos-softplus(-x)
.Declaração
@differentiable public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o softplus do tensor especificado em termos de elemento. Especificamente, calcula
log(exp(features) + 1)
.Declaração
@differentiable public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o softsign do tensor especificado em termos de elemento. Especificamente, calcula
features/ (abs(features) + 1)
.Declaração
@differentiable public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o softmax do tensor especificado ao longo do último eixo. Especificamente, calcula
exp(x) / exp(x).sum(alongAxes: -1)
.Declaração
@differentiable public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o softmax do tensor especificado ao longo do eixo especificado. Especificamente, calcula
exp(x) / exp(x).sum(alongAxes: axis)
.Declaração
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o log-softmax do tensor especificado em termos de elemento.
Declaração
@differentiable public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor aplicando uma unidade linear exponencial. Especificamente, calcula
exp(x) - 1
, se <0,x
em contrário. Veja Rápido e Preciso profunda Learning Network por Exponencial unidades lineares (Elus)Declaração
@differentiable public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna as ativações da Unidade Linear de Erro Gaussiano (GELU) do tensor especificado em termos de elemento.
Especificamente,
gelu
aproximaxP(X <= x)
, em queP(X <= x)
é a distribuição cumulativa de Gauss Padrão, calculando: x * [0,5 * (1 + tanh [√ (2 / π) * (x + 0,044715 * x ^ 3)])].Declaração
@differentiable public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor aplicando a função de ativação ReLU ao tensor especificado em termos de elemento. Especificamente, calcula
max(0, x)
.Declaração
@differentiable public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor, aplicando a função de activação ReLU6, nomeadamente
min(max(0, x), 6)
.Declaração
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor aplicando a função de ativação ReLU com vazamento ao tensor especificado em termos de elemento. Especificamente, calcula
max(x, x * alpha)
.Declaração
@differentiable(wrt: x) public func leakyRelu<T: TensorFlowFloatingPoint>( _ x: Tensor<T>, alpha: Double = 0.2 ) -> Tensor<T>
Retorna um tensor, aplicando a função de activação selu, nomeadamente
scale * alpha * (exp(x) - 1)
sex < 0
, escale * x
em contrário.Observação
Isso é projetado para ser usado junto com os inicializadores de camada de escala de variação. Por favor, consulte Auto-Normalizing Neural Networks para mais informações.Declaração
@differentiable public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor, aplicando a função de activação abanada, ou seja,
x * sigmoid(x)
.Fonte: (. Ramachandran et al 2017) “Procura funções de activação” https://arxiv.org/abs/1710.05941
Declaração
@differentiable public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor, aplicando a função de activação sigmóide duro, nomeadamente
Relu6(x+3)/6
.Fonte: “Procurando MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244
Declaração
@differentiable public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor, aplicando a função de activação abanada duro, ou seja,
x * Relu6(x+3)/6
.Fonte: “Procurando MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244
Declaração
@differentiable public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna um tensor, aplicando a função de activação mish_nfs, ou seja,
x * tanh(softplus(x))
.Fonte: “Mish: Função A Self regularizada não monótono Neural Activation” https://arxiv.org/abs/1908.08681
Declaração
@differentiable public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a potência do primeiro tensor para o segundo tensor.
Declaração
@differentiable public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a potência do escalar para o tensor, transmitindo o escalar.
Declaração
@differentiable(wrt: rhs) public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a potência do tensor para o escalar, transmitindo o escalar.
Declaração
@differentiable(wrt: lhs) public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a potência do tensor para o escalar, transmitindo o escalar.
Declaração
@differentiable public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna o elemento-wise
n
º raiz do tensor.Declaração
@differentiable public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
Retorna a diferença de quadrados entre
x
ey
.Declaração
@differentiable public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
Valor de retorno
(x - y) ^ 2
.Retorna o máximo elemento a elemento de dois tensores.
Observação
max
suportes transmitindo.Declaração
@differentiable public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Retorna o máximo elemento a elemento do escalar e do tensor, transmitindo o escalar.
Declaração
@differentiable(wrt: rhs) public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Retorna o máximo elemento a elemento do escalar e do tensor, transmitindo o escalar.
Declaração
@differentiable(wrt: lhs) public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Retorna o mínimo elemento a elemento de dois tensores.
Observação
min
suporta radiodifusão.Declaração
@differentiable public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Retorna o mínimo elemento a elemento do escalar e do tensor, transmitindo o escalar.
Declaração
@differentiable(wrt: rhs) public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Retorna o mínimo elemento a elemento do escalar e do tensor, transmitindo o escalar.
Declaração
@differentiable(wrt: lhs) public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Retorna a similaridade do cosseno entre
x
ey
.Declaração
@differentiable public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
Retorna a distância cosseno entre
x
ey
. Distância cosseno é definido como1 - cosineSimilarity(x, y)
.Declaração
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
Retorna uma convolução 1-D com a entrada, filtro, passo e preenchimento especificados.
Condição prévia
input
deve ter posto3
.Condição prévia
filter
deve ter posto 3.Declaração
@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
A entrada.
filter
O filtro de convolução.
stride
O passo do filtro deslizante.
padding
O preenchimento para a operação.
dilation
O fator de dilatação.
Retorna uma convolução 2-D com a entrada, filtro, passos e preenchimento especificados.
Condição prévia
input
deve ter posto4
.Condição prévia
filter
deve ter posto 4.Declaração
@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
A entrada.
filter
O filtro de convolução.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação
dilations
O fator de dilatação para cada dimensão da entrada.
Retorna uma convolução transposta 2-D com a entrada, filtro, passos e preenchimento especificados.
Condição prévia
input
deve ter posto4
.Condição prévia
filter
deve ter posto 4.Declaração
@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
A entrada.
shape
A forma de saída da operação de deconvolução.
filter
O filtro de convolução.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação
dilations
O fator de dilatação para cada dimensão da entrada.
Retorna uma convolução 3-D com a entrada, filtro, passos, preenchimento e dilatações especificados.
Condição prévia
input
deve ter posto5
.Condição prévia
filter
deve ter posto 5.Declaração
@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
A entrada.
filter
O filtro de convolução.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação.
dilations
O fator de dilatação para cada dimensão da entrada.
Retorna uma convolução de profundidade 2-D com a entrada, filtro, passos e preenchimento especificados.
Condição prévia
input
deve ter posto 4.Condição prévia
filter
deve ter posto 4.Declaração
@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
A entrada.
filter
O filtro de convolução em profundidade.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação.
Retorna um pooling máximo 2-D, com os tamanhos de filtro, passos e preenchimento especificados.
Declaração
@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
A entrada.
filterSize
As dimensões do kernel do pool.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação.
Retorna um pooling máximo 3-D, com os tamanhos de filtro, passos e preenchimento especificados.
Declaração
@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
A entrada.
filterSize
As dimensões do kernel do pool.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação.
Retorna um pooling médio 2-D, com os tamanhos de filtro, passos e preenchimento especificados.
Declaração
@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
A entrada.
filterSize
As dimensões do kernel do pool.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação.
Retorna um pooling médio 3-D, com os tamanhos de filtro, passos e preenchimento especificados.
Declaração
@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
A entrada.
filterSize
As dimensões do kernel do pool.
strides
As passadas do filtro deslizante para cada dimensão da entrada.
padding
O preenchimento para a operação.
Retorna um pool máximo fracionário 2-D, com as taxas de pool especificadas.
Nota:
fractionalMaxPool
não tem uma implementação XLA, e, portanto, pode ter implicações de desempenho.Declaração
@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
A Tensor. 4-D com a forma
[batch, height, width, channels]
.poolingRatio
Uma lista de
Doubles
. Pooling proporção para cada dimensão deinput
, actualmente apenas suporta dimensão da linha e col e deve ser> = 1,0.pseudoRandom
Um opcional
Bool
. O padrão éfalse
. Quando ajustado paratrue
, gera a sequência de pooling de uma forma pseudo-aleatória, de outro modo, de uma forma aleatória.overlapping
Um opcional
Bool
. O padrão éfalse
. Quando ajustado paratrue
, isto significa que quando o agrupamento, os valores do limite de células de agrupamento adjacentes são usados por ambas as células.deterministic
Um opcional
Bool
. Quando ajustado paratrue
, uma região de agrupamento fixo irá ser utilizado quando a iteração através de um nó fractionalMaxPool2D no gráfico de computação.seed
Um opcional
Int64
. O padrão é0
. Se definido como diferente de zero, o gerador de número aleatório é propagado pela semente fornecida.seed2
Um opcional
Int64
. O padrão é0
. Uma segunda semente para evitar a colisão de sementes.Devolve uma cópia da
input
, onde os valores da dimensão de profundidade são movidos em blocos espaciais para a altura e largura.Por exemplo, dada uma entrada de forma
[1, 2, 2, 1]
, data_format = “NHWC” e block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
Esta saída funcionamento vontade um tensor de forma
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
Aqui, a entrada tem um lote de 1 e cada elemento lote tem a forma
[2, 2, 1]
, a saída correspondente terá um único elemento (ou seja, largura e altura são ambos 1) e terá uma profundidade de 4 canais (1 * block_size * block_size). A forma elemento de saída é[1, 1, 4]
.Para um tensor de entrada com maior profundidade, aqui de forma
[1, 2, 2, 3]
, por exemplo,x = [[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]]
Esta operação, por block_size de 2, voltará a seguinte tensor de forma
[1, 1, 1, 12]
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
Da mesma forma, para o seguinte de entrada de forma
[1 4 4 1]
, e um tamanho de bloco de 2:x = [[[[1], [2], [5], [6]], [[3], [4], [7], [8]], [[9], [10], [13], [14]], [[11], [12], [15], [16]]]]
o operador irá devolver o seguinte tensor de forma
[1 2 2 4]
:x = [[[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]]]
Condição prévia
input.rank == 4 && b >= 2
.Condição prévia
O número de recursos deve ser divisível por quadrado deb
.Declaração
@differentiable(wrt: input) public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
Devolve uma cópia da
input
, onde os valores da altura e largura dimensões são movidos para a dimensão de profundidade.Por exemplo, dada uma entrada de forma
[1, 2, 2, 1]
, data_format = “NHWC” e block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
Esta saída funcionamento vontade um tensor de forma
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
Aqui, a entrada tem um lote de 1 e cada elemento lote tem a forma
[2, 2, 1]
, a saída correspondente terá um único elemento (ou seja, largura e altura são ambos 1) e terá uma profundidade de 4 canais (1 * block_size * block_size). A forma elemento de saída é[1, 1, 4]
.Para um tensor de entrada com maior profundidade, aqui de forma
[1, 2, 2, 3]
, por exemplo,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 byb
.Precondition
The width of the input must be divisible byb
.Declaração
@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 ).
Declaração
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.
Declaração
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.
Declaração
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.
Declaração
public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
Concatenates two values.
Declaração
@differentiable public func concatenate<T: Mergeable>( _ first: T, _ second: T ) -> T
Adds two values and produces their sum.
Declaração
@differentiable public func sum<T: Mergeable>( _ first: T, _ second: T ) -> T
Averages two values.
Declaração
@differentiable public func average<T: Mergeable>( _ first: T, _ second: T ) -> T
Multiplies two values.
Declaração
@differentiable public func multiply<T: Mergeable>( _ first: T, _ second: T ) -> T
Stack two values.
Declaração
@differentiable public func stack<T: Mergeable>( _ first: T, _ second: T ) -> T
Declaração
public func PrintX10Metrics()
Creates a string summary of a list of training and testing stats.
Declaração
public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
Declaração
public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics) -> String
Maps a function over n threads.
Declaração
public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]