Structures

Une concaténation de deux séquences avec le même type d'élément.

Une vue pivotée sur une collection.

Une valeur dérivée effacée par type.

Le type AnyDerivative transmet ses opérations à une valeur dérivée de base sous-jacente arbitraire conforme à Differentiable et AdditiveArithmetic , masquant les spécificités de la valeur sous-jacente.

Tableau multidimensionnel d'éléments qui est une généralisation de vecteurs et de matrices à des dimensions potentiellement supérieures.

Le paramètre générique Scalar décrit le type de scalaires dans le tenseur (tels que Int32 , Float , etc.).

Une fonction de pullback qui effectue la transposition de la diffusion de deux Tensors .

Un contexte qui stocke les informations contextuelles locales du thread utilisées par les API d'apprentissage en profondeur telles que les couches.

Utilisez Context.local pour récupérer le contexte local du thread actuel.

Exemples:

• Définissez la phase d'apprentissage actuelle sur la formation afin que des couches telles que BatchNorm calculent la moyenne et la variance lorsqu'elles sont appliquées aux entrées.

  Context.local.learningPhase = .training

• Définissez la phase d'apprentissage actuelle sur l'inférence afin que les couches telles que Dropout ne suppriment pas les unités lorsqu'elles sont appliquées aux entrées.

  Context.local.learningPhase = .inference

Une couche de convolution 1D (par exemple, convolution temporelle sur une série temporelle).

Cette couche crée un filtre de convolution qui est convolué avec l'entrée de la couche pour produire un tenseur de sorties.

Une couche de convolution 2D (par exemple convolution spatiale sur les images).

Cette couche crée un filtre de convolution qui est convolué avec l'entrée de la couche pour produire un tenseur de sorties.

Une couche de convolution 3D pour la convolution spatiale/spatio-temporelle sur les images.

Cette couche crée un filtre de convolution qui est convolué avec l'entrée de la couche pour produire un tenseur de sorties.

Une couche de convolution transposée 1D (par exemple, convolution temporelle transposée sur les images).

Cette couche crée un filtre de convolution qui est transposé-convolué avec l'entrée de la couche pour produire un tenseur de sorties.

Une couche de convolution transposée 2D (par exemple, convolution spatiale transposée sur les images).

Cette couche crée un filtre de convolution qui est transposé-convolué avec l'entrée de la couche pour produire un tenseur de sorties.

Une couche de convolution transposée en 3D (par exemple, convolution spatiale transposée sur des images).

Cette couche crée un filtre de convolution qui est transposé-convolué avec l'entrée de la couche pour produire un tenseur de sorties.

Une couche de convolution 2D en profondeur.

Cette couche crée des filtres de convolution séparables qui sont convolués avec l'entrée de la couche pour produire un tenseur de sorties.

Un calque pour ajouter un remplissage nul dans la dimension temporelle.

Un calque pour ajouter un remplissage nul dans les dimensions spatiales.

Un calque pour ajouter un remplissage nul dans les dimensions spatiales/spatio-temporelles.

Une couche de convolution séparable 1D.

Cette couche effectue une convolution en profondeur qui agit séparément sur les canaux, suivie d'une convolution ponctuelle qui mélange les canaux.

Une couche de convolution séparable 2D.

Cette couche effectue une convolution en profondeur qui agit séparément sur les canaux, suivie d'une convolution ponctuelle qui mélange les canaux.

Une couche aplatie.

Un calque d'aplatissement aplatit l'entrée lorsqu'il est appliqué sans affecter la taille du lot.

Un calque de remodelage.

Une couche qui contient une fonction différenciable personnalisée.

Valeur de type dynamique TensorFlow qui peut être créée à partir de types conformes à TensorFlowScalar .

Représente un ensemble potentiellement important d’éléments.

Un Dataset peut être utilisé pour représenter un pipeline d'entrée sous la forme d'une collection de tenseurs d'éléments.

Type qui permet l'itération sur les éléments d'un ensemble de données.

Une structure de type 2 tuples conforme à TensorGroup qui représente un tuple de 2 types conformes à TensorGroup .

Une couche de réseau neuronal densément connectée.

Dense implémente l'opération activation(matmul(input, weight) + bias) , où weight est une matrice de poids, bias est un vecteur de biais et activation est une fonction d'activation par élément.

Cette couche prend également en charge les tenseurs de poids 3D avec des matrices de biais 2D. Dans ce cas, la première dimension des deux est traitée comme la taille du lot qui est alignée avec la première dimension d' input et la variante par lots de l'opération matmul(_:_:) est utilisée, utilisant ainsi un poids et un biais différents pour chaque élément. dans le lot d'entrée.

Un appareil sur lequel des Tensor peuvent être alloués.

Une couche d'abandon.

L'abandon consiste à mettre aléatoirement à 0 une fraction d'unités d'entrée à chaque mise à jour pendant le temps d'entraînement, ce qui permet d'éviter le surapprentissage.

GaussianNoise ajoute du bruit échantillonné à partir d'une distribution normale.

Le bruit ajouté a toujours une moyenne nulle, mais un écart type configurable.

GaussianDropout multiplie l'entrée avec le bruit échantillonné à partir d'une distribution normale de moyenne 1,0.

Puisqu’il s’agit d’une couche de régularisation, elle n’est active que pendant la période d’entraînement. Pendant l'inférence, GaussianDropout traverse l'entrée sans modification.

Une couche de suppression Alpha.

Alpha Dropout est un Dropout qui maintient la moyenne et la variance des entrées à leurs valeurs d'origine, afin de garantir la propriété d'auto-normalisation même après cet abandon. Alpha Dropout s'adapte bien aux unités linéaires exponentielles mises à l'échelle en définissant de manière aléatoire les activations sur la valeur de saturation négative.

Source : Réseaux de neurones auto-normalisés : https://arxiv.org/abs/1706.02515

Une couche d'intégration.

Embedding est en fait une table de recherche qui mappe les indices d'un vocabulaire fixe à des représentations vectorielles de taille fixe (dense), par exemple [[0], [3]] -> [[0.25, 0.1], [0.6, -0.2]] .

Une structure vide représentant des TangentVector vides pour les couches sans paramètre.

Paire de premier et deuxième moments (c'est-à-dire moyenne et variance).

Une couche de dilatation morphologique 2D

Cette couche renvoie la dilatation morphologique du tenseur d'entrée avec les filtres fournis

Une couche d'érosion morphologique 2D

Cette couche renvoie l'érosion morphologique du tenseur d'entrée avec les filtres fournis

Une sélection paresseuse d'éléments, dans un ordre donné, à partir d'une collection de base.

Une collection des tranches contiguës non chevauchantes les plus longues d'une collection Base , en commençant par son premier élément et ayant une longueur maximale fixe.

Les éléments de cette collection, à l'exception du dernier, ont tous un count de batchSize , sauf si Base.count % batchSize !=0 , auquel cas le count du dernier lot est base.count % batchSize.

Une couche de normalisation par lots.

Normalise les activations de la couche précédente à chaque lot, c'est à dire applique une transformation qui maintient l'activation moyenne proche de 0 et l'écart type d'activation proche de 1 .

Référence : Normalisation par lots : accélérer la formation approfondie du réseau en réduisant le décalage des covariables internes .

Une couche qui applique la normalisation des couches sur un mini-lot d'entrées.

Référence : Normalisation des couches .

Une couche qui applique la normalisation de groupe sur un mini-lot d'entrées.

Référence : Normalisation de groupe .

Une couche qui applique la normalisation d'instance sur un mini-lot d'entrées.

Référence : Normalisation d'instance : l'ingrédient manquant pour une stylisation rapide .

État pour une seule étape d'un seul poids à l'intérieur d'un optimiseur.

État global accessible via StateAccessor .

[String: Float] mais les éléments sont accessibles comme s'ils étaient membres.

Un optimiseur qui fonctionne sur un seul groupe de paramètres.

Un wrapper de type sécurisé autour d’une valeur d’index Int pour les valeurs locales de l’optimiseur.

Un wrapper de type sécurisé autour d’une valeur d’index Int pour les valeurs globales de l’optimiseur.

Un wrapper de type sécurisé autour d’une valeur d’index Int pour les valeurs d’état de l’optimiseur.

Construit un ParameterGroupOptimizer . Ceci est utilisé essentiellement au niveau d’un poids unique dans le modèle. Un mappage des groupes de paramètres sélectionnés par ( [Bool] vers ParameterGroupOptimizer) définit l'optimiseur final.

Une couche de pooling maximale pour les données temporelles.

Une couche de pooling maximale pour les données spatiales.

Une couche de pooling maximale pour les données spatiales ou spatio-temporelles.

Une couche de pooling moyenne pour les données temporelles.

Une couche de regroupement moyenne pour les données spatiales.

Une couche de regroupement moyenne pour les données spatiales ou spatio-temporelles.

Une couche de regroupement moyenne globale pour les données temporelles.

Une couche de regroupement moyenne globale pour les données spatiales.

Une couche de mise en commun moyenne globale pour les données spatiales et spatio-temporelles.

Une couche de pooling maximale globale pour les données temporelles.

Une couche de pooling maximale globale pour les données spatiales.

Une couche de pooling maximale globale pour les données spatiales et spatio-temporelles.

Une couche de pooling maximale fractionnée pour les données spatiales. Remarque : FractionalMaxPool n'a pas d'implémentation XLA et peut donc avoir des implications en termes de performances.

PythonObject représente un objet en Python et prend en charge la recherche dynamique de membres. Tout accès membre comme object.foo demandera dynamiquement le runtime Python pour un membre portant le nom spécifié dans cet objet.

PythonObject est transmis et renvoyé par tous les appels de fonction Python et références de membres. Il prend en charge les opérateurs arithmétiques et de comparaison Python standard.

En interne, PythonObject est implémenté en tant que pointeur à références vers une API Python C PyObject .

Un wrapper PythonObject qui permet de lancer des appels de méthode. Les exceptions produites par les fonctions Python sont reflétées sous forme d'erreurs Swift et levées.

Un wrapper PythonObject qui permet les accès aux membres. Les opérations d’accès aux membres renvoient un résultat Optional . Lorsque l’accès des membres échoue, nil est renvoyé.

Une interface pour Python.

PythonInterface permet l'interaction avec Python. Il peut être utilisé pour importer des modules et accéder dynamiquement aux types et fonctions intégrés de Python.

Un générateur de nombres aléatoires effacés par type.

Le type AnyRandomNumberGenerator transmet les opérations de génération de nombres aléatoires à un générateur de nombres aléatoires sous-jacent, masquant son type sous-jacent spécifique.

Une implémentation de SeedableRandomNumberGenerator utilisant ARC4.

ARC4 est un chiffrement de flux qui génère un flux d'octets pseudo-aléatoire. Ce PRNG utilise la graine comme clé.

ARC4 est décrit dans Schneier, B., « Applied Cryptography : Protocols, Algorithms, and Source Code in C », 2e édition, 1996.

Un générateur individuel n'est pas thread-safe, mais des générateurs distincts ne partagent pas d'état. Les données aléatoires générées sont de haute qualité, mais ne conviennent pas aux applications cryptographiques.

Une implémentation de SeedableRandomNumberGenerator utilisant Threefry. Saumon et coll. SC 2011. Nombres aléatoires parallèles : aussi simple que 1, 2, 3. http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

Cette structure implémente un PRNG Threefry2x32 à 20 tours. Il doit être initialisé avec une valeur de 64 bits.

Un générateur individuel n'est pas thread-safe, mais des générateurs distincts ne partagent pas d'état. Les données aléatoires générées sont de haute qualité, mais ne conviennent pas aux applications cryptographiques.

Une implémentation de SeedableRandomNumberGenerator utilisant Philox. Saumon et coll. SC 2011. Nombres aléatoires parallèles : aussi simple que 1, 2, 3. http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

Cette structure implémente un PRNG Philox4x32 à 10 tours. Il doit être initialisé avec une valeur de 64 bits.

Un générateur individuel n'est pas thread-safe, mais des générateurs distincts ne partagent pas d'état. Les données aléatoires générées sont de haute qualité, mais ne conviennent pas aux applications cryptographiques.

Une entrée dans un réseau neuronal récurrent.

Une sortie vers un réseau neuronal récurrent.

Une cellule RNN de base.

Une cellule LSTM.

Une cellule GRU.

Un calque qui compose séquentiellement deux ou plusieurs autres calques.

Exemples:

• Créez un modèle de perceptron simple à 2 couches pour MNIST :

let inputSize = 28 * 28
let hiddenSize = 300
var classifier = Sequential {
     Dense<Float>(inputSize: inputSize, outputSize: hiddenSize, activation: relu)
     Dense<Float>(inputSize: hiddenSize, outputSize: 3, activation: identity)
 }

• Créez un encodeur automatique pour MNIST :

var autoencoder = Sequential {
    // The encoder.
    Dense<Float>(inputSize: 28 * 28, outputSize: 128, activation: relu)
    Dense<Float>(inputSize: 128, outputSize: 64, activation: relu)
    Dense<Float>(inputSize: 64, outputSize: 12, activation: relu)
    Dense<Float>(inputSize: 12, outputSize: 3, activation: relu)
    // The decoder.
    Dense<Float>(inputSize: 3, outputSize: 12, activation: relu)
    Dense<Float>(inputSize: 12, outputSize: 64, activation: relu)
    Dense<Float>(inputSize: 64, outputSize: 128, activation: relu)
    Dense<Float>(inputSize: 128, outputSize: imageHeight * imageWidth, activation: tanh)
}

ShapedArray est un tableau multidimensionnel. Il a une forme, qui est de type [Int] et définit les dimensions du tableau, et utilise un TensorBuffer en interne comme stockage.

Tranche contiguë d'une instance ShapedArray ou ShapedArraySlice .

ShapedArraySlice permet des opérations rapides et efficaces sur des tranches contiguës d'instances ShapedArray . Les instances ShapedArraySlice ne disposent pas de leur propre stockage. Au lieu de cela, ils fournissent une vue sur le stockage de leur ShapedArray de base. ShapedArraySlice peut représenter deux types différents de tranches : les tableaux d'éléments et les sous-tableaux.

Les tableaux d'éléments sont des éléments sous-dimensionnels d'un ShapedArray : leur rang est inférieur d'un à celui de leur base. Les tranches de tableau d'éléments sont obtenues en indexant une instance ShapedArray avec un index Int32 singulier.

Par exemple:

    var matrix = ShapedArray(shape: [2, 2], scalars: [0, 1, 2, 3])
    // `matrix` represents [[0, 1], [2, 3]].

    let element = matrix[0]
    // `element` is a `ShapedArraySlice` with shape [2]. It is an element
    // array, specifically the first element in `matrix`: [0, 1].

    matrix[1] = ShapedArraySlice(shape: [2], scalars: [4, 8])
    // The second element in `matrix` has been mutated.
    // `matrix` now represents [[0, 1, 4, 8]].

Les sous-tableaux sont une plage contiguë d'éléments dans un ShapedArray . Le rang d'un sous-tableau est le même que celui de sa base, mais sa dimension principale est le nombre de tranches. Les tranches de sous-tableau sont obtenues en indexant un ShapedArray avec un Range<Int32> qui représente une plage d'éléments (dans la dimension principale). Des méthodes telles que prefix(:) et suffix(:) qui indexent en interne avec une plage produisent également un sous-tableau.

Par exemple:

    let zeros = ShapedArray(repeating: 0, shape: [3, 2])
    var matrix = ShapedArray(shape: [3, 2], scalars: Array(0..<6))
    // `zeros` represents [[0, 0], [0, 0], [0, 0]].
    // `matrix` represents [[0, 1], [2, 3], [4, 5]].

    let subarray = matrix.prefix(2)
    // `subarray` is a `ShapedArraySlice` with shape [2, 2]. It is a slice
    // of the first 2 elements in `matrix` and represents [[0, 1], [2, 3]].

    matrix[0..<2] = zeros.prefix(2)
    // The first 2 elements in `matrix` have been mutated.
    // `matrix` now represents [[0, 0], [0, 0], [4, 5]].

StringTensor est un tableau multidimensionnel dont les éléments sont des String .

TensorHandle est le type utilisé par les opérations. Il inclut un type Scalar , que les internes du compilateur peuvent utiliser pour déterminer les types de données des paramètres lorsqu'ils sont extraits dans un programme tensoriel.

Une structure représentant la forme d'un tenseur.

TensorShape est une fine enveloppe autour d'un tableau d'entiers qui représentent les dimensions de la forme. Tous les types de tenseurs utilisent TensorShape pour représenter leur forme.

TensorVisitorPlan se rapproche de [WritableKeyPath<Base, Tensor<Float>] mais est plus efficace. Ceci est utile pour écrire des optimiseurs génériques qui souhaitent cartographier les gradients, les poids existants et un index qui peut être utilisé pour trouver des poids stockés auxiliairement. C'est légèrement plus efficace (~ 2x) mais cela pourrait être mieux car cela échange des frais généraux légèrement plus élevés (déréférencement de pointeur supplémentaire) pour ne pas avoir à effectuer le travail O (deep_of_tree) requis avec une liste simple pour retrouver chaque KeyPath individuel.

Une couche de suréchantillonnage pour les entrées 1D.

Une couche de suréchantillonnage pour les entrées 2D.

Une couche de suréchantillonnage pour les entrées 3D.

Collecte les compteurs de prédictions corrects et les totaux de pertes.