Funzioni

Le seguenti funzioni sono disponibili a livello globale.

  • 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

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

  • Restituisce la perdita di cerniera al quadrato 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

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

  • Restituisce la divergenza di Kullback-Leibler (divergenza KL) tra le aspettative e le previsioni. Date due distribuzioni p e q , la divergenza KL 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Uscite codificate a caldo da una rete neurale.

    labels

    Indici (indicizzati con zero) degli output corretti.

  • Restituisce l'entropia incrociata sigmoidea (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 scalari del tensore specificato.

    Dichiarazione 

    @differentiable
public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

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

    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 ripristinato dopo il ritorno della chiusura.

    body

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

    Valore restituito

    Il valore restituito, se presente, della chiusura del body .

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

    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 richiamata e ripristinata al ritorno della chiusura.

    body

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

    Valore restituito

    Il valore restituito, se presente, della chiusura del body .

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

    Dichiarazione 

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

    Parametri

    randomSeed

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

    body

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

    Valore restituito

    Il valore restituito, se presente, della chiusura del body .

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

    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 ripristinato dopo il ritorno della chiusura.

    body

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

    Valore restituito

    Il valore restituito, se presente, della chiusura del body .

  • 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 fornito) siano pianificati 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 tradizionale differenziazione automatica.

    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 vettoriali Jacobiani.

    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 vettoriali Jacobiani.

    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à. Se utilizzata in un contesto in cui x viene differenziato rispetto a, questa funzione non produrrà alcuna derivata in x .

    Dichiarazione 

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

  • Applica il body di chiusura specificato a x . Se utilizzata in un contesto in cui x viene differenziato rispetto a, questa funzione non produrrà alcuna 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 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 le 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 del tuo computer 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 eseguire operazioni TensorFlow su qualsiasi dispositivo. Ciò 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 utilizzando il metodo specificato.

    Precondizione

    Le immagini devono avere il 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

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

    size

    La nuova dimensione delle immagini.

    method

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

    antialias

    Se fosse true , usa un filtro anti-aliasing quando esegui il downsampling di un'immagine.

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

    Precondizione

    Le immagini devono avere il rango 3 o 4 .

    Precondizione

    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

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

    size

    La nuova dimensione delle immagini.

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

    Precondizione

    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.

    Precondizione

    input deve avere rango 4 .

    Precondizione

    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 dell'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 su 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 sul valore fornito. Tieni presente che la trasmissione del valore fornito non è supportata.

    Dichiarazione 

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

  • Restituisce una funzione che crea un tensore eseguendo l'inizializzazione uniforme di Glorot (Xavier) per la forma specificata, campionando casualmente valori scalari da una distribuzione uniforme tra -limit e limit , generata dal generatore di numeri casuali predefinito, dove limit è sqrt(6 / (fanIn + fanOut)) e fanIn / fanOut rappresentano il numero di caratteristiche di input e output moltiplicate per il campo ricettivo, se presente.

    Dichiarazione 

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

  • Restituisce una funzione che crea un tensore eseguendo l'inizializzazione normale Glorot (Xavier) per la forma specificata, campionando casualmente valori scalari da una distribuzione normale troncata centrata 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 ricettivo, se presente.

    Dichiarazione 

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

  • Restituisce una funzione che crea un tensore eseguendo l'inizializzazione uniforme He (Kaiming) per la forma specificata, campionando casualmente valori scalari da una distribuzione uniforme tra -limit e limit , generata dal generatore di numeri casuali predefinito, dove limit è sqrt(6 / fanIn) e fanIn rappresenta il numero di caratteristiche di input moltiplicato per il campo ricettivo, se presente.

    Dichiarazione 

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

  • Restituisce una funzione che crea un tensore eseguendo l'inizializzazione normale He (Kaiming) per la forma specificata, campionando casualmente valori scalari da una distribuzione normale troncata centrata su 0 con deviazione standard sqrt(2 / fanIn) , dove fanIn rappresenta il numero di caratteristiche di input moltiplicato per la dimensione del campo ricettivo, se presente.

    Dichiarazione 

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

  • Restituisce una funzione che crea un tensore eseguendo l'inizializzazione uniforme LeCun per la forma specificata, campionando casualmente valori scalari da una distribuzione uniforme tra -limit e limit , generata dal generatore di numeri casuali predefinito, dove limit è sqrt(3 / fanIn) e fanIn rappresenta il numero di caratteristiche di input moltiplicato per il campo ricettivo, se presente.

    Dichiarazione 

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

  • Restituisce una funzione che crea un tensore eseguendo l'inizializzazione normale LeCun per la forma specificata, campionando casualmente valori scalari da una distribuzione normale troncata centrata su 0 con deviazione standard sqrt(1 / fanIn) , dove fanIn rappresenta il numero di caratteristiche di input moltiplicato per dimensione del campo ricettivo, 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 , ad eccezione del fatto che i valori la cui grandezza è superiore a due deviazioni standard dalla media vengono eliminati e ricampionati.

    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 restituito

    Una funzione di inizializzazione dei parametri normali 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 ciascuna matrice batch.

    columnCount

    Il numero di colonne in ciascuna matrice batch.

    batchShape

    Le dimensioni batch principali del tensore restituito.

  • Calcola la traccia di una matrice raggruppata facoltativamente. La traccia è la somma lungo la diagonale principale di ciascuna matrice più interna.

    L'input è un tensore con forma [..., M, N] . L'output è un tensore con forma [...] .

    Precondizione

    matrix deve essere un tensore con 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'input è un tensore di forma [..., M, M] le cui 2 dimensioni più interne formano matrici quadrate.

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

    L'output è un tensore della stessa forma dell'input contenente le scomposizioni di Cholesky per tutte le sottomatrici di input [..., :, :] .

    Dichiarazione 

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

    Parametri

    input

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

  • Restituisce la soluzione x del sistema di equazioni lineari rappresentato da Ax = b .

    Precondizione

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

    Precondizione

    rhs deve essere un tensore con 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

    La matrice dei coefficienti triangolari di input, che rappresenta A in Ax = b .

    rhs

    Valori del lato destro, che rappresentano b in Ax = b .

    lower

    Indica se matrix è triangolare inferiore ( true ) o triangolare superiore ( false ). Il valore predefinito è true .

    adjoint

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

    Valore restituito

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

  • Calcola la perdita L1 tra 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

    Risultati previsti da una rete neurale.

    expected

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

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita L2 tra 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

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

  • Calcola l'errore logaritmico quadratico medio tra la perdita predicted e expected loss = square(log(expected) - log(predicted))

    Nota

    Le voci del tensore negativo verranno bloccate a 0 per evitare un comportamento logaritmico indefinito, poiché log(_:) non è definito per i 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

    Risultati previsti da una rete neurale.

    expected

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

  • Calcola l'errore percentuale medio assoluto 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

    Risultati previsti da una rete neurale.

    expected

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

  • Calcola la perdita di cerniera tra predicted e expected . loss = reduction(max(0, 1 - predicted * expected)) i valori expected 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

    Risultati previsti da una rete neurale.

    expected

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

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita di cerniera al quadrato tra predicted e expected . loss = reduction(square(max(0, 1 - predicted * expected))) i valori expected 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

    Risultati previsti da una rete neurale.

    expected

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

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita di cerniera categoriale tra 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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

    Risultati previsti da una rete neurale.

    expected

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

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita di Poisson tra previsto e atteso. La perdita di Poisson è la media degli elementi del 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

    Risultati previsti da una rete neurale.

    expected

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

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola la perdita di divergenza di Kullback-Leibler tra 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

    Risultati previsti da una rete neurale.

    expected

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

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola l'entropia incrociata softmax sparsa (entropia incrociata categoriale) tra logit ed etichette. Utilizzare questa funzione di perdita di entropia incrociata quando sono presenti due o più classi di etichette. Ci aspettiamo che le etichette vengano fornite come numeri interi. Dovrebbero esserci # classes valori in virgola mobile per caratteristica per logits e un singolo valore in virgola mobile per caratteristica 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

    Uscite codificate a caldo da una rete neurale.

    labels

    Indici (indicizzati con zero) degli output corretti.

    reduction

    Riduzione da applicare sui valori di perdita calcolati per elemento.

  • Calcola l'entropia incrociata softmax sparsa (entropia incrociata categoriale) tra logit ed etichette. Utilizzare questa funzione di perdita di entropia incrociata quando sono presenti due o più classi di etichette. Ci aspettiamo che le etichette vengano fornite in una rappresentazione one_hot . Dovrebbero esserci # classes per 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 incrociata sigmoidea (entropia incrociata binaria) tra logit ed etichette. Utilizzare questa perdita di entropia incrociata quando ci sono solo due classi di etichette (assunte come 0 e 1). Per ogni esempio, dovrebbe essere presente un unico 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 di Huber tra 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

    Risultati previsti da una rete neurale.

    expected

    Valori attesi, 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 in termini di elementi.

    Dichiarazione 

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

  • Restituisce il logaritmo in base due del tensore specificato a livello di elemento.

    Dichiarazione 

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

  • Restituisce il logaritmo in base dieci del tensore specificato a livello di elemento.

    Dichiarazione 

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

  • Restituisce il logaritmo di 1 + x per elemento.

    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 di: 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 in termini di elementi.

    Dichiarazione 

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

  • Restituisce il coseno del tensore specificato in termini di elementi.

    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 in termini di elementi.

    Dichiarazione 

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

  • Restituisce il coseno iperbolico del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce la tangente iperbolica del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce l'arcoseno del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce il seno inverso del tensore specificato a livello di elemento.

    Dichiarazione 

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

  • Restituisce la tangente inversa del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce l'arcoseno iperbolico del tensore specificato in termini di elemento.

    Dichiarazione 

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

  • Restituisce il seno iperbolico inverso del tensore specificato a livello di elemento.

    Dichiarazione 

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

  • Restituisce la tangente iperbolica inversa del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce la radice quadrata del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce la radice quadrata inversa del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce l'esponenziale del tensore specificato in termini di elementi.

    Dichiarazione 

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

  • Restituisce due elevati alla potenza del tensore specificato per elemento.

    Dichiarazione 

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

  • Restituisce dieci elevati alla potenza del tensore specificato in termini di elemento.

    Dichiarazione 

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

  • Restituisce l'esponenziale di x - 1 in termini di elementi.

    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 tetto del tensore specificato a livello di elemento.

    Dichiarazione 

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

  • Restituisce il fondo del tensore specificato a livello di 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. Nello specifico, 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 in termini di elementi. Nello specifico, calcola 1 / (1 + exp(-x)) .

    Dichiarazione 

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

  • Restituisce il sigmoide log del tensore specificato a livello di elemento. Nello specifico, log(1 / (1 + exp(-x))) . Per la stabilità numerica, utilizziamo -softplus(-x) .

    Dichiarazione 

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

  • Restituisce il softplus del tensore specificato a livello di elemento. Nello specifico, 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 a livello di elemento. Nello specifico, 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. Nello specifico, 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. Nello specifico, 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 a livello di elemento.

    Dichiarazione 

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

  • Restituisce un tensore applicando un'unità lineare esponenziale. Nello specifico, calcola exp(x) - 1 se < 0, x altrimenti. Scopri Apprendimento di rete profondo rapido e accurato in base alle unità lineari esponenziali (ELU)

    Dichiarazione 

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

  • Restituisce le attivazioni dell'unità lineare dell'errore gaussiano (GELU) del tensore specificato a livello di elemento.

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

    Vedere Unità lineari dell'errore gaussiano .

    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 a livello di elemento. Nello specifico, 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, ovvero 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 leaky al tensore specificato a livello di elemento. Nello specifico, 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, ovvero 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. Per ulteriori informazioni fare riferimento a Reti neurali autonormalizzanti .

    Dichiarazione 

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

  • Restituisce un tensore applicando la funzione di attivazione swish, vale a dire x * sigmoid(x) .

    Fonte: “Ricerca di funzioni di attivazione” (Ramachandran et al. 2017) 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 sigmoidea dura, ovvero Relu6(x+3)/6 .

    Fonte: "Searching for 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 hard swish, vale a dire x * Relu6(x+3)/6 .

    Fonte: "Searching for 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, ovvero x * tanh(softplus(x)) .

    Fonte: "Mish: una funzione di attivazione neurale non monotona autoregolarizzata" 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 la radice n-esima n senso degli elementi del tensore.

    Dichiarazione 

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

  • Restituisce la differenza al quadrato tra x e y .

    Dichiarazione 

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

    Valore restituito

    (x - y) ^ 2 .

  • Restituisce il massimo degli elementi di due tensori.

    Nota

    max supporta la 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 in termini di elementi 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 in termini di elementi 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 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 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 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 del coseno tra x e y .

    Dichiarazione 

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

  • Restituisce la distanza coseno tra x e y . La distanza del 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 della matrice 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.

    Precondizione

    input deve avere rango 3 .

    Precondizione

    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.

    Precondizione

    input deve avere rango 4 .

    Precondizione

    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 bidimensionale con l'input, il filtro, i passi e il riempimento specificati.

    Precondizione

    input deve avere rango 4 .

    Precondizione

    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.

    Precondizione

    input deve avere rango 5 .

    Precondizione

    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 profonda 2D con l'input, il filtro, i passi e il riempimento specificati.

    Precondizione

    input deve avere rango 4.

    Precondizione

    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 di convoluzione profonda.

    strides

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

    padding

    L'imbottitura per l'operazione.

  • Restituisce un pooling massimo 2D, con le dimensioni del filtro, gli step 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 pooling massimo 3D, con le dimensioni del filtro, gli step 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, gli step 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, gli step 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 pooling specificati.

    Nota: fractionalMaxPool non dispone di un'implementazione XLA e pertanto 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 con forma [batch, height, width, channels] .

    poolingRatio

    Un elenco di Doubles . Il rapporto di pooling per ciascuna dimensione di input , attualmente supporta solo la dimensione riga e colonna e dovrebbe essere >= 1,0.

    pseudoRandom

    Un Bool opzionale. Il valore predefinito è false . Se impostato su true , genera la sequenza di pooling in modo pseudocasuale, altrimenti in modo casuale.

    overlapping

    Un Bool opzionale. Il valore predefinito è false . Se impostato su true , significa che durante il pooling, i valori al confine delle celle di pooling adiacenti vengono utilizzati da entrambe le celle.

    deterministic

    Un Bool opzionale. Se impostato su true , verrà utilizzata una regione di pooling fissa durante l'iterazione su un nodo frazionarioMaxPool2D nel grafico di calcolo.

    seed

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

    seed2

    Un Int64 facoltativo. Il valore predefinito è 0 . Un secondo seme per evitare la collisione dei semi.

  • Restituisce una copia input in cui i valori dalla dimensione di profondità vengono spostati in blocchi spaziali alle dimensioni di 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 operazione produrrà un tensore di forma [1, 1, 1, 4] :

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

    Qui, l'input ha un batch pari a 1 e ogni elemento batch ha forma [2, 2, 1] , l'output corrispondente avrà un singolo elemento (ovvero larghezza e altezza sono entrambi 1) e avrà una profondità di 4 canali (1 * dimensione_blocco * dimensione_blocco). La forma dell'elemento di output è [1, 1, 4] .

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

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

    Questa operazione, per block_size pari a 2, restituirà il seguente tensore di forma [1, 1, 1, 12]

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

    Allo stesso modo, per il seguente input di forma [1 4 4 1] e una dimensione del blocco pari a 2:

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

    l'operatore restituirà il seguente tensore di forma [1 2 2 4] :

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

    Precondizione

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

    Precondizione

    Il numero delle caratteristiche deve essere divisibile per il quadrato di b .

    Dichiarazione 

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

  • Restituisce una copia input in cui i valori delle dimensioni di altezza e larghezza vengono spostati nella dimensione di profondità.

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

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

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

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

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

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

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

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

    Allo stesso modo, per il seguente input di forma [1 4 4 1] e una dimensione del blocco di 2:

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

    L'operatore restituirà il seguente tensore di forma [1 2 2 4] :

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

    Precondizionismo

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

    Precondizionismo

    L'altezza dell'input deve essere divisibile da b .

    Precondizionismo

    La larghezza dell'input deve essere divisibile da b .

    Dichiarazione 

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

  • Costruisce un ottimizzatore per peso per 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

  • Costruisce un ottimizzatore per peso basato su SGD.

    Dichiarazione 

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

  • Costruisce un ottimizzatore per peso per Adam con decadimento del peso.

    Riferimento: "Adam - Un metodo per l'ottimizzazione stocastica"

    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

  • Genera un nuovo seme casuale per Tensorflow.

    Dichiarazione 

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

  • Concatena due valori.

    Dichiarazione 

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

  • Aggiunge due valori e produce la loro somma.

    Dichiarazione 

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

  • Media due valori.

    Dichiarazione 

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

  • Moltiplica due valori.

    Dichiarazione 

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

  • Impilare due valori.

    Dichiarazione 

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

  • Dichiarazione 

    public func PrintX10Metrics()

  • Crea un riepilogo della stringa di un elenco di statistiche di addestramento e test.

    Dichiarazione 

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

  • Dichiarazione 

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

  • Mappa una funzione su n thread.

    Dichiarazione 

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