Attend the Women in ML Symposium on December 7 Register now

Funções

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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

  • Retorna a perda de L1 entre previsões e expectativas.

    Declaração

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Retorna a perda L2 entre previsões e expectativas.

    Declaração

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Retorna a perda de dobradiça entre previsões e expectativas.

    Declaração

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Retorna a perda de dobradiça quadrada entre previsões e expectativas.

    Declaração

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Retorna a perda de dobradiça categórica entre previsões e expectativas.

    Declaração

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Retorna o logaritmo do cosseno hiperbólico do erro entre as previsões e as expectativas.

    Declaração

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Retorna a perda de Poisson entre previsões e expectativas.

    Declaração

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

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Retorna a divergência de Kullback-Leibler (divergência KL) entre as expectativas e as previsões. Dadas duas distribuições de p 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 fechamento tem um valor de retorno, esse valor também é usado como o valor de retorno do withContext(_:_:) função.

    Valor de retorno

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

  • Chama o encerramento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto para a fase de aprendizagem fornecida.

    Declaração

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

    Parâmetros

    learningPhase

    Uma fase de aprendizado que será definida antes que o fechamento seja chamado e restaurada após o retorno do fechamento.

    body

    Um fechamento nulo. Se o fechamento tem um valor de retorno, esse valor também é usado como o valor de retorno do withLearningPhase(_:_:) função.

    Valor de retorno

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

  • Chama o fechamento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto para a semente aleatória fornecida.

    Declaração

    public func withRandomSeedForTensorFlow<R>(
      _ randomSeed: TensorFlowSeed,
      _ body: () throws -> R
    ) rethrows -> R

    Parâmetros

    randomSeed

    Uma semente aleatória que será definida antes que o encerramento seja chamado e restaurado após o retorno do encerramento.

    body

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

    Valor de retorno

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

  • Chama o encerramento fornecido dentro de um contexto que tem tudo idêntico ao contexto atual, exceto para o gerador de número aleatório fornecido.

    Declaração

    public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>(
      _ randomNumberGenerator: inout G,
      _ body: () throws -> R
    ) rethrows -> R

    Parâmetros

    randomNumberGenerator

    Um gerador de números aleatórios que será definido antes que o encerramento seja chamado e restaurado após o retorno do encerramento.

    body

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

    Valor de retorno

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

  • Declaração

    public func zip<T: TensorGroup, U: TensorGroup>(
      _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
    ) -> Dataset<Zip2TensorGroup<T, U>>
  • LazyTensorBarrier garante que todos os tensores ativos (no dispositivo, se fornecido) estejam agendados e em execução. Se esperar for definido como verdadeiro, essa chamada será bloqueada até que o cálculo seja concluído.

    Declaração

    public func 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 a partir de uma função de produtos vetoriais Jacobiana.

    Declaração

    public func differentiableFunction<T, U, R>(
      from vjp: @escaping (T, U)
               -> (value: R, pullback: (R.TangentVector)
                 -> (T.TangentVector, U.TangentVector))
    ) -> @differentiable (T, U) -> R
  • Retorna x como uma função de identidade. Quando utilizada num contexto em que x está a ser diferenciados no que diz respeito a, esta função não produzirá qualquer derivado em x .

    Declaração

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T>(at x: T) -> T
  • Aplica-se o dado de fecho body de x . Quando utilizada num contexto em que x está a ser diferenciados no que diz respeito a, esta função não produzirá qualquer derivado 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 fechamento cujas operações do TensorFlow devem ser executadas no tipo de dispositivo especificado.

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

    Alguns exemplos de nomes de dispositivos:

    • “/ Dispositivo: CPU: 0”: A CPU da sua máquina.
    • “/ GPU: 0”: notação abreviada para a primeira GPU da sua máquina que é visível para o TensorFlow
    • “/ Job: localhost / replica: 0 / task: 0 / device: GPU: 1”: nome totalmente qualificado da segunda GPU de sua máquina que é visível para o TensorFlow.

    Declaração

    public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R

    Parâmetros

    name

    Nome do dispositivo.

    body

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

  • Executa um fechamento, permitindo que o TensorFlow coloque operações do TensorFlow em qualquer dispositivo. Isso deve restaurar o comportamento de posicionamento padrão.

    Declaração

    public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R

    Parâmetros

    body

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

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

    Condição prévia

    As imagens devem ter grau 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

    4-D Tensor de forma [batch, height, width, channels] ou 3-D Tensor 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 , usar um filtro anti-aliasing quando downsampling uma imagem.

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

    Condição prévia

    As imagens devem ter grau 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

    4-D Tensor de forma [batch, height, width, channels] ou 3-D Tensor de 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 posto 4 .

    Condição prévia

    filter deve ter posto 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 posto 4 .

    Condição prévia

    filter deve ter posto 3.

    Declaração

    @differentiable(wrt: (input, filter)
    public func erosion2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
      rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
      padding: Padding = .valid
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filter

    O filtro de erosão.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação

    rates

    As taxas de dilatação para cada dimensão da entrada.

  • Retorna uma função que cria um tensor inicializando todos os seus valores para zeros.

    Declaração

    public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
  • Retorna uma função que cria um tensor inicializando todos os seus valores com o valor fornecido.

    Declaração

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Scalar
    ) -> ParameterInitializer<Scalar>
  • Retorna uma função que cria um tensor inicializando-o com o valor fornecido. Note-se que a transmissão do valor fornecido não é suportado.

    Declaração

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Tensor<Scalar>
    ) -> ParameterInitializer<Scalar>
  • Retorna uma função que gera um tensor efectuando Glorot (Xavier) inicialização uniforme para a forma especificado, a amostragem de valores escalares aleatoriamente a partir de uma distribuição uniforme entre -limit e limit , gerado pelo gerador de números aleatórios padrão, onde o limite é sqrt(6 / (fanIn + fanOut)) , e fanIn / fanOut representam o número de entrada e de saída possui multiplicado pelo campo receptivo, se presente.

    Declaração

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Retorna uma função que gera um tensor efectuando Glorot (Xavier) inicialização normal para a forma especificada, a amostragem de forma aleatória valores escalares de uma distribuição normal truncada centrado em 0 com desvio padrã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 gera um tensor efectuando Ele (Kaiming) inicialização uniforme para a forma especificada, a amostragem de valores escalares aleatoriamente a partir de uma distribuição uniforme entre -limit e limit , gerado pelo gerador de números aleatórios padrão, onde o limite é sqrt(6 / fanIn) , e fanIn representa o número de recursos de entrada multiplicado pelo campo receptivo, se presente.

    Declaração

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Retorna uma função que gera um tensor efectuando Ele (Kaiming) inicialização normal para a forma especificado, a amostragem de forma aleatória valores escalares de uma distribuição normal truncada centrado em 0 com um desvio padrã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 gera um tensor efectuando LeCun inicialização uniforme para a forma especificada, a amostragem de valores escalares aleatoriamente a partir de uma distribuição uniforme entre -limit e limit , gerado pelo gerador de números aleatórios padrão, onde o limite é sqrt(3 / fanIn) , e fanIn representa o número de recursos de entrada multiplicado pelo campo receptivo, se presente.

    Declaração

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Retorna uma função que gera um tensor efectuando LeCun inicialização normal para a forma especificada, a amostragem de forma aleatória valores escalares de uma distribuição normal truncada centrado em 0 com um desvio padrão sqrt(1 / fanIn) , onde fanIn representa o número de entrada possui multiplicado pela tamanho do campo receptivo, se presente.

    Declaração

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Retorna uma função que cria um tensor inicializando todos os seus valores aleatoriamente a partir de uma distribuição Normal truncada. Os valores gerados seguem uma distribuição normal com média mean e desvio padrã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 a forma [..., M, N] . A saída é um tensor com forma [...] .

    Condição prévia

    matrix deve ser um tensor com a forma [..., M, N] .

    Declaração

    @differentiable(wrt: matrix)
    public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    Parâmetros

    matrix

    Um tensor de forma [..., M, N] .

  • Retorna a decomposição de Cholesky de uma ou mais matrizes quadradas.

    A entrada é um tensor de forma [..., M, M] , cuja maior parte dos 2-dimensões interior formar matrizes quadradas.

    A entrada deve ser simétrica e definida positivamente. Apenas a parte triangular inferior da entrada será usada para esta operação. A parte triangular superior não será lida.

    A saída é um tensor da mesma forma que a entrada contendo as decomposições Cholesky para todas as submatrizes de entrada [..., :, :] .

    Declaração

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

    Parâmetros

    input

    Um tensor de forma [..., M, M] .

  • Retorna a solução x para o sistema de equações lineares representado 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 entrada triangular coeficiente de matriz, representando A em Ax = b .

    rhs

    Valores 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 , resolver com o adjunto da matrix em vez de matrix . O valor padrão é false .

    Valor de retorno

    A solução de 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 à saída correta.

    reduction

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

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

    reduction

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

  • Calcula a média da diferença absoluta entre rótulos e previsões. loss = mean(abs(expected - predicted))

    Declaração

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Calcula a média dos quadrados dos erros entre rótulos e previsões. loss = mean(square(expected - predicted))

    Declaração

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanSquaredError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    Parâmetros

    predicted

    Saídas previstas de uma rede neural.

    expected

    Valores esperados, ou seja, metas, que correspondem à saída correta.

  • Calcula o erro logarítmica quadrado médio entre predicted e expected loss = square(log(expected) - log(predicted))

    Observação

    Entradas tensor negativos será fixada em 0 a evitar comportamentos logarítmica indefinido, como 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 médio absoluto percentual 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 charneira entre predicted e expected . loss = reduction(max(0, 1 - predicted * expected)) expected valores deverão 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 dobradiça quadrados entre predicted e expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected valores deverão 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

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

  • Calcula a perda 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) , em que 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 o previsto e esperado que 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 Kullback-Leibler perda de divergência 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 à saída correta.

    reduction

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

  • Calcula a entropia cruzada softmax esparsa (entropia cruzada categórica) entre logits e rótulos. Use esta função de perda de entrecropia cruzada quando houver duas ou mais classes de rótulo. Esperamos que os rótulos sejam fornecidos como inteiros. Deve haver # classes valores de ponto por recurso flutuante 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 rótulos a serem fornecidos fornecido em um one_hot representação. Deve haver # classes Valores de ponto flutuante por função.

    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

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

  • Calcula a perda Huber entre predicted e expected .

    Para cada valor de x em error = expected - predicted :

    • 0.5 * x^2 se |x| <= δ .
    • 0.5 * δ^2 + δ * (|x| - δ) de outra forma.

    • Fonte: 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-wise.

    Declaração

    @differentiable
    public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Devoluções log(1 - exp(x)) usando uma abordagem numericamente estável.

    Observação

    A abordagem é mostrada na Equação 7 de: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

    Declaração

    @differentiable
    public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o seno do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o cosseno do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a tangente do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o seno hiperbólico do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o cosseno hiperbólico do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a tangente hiperbólica do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o cosseno inverso do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o seno inverso do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a tangente inversa do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o cosseno hiperbólico inverso do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o seno hiperbólico inverso do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a tangente hiperbólica inversa do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a raiz quadrada do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a raiz quadrada inversa do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o exponencial do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna dois elevados à potência do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna dez elevado à potência do tensor especificado em termos de elemento.

    Declaração

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

    Declaração

    @differentiable
    public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna os valores do tensor especificado, arredondados para o inteiro mais próximo, elemento a elemento.

    Declaração

    @differentiable
    public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o teto do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o piso do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna uma indicação do sinal do tensor especificado em termos de elemento. Especificamente, calcula y = sign(x) = -1 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 log(exp(features) + 1) .

    Declaração

    @differentiable
    public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o softsign do tensor especificado em termos de elemento. Especificamente, calcula features/ (abs(features) + 1) .

    Declaração

    @differentiable
    public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o softmax do tensor especificado ao longo do último eixo. Especificamente, calcula exp(x) / exp(x).sum(alongAxes: -1) .

    Declaração

    @differentiable
    public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o softmax do tensor especificado ao longo do eixo especificado. Especificamente, calcula exp(x) / exp(x).sum(alongAxes: axis) .

    Declaração

    @differentiable
    public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o log-softmax do tensor especificado em termos de elemento.

    Declaração

    @differentiable
    public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor aplicando uma unidade linear exponencial. Especificamente, calcula exp(x) - 1 , se <0, x em contrário. Veja Rápido e Preciso profunda Learning Network por Exponencial unidades lineares (Elus)

    Declaração

    @differentiable
    public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna as ativações da Unidade Linear de Erro Gaussiano (GELU) do tensor especificado em termos de elemento.

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

    Veja Gaussian erro unidades lineares .

    Declaração

    @differentiable
    public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor aplicando a função de ativação ReLU ao tensor especificado em termos de elemento. Especificamente, calcula max(0, x) .

    Declaração

    @differentiable
    public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor, aplicando a função de activação ReLU6, nomeadamente min(max(0, x), 6) .

    Declaração

    @differentiable
    public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor aplicando a função de ativação ReLU com vazamento ao tensor especificado em termos de elemento. Especificamente, calcula max(x, x * alpha) .

    Declaração

    @differentiable(wrt: x)
    public func leakyRelu<T: TensorFlowFloatingPoint>(
      _ x: Tensor<T>,
      alpha: Double = 0.2
    ) -> Tensor<T>
  • Retorna um tensor, aplicando a função de activação selu, nomeadamente scale * alpha * (exp(x) - 1) se x < 0 , e scale * x em contrário.

    Observação

    Isso é projetado para ser usado junto com os inicializadores de camada de escala de variação. Por favor, consulte Auto-Normalizing Neural Networks para mais informações.

    Declaração

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor, aplicando a função de activação abanada, ou seja, x * sigmoid(x) .

    Fonte: (. Ramachandran et al 2017) “Procura funções de activação” https://arxiv.org/abs/1710.05941

    Declaração

    @differentiable
    public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor, aplicando a função de activação sigmóide duro, nomeadamente Relu6(x+3)/6 .

    Fonte: “Procurando MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244

    Declaração

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor, aplicando a função de activação abanada duro, ou seja, x * Relu6(x+3)/6 .

    Fonte: “Procurando MobileNetV3” (. Howard et al 2019) https://arxiv.org/abs/1905.02244

    Declaração

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna um tensor, aplicando a função de activação mish_nfs, ou seja, x * tanh(softplus(x)) .

    Fonte: “Mish: Função A Self regularizada não monótono Neural Activation” https://arxiv.org/abs/1908.08681

    Declaração

    @differentiable
    public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a potência do primeiro tensor para o segundo tensor.

    Declaração

    @differentiable
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a potência do escalar para o tensor, transmitindo o escalar.

    Declaração

    @differentiable(wrt: rhs)
    public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a potência do tensor para o escalar, transmitindo o escalar.

    Declaração

    @differentiable(wrt: lhs)
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a potência do tensor para o escalar, transmitindo o escalar.

    Declaração

    @differentiable
    public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna o elemento-wise n º raiz do tensor.

    Declaração

    @differentiable
    public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Retorna a diferença de quadrados entre x 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 suportes transmitindo.

    Declaração

    @differentiable
    public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Retorna o máximo elemento a elemento do escalar e do tensor, transmitindo o escalar.

    Declaração

    @differentiable(wrt: rhs)
    public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Retorna o máximo elemento a elemento do escalar e do tensor, transmitindo o escalar.

    Declaração

    @differentiable(wrt: lhs)
    public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Retorna o mínimo elemento a elemento de dois tensores.

    Observação

    min suporta radiodifusão.

    Declaração

    @differentiable
    public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Retorna o mínimo elemento a elemento do escalar e do tensor, transmitindo o escalar.

    Declaração

    @differentiable(wrt: rhs)
    public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Retorna o mínimo elemento a elemento do escalar e do tensor, transmitindo o escalar.

    Declaração

    @differentiable(wrt: lhs)
    public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Retorna a similaridade do cosseno entre x 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 . Distância cosseno é definido 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 posto 3 .

    Condição prévia

    filter deve ter posto 3.

    Declaração

    @differentiable(wrt: (input, filter)
    public func conv1D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      stride: Int = 1,
      padding: Padding = .valid,
      dilation: Int = 1
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filter

    O filtro de convolução.

    stride

    O passo do filtro deslizante.

    padding

    O preenchimento para a operação.

    dilation

    O fator de dilatação.

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

    Condição prévia

    input deve ter posto 4 .

    Condição prévia

    filter deve ter posto 4.

    Declaração

    @differentiable(wrt: (input, filter)
    public func conv2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
      padding: Padding = .valid,
      dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filter

    O filtro de convolução.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação

    dilations

    O fator de dilatação para cada dimensão da entrada.

  • Retorna uma convolução transposta 2-D com a entrada, filtro, passos e preenchimento especificados.

    Condição prévia

    input deve ter posto 4 .

    Condição prévia

    filter deve ter posto 4.

    Declaração

    @differentiable(wrt: (input, filter)
    public func transposedConv2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      shape: [Int64],
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
      padding: Padding = .valid,
      dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    shape

    A forma de saída da operação de deconvolução.

    filter

    O filtro de convolução.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação

    dilations

    O fator de dilatação para cada dimensão da entrada.

  • Retorna uma convolução 3-D com a entrada, filtro, passos, preenchimento e dilatações especificados.

    Condição prévia

    input deve ter posto 5 .

    Condição prévia

    filter deve ter posto 5.

    Declaração

    @differentiable(wrt: (input, filter)
    public func conv3D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1),
      padding: Padding = .valid,
      dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1)
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filter

    O filtro de convolução.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

    dilations

    O fator de dilatação para cada dimensão da entrada.

  • Retorna uma convolução de profundidade 2-D com a entrada, filtro, passos e preenchimento especificados.

    Condição prévia

    input deve ter posto 4.

    Condição prévia

    filter deve ter posto 4.

    Declaração

    @differentiable(wrt: (input, filter)
    public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filter

    O filtro de convolução em profundidade.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pooling máximo 2-D, com os tamanhos de filtro, passos e preenchimento especificados.

    Declaração

    @differentiable(wrt: input)
    public func maxPool2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int),
      strides: (Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filterSize

    As dimensões do kernel do pool.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pooling máximo 3-D, com os tamanhos de filtro, passos e preenchimento especificados.

    Declaração

    @differentiable(wrt: input)
    public func maxPool3D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int, Int),
      strides: (Int, Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filterSize

    As dimensões do kernel do pool.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pooling médio 2-D, com os tamanhos de filtro, passos e preenchimento especificados.

    Declaração

    @differentiable(wrt: input)
    public func avgPool2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int),
      strides: (Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filterSize

    As dimensões do kernel do pool.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

  • Retorna um pooling médio 3-D, com os tamanhos de filtro, passos e preenchimento especificados.

    Declaração

    @differentiable(wrt: input)
    public func avgPool3D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filterSize: (Int, Int, Int, Int, Int),
      strides: (Int, Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A entrada.

    filterSize

    As dimensões do kernel do pool.

    strides

    As passadas do filtro deslizante para cada dimensão da entrada.

    padding

    O preenchimento para a operação.

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

    Nota: fractionalMaxPool não tem uma implementação XLA, e, portanto, pode ter implicações de desempenho.

    Declaração

    @differentiable(wrt: input)
    public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      poolingRatio: (Double, Double, Double, Double),
      pseudoRandom: Bool = false,
      overlapping: Bool = false,
      deterministic: Bool = false,
      seed: Int64 = 0,
      seed2: Int64 = 0
    ) -> Tensor<Scalar>

    Parâmetros

    input

    A Tensor. 4-D com a forma [batch, height, width, channels] .

    poolingRatio

    Uma lista de Doubles . Pooling proporção para cada dimensão de input , actualmente apenas suporta dimensão da linha e col e deve ser> = 1,0.

    pseudoRandom

    Um opcional Bool . O padrão é false . Quando ajustado para true , gera a sequência de pooling de uma forma pseudo-aleatória, de outro modo, de uma forma aleatória.

    overlapping

    Um opcional Bool . O padrão é false . Quando ajustado para true , isto significa que quando o agrupamento, os valores do limite de células de agrupamento adjacentes são usados por ambas as células.

    deterministic

    Um opcional Bool . Quando ajustado para true , uma região de agrupamento fixo irá ser utilizado quando a iteração através de um nó fractionalMaxPool2D no gráfico de computação.

    seed

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

    seed2

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

  • Devolve uma cópia da input , onde os valores da dimensão de profundidade são movidos em blocos espaciais para a altura e largura.

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

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

    Esta saída funcionamento vontade um tensor de forma [1, 1, 1, 4] :

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

    Aqui, a entrada tem um lote de 1 e cada elemento lote tem a forma [2, 2, 1] , a saída correspondente terá um único elemento (ou seja, largura e altura são ambos 1) e terá uma profundidade de 4 canais (1 * block_size * block_size). A forma elemento de saída é [1, 1, 4] .

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

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

    Esta operação, por block_size de 2, voltará a seguinte tensor de forma [1, 1, 1, 12]

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

    Da mesma forma, para o seguinte de entrada de forma [1 4 4 1] , e um tamanho de bloco de 2:

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

    o operador irá devolver o seguinte tensor de forma [1 2 2 4] :

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

    Condição prévia

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

    Condição prévia

    O número de recursos deve ser divisível por quadrado de b .

    Declaração

    @differentiable(wrt: input)
    public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Devolve uma cópia da input , onde os valores da altura e largura dimensões são movidos para a dimensão de profundidade.

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

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

    Esta saída funcionamento vontade um tensor de forma [1, 1, 1, 4] :

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

    Aqui, a entrada tem um lote de 1 e cada elemento lote tem a forma [2, 2, 1] , a saída correspondente terá um único elemento (ou seja, largura e altura são ambos 1) e terá uma profundidade de 4 canais (1 * block_size * block_size). A forma elemento de saída é [1, 1, 4] .

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

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

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

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

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

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

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

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

    Precondition

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

    Precondition

    The height of the input must be divisible 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]