Partecipa al simposio Women in ML il 7 dicembre Registrati ora

Funzioni

Le seguenti funzioni sono disponibili globalmente.

  • Restituisce la perdita L1 tra previsioni e aspettative.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce la perdita L2 tra previsioni e aspettative.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce la perdita di cerniera tra previsioni e aspettative.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce la perdita di cerniera quadrata tra previsioni e aspettative.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce la perdita di cerniera categoriale tra previsioni e aspettative.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce il logaritmo del coseno iperbolico dell'errore tra previsioni e aspettative.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce la perdita di Poisson tra previsioni e aspettative.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce la divergenza Kullback-Leibler (divergenza KL) tra aspettative e previsioni. Dati due distribuzioni p e q , KL divergenza calcola p * log(p / q) .

    Dichiarazione

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

    Parametri

    predicted

    Output previsti da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Restituisce l'entropia incrociata softmax (entropia incrociata categoriale) tra logit ed etichette.

    Dichiarazione

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

    Parametri

    logits

    Output codificati a caldo da una rete neurale.

    labels

    Indici (a zero indici) delle uscite corrette.

  • Restituisce l'entropia incrociata sigmoide (entropia incrociata binaria) tra logit ed etichette.

    Dichiarazione

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

    Parametri

    logits

    L'output non scalato di una rete neurale.

    labels

    Valori interi che corrispondono all'output corretto.

  • Restituisce un tensore con la stessa forma e gli stessi scalari del tensore specificato.

    Dichiarazione

    @differentiable
    public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Richiama la data chiusura all'interno di un contesto che ha tutto identico al contesto corrente tranne che per la data fase di apprendimento.

    Dichiarazione

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

    Parametri

    context

    Un contesto che verrà impostato prima che la chiusura venga chiamata e ripristinata dopo il ritorno della chiusura.

    body

    Una chiusura nulla. Se la chiusura ha un valore di ritorno, tale valore viene utilizzato anche come valore di ritorno della withContext(_:_:) funzione.

    Valore di ritorno

    Il valore di ritorno, se del caso, il body di chiusura.

  • Richiama la data chiusura all'interno di un contesto che ha tutto identico al contesto corrente tranne che per la data fase di apprendimento.

    Dichiarazione

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

    Parametri

    learningPhase

    Una fase di apprendimento che verrà impostata prima che la chiusura venga chiamata e ripristinata al ritorno della chiusura.

    body

    Una chiusura nulla. Se la chiusura ha un valore di ritorno, tale valore viene utilizzato anche come valore di ritorno della withLearningPhase(_:_:) funzione.

    Valore di ritorno

    Il valore di ritorno, se del caso, il body di chiusura.

  • Chiama la chiusura data all'interno di un contesto che ha tutto identico al contesto corrente tranne che per il seme casuale dato.

    Dichiarazione

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

    Parametri

    randomSeed

    Un seme casuale che verrà impostato prima che la chiusura venga chiamata e ripristinata dopo il ritorno della chiusura.

    body

    Una chiusura nulla. Se la chiusura ha un valore di ritorno, tale valore viene utilizzato anche come valore di ritorno della withRandomSeedForTensorFlow(_:_:) funzione.

    Valore di ritorno

    Il valore di ritorno, se del caso, il body di chiusura.

  • Chiama la chiusura data all'interno di un contesto che ha tutto identico al contesto corrente tranne per il dato generatore di numeri casuali.

    Dichiarazione

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

    Parametri

    randomNumberGenerator

    Un generatore di numeri casuali che verrà impostato prima che la chiusura venga chiamata e ripristinata dopo il ritorno della chiusura.

    body

    Una chiusura nulla. Se la chiusura ha un valore di ritorno, tale valore viene utilizzato anche come valore di ritorno della withRandomNumberGeneratorForTensorFlow(_:_:) funzione.

    Valore di ritorno

    Il valore di ritorno, se del caso, il body di chiusura.

  • Dichiarazione

    public func zip<T: TensorGroup, U: TensorGroup>(
      _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
    ) -> Dataset<Zip2TensorGroup<T, U>>
  • LazyTensorBarrier garantisce che tutti i tensori attivi (sul dispositivo se forniti) siano programmati e in esecuzione. Se wait è impostato su true, questa chiamata si blocca fino al completamento del calcolo.

    Dichiarazione

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

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

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

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

    public func valueWithGradient<T, R>(
      of f: @escaping @differentiable (T) -> Tensor<R>
    ) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
    where T: Differentiable, R: TensorFlowFloatingPoint
  • Dichiarazione

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

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

    public func gradient<T, R>(
      at x: T,
      in f: @differentiable (T) -> Tensor<R>
    ) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
  • Dichiarazione

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

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

    public func gradient<T, R>(
      of f: @escaping @differentiable (T) -> Tensor<R>
    ) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
  • Dichiarazione

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

    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
  • Fare in modo che una funzione venga ricalcolata nel suo pullback, noto come "checkpoint" nella differenziazione automatica tradizionale.

    Dichiarazione

    public func withRecomputationInPullbacks<T, U>(
      _ body: @escaping @differentiable (T) -> U
    ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable
  • Creare una funzione differenziabile da una funzione di prodotti vettoriale-Jacobian.

    Dichiarazione

    public func differentiableFunction<T : Differentiable, R : Differentiable>(
      from vjp: @escaping (T)
               -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
    ) -> @differentiable (T) -> R
  • Creare una funzione differenziabile da una funzione di prodotti vettoriale-Jacobian.

    Dichiarazione

    public func differentiableFunction<T, U, R>(
      from vjp: @escaping (T, U)
               -> (value: R, pullback: (R.TangentVector)
                 -> (T.TangentVector, U.TangentVector))
    ) -> @differentiable (T, U) -> R
  • Restituisce x come una funzione identità. Quando utilizzato in un contesto dove x viene differenziato rispetto a questa funzione non produrrà alcun derivata in x .

    Dichiarazione

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T>(at x: T) -> T
  • Si applica la data di chiusura body a x . Quando utilizzato in un contesto dove x viene differenziato rispetto a questa funzione non produrrà alcun derivata in x .

    Dichiarazione

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R
  • Esegue una chiusura, facendo eseguire le operazioni di TensorFlow su un tipo specifico di dispositivo.

    Dichiarazione

    public func withDevice<R>(
      _ kind: DeviceKind,
      _ index: UInt = 0,
      perform body: () throws -> R
    ) rethrows -> R

    Parametri

    kind

    Una sorta di dispositivo su cui eseguire operazioni TensorFlow.

    index

    Il dispositivo su cui eseguire le operazioni.

    body

    Una chiusura le cui operazioni TensorFlow devono essere eseguite sul tipo di dispositivo specificato.

  • Esegue una chiusura, facendo eseguire le operazioni TensorFlow su un dispositivo con un nome specifico.

    Alcuni esempi di nomi di dispositivi:

    • “/device:CPU:0”: La CPU della tua macchina.
    • "/GPU:0": notazione abbreviata per la prima GPU della macchina visibile a TensorFlow
    • "/job:localhost/replica:0/task:0/device:GPU:1": nome completo della seconda GPU della macchina visibile a TensorFlow.

    Dichiarazione

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

    Parametri

    name

    Nome del dispositivo.

    body

    Una chiusura le cui operazioni TensorFlow devono essere eseguite sul tipo di dispositivo specificato.

  • Esegue una chiusura, consentendo a TensorFlow di posizionare le operazioni TensorFlow su qualsiasi dispositivo. Questo dovrebbe ripristinare il comportamento di posizionamento predefinito.

    Dichiarazione

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

    Parametri

    body

    Una chiusura le cui operazioni TensorFlow devono essere eseguite sul tipo di dispositivo specificato.

  • Ridimensiona le immagini alle dimensioni utilizzando il metodo specificato.

    Prerequisito

    Le immagini devono avere rango 3 o 4 .

    Precondizione

    La dimensione deve essere positiva.

    Dichiarazione

    @differentiable(wrt: images)
    public func resize(
      images: Tensor<Float>,
      size: (newHeight: Int, newWidth: Int),
      method: ResizeMethod = .bilinear,
      antialias: Bool = false
    ) -> Tensor<Float>

    Parametri

    images

    4-D Tensor di forma [batch, height, width, channels] oppure 3-D Tensor di forma [height, width, channels] .

    size

    La nuova dimensione delle immagini.

    method

    Il metodo di ridimensionamento. Il valore di default è .bilinear .

    antialias

    Iff true , utilizzare un filtro anti-aliasing quando downsampling di un'immagine.

  • Ridimensiona le immagini alle dimensioni utilizzando l'interpolazione dell'area.

    Prerequisito

    Le immagini devono avere rango 3 o 4 .

    Prerequisito

    La dimensione deve essere positiva.

    Dichiarazione

    public func resizeArea<Scalar: TensorFlowNumeric>(
      images: Tensor<Scalar>,
      size: (newHeight: Int, newWidth: Int),
      alignCorners: Bool = false
    ) -> Tensor<Float>

    Parametri

    images

    4-D Tensor di forma [batch, height, width, channels] oppure 3-D Tensor di forma [height, width, channels] .

    size

    La nuova dimensione delle immagini.

  • Restituisce una dilatazione 2D con l'input, il filtro, i passi e il riempimento specificati.

    Prerequisito

    input deve avere rango 4 .

    Precondizione

    filter deve avere rango 3 .

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filter

    Il filtro di dilatazione.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione

    rates

    I tassi di dilatazione per ciascuna dimensione dell'input.

  • Restituisce un'erosione 2D con l'input, il filtro, i passi e il riempimento specificati.

    Prerequisito

    input deve avere rango 4 .

    Prerequisito

    filter deve avere rango 3.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filter

    Il filtro contro l'erosione.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione

    rates

    I tassi di dilatazione per ciascuna dimensione dell'input.

  • Restituisce una funzione che crea un tensore inizializzando tutti i suoi valori a zero.

    Dichiarazione

    public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
  • Restituisce una funzione che crea un tensore inizializzando tutti i suoi valori sul valore fornito.

    Dichiarazione

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Scalar
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore inizializzandolo al valore fornito. Si noti che la trasmissione del valore fornito non è supportato.

    Dichiarazione

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Tensor<Scalar>
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore eseguendo Glorot (Xavier) inizializzazione uniforme per la forma specificata, casualmente campionamento valori scalari da una distribuzione uniforme tra -limit e limit , generato dal generatore di numeri casuali predefinita, dove il limite è sqrt(6 / (fanIn + fanOut)) , e fanIn / fanOut rappresentano il numero di input e output caratteristiche moltiplicati per il campo recettivo, se presente.

    Dichiarazione

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore eseguendo Glorot (Xavier) inizializzazione normale per la forma specificata, casualmente campionamento valori scalari da una distribuzione normale troncato centrate su 0 con deviazione standard sqrt(2 / (fanIn + fanOut)) , dove fanIn / fanOut rappresentano il numero di caratteristiche di input e output moltiplicato per la dimensione del campo recettivo, se presente.

    Dichiarazione

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore eseguendo He (Kaiming) inizializzazione uniforme per la forma specificata, casualmente campionamento valori scalari da una distribuzione uniforme tra -limit e limit , generato dal generatore di numeri casuali predefinita, dove il limite è sqrt(6 / fanIn) , e fanIn rappresenta il numero di funzioni di input moltiplicato per il campo recettivo, se presente.

    Dichiarazione

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore eseguendo He (Kaiming) inizializzazione normale per la forma specificata, casualmente campionamento valori scalari da una distribuzione normale troncato centrate su 0 con deviazione standard sqrt(2 / fanIn) , dove fanIn rappresenta il numero di funzioni di input moltiplicato per la dimensione del campo recettivo, se presente.

    Dichiarazione

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore eseguendo LeCun inizializzazione uniforme per la forma specificata, casualmente campionamento valori scalari da una distribuzione uniforme tra -limit e limit , generato dal generatore di numeri casuali predefinita, dove il limite è sqrt(3 / fanIn) , e fanIn rappresenta il numero di funzioni di input moltiplicato per il campo recettivo, se presente.

    Dichiarazione

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore eseguendo LeCun inizializzazione normale per la forma specificata, casualmente campionamento valori scalari da una distribuzione normale troncato centrate su 0 con deviazione standard sqrt(1 / fanIn) , dove fanIn rappresenta il numero di ingressi caratteristiche moltiplicato per il dimensione del campo recettivo, se presente.

    Dichiarazione

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Restituisce una funzione che crea un tensore inizializzando tutti i suoi valori in modo casuale da una distribuzione Normale troncata. I valori generati seguono una distribuzione normale con media mean e deviazione standard standardDeviation , tranne che valori la cui ampiezza è superiore a due deviazioni standard dalla media vengono scartati e ricampionate.

    Dichiarazione

    public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>(
      mean: Tensor<Scalar> = Tensor<Scalar>(0),
      standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1),
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>

    Parametri

    mean

    Media della distribuzione normale.

    standardDeviation

    Deviazione standard della distribuzione normale.

    Valore di ritorno

    Una funzione di inizializzazione del parametro normale troncata.

  • Dichiarazione

    public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
  • Restituisce una matrice identità o un batch di matrici.

    Dichiarazione

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

    Parametri

    rowCount

    Il numero di righe in ogni matrice batch.

    columnCount

    Il numero di colonne in ogni matrice batch.

    batchShape

    Le dimensioni batch principali del tensore restituito.

  • Calcola la traccia di una matrice in batch facoltativa. La traccia è la somma lungo la diagonale principale di ciascuna matrice più interna.

    L'ingresso è un tensore di forma [..., M, N] . L'uscita è un tensore di forma [...] .

    Prerequisito

    matrix deve essere un tensore di forma [..., M, N] .

    Dichiarazione

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

    Parametri

    matrix

    Un tensore di forma [..., M, N] .

  • Restituisce la scomposizione di Cholesky di una o più matrici quadrate.

    L'ingresso è un tensore di forma [..., M, M] le cui dimensioni 2-più interna formare matrici quadrate.

    L'input deve essere simmetrico e definito positivo. Per questa operazione verrà utilizzata solo la parte triangolare inferiore dell'ingresso. La parte triangolare superiore non verrà letta.

    L'uscita è un tensore della stessa forma come ingresso contenente decomposizioni Cholesky per tutte le sottomatrici di ingresso [..., :, :] .

    Dichiarazione

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

    Parametri

    input

    Un tensore di forma [..., M, M] .

  • Restituisce le soluzione x del sistema di equazioni lineari rappresentati da Ax = b .

    Prerequisito

    matrix deve essere un tensore di forma [..., M, M] .

    Prerequisito

    rhs deve essere un tensore di forma [..., M, K] .

    Dichiarazione

    @differentiable
    public func triangularSolve<T: TensorFlowFloatingPoint>(
      matrix: Tensor<T>,
      rhs: Tensor<T>,
      lower: Bool = true,
      adjoint: Bool = false
    ) -> Tensor<T>

    Parametri

    matrix

    L'ingresso triangolare coefficiente matrice, rappresentando A in Ax = b .

    rhs

    I valori a destra, che rappresenta b in Ax = b .

    lower

    Sia matrix è triangolare inferiore ( true ) oppure triangolare superiore ( false ). Il valore predefinito è true .

    adjoint

    Se true , risolvere con l'aggiunto di matrix invece di matrix . Il valore predefinito è false .

    Valore di ritorno

    La soluzione x del sistema di equazioni lineari rappresentato da Ax = b . x ha la stessa forma b .

  • Calcola la perdita L1 tra il expected e predicted . loss = reduction(abs(expected - predicted))

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita L2 tra il expected e predicted . loss = reduction(square(expected - predicted))

    Dichiarazione

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

    Parametri

    predicted

    Output previsti da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la media della differenza assoluta tra etichette e previsioni. loss = mean(abs(expected - predicted))

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Calcola la media dei quadrati degli errori tra etichette e previsioni. loss = mean(square(expected - predicted))

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Calcola l'errore logaritmica quadrato medio fra predicted e expected loss = square(log(expected) - log(predicted))

    Nota

    Voci tensoriali negativi saranno fissati a 0 per evitare comportamenti logaritmico indefinito, come log(_:) non è definito per reali negativi.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Calcola la media errore percentuale assoluta tra predicted e expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

  • Calcola la perdita cerniera tra predicted e expected . loss = reduction(max(0, 1 - predicted * expected)) expected valori dovrebbero essere -1 o 1.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita cerniera quadrato tra predicted e expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected valori dovrebbero essere -1 o 1.

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita di cerniera categorica tra il predicted e expected . loss = maximum(negative - positive + 1, 0) dove negative = max((1 - expected) * predicted) e positive = sum(predicted * expected)

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola il logaritmo del coseno iperbolico dell'errore di previsione. logcosh = log((exp(x) + exp(-x))/2) , dove è x l'errore predicted - expected

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita di Poisson tra il previsto e atteso La perdita di Poisson è la media degli elementi della Tensor predicted - expected * log(predicted) .

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Perdita di divergenza Calcola Kullback-Leibler tra il expected e predicted . loss = reduction(expected * log(expected / predicted))

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola l'entropia incrociata sparsa softmax (entropia incrociata categoriale) tra logit ed etichette. Utilizzare questa funzione di perdita dell'entropia incrociata quando sono presenti due o più classi di etichette. Ci aspettiamo che le etichette vengano fornite come numeri interi. Ci dovrebbe essere # classes valori in virgola mobile per funzionalità per logits e un singolo valore in virgola mobile per funzionalità per expected .

    Dichiarazione

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

    Parametri

    logits

    Output codificati a caldo da una rete neurale.

    labels

    Indici (a zero indici) delle uscite corrette.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola l'entropia incrociata sparsa softmax (entropia incrociata categoriale) tra logit ed etichette. Utilizzare questa funzione di perdita dell'entropia incrociata quando sono presenti due o più classi di etichette. Ci aspettiamo che le etichette che devono essere forniti forniti in un one_hot di rappresentanza. Ci dovrebbe essere # classes valori in virgola mobile per ogni funzione.

    Dichiarazione

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

    Parametri

    logits

    Probabilità di log non scalate da una rete neurale.

    probabilities

    Valori di probabilità che corrispondono all'output corretto. Ogni riga deve essere una distribuzione di probabilità valida.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola l'entropia della croce sigmoide (entropia della croce binaria) tra logit ed etichette. Utilizzare questa perdita di entropia incrociata quando sono presenti solo due classi di etichette (si presume che siano 0 e 1). Per ogni esempio, dovrebbe esserci un singolo valore a virgola mobile per previsione.

    Dichiarazione

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

    Parametri

    logits

    L'output non scalato di una rete neurale.

    labels

    Valori interi che corrispondono all'output corretto.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita Huber tra il predicted e expected .

    Per ogni valore x in error = expected - predicted :

    Dichiarazione

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

    Parametri

    predicted

    Uscite previste da una rete neurale.

    expected

    Valori previsti, ovvero obiettivi, che corrispondono all'output corretto.

    delta

    Uno scalare in virgola mobile che rappresenta il punto in cui la funzione di perdita di Huber cambia da quadratica a lineare.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Restituisce il valore assoluto del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
  • Restituisce il logaritmo naturale del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il logaritmo in base due del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il logaritmo in base dieci del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il logaritmo di 1 + x elemento-saggio.

    Dichiarazione

    @differentiable
    public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce log(1 - exp(x)) utilizzando un approccio numericamente stabile.

    Nota

    L'approccio è mostrato nell'Equazione 7: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

    Dichiarazione

    @differentiable
    public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il seno del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il coseno del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la tangente del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il seno iperbolico del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il coseno iperbolico del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la tangente iperbolica del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il coseno inverso del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il seno inverso del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la tangente inversa del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il coseno iperbolico inverso del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il seno iperbolico inverso del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la tangente iperbolica inversa del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la radice quadrata del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la radice quadrata inversa del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce l'esponenziale del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce due elevato alla potenza del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce dieci elevato alla potenza del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce l'esponenziale di x - 1 elemento-saggio.

    Dichiarazione

    @differentiable
    public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce i valori del tensore specificato arrotondati all'intero più vicino, per elemento.

    Dichiarazione

    @differentiable
    public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il limite massimo del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il floor del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un'indicazione del segno del tensore specificato per elemento. Specificamente, calcola y = sign(x) = -1 se x < 0 ; 0 se x == 0 ; 1 se x > 0 .

    Dichiarazione

    @differentiable
    public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
  • Restituisce il sigmoide del tensore specificato per elemento. Specificamente, calcola 1 / (1 + exp(-x)) .

    Dichiarazione

    @differentiable
    public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il log-sigmoid del tensore specificato per elemento. In particolare, log(1 / (1 + exp(-x))) . Per la stabilità numerica, usiamo -softplus(-x) .

    Dichiarazione

    @differentiable
    public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il softplus del tensore specificato per elemento. Specificamente, calcola log(exp(features) + 1) .

    Dichiarazione

    @differentiable
    public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il softsign del tensore specificato per elemento. Specificamente, calcola features/ (abs(features) + 1) .

    Dichiarazione

    @differentiable
    public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il softmax del tensore specificato lungo l'ultimo asse. Specificamente, calcola exp(x) / exp(x).sum(alongAxes: -1) .

    Dichiarazione

    @differentiable
    public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il softmax del tensore specificato lungo l'asse specificato. Specificamente, calcola exp(x) / exp(x).sum(alongAxes: axis) .

    Dichiarazione

    @differentiable
    public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il log-softmax del tensore specificato per elemento.

    Dichiarazione

    @differentiable
    public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando un'unità lineare esponenziale. Specificamente, calcola exp(x) - 1 se <0, x altrimenti. Vedere veloce e preciso profonda Learning Network da esponenziale Unità lineari (ELUS)

    Dichiarazione

    @differentiable
    public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce le attivazioni dell'unità lineare di errore gaussiano (GELU) del tensore specificato per elemento.

    Specificamente, gelu approssima xP(X <= x) , dove P(X <= x) è la distribuzione cumulativa standard gaussiana, calcolando: x * [0,5 * (1 + tanh [√ (2 / π) * (x + 0,044715 * x^3)])].

    Vedere Errore gaussiana unità lineari .

    Dichiarazione

    @differentiable
    public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando la funzione di attivazione ReLU al tensore specificato per elemento. Specificamente, calcola max(0, x) .

    Dichiarazione

    @differentiable
    public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando la funzione di attivazione ReLU6, cioè min(max(0, x), 6) .

    Dichiarazione

    @differentiable
    public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando la funzione di attivazione ReLU che perde al tensore specificato per elemento. Specificamente, calcola max(x, x * alpha) .

    Dichiarazione

    @differentiable(wrt: x)
    public func leakyRelu<T: TensorFlowFloatingPoint>(
      _ x: Tensor<T>,
      alpha: Double = 0.2
    ) -> Tensor<T>
  • Restituisce un tensore applicando la funzione di attivazione Selu, cioè scale * alpha * (exp(x) - 1) se x < 0 e scale * x altrimenti.

    Nota

    Questo è progettato per essere utilizzato insieme agli inizializzatori del livello di ridimensionamento della varianza. Si prega di fare riferimento alla Self-normalizzante Reti Neurali per ulteriori informazioni.

    Dichiarazione

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando la funzione di attivazione fruscio, cioè x * sigmoid(x) .

    Fonte: (. Ramachandran et al 2017) “Ricerca di funzioni di attivazione” https://arxiv.org/abs/1710.05941

    Dichiarazione

    @differentiable
    public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando la funzione di attivazione sigmoide duro, cioè Relu6(x+3)/6 .

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

    Dichiarazione

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando la funzione di attivazione fruscio duro, cioè x * Relu6(x+3)/6 .

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

    Dichiarazione

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce un tensore applicando la funzione di attivazione mish, cioè x * tanh(softplus(x)) .

    Fonte: “Mish: Funzione A Self regolarizzata non monotona neurale di attivazione” https://arxiv.org/abs/1908.08681

    Dichiarazione

    @differentiable
    public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la potenza del primo tensore al secondo tensore.

    Dichiarazione

    @differentiable
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la potenza dello scalare al tensore, trasmettendo lo scalare.

    Dichiarazione

    @differentiable(wrt: rhs)
    public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la potenza del tensore allo scalare, trasmettendo lo scalare.

    Dichiarazione

    @differentiable(wrt: lhs)
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce la potenza del tensore allo scalare, trasmettendo lo scalare.

    Dichiarazione

    @differentiable
    public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce l'elemento-saggio n esima radice del tensore.

    Dichiarazione

    @differentiable
    public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Restituisce il quadrato della differenza tra x ed y .

    Dichiarazione

    @differentiable
    public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    Valore di ritorno

    (x - y) ^ 2 .

  • Restituisce il massimo elemento per elemento di due tensori.

    Nota

    max supporti trasmissione.

    Dichiarazione

    @differentiable
    public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Restituisce il massimo per elemento dello scalare e del tensore, trasmettendo lo scalare.

    Dichiarazione

    @differentiable(wrt: rhs)
    public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Restituisce il massimo per elemento dello scalare e del tensore, trasmettendo lo scalare.

    Dichiarazione

    @differentiable(wrt: lhs)
    public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Restituisce il minimo elemento per elemento di due tensori.

    Nota

    min supporta la trasmissione.

    Dichiarazione

    @differentiable
    public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Restituisce il minimo per elemento dello scalare e del tensore, trasmettendo lo scalare.

    Dichiarazione

    @differentiable(wrt: rhs)
    public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Restituisce il minimo per elemento dello scalare e del tensore, trasmettendo lo scalare.

    Dichiarazione

    @differentiable(wrt: lhs)
    public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Restituisce la somiglianza coseno tra x ed y .

    Dichiarazione

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Restituisce la distanza tra coseno x ed y . Distanza coseno è definita come 1 - cosineSimilarity(x, y) .

    Dichiarazione

    @differentiable
    public func cosineDistance<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Esegue la moltiplicazione di matrici con un altro tensore e produce il risultato.

    Dichiarazione

    @differentiable
    public func matmul<Scalar: Numeric>(
      _ lhs: Tensor<Scalar>,
      transposed transposeLhs: Bool = false,
      _ rhs: Tensor<Scalar>,
      transposed transposeRhs: Bool = false
    ) -> Tensor<Scalar>
  • Restituisce una convoluzione 1D con l'input, il filtro, il passo e il riempimento specificati.

    Prerequisito

    input deve avere rango 3 .

    Prerequisito

    filter deve avere rango 3.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filter

    Il filtro di convoluzione.

    stride

    Il passo del filtro scorrevole.

    padding

    L'imbottitura per l'operazione.

    dilation

    Il fattore di dilatazione.

  • Restituisce una convoluzione 2D con l'input, il filtro, i passi e il riempimento specificati.

    Prerequisito

    input deve avere rango 4 .

    Prerequisito

    filter deve avere rango 4.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filter

    Il filtro di convoluzione.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione

    dilations

    Il fattore di dilatazione per ciascuna dimensione dell'input.

  • Restituisce una convoluzione trasposta 2D con l'input, il filtro, i passi e il riempimento specificati.

    Prerequisito

    input deve avere rango 4 .

    Prerequisito

    filter deve avere rango 4.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    shape

    La forma di output dell'operazione di deconvoluzione.

    filter

    Il filtro di convoluzione.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione

    dilations

    Il fattore di dilatazione per ciascuna dimensione dell'input.

  • Restituisce una convoluzione 3D con l'input, il filtro, i passi, il riempimento e le dilatazioni specificati.

    Prerequisito

    input deve avere rango 5 .

    Prerequisito

    filter deve avere rango 5.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filter

    Il filtro di convoluzione.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione.

    dilations

    Il fattore di dilatazione per ciascuna dimensione dell'input.

  • Restituisce una convoluzione 2D in profondità con l'input, il filtro, i passi e il riempimento specificati.

    Prerequisito

    input deve avere rango 4.

    Prerequisito

    filter deve avere rango 4.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filter

    Il filtro a convoluzione in profondità.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione.

  • Restituisce un pool di max 2D, con le dimensioni del filtro, i passi e il riempimento specificati.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filterSize

    Le dimensioni del kernel di pooling.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione.

  • Restituisce un pool 3D max, con le dimensioni del filtro, i passi e il riempimento specificati.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filterSize

    Le dimensioni del kernel di pooling.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione.

  • Restituisce un pool medio 2D, con le dimensioni del filtro, i passi e il riempimento specificati.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filterSize

    Le dimensioni del kernel di pooling.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione.

  • Restituisce un pool medio 3D, con le dimensioni del filtro, i passi e il riempimento specificati.

    Dichiarazione

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

    Parametri

    input

    L'ingresso.

    filterSize

    Le dimensioni del kernel di pooling.

    strides

    I passi del filtro scorrevole per ogni dimensione dell'input.

    padding

    L'imbottitura per l'operazione.

  • Restituisce un pool massimo frazionario 2D, con i rapporti di pool specificati.

    Nota: fractionalMaxPool non ha un'implementazione XLA, e, quindi, potrebbe avere implicazioni sulle prestazioni.

    Dichiarazione

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

    Parametri

    input

    Un tensore. 4-D di forma [batch, height, width, channels] .

    poolingRatio

    Un elenco di Doubles . Rapporto in comune, per ogni dimensione di input , attualmente supporta solo riga e col dimensione e dovrebbe essere> = 1.0.

    pseudoRandom

    Un optional Bool . Il valore predefinito è false . Quando è impostato su true , genera la sequenza di messa in comune in modo pseudocasuale, tuttavia, in modo casuale.

    overlapping

    Un optional Bool . Il valore predefinito è false . Quando è impostato su true , significa quando il pool, i valori al confine delle cellule pooling adiacenti sono utilizzati da entrambe le celle.

    deterministic

    Un opzionale Bool . Quando è impostato a true , una regione pool fisso verrà utilizzata quando iterare su un nodo fractionalMaxPool2D nel grafico calcolo.

    seed

    Un optional Int64 . Il valore predefinito è 0 . Se impostato su un valore diverso da zero, il generatore di numeri casuali viene seminato dal seme dato.

    seed2

    Un optional Int64 . Il valore predefinito è 0 . Un secondo seme per evitare la collisione del seme.

  • Restituisce una copia di input in cui i valori della dimensione della profondità vengono spostati in blocchi spaziali all'altezza e larghezza.

    Ad esempio, dato un input di forma [1, 2, 2, 1] , data_format = “NHWC” e BLOCK_SIZE = 2:

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

    Questa uscita operazione volontà un tensore di forma [1, 1, 1, 4] :

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

    Qui, l'ingresso ha un lotto di 1 e ciascun elemento lotto ha forma [2, 2, 1] , l'uscita corrispondente avrà un singolo elemento (cioè la larghezza e l'altezza sono entrambi 1) ed avrà una profondità di 4 canali (1 * block_size * block_size). La forma dell'elemento di uscita è [1, 1, 4] .

    Per un tensore di ingresso con la profondità maggiore, qui di forma [1, 2, 2, 3] , ad esempio

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

    Tale operazione, per BLOCK_SIZE di 2, restituirà il seguente tensore di forma [1, 1, 1, 12]

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

    Analogamente, per il seguente ingresso di forma [1 4 4 1] , e una dimensione di blocco di 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 .

    Dichiarazione

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

    Dichiarazione

    @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 ).

    Dichiarazione

    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.

    Dichiarazione

    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”

    Dichiarazione

    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.

    Dichiarazione

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    Dichiarazione

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    Dichiarazione

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    Dichiarazione

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    Dichiarazione

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    Dichiarazione

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

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    Dichiarazione

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

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    Dichiarazione

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