Cette page a été traduite par l'API Cloud Translation.
Switch to English

Structures

Les structures suivantes sont disponibles dans le monde entier.

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

    Déclaration

    public struct Concatenation<Base1: Sequence, Base2: Sequence>: Sequence
    where Base1.Element == Base2.Element
    extension Concatenation: Collection where Base1: Collection, Base2: Collection
    extension Concatenation: BidirectionalCollection
    where Base1: BidirectionalCollection, Base2: BidirectionalCollection
    extension Concatenation: RandomAccessCollection
    where Base1: RandomAccessCollection, Base2: RandomAccessCollection
  • Une vue tournée sur une collection.

    Déclaration

    public struct RotatedCollection<Base> : Collection where Base : Collection
    extension RotatedCollection: BidirectionalCollection
    where Base: BidirectionalCollection
    extension RotatedCollection: RandomAccessCollection
    where Base: RandomAccessCollection
  • Déclaration

    public struct AnyDifferentiable : Differentiable
  • Une valeur dérivée effacée de 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.

    Déclaration

    @frozen
    public struct AnyDerivative : Differentiable & AdditiveArithmetic
  • Un tableau multidimensionnel d'éléments qui est une généralisation de vecteurs et de matrices à des dimensions potentiellement plus élevées.

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

    Déclaration

    @frozen
    public struct Tensor<Scalar> where Scalar : TensorFlowScalar
    extension Tensor: Collatable
    extension Tensor: CopyableToDevice
    extension Tensor: AnyTensor
    extension Tensor: ExpressibleByArrayLiteral
    extension Tensor: CustomStringConvertible
    extension Tensor: CustomPlaygroundDisplayConvertible
    extension Tensor: CustomReflectable
    extension Tensor: TensorProtocol
    extension Tensor: TensorGroup
    extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
    0c7d2ba0df0810 0dcaaa77 0c7d2ba0df0810 0dcaaa77 0c7d2ba0810 0dcaaa77 0c7d2ba0810 0dcaaa77 0c7d2ba0810 0dcaaa77 0c7d2ba0810 0dcaaa77 0c7d2ba0810 0dcaa778
  • Une fonction de pullback qui effectue la transposition de la diffusion de deux Tensors .

    Déclaration

    public struct BroadcastingPullback
  • Un contexte qui stocke les informations contextuelles locales des threads 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 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
    

    Déclaration

    public struct Context
  • Une couche de convolution 1-D (par exemple, convolution temporelle sur une série temporelle).

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

    Déclaration

    @frozen
    public struct Conv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche de convolution 2D (par exemple, convolution spatiale sur des images).

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

    Déclaration

    @frozen
    public struct Conv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche de convolution 3-D 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.

    Déclaration

    @frozen
    public struct Conv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche de convolution transposée 1-D (par exemple, une convolution transposée temporelle 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.

    Déclaration

    @frozen
    public struct TransposedConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche de convolution transposée 2-D (par exemple, une convolution transposée spatiale 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.

    Déclaration

    @frozen
    public struct TransposedConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche de convolution transposée 3-D (par exemple, une convolution transposée spatiale 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.

    Déclaration

    @frozen
    public struct TransposedConv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche de convolution en profondeur 2D.

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

    Déclaration

    @frozen
    public struct DepthwiseConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Un calque pour ajouter un remplissage nul dans la dimension temporelle.

    Déclaration

    public struct ZeroPadding1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Un calque pour ajouter un remplissage nul dans les dimensions spatiales.

    Déclaration

    public struct ZeroPadding2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Un calque pour ajouter un remplissage nul dans les dimensions spatiales / spatio-temporelles.

    Déclaration

    public struct ZeroPadding3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de convolution séparable 1-D.

    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.

    Déclaration

    @frozen
    public struct SeparableConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • 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.

    Déclaration

    @frozen
    public struct SeparableConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche aplatie.

    Une couche d'aplatissement aplatit l'entrée lorsqu'elle est appliquée sans affecter la taille du lot.

    Déclaration

    @frozen
    public struct Flatten<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Un calque de remodelage.

    Déclaration

    @frozen
    public struct Reshape<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche qui renferme une fonction différentiable personnalisée.

    Déclaration

    public struct Function<Input, Output> : ParameterlessLayer where Input : Differentiable, Output : Differentiable
  • Valeur de type dynamique TensorFlow qui peut être créée à partir de types conformes à TensorFlowScalar .

    Déclaration

    public struct TensorDataType : Equatable
  • Déclaration

    @frozen
    public struct BFloat16
    extension BFloat16: TensorFlowScalar
    extension BFloat16: XLAScalarType
  • Représente un ensemble d'éléments potentiellement volumineux.

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

    Déclaration

    @available(*, deprecated, message: "Datasets will be removed in S4TF v0.10. Please use the new Batches API instead.")
    @frozen
    public struct Dataset<Element> where Element : TensorGroup
    extension Dataset: Sequence
  • Le type qui permet l'itération sur les éléments d'un ensemble de données.

    Déclaration

    @available(*, deprecated)
    @frozen
    public struct DatasetIterator<Element> where Element : TensorGroup
    extension DatasetIterator: IteratorProtocol
  • Structure de type 2-tuple conforme à TensorGroup qui représente un tuple de 2 types conforme à TensorGroup .

    Déclaration

    @frozen
    public struct Zip2TensorGroup<T, U> : TensorGroup where T : TensorGroup, U : TensorGroup
  • Une couche de réseau neuronal densément connectée.

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

    Cette couche prend également en charge les tenseurs de poids 3-D avec des matrices de biais 2-D. Dans ce cas, la première dimension des deux est traitée comme la taille du lot alignée sur la première dimension de l' input et la variante de lot 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.

    Déclaration

    @frozen
    public struct Dense<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Un appareil sur lequel les Tensor peuvent être attribués.

    Déclaration

    public struct Device
    extension Device: Equatable
    extension Device: CustomStringConvertible
  • Une couche d'abandon.

    L'abandon consiste à définir de manière aléatoire une fraction d'unités d'entrée à 0 à chaque mise à jour pendant le temps d'entraînement, ce qui permet d'éviter le surajustement.

    Déclaration

    @frozen
    public struct Dropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • GaussianNoise ajoute du bruit échantillonné à partir d'une distribution normale.

    Le bruit ajouté a toujours une moyenne de zéro, mais a un écart type configurable.

    Déclaration

    public struct GaussianNoise<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • GaussianDropout multiplie l'entrée avec le bruit échantillonné à partir d'une distribution normale avec une moyenne de 1,0.

    Comme il s'agit d'une couche de régularisation, elle n'est active que pendant le temps d'entraînement. Pendant l'inférence, GaussianDropout passe par l'entrée sans modification.

    Déclaration

    public struct GaussianDropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche d'abandon Alpha.

    Alpha Dropout est un Dropout qui maintient la moyenne et la variance des entrées à leurs valeurs d'origine, afin d'assurer la propriété d'auto-normalisation même après ce décrochage. Le décrochage alpha 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

    Déclaration

    @frozen
    public struct AlphaDropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • 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]] .

    Déclaration

    public struct Embedding<Scalar> : Module where Scalar : TensorFlowFloatingPoint
  • Une structure vide représentant des TangentVector s vides pour les couches sans paramètre.

  • Paire de premier et deuxième moments (c.-à-d. Moyenne et variance).

    Remarque

    Cela est nécessaire car les types de tuple ne sont pas différenciables.

    Déclaration

    public struct Moments<Scalar> : Differentiable where Scalar : TensorFlowFloatingPoint
  • Une couche de dilatation morphologique 2D

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

    Déclaration

    @frozen
    public struct Dilation2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche d'érosion morphologique 2D

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

    Déclaration

    @frozen
    public struct Erosion2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une sélection paresseuse d'éléments, dans un ordre donné, à partir d'une collection de base.

    Déclaration

    public struct Sampling<Base: Collection, Selection: Collection>
    where Selection.Element == Base.Index
    extension Sampling: SamplingProtocol
    extension Sampling: Collection
    extension Sampling: BidirectionalCollection
      where Selection: BidirectionalCollection
    extension Sampling: RandomAccessCollection
      where Selection: RandomAccessCollection
  • Une collection des plus longues tranches contiguës non chevauchantes d'une collection de Base , 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.

    Déclaration

    public struct Slices<Base> where Base : Collection
    extension Slices: Collection
  • 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 des lots: accélération de la formation en réseau profond en réduisant le décalage de covariable interne .

    Déclaration

    @frozen
    public struct BatchNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche qui applique la normalisation de couche sur un mini-lot d'entrées.

    Référence: Normalisation des couches .

    Déclaration

    @frozen
    public struct LayerNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Une couche qui applique la normalisation de groupe sur un mini-lot d'entrées.

    Référence: Normalisation de groupe .

    Déclaration

    @frozen
    public struct GroupNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • 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 .

    Déclaration

    @frozen
    public struct InstanceNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • Déclarez pour une seule étape d'un seul poids dans un optimiseur.

    Déclaration

    public struct OptimizerWeightStepState
  • État global accessible via StateAccessor .

    Déclaration

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

    Déclaration

    @dynamicMemberLookup
    public struct HyperparameterDictionary
  • Un optimiseur qui fonctionne sur un seul groupe de paramètres.

    Déclaration

    public struct ParameterGroupOptimizer
  • Un wrapper de type sécurisé autour d'une valeur d'index Int pour les valeurs locales de l'optimiseur.

    Déclaration

    public struct LocalAccessor
  • Un wrapper de type sécurisé autour d'une valeur d'index Int pour les valeurs globales de l'optimiseur.

    Déclaration

    public struct GlobalAccessor
  • Un wrapper de type sécurisé autour d'une valeur d'index Int pour les valeurs d'état de l'optimiseur.

    Déclaration

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

    Déclaration

    public struct ParameterGroupOptimizerBuilder
  • Une couche de mise en commun maximale pour les données temporelles.

    Déclaration

    @frozen
    public struct MaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun maximale pour les données spatiales.

    Déclaration

    @frozen
    public struct MaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun maximale pour les données spatiales ou spatio-temporelles.

    Déclaration

    @frozen
    public struct MaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun moyenne pour les données temporelles.

    Déclaration

    @frozen
    public struct AvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun moyenne pour les données spatiales.

    Déclaration

    @frozen
    public struct AvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun moyenne pour les données spatiales ou spatio-temporelles.

    Déclaration

    @frozen
    public struct AvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun moyenne globale pour les données temporelles.

    Déclaration

    @frozen
    public struct GlobalAvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun moyenne globale pour les données spatiales.

    Déclaration

    @frozen
    public struct GlobalAvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de mise en commun moyenne globale pour les données spatiales et spatio-temporelles.

    Déclaration

    @frozen
    public struct GlobalAvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche globale de mise en commun maximale pour les données temporelles.

    Déclaration

    @frozen
    public struct GlobalMaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche globale de mise en commun maximale pour les données spatiales.

    Déclaration

    @frozen
    public struct GlobalMaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche globale de mise en commun maximale pour les données spatiales et spatio-temporelles.

    Déclaration

    @frozen
    public struct GlobalMaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de pooling max fractionnaire pour les données spatiales. Remarque: FractionalMaxPool n'a pas d'implémentation XLA et peut donc avoir des implications sur les performances.

    Déclaration

    @frozen
    public struct FractionalMaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • 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 avec le nom spécifié dans cet objet.

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

    En interne, PythonObject est implémenté en tant que pointeur compté par référence vers un PyObject API C Python.

    Déclaration

    @dynamicCallable
    @dynamicMemberLookup
    public struct PythonObject
    extension PythonObject : CustomStringConvertible
    extension PythonObject : CustomPlaygroundDisplayConvertible
    extension PythonObject : CustomReflectable
    extension PythonObject : PythonConvertible, ConvertibleFromPython
    extension PythonObject : SignedNumeric
    extension PythonObject : Strideable
    extension PythonObject : Equatable, Comparable
    extension PythonObject : Hashable
    extension PythonObject : MutableCollection
    extension PythonObject : Sequence
    extension PythonObject : ExpressibleByBooleanLiteral, ExpressibleByIntegerLiteral,
    ExpressibleByFloatLiteral, ExpressibleByStringLiteral
    extension PythonObject : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral
  • Un wrapper PythonObject qui permet de lancer des appels de méthode. Les exceptions produites par les fonctions Python sont reflétées comme des erreurs Swift et levées.

    Remarque

    Il est intentionnel que ThrowingPythonObject n'ait pas l'attribut @dynamicCallable car la syntaxe d'appel n'est pas intuitive: x.throwing(arg1, arg2, ...) . Les méthodes seront toujours nommées dynamicallyCall jusqu'à une discussion / conception plus approfondie.

    Déclaration

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

    Déclaration

    @dynamicMemberLookup
    public struct CheckingPythonObject
  • Une interface pour Python.

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

    Remarque

    Il n'est pas prévu que PythonInterface soit initialisé directement. À la place, veuillez utiliser l'instance globale de PythonInterface appelée Python .

    Déclaration

    @dynamicMemberLookup
    public struct PythonInterface
  • Déclaration

    public struct PythonLibrary
  • Un générateur de nombres aléatoires effacés de 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.

    Déclaration

    public struct AnyRandomNumberGenerator : RandomNumberGenerator
  • Une implémentation de SeedableRandomNumberGenerator utilisant ARC4.

    ARC4 est un chiffrement de flux qui génère un flux pseudo-aléatoire d'octets. 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 l'état. Les données aléatoires générées sont de haute qualité, mais ne conviennent pas aux applications cryptographiques.

    Déclaration

    @frozen
    public struct ARC4RandomNumberGenerator : SeedableRandomNumberGenerator
  • Une implémentation de SeedableRandomNumberGenerator utilisant Threefry. Salmon 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 de 20 tours. Il doit être amorcé avec une valeur 64 bits.

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

    Déclaration

    public struct ThreefryRandomNumberGenerator : SeedableRandomNumberGenerator
  • Une implémentation de SeedableRandomNumberGenerator utilisant Philox. Salmon 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 de 10 coups. Il doit être amorcé avec une valeur 64 bits.

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

    Déclaration

    public struct PhiloxRandomNumberGenerator : SeedableRandomNumberGenerator
  • Déclaration

    @frozen
    public struct UniformIntegerDistribution<T> : RandomDistribution where T : FixedWidthInteger
  • Déclaration

    @frozen
    public struct UniformFloatingPointDistribution<T: BinaryFloatingPoint>: RandomDistribution
    where T.RawSignificand: FixedWidthInteger
  • Déclaration

    @frozen
    public struct NormalDistribution<T: BinaryFloatingPoint>: RandomDistribution
    where T.RawSignificand: FixedWidthInteger
  • Déclaration

    @frozen
    public struct BetaDistribution : RandomDistribution
  • Une entrée vers un réseau neuronal récurrent.

    Déclaration

    public struct RNNCellInput<Input, State> : Differentiable where Input : Differentiable, State : Differentiable
    extension RNNCellInput: EuclideanDifferentiable
    where Input: EuclideanDifferentiable, State: EuclideanDifferentiable
  • Une sortie vers un réseau neuronal récurrent.

    Déclaration

    public struct RNNCellOutput<Output, State> : Differentiable where Output : Differentiable, State : Differentiable
    extension RNNCellOutput: EuclideanDifferentiable
    where Output: EuclideanDifferentiable, State: EuclideanDifferentiable
  • Une cellule RNN de base.

    Déclaration

    public struct BasicRNNCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint
  • Une cellule LSTM.

    Déclaration

    public struct LSTMCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint
  • Une cellule GRU.

    Déclaration

    public struct GRUCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint
  • Déclaration

    public struct RecurrentLayer<Cell> : Layer where Cell : RecurrentLayerCell
    extension RecurrentLayer: Equatable where Cell: Equatable
    extension RecurrentLayer: AdditiveArithmetic where Cell: AdditiveArithmetic
  • Déclaration

    public struct BidirectionalRecurrentLayer<Cell: RecurrentLayerCell>: Layer
    where Cell.TimeStepOutput: Mergeable
  • Un calque qui compose séquentiellement deux ou plusieurs autres calques.

    Exemples:

    • Construisez 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)
    }
    

    Déclaration

    public struct Sequential<Layer1: Module, Layer2: Layer>: Module
        where Layer1.Output == Layer2.Input,
              Layer1.TangentVector.VectorSpaceScalar == Layer2.TangentVector.VectorSpaceScalar
    extension Sequential: Layer where Layer1: Layer
  • Déclaration

    @_functionBuilder
    public struct LayerBuilder
  • ShapedArray est un tableau multidimensionnel. Il a une forme, qui a le type [Int] et définit les dimensions du tableau, et utilise un TensorBuffer interne comme stockage.

    Déclaration

    @frozen
    public struct ShapedArray<Scalar> : _ShapedArrayProtocol
    extension ShapedArray: RandomAccessCollection, MutableCollection
    extension ShapedArray: CustomStringConvertible
    extension ShapedArray: CustomPlaygroundDisplayConvertible
    extension ShapedArray: CustomReflectable
    extension ShapedArray: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar
    extension ShapedArray: Equatable where Scalar: Equatable
    extension ShapedArray: Hashable where Scalar: Hashable
    extension ShapedArray: Codable where Scalar: Codable
  • Une tranche contiguë d'une instance ShapedArray ou ShapedArraySlice .

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

    Les tableaux d'éléments sont des éléments sous-dimensionnels d'un ShapedArray : leur rang est inférieur de 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ë des éléments d'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 la plage 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). Les méthodes comme 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]].
    

    Déclaration

    @frozen
    public struct ShapedArraySlice<Scalar> : _ShapedArrayProtocol
    extension ShapedArraySlice: RandomAccessCollection, MutableCollection
    extension ShapedArraySlice: CustomStringConvertible
    extension ShapedArraySlice: CustomPlaygroundDisplayConvertible
    extension ShapedArraySlice: CustomReflectable
    extension ShapedArraySlice: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar
    extension ShapedArraySlice: Equatable where Scalar: Equatable
    extension ShapedArraySlice: Hashable where Scalar: Hashable
    extension ShapedArraySlice: Codable where Scalar: Codable
  • StringTensor est un tableau multidimensionnel dont les éléments sont des String s.

    Déclaration

    @frozen
    public struct StringTensor
    extension StringTensor: TensorGroup
  • TensorHandle est le type utilisé par ops. 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.

    Déclaration

    public struct TensorHandle<Scalar> where Scalar : _TensorFlowDataTypeCompatible
    extension TensorHandle: TensorGroup
  • Déclaration

    public struct ResourceHandle
    extension ResourceHandle: TensorGroup
  • Déclaration

    public struct VariantHandle
    extension VariantHandle: TensorGroup
  • Une structure représentant la forme d'un tenseur.

    TensorShape est un wrapper fin autour d'un tableau d'entiers qui représentent les dimensions de la forme. Tous les types de tenseur utilisent TensorShape pour représenter leur forme.

    Déclaration

    @frozen
    public struct TensorShape : ExpressibleByArrayLiteral
    extension TensorShape: Collection, MutableCollection
    extension TensorShape: RandomAccessCollection
    extension TensorShape: RangeReplaceableCollection
    extension TensorShape: Equatable
    extension TensorShape: Codable
    extension TensorShape: CustomStringConvertible
  • TensorVisitorPlan se rapproche de [WritableKeyPath<Base, Tensor<Float>] mais est plus efficace. Ceci est utile pour écrire des optimiseurs génériques qui veulent mapper sur les gradients, les poids existants et un index qui peut être utilisé pour trouver des poids stockés auxiliaires. C'est un peu 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érence de pointeur supplémentaire) pour ne pas avoir à faire le travail O (depth_of_tree) qui est nécessaire avec une liste simple pour suivre chaque KeyPath individuel.

    Déclaration

    public struct TensorVisitorPlan<Base>
  • Une couche de suréchantillonnage pour les entrées 1D.

    Déclaration

    @frozen
    public struct UpSampling1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de suréchantillonnage pour les entrées 2D.

    Déclaration

    @frozen
    public struct UpSampling2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Une couche de suréchantillonnage pour les entrées 3-D.

    Déclaration

    @frozen
    public struct UpSampling3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • Collecte des compteurs de prédiction et des totaux de pertes corrects.

    Déclaration

    public struct HostStatistics