Assista palestras, sessões de produtos, workshops e muito mais na lista de reprodução do Google I / O See

Funções

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 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 à 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 e q , KL divergência 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 à 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 encerramento 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 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 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 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 fechamento seja chamado e restaurado 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 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 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 encerramento 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 programados 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 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
  • 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 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 usada em um contexto em que x está sendo diferenciado em relação a, essa 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 fechamento fornecido a x . Quando usada em um contexto em que x está sendo diferenciado em relação a, essa 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 para executar as operações.

    body

    Um encerramento 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 de 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 as 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 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 da forma [batch, height, width, channels] ou Tensor 3-D da forma [height, width, channels] .

    size

    O novo tamanho das imagens.

    method

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

    antialias

    Sim, é 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 da forma [batch, height, width, channels] ou Tensor 3-D da forma [height, width, channels] .

    size

    O novo tamanho das imagens.

  • Retorna uma dilatação 2-D com a entrada, filtro, passos 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

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

    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. Observe que a transmissão do valor fornecido não é compatível.

    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, valores escalares de amostragem aleatória de uma distribuição uniforme entre -limit e limit , gerado pelo gerador de número aleatório 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 houver.

    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, valores escalares de amostragem aleatória 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 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 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úmero aleatório 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, valores escalares de amostragem aleatória de uma distribuição uniforme entre -limit e limit , gerado pelo gerador de número aleatório 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, valores escalares de amostragem aleatória 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 multiplicado 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 é 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

    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 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 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 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 com a mesma forma da entrada que contém 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 coeficiente triangular de entrada, representando A em Ax = b .

    rhs

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

    lower

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

    adjoint

    Se true , resolva com o adjunto da matrix vez da 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 de b .

  • Calcula a perda de 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 à saída correta.

    reduction

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

  • Calcula a perda de L2 entre o expected e o 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 à 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ítmico médio quadrático entre a loss = square(log(expected) - log(predicted)) predicted e expected loss = square(log(expected) - log(predicted))

    Observação

    As entradas de 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 à saída correta.

  • Calcula o erro percentual absoluto médio 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 à saída correta.

  • Calcula a perda de dobradiça entre predicted e expected . loss = reduction(max(0, 1 - predicted * expected)) expected valores esperados devem ser -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 à saída correta.

    reduction

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

  • Calcula a perda de dobradiça quadrada entre predicted e expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected valores esperados devem ser -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 à saída correta.

    reduction

    A redução deve ser aplicada aos valores de perda calculados por elemento.

  • 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 à 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) , 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 à saída correta.

    reduction

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

  • Calcula a perda de Poisson entre prevista e esperada 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 à saída correta.

    reduction

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

  • Calcula a perda de divergência de Kullback-Leibler entre o expected e o 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 à 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 flutuante por recurso para logits e um único valor de ponto flutuante por recurso para o 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 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 em uma representação one_hot . Deve haver # classes 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 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

    @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 fora de escala de uma rede neural.

    labels

    Valores inteiros que correspondem à saída correta.

    reduction

    A redução deve ser aplicada aos valores de perda calculados por elemento.

  • Calcula a perda de Huber entre predicted e expected .

    Para cada valor x com error = expected - predicted :

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

    • Fonte: artigo da Wikipedia .

    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 à 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 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 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 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 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 se 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 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 o 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 caso contrário. Veja Aprendizado de Rede Profundo 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 em termos de elemento.

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

    Observação

    Isso é projetado para ser usado junto com os inicializadores de camada de escala de variação. Consulte Redes neurais autonormalizáveis 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: “Searching for Activation Functions” (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 de swish forte, 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: A Self Regularized Non-Monotonic Neural Activation Function” 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 quadrática 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 similaridade do 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 cosseno entre x e y . A distância 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 da matriz 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, passo 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, passos 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

    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 2-D transposta com a entrada, filtro, passos 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 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 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

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

    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.

    Observação: 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 forma [batch, height, width, channels] .

    poolingRatio

    Uma lista de Doubles . A proporção de pooling para cada dimensão de input , atualmente suporta apenas dimensão 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 pseudo-aleatória, caso contrário, de forma aleatória.

    overlapping

    Um Bool opcional. O padrão é false . Quando definido como true , significa que, ao agrupar, os valores no limite das células de agrupamento adjacentes 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úmero aleatório é propagado pela semente fornecida.

    seed2

    Um Int64 opcional. O padrão é 0 . Uma segunda semente para evitar a 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 forma [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]]]]
    

    Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

    For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

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

    This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

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

    Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

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

    the operator will return the following tensor of shape [1 2 2 4] :

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

    Precondition

    input.rank == 4 && b >= 2 .

    Precondition

    The number of the features must be divisible by square of b .

    Declaração

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

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

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

    This operation will output a tensor of shape [1, 1, 1, 4] :

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

    Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

    For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

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

    This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

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

    Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

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

    the operator will return the following tensor of shape [1 2 2 4] :

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

    Precondition

    input.rank == 4 && b >= 2 .

    Precondition

    The height of the input must be divisible by b .

    Precondition

    The width of the input must be divisible by b .

    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.

    Reference: “Adam - A Method for Stochastic Optimization”

    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]