Funções

As seguintes funções estão disponíveis globalmente.

  • Retorna a perda 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 ao resultado correto.

  • 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 ao resultado correto.

  • Retorna a perda de articulação 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 ao resultado correto.

  • Retorna a perda quadrada da dobradiça 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 ao resultado correto.

  • 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 ao resultado correto.

  • Retorna o logaritmo do cosseno hiperbólico do erro entre previsões e 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 ao resultado correto.

  • 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 ao resultado correto.

  • Retorna a divergência de Kullback-Leibler (divergência KL) entre expectativas e previsões. Dadas duas distribuições p e q , a divergência KL calcula p * 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 ao resultado correto.

  • 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 não dimensionada 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 dado dentro de um contexto que tem tudo idêntico ao contexto actual, excepto para a fase de aprendizagem dada.

    Declaração 

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

    Parâmetros

    context

    Um contexto que será definido antes do fechamento ser chamado e restaurado após o retorno do fechamento.

    body

    Um fechamento nulo. Se o fechamento tiver um valor de retorno, esse valor também será usado como o valor de retorno da função withContext(_:_:) .

    Valor de retorno

    O valor de retorno, se houver, do fechamento do body .

  • Chama o encerramento dado dentro de um contexto que tem tudo idêntico ao contexto actual, excepto para a fase de aprendizagem dada.

    Declaração 

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

    Parâmetros

    learningPhase

    Uma fase de aprendizagem que será definida antes do fechamento ser chamada e restaurada após o retorno do fechamento.

    body

    Um fechamento nulo. Se o encerramento tiver um valor de retorno, esse valor também será usado como o valor de retorno da função withLearningPhase(_:_:) .

    Valor de retorno

    O valor de retorno, se houver, do fechamento do body .

  • Chama o encerramento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto 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 do fechamento ser chamada e restaurada após o retorno do fechamento.

    body

    Um fechamento nulo. Se o fechamento tiver um valor de retorno, esse valor também será usado como o valor de retorno da função withRandomSeedForTensorFlow(_:_:) .

    Valor de retorno

    O valor de retorno, se houver, do fechamento do body .

  • Chama o encerramento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto o gerador de números aleatórios 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á configurado antes do fechamento ser chamado e restaurado após o retorno do fechamento.

    body

    Um fechamento nulo. Se o fechamento tiver um valor de retorno, esse valor também será usado como o valor de retorno da função withRandomNumberGeneratorForTensorFlow(_:_:) .

    Valor de retorno

    O valor de retorno, se houver, do fechamento do body .

  • 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 wait for definido como verdadeiro, esta chamada será bloqueada até que o cálculo seja concluído.

    Declaração 

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

  • 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

  • Fazer com que uma função seja recalculada em seu pullback, 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 jacobianos.

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

    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 usada em um contexto onde x está sendo diferenciado em relação a, esta função não produzirá nenhuma derivada em x .

    Declaração 

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

  • Aplica o body de fechamento fornecido a x . Quando usada em um contexto onde x está sendo diferenciado em relação a, esta função não produzirá nenhuma derivada em x .

    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 no qual executar as operações.

    body

    Um encerramento cujas operações do TensorFlow devem ser executadas no tipo de dispositivo especificado.

  • Executa um encerramento, fazendo com que as operações do TensorFlow sejam executadas em um dispositivo com um nome específico.

    Alguns exemplos de nomes de dispositivos:

    • “/device:CPU:0”: A CPU da sua máquina.
    • “/GPU:0”: notação abreviada para a primeira GPU da sua máquina que está visível para o TensorFlow
    • “/job:localhost/replica:0/task:0/device:GPU:1”: nome totalmente qualificado da segunda GPU da sua máquina que está 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 encerramento 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 encerramento cujas operações do TensorFlow devem ser executadas no tipo de dispositivo especificado.

  • Redimensione as imagens para o tamanho desejado usando o método especificado.

    Condição prévia

    As imagens devem ter classificação 3 ou 4 .

    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

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

    size

    O novo tamanho das imagens.

    method

    O método de redimensionamento. O valor padrão é .bilinear .

    antialias

    Iff true , use um filtro anti-aliasing ao reduzir a resolução de uma imagem.

  • Redimensione imagens para o tamanho usando interpolação de área.

    Condição prévia

    As imagens devem ter classificação 3 ou 4 .

    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>

    Parâmetros

    images

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

    size

    O novo tamanho das imagens.

  • Retorna uma dilatação 2D com a entrada, filtro, avanços e preenchimento especificados.

    Condição prévia

    input deve ter classificação 4 .

    Condição prévia

    filter deve ter classificação 3 .

    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

    Os avanços 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 2D com a entrada, filtro, avanços e preenchimento especificados.

    Condição prévia

    input deve ter classificação 4 .

    Condição prévia

    filter deve ter classificação 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

    Os avanços 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 com 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. Observe que a transmissão do valor fornecido não é suportada.

    Declaração 

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

  • Retorna uma função que cria um tensor executando a inicialização uniforme Glorot (Xavier) para a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição uniforme entre -limit e limit , gerada pelo gerador de números aleatórios padrão, onde limit é sqrt(6 / (fanIn + fanOut)) e fanIn / fanOut representam o número de recursos de entrada e saída multiplicados pelo campo receptivo, se presente.

    Declaração 

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

  • Retorna uma função que cria um tensor executando a inicialização normal Glorot (Xavier) para a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição normal truncada centrada em 0 com desvio padrão sqrt(2 / (fanIn + fanOut)) , onde fanIn / fanOut representam o número de recursos de entrada e saída multiplicado pelo tamanho do campo receptivo, se presente.

    Declaração 

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

  • Retorna uma função que cria um tensor executando a inicialização uniforme He (Kaiming) para a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição uniforme entre -limit e limit , gerada pelo gerador de números aleatórios padrão, onde limit é sqrt(6 / fanIn) e fanIn representa o número de recursos de entrada multiplicados pelo campo receptivo, se presente.

    Declaração 

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

  • Retorna uma função que cria um tensor executando a inicialização normal He (Kaiming) para a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição normal truncada centrada em 0 com desvio padrão sqrt(2 / fanIn) , onde fanIn 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 cria um tensor executando a inicialização uniforme LeCun para a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição uniforme entre -limit e limit , gerada pelo gerador de números aleatórios padrão, onde limit é sqrt(3 / fanIn) , e fanIn representa o número de recursos de entrada multiplicados pelo campo receptivo, se presente.

    Declaração 

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

  • Retorna uma função que cria um tensor executando a inicialização normal LeCun para a forma especificada, amostrando aleatoriamente valores escalares de uma distribuição normal truncada centrada em 0 com desvio padrão sqrt(1 / fanIn) , onde fanIn representa o número de recursos de entrada multiplicados pelo 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ão standardDeviation , exceto que os valores cuja magnitude é superior a dois desvios padrão da média são descartados e reamostrados.

    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 identidade ou um lote de matrizes.

    Declaração 

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

    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 principais dimensões do lote do tensor retornado.

  • Calcula o rastreamento 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 forma [..., M, N] . A saída é um tensor com forma [...] .

    Condição prévia

    matrix deve ser um tensor com 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] cujas 2 dimensões mais internas formam matrizes quadradas.

    A entrada deve ser simétrica e positiva definida. Somente 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 de 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 por Ax = 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 matriz de coeficientes triangulares de entrada, representando A em Ax = b .

    rhs

    Valores do lado direito, representando b em Ax = b .

    lower

    Se matrix é triangular inferior ( true ) ou triangular superior ( false ). O valor padrão é true .

    adjoint

    Se true , resolva com o adjunto de matrix em vez de matrix . O valor padrão é false .

    Valor de retorno

    A solução x para o sistema de equações lineares representado por Ax = b . x tem a mesma forma que b .

  • Calcula a perda L1 entre expected e predicted . loss = reduction(abs(expected - predicted))

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula a perda L2 entre expected e predicted . loss = reduction(square(expected - predicted))

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • 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 ao resultado correto.

  • 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 ao resultado correto.

  • Calcula o erro logarítmico quadrático médio entre a perda predicted e expected loss = square(log(expected) - log(predicted))

    Observação

    As entradas do tensor negativo serão fixadas em 0 para evitar comportamento logarítmico indefinido, já que log(_:) é 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 ao resultado correto.

  • Calcula o erro percentual médio absoluto entre predicted e expected . 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 ao resultado correto.

  • Calcula a perda de dobradiça entre predicted e expected . loss = reduction(max(0, 1 - predicted * expected)) espera-se que os valores expected sejam -1 ou 1.

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula a perda de dobradiça quadrada entre predicted e expected . loss = reduction(square(max(0, 1 - predicted * expected))) espera-se que os valores expected sejam -1 ou 1.

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula a perda de dobradiça categórica entre predicted e expected . loss = maximum(negative - positive + 1, 0) onde negative = max((1 - expected) * predicted) e positive = sum(predicted * expected)

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula o logaritmo do cosseno hiperbólico do erro de previsão. logcosh = log((exp(x) + exp(-x))/2) , onde x é o erro predicted - expected

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula a perda de Poisson entre o previsto e o esperado. A perda de Poisson é a média dos elementos do Tensor predicted - expected * log(predicted) .

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula a perda de divergência de Kullback-Leibler entre expected e predicted . loss = reduction(expected * log(expected / predicted))

    Declaração 

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula a entropia cruzada softmax esparsa (entropia cruzada categórica) entre logits e rótulos. Use esta função de perda de entropia cruzada quando houver duas ou mais classes de rótulos. Esperamos que os rótulos sejam fornecidos como números inteiros. Deve haver # classes de valores de ponto flutuante por recurso para logits e um único valor de ponto flutuante por recurso para expected .

    Declaração 

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

    Parâmetros

    logits

    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 por elemento calculados.

  • Calcula a entropia cruzada softmax esparsa (entropia cruzada categórica) entre logits e rótulos. Use esta função de perda de entropia cruzada quando houver duas ou mais classes de rótulos. Esperamos que os rótulos sejam fornecidos em uma representação one_hot . Deve haver # classes de valores de ponto flutuante por recurso.

    Declaração 

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

    Parâmetros

    logits

    Probabilidades de log não dimensionadas 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 por elemento calculados.

  • 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ótulos (assumidas como 0 e 1). Para cada exemplo, deve haver um único valor de ponto flutuante por predição.

    Declaração 

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

    Parâmetros

    logits

    A saída não dimensionada de uma rede neural.

    labels

    Valores inteiros que correspondem à saída correta.

    reduction

    Redução a ser aplicada aos valores de perda por elemento calculados.

  • Calcula a perda de Huber entre predicted e expected .

    Para cada valor x em error = expected - predicted :

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

    • 0.5 * δ^2 + δ * (|x| - δ) caso contrário.

    • Fonte: artigo da Wikipédia .

    Declaração 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func huberLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  delta: Scalar,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem ao resultado correto.

    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 por elemento calculados.

  • Retorna o valor absoluto do tensor especificado elemento a 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 elemento a 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 elemento a 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 elemento a elemento.

    Declaração 

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

  • Retorna o logaritmo de 1 + x elemento a elemento.

    Declaração 

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

  • Retorna 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 elemento a elemento.

    Declaração 

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

  • Retorna o cosseno do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna a tangente do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna o seno hiperbólico do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna o cosseno hiperbólico do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna a tangente hiperbólica do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna o cosseno inverso do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna o seno inverso do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna a tangente inversa do tensor especificado elemento a 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 elemento a 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 elemento a 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 elemento a elemento.

    Declaração 

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

  • Retorna a raiz quadrada do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna a raiz quadrada inversa do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna o exponencial do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna dois elevados à potência do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna dez elevado à potência do tensor especificado elemento a elemento.

    Declaração 

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

  • Retorna o exponencial de x - 1 elemento a elemento.

    Declaração 

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

  • Retorna os valores do tensor especificado arredondados para o número 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 elemento a elemento.

    Declaração 

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

  • Retorna o piso do tensor especificado elemento a 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 elemento a elemento. Especificamente, calcula y = sign(x) = -1 if x < 0 ; 0 se x == 0 ; 1 se x > 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 elemento a 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 elemento a 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 por elemento. Especificamente, calcula log(exp(features) + 1) .

    Declaração 

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

  • Retorna o sinal suave do tensor especificado elemento a 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 elemento a 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 caso contrário. Veja o aprendizado profundo de rede rápido e preciso por unidades lineares exponenciais (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 elemento a elemento.

    Especificamente, gelu se aproxima xP(X <= x) , onde P(X <= x) é a distribuição cumulativa gaussiana padrão, calculando: x * [0,5 * (1 + tanh[√(2/π) * (x + 0,044715 * x^3)])].

    Consulte Unidades Lineares de Erro Gaussiano .

    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 elemento a 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 ativação ReLU6, ou seja 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 elemento a 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 ativação SeLU, ou seja scale * alpha * (exp(x) - 1) se x < 0 e scale * x caso contrário.

    Observação

    Isso foi projetado para ser usado junto com os inicializadores da camada de escala de variação. Consulte Redes Neurais de Auto-Normalização para obter 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 ativação swish, ou seja, x * sigmoid(x) .

    Fonte: “Busca por funções de ativação” (Ramachandran et al. 2017) 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 ativação sigmóide rígida, ou seja, Relu6(x+3)/6 .

    Fonte: “Searching for 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 ativação hard swish, ou seja, x * Relu6(x+3)/6 .

    Fonte: “Searching for 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 ativação mish, ou seja, x * tanh(softplus(x)) .

    Fonte: “Mish: uma função de ativação neural não monotônica auto-regulada” 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 ao 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 ao 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 ao escalar, transmitindo o escalar.

    Declaração 

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

  • Retorna a n-ésima n elemento a elemento do tensor.

    Declaração 

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

  • Retorna a diferença quadrada entre x e y .

    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 suporta transmissão.

    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 transmissã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 semelhança de cosseno entre x e y .

    Declaração 

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

  • Retorna a distância do cosseno entre x e y . A distância do cosseno é definida como 1 - cosineSimilarity(x, y) .

    Declaração 

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

  • Executa a multiplicação de matrizes com outro tensor e produz o resultado.

    Declaração 

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

  • Retorna uma convolução 1-D com a entrada, filtro, passada e preenchimento especificados.

    Condição prévia

    input deve ter classificação 3 .

    Condição prévia

    filter deve ter classificação 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, avanços e preenchimento especificados.

    Condição prévia

    input deve ter classificação 4 .

    Condição prévia

    filter deve ter classificação 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

    Os avanços 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, avanços e preenchimento especificados.

    Condição prévia

    input deve ter classificação 4 .

    Condição prévia

    filter deve ter classificação 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 desconvolução.

    filter

    O filtro de convolução.

    strides

    Os avanços 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 3D com a entrada, filtro, avanços, preenchimento e dilatações especificados.

    Condição prévia

    input deve ter classificação 5 .

    Condição prévia

    filter deve ter classificação 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

    Os avanços 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 em profundidade 2-D com a entrada, filtro, avanços e preenchimento especificados.

    Condição prévia

    input deve ter classificação 4.

    Condição prévia

    filter deve ter classificação 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

    Os avanços 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, avanços 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 de pooling.

    strides

    Os avanços do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pooling máximo 3D, com os tamanhos de filtro, avanços 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 de pooling.

    strides

    Os avanços do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pool médio 2D, com os tamanhos de filtro, avanços 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 de pooling.

    strides

    Os avanços do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pool médio 3D, com os tamanhos de filtro, avanços 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 de pooling.

    strides

    Os avanços do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pool máximo fracionário 2D, com as taxas de pool especificadas.

    Nota: fractionalMaxPool não possui uma implementação XLA e, portanto, pode ter implicações no 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

    Um tensor. 4-D com forma [batch, height, width, channels] .

    poolingRatio

    Uma lista de Doubles . A proporção de agrupamento para cada dimensão de input , atualmente suporta apenas dimensões de linha e coluna e deve ser >= 1,0.

    pseudoRandom

    Um Bool opcional. O padrão é false . Quando definido como true , gera a sequência de agrupamento de forma pseudoaleatória, caso contrário, de forma aleatória.

    overlapping

    Um Bool opcional. O padrão é false . Quando definido como true , significa que durante o pool, os valores no limite das células adjacentes do pool são usados ​​por ambas as células.

    deterministic

    Um Bool opcional. Quando definido como true , uma região de pool fixa será usada ao iterar sobre um nó fracionárioMaxPool2D no gráfico de computação.

    seed

    Um Int64 opcional. O padrão é 0 . Se definido como diferente de zero, o gerador de números aleatórios é propagado pela semente fornecida.

    seed2

    Um Int64 opcional. O padrão é 0 . Uma segunda semente para evitar colisão de sementes.

  • Retorna uma cópia da input onde os valores da dimensão de profundidade são movidos em blocos espaciais para as dimensões de altura e largura.

    Por exemplo, dada uma entrada de formato [1, 2, 2, 1] , data_format = “NHWC” e block_size = 2:

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

    Esta operação produzirá um tensor de forma [1, 1, 1, 4] :

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

    Aqui, a entrada tem um lote de 1 e cada elemento do lote tem formato [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 * tamanho_bloco * tamanho_bloco). A forma do elemento de saída é [1, 1, 4] .

    Para um tensor de entrada com maior profundidade, aqui de formato [1, 2, 2, 3] , por exemplo

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

    Esta operação, para block_size de 2, retornará o seguinte tensor de forma [1, 1, 1, 12]

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

    Da mesma forma, para a seguinte entrada de formato [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 retornará 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 pelo quadrado de b .

    Declaração 

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

  • Retorna uma cópia da input onde os valores das dimensões de altura e largura são movidos para a dimensão de profundidade.

    Por exemplo, dada uma entrada de formato [1, 2, 2, 1] , data_format = “NHWC” e block_size = 2:

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

    Esta operação produzirá um tensor de forma [1, 1, 1, 4] :

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

    Aqui, a entrada tem um lote de 1 e cada elemento do lote tem formato [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 * tamanho_bloco * tamanho_bloco). A forma do elemento de saída é [1, 1, 4] .

    Para um tensor de entrada com maior profundidade, aqui de formato [1, 2, 2, 3] , por exemplo

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

    Esta operação, para block_size de 2, retornará o seguinte tensor de forma [1, 1, 1, 12]

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

    Da mesma forma, para a seguinte 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 retornará 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

    A altura da entrada deve ser divisível por b .

    Condição prévia

    A largura da entrada deve ser divisível por b .

    Declaração 

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

  • Construa um otimizador por peso para 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

  • Construa um otimizador baseado em peso SGD.

    Declaração 

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

  • Construa um otimizador por peso para Adam com decaimento de peso.

    Referência: “Adam - um método para otimização estocástica”

    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

  • Gera uma nova semente aleatória para o tensorflow.

    Declaração 

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

  • Concatena dois valores.

    Declaração 

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

  • Adiciona dois valores e produz sua soma.

    Declaração 

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

  • Média de dois valores.

    Declaração 

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

  • Multiplica dois valores.

    Declaração 

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

  • Empilhe dois valores.

    Declaração 

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

  • Declaração 

    public func PrintX10Metrics()

  • Cria um resumo da string de uma lista de estatísticas de treinamento e teste.

    Declaração 

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

  • Declaração 

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

  • Mapeia uma função sobre n threads.

    Declaração 

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