Funzioni

Le seguenti funzioni sono disponibili a livello globale.

• l1Perdita(prevista:prevista:)
  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.

• l2Perdita(previsto:previsto:)
  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.

• Perdita cerniera(previsto:previsto:)
  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.

• quadratoPerditaHinge(previsto:previsto:)
  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.

• categorialeHingeLoss(previsto:previsto:)
  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.

• logCoshLoss(previsto:previsto:)
  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.

• perdita di poisson(previsto:previsto:)
  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.

• kullbackLeiblerDivergence(previsto:previsto:)
  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.

• softmaxCrossEntropy(logit:probabilità:)
  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.

• sigmoidIncrocioEntropia(logits:etichette:)
  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.

• identità(_:)
  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

• conContesto(_:_:)
  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 di ritorno

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

• conFase di Apprendimento(_:_:)
  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 di ritorno

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

• conSeme CasualePerTensorFlow(_:_:)
  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 di ritorno

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

• conGeneratore di numeri casuali per flusso tensore (_:_:)
  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 di ritorno

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

• cerniera lampo(_:_:)
  Dichiarazione

  public func zip<T: TensorGroup, U: TensorGroup>(
    _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
  ) -> Dataset<Zip2TensorGroup<T, U>>

• LazyTensorBarrier(su:dispositivi:attendi:)
  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)

• valoreConGradiente(at:in:)
  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

• valoreConGradiente(a:_:in:)
  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

• valoreConGradiente(a:_:_:in:)
  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

• valoreConGradiente(di:)
  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

• valoreConGradiente(di:)
  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

• valoreConGradiente(di:)
  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

• gradiente(a:in:)
  Dichiarazione

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

• gradiente(a:_:in:)
  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

• gradiente(a:_:_:in:)
  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

• gradiente(di:)
  Dichiarazione

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

• gradiente(di:)
  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

• gradiente(di:)
  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

• conRecomputationInPullbacks(_:)
  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

• Funzione differenziabile(da:)
  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

• Funzione differenziabile(da:)
  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

• senza derivata(at:)
  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

• senzaDerivativa(at:in:)
  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

• conDispositivo(_:_:esegui:)
  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.

• conDispositivo(denominato:esegui:)
  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.

• conDispositivoDefault(esegui:)
  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(immagini:dimensione:metodo:antialias:)
  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.

• resizeArea(immagini:dimensione:alignCorners:)
  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.

• dilation2D(_:filter:strides:rates:padding:)
  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.

• erosione2D(_:filter:strides:rates:padding:)
  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.

• zeri()
  Restituisce una funzione che crea un tensore inizializzando tutti i suoi valori su zero.

  Dichiarazione

  public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint

• ConstantInitializer(valore:)
  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>

• ConstantInitializer(valore:)
  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>

• glorotUniforme(seme:)
  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>

• glorotNormale(seme:)
  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>

• luiUniforme(seme:)
  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>

• heNormal(seme:)
  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>

• leCunUniform(seme:)
  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>

• leCunNormal(seme:)
  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>

• truncatedNormalInitializer(mean:standardDeviation:seed:)
  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 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 di ritorno

  Una funzione di inizializzazione dei parametri normali troncata.

• ==(_:_:)
  Dichiarazione

  public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool

• eye(Conteggiorighe:Conteggiocolonne:batchForma:on:)
  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.

• traccia(_:)
  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] .

• Colesky(_:)
  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] .

• triangolareRisolvi(matrice:destra:inferiore:aggiunto:)
  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 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 di b .

• l1Perdita(prevista:prevista:riduzione:)
  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.

• l2Perdita(previsto:previsto:riduzione:)
  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.

• meanAbsoluteError(previsto:previsto:)
  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.

• errorequadrato medio(previsto:previsto:)
  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.

• errore logaritmico quadrato medio(previsto:previsto:)
  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.

• errore%medioassoluto(previsto:previsto:)
  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.

• Perdita cerniera(previsto:previsto:riduzione:)
  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.

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

• categorialeHingeLoss(previsto:previsto:riduzione:)
  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.

• logPerditaCosh(previsto:previsto:riduzione:)
  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.

• poissonPerdita(previsto:previsto:riduzione:)
  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.

• kullbackLeiblerDivergence(previsto:previsto:riduzione:)
  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.

• softmaxCrossEntropy(logit:etichette:riduzione:)
  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.

• softmaxCrossEntropy(logit:probabilità:riduzione:)
  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.

• sigmoidCrossEntropy(logits:etichette:riduzione:)
  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.

• huberLoss(previsto:previsto:delta:riduzione:)
  Calcola la perdita di Huber tra predicted e expected .

  Per ogni valore x in error = expected - predicted :

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

  • 0.5 * δ^2 + δ * (|x| - δ) altrimenti.

  • Fonte: articolo di Wikipedia .

  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.

• addominali(_:)
  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

• tronco d'albero(_:)
  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

• log2(_:)
  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

• log10(_:)
  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

• log1p(_:)
  Restituisce il logaritmo di 1 + x per elemento.

  Dichiarazione

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

• log1mexp(_:)
  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

• peccato(_:)
  Restituisce il seno del tensore specificato in termini di elementi.

  Dichiarazione

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

• cos(_:)
  Restituisce il coseno del tensore specificato in termini di elementi.

  Dichiarazione

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

• abbronzatura(_:)
  Restituisce la tangente del tensore specificato per elemento.

  Dichiarazione

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

• peccato(_:)
  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

• cosh(_:)
  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

• tanto(_:)
  Restituisce la tangente iperbolica del tensore specificato in termini di elemento.

  Dichiarazione

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

• acos(_:)
  Restituisce l'arcoseno del tensore specificato in termini di elementi.

  Dichiarazione

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

• come in(_:)
  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

• un'abbronzatura(_:)
  Restituisce la tangente inversa del tensore specificato in termini di elemento.

  Dichiarazione

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

• acosh(_:)
  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

• asinh(_:)
  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

• atanh(_:)
  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

• quadrato(_:)
  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

• risposta(_:)
  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

• esp(_:)
  Restituisce l'esponenziale del tensore specificato in termini di elementi.

  Dichiarazione

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

• esp2(_:)
  Restituisce due elevati alla potenza del tensore specificato per elemento.

  Dichiarazione

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

• esp10(_:)
  Restituisce dieci elevati alla potenza del tensore specificato in termini di elementi.

  Dichiarazione

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

• expm1(_:)
  Restituisce l'esponenziale di x - 1 in termini di elementi.

  Dichiarazione

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

• girare(_:)
  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

• numero(_:)
  Restituisce il tetto del tensore specificato a livello di elemento.

  Dichiarazione

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

• pavimento(_:)
  Restituisce il fondo del tensore specificato a livello di elemento.

  Dichiarazione

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

• cartello(_:)
  Restituisce un'indicazione del segno del tensore specificato a livello di 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

• sigmoide(_:)
  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

• logSigma(_:)
  Restituisce il sigmoide log del tensore specificato in termini di elementi. 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

• softplus(_:)
  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

• segno morbido(_:)
  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

• softmax(_:)
  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

• softmax(_:lungo l'asse:)
  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

• logSoftmax(_:)
  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

• elu(_:)
  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

• gelu(_:)
  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

• relu(_:)
  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

• relu6(_:)
  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

• leakyRelu(_:alfa:)
  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>

• selu(_:)
  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

• fruscio(_:)
  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

• duroSigmoide(_:)
  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

• difficileSwish(_:)
  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

• miserabile(_:)
  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

• po(_:_:)
  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

• po(_:_:)
  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

• po(_:_:)
  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

• po(_:_:)
  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

• radice(_:_:)
  Restituisce la radice n -esima nel senso degli elementi del tensore.

  Dichiarazione

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

• Differenza al quadrato(_:_:)
  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 di ritorno

  (x - y) ^ 2 .

• massimo(_:_:)
  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

• massimo(_:_:)
  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

• massimo(_:_:)
  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

• min(_:_:)
  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

• min(_:_:)
  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

• min(_:_:)
  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

• cosenoSomiglianza(_:_:)
  Restituisce la somiglianza del coseno tra x e y .

  Dichiarazione

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

• cosenoDistanza(_:_:)
  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>

• matmul(_:trasposto:_:trasposto:)
  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>

• conv1D(_:filtro:falcata:imbottitura:dilatazione:)
  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.

• conv2D(_:filter:strides:padding:dilations:)
  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.

• transposedConv2D(_:shape:filter:strides:padding:dilations:)
  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.

• conv3D(_:filter:strides:padding:dilations:)
  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.

• DepthwiseConv2D(_:filter:strides:padding:)
  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.

• maxPool2D(_:filterSize:strides:padding:)
  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.

• maxPool3D(_:filterSize:strides:padding:)
  Restituisce un pool 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.

• avgPool2D(_:filterSize:strides:padding:)
  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.

• avgPool3D(_:filterSize:strides:padding:)
  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.

• frazionarioMaxPool2D(_:poolingRatio:pseudoCasuale:sovrapposizione:deterministico:seme:seme2:)
  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.

• profonditàSpazio(_:dimensioneblocco:)
  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

• spazioInProfondità(_:dimensioneblocco:)
  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 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 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

• Makelars (LearningRate: Momentum: TrustCoefficienti: Nesterov: Epsilon: WeightDecay :)
  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

• makeSGD(tasso di apprendimento:momento:pesoDecay:nesterov:)
  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

• Makeadam (LearningRate: Beta1: Beta2: WeightDecayrate: Epsilon :)
  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

• casualseedforsorflow (usando :)
  Genera un nuovo seme casuale per Tensorflow.

  Dichiarazione

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

• concatenare(_:_:)
  Concatena due valori.

  Dichiarazione

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

• somma(_:_:)
  Aggiunge due valori e produce la loro somma.

  Dichiarazione

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

• media(_:_:)
  Media due valori.

  Dichiarazione

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

• moltiplicare(_:_:)
  Moltiplica due valori.

  Dichiarazione

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

• pila(_:_:)
  Impilare due valori.

  Dichiarazione

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

• Printx10metrics ()
  Dichiarazione

  public func PrintX10Metrics()

• FormatStatistics (_ :)
  Crea un riepilogo della stringa di un elenco di statistiche di addestramento e test.

  Dichiarazione

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

• FormatStatistics (treno: test :)
  Dichiarazione

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

• runonnthreads (_: _ :)
  Mappa una funzione su n thread.

  Dichiarazione

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