Estructuras

Las siguientes estructuras están disponibles a nivel mundial.

  • Una concatenación de dos secuencias con el mismo tipo de elemento.

    Declaración

    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

  • Una vista rotada de una colección.

    Declaración

    public struct RotatedCollection<Base> : Collection where Base : Collection
    extension RotatedCollection: BidirectionalCollection
where Base: BidirectionalCollection
    extension RotatedCollection: RandomAccessCollection
where Base: RandomAccessCollection

  • Declaración

    public struct AnyDifferentiable : Differentiable

  • Un valor derivado de tipo borrado.

    El AnyDerivative tipo reenvía sus operaciones a un valor derivado de base subyacente arbitraria conforme a Differentiable y AdditiveArithmetic , ocultando los detalles del valor subyacente.

    Declaración

    @frozen
public struct AnyDerivative : Differentiable & AdditiveArithmetic

  • Una matriz multidimensional de elementos que es una generalización de vectores y matrices a dimensiones potencialmente más altas.

    El parámetro genérico Scalar describe el tipo de escalares en el tensor (tales como Int32 , Float , etc).

    Declaración

    @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
    extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
    extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
    extension Tensor: Equatable where Scalar: Equatable
    extension Tensor: Codable where Scalar: Codable
    extension Tensor: AdditiveArithmetic where Scalar: Numeric
    extension Tensor: PointwiseMultiplicative where Scalar: Numeric
    extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
    extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

  • Una función de retroceso que realiza la transpuesta de radiodifusión dos Tensors .

    Declaración

    public struct BroadcastingPullback

  • Un contexto que almacena información contextual local de subprocesos utilizada por API de aprendizaje profundo, como capas.

    Utilice Context.local para recuperar el contexto local de subprocesos actual.

    Ejemplos:

    • Establecer la fase de aprendizaje actual para la formación de capas de manera que como BatchNorm calcularán media y la varianza cuando se aplica a las entradas.
      Context.local.learningPhase = .training
    • Establecer la fase de aprendizaje actual a la inferencia de modo que las capas como Dropout no se retirarán las unidades cuando se aplica a las entradas.
      Context.local.learningPhase = .inference

    Declaración

    public struct Context

  • Una capa de convolución 1-D (por ejemplo, convolución temporal sobre una serie de tiempo).

    Esta capa crea un filtro de convolución que se convoluciona con la entrada de la capa para producir un tensor de salidas.

    Declaración

    @frozen
public struct Conv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución 2-D (por ejemplo, convolución espacial sobre imágenes).

    Esta capa crea un filtro de convolución que se convoluciona con la entrada de la capa para producir un tensor de salidas.

    Declaración

    @frozen
public struct Conv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución 3-D para convolución espacial / espacio-temporal sobre imágenes.

    Esta capa crea un filtro de convolución que se convoluciona con la entrada de la capa para producir un tensor de salidas.

    Declaración

    @frozen
public struct Conv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución transpuesta 1-D (por ejemplo, convolución transpuesta temporal sobre imágenes).

    Esta capa crea un filtro de convolución que se transpone-convoluciona con la entrada de la capa para producir un tensor de salidas.

    Declaración

    @frozen
public struct TransposedConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución transpuesta 2-D (por ejemplo, convolución transpuesta espacial sobre imágenes).

    Esta capa crea un filtro de convolución que se transpone-convoluciona con la entrada de la capa para producir un tensor de salidas.

    Declaración

    @frozen
public struct TransposedConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución transpuesta 3-D (por ejemplo, convolución transpuesta espacial sobre imágenes).

    Esta capa crea un filtro de convolución que se transpone-convoluciona con la entrada de la capa para producir un tensor de salidas.

    Declaración

    @frozen
public struct TransposedConv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución en profundidad 2-D.

    Esta capa crea filtros de convolución separables que se convolucionan con la entrada de la capa para producir un tensor de salidas.

    Declaración

    @frozen
public struct DepthwiseConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa para agregar relleno de ceros en la dimensión temporal.

    Declaración

    public struct ZeroPadding1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa para agregar relleno de ceros en las dimensiones espaciales.

    Declaración

    public struct ZeroPadding2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa para agregar relleno de ceros en las dimensiones espacial / espacio-temporal.

    Declaración

    public struct ZeroPadding3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución separable 1-D.

    Esta capa realiza una convolución en profundidad que actúa por separado en los canales seguida de una convolución puntual que mezcla los canales.

    Declaración

    @frozen
public struct SeparableConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de convolución 2-D Separable.

    Esta capa realiza una convolución en profundidad que actúa por separado en los canales seguida de una convolución puntual que mezcla los canales.

    Declaración

    @frozen
public struct SeparableConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa plana.

    Una capa plana aplana la entrada cuando se aplica sin afectar el tamaño del lote.

    Declaración

    @frozen
public struct Flatten<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa remodelada.

    Declaración

    @frozen
public struct Reshape<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa que encierra una función diferenciable personalizada.

    Declaración

    public struct Function<Input, Output> : ParameterlessLayer where Input : Differentiable, Output : Differentiable

  • Un TensorFlow valor de tipo dinámico que puede ser creado a partir de los tipos que se ajusten a TensorFlowScalar .

    Declaración

    public struct TensorDataType : Equatable

  • Declaración

    @frozen
public struct BFloat16
    extension BFloat16: TensorFlowScalar
    extension BFloat16: XLAScalarType

  • Representa un conjunto de elementos potencialmente grande.

    Un Dataset se puede utilizar para representar una tubería de entrada como una colección de los tensores de los elementos.

    Declaración

    @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

  • El tipo que permite la iteración sobre los elementos de un conjunto de datos.

    Declaración

    @available(*, deprecated)
@frozen
public struct DatasetIterator<Element> where Element : TensorGroup
    extension DatasetIterator: IteratorProtocol

  • A struct 2-tupla-como que se ajuste a TensorGroup que representa una tupla de 2 tipos conformes a TensorGroup .

    Declaración

    @frozen
public struct Zip2TensorGroup<T, U> : TensorGroup where T : TensorGroup, U : TensorGroup

  • Una capa de red neuronal densamente conectada.

    Dense implementa la operación activation(matmul(input, weight) + bias) , donde weight es una matriz de pesos, bias es un vector de polarización, y activation es una función de activación elemento a elemento.

    Esta capa también admite tensores de peso 3-D con matrices de polarización 2-D. En este caso la primera dimensión de ambos es entendido como el tamaño del lote que está alineado con la primera dimensión de input y la variante de lote del matmul(_:_:) operación se utiliza, por lo tanto con un peso y el sesgo diferente para cada elemento en lote de entrada.

    Declaración

    @frozen
public struct Dense<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Un dispositivo en el que Tensor pueden asignarse s.

    Declaración

    public struct Device
    extension Device: Equatable
    extension Device: CustomStringConvertible

  • Una capa de abandono.

    Deserción consiste en establecer aleatoriamente una fracción de las unidades de entrada a 0 en cada actualización durante el tiempo de formación, lo que ayuda a evitar el sobreajuste.

    Declaración

    @frozen
public struct Dropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • GaussianNoise añade ruido muestreado de una distribución normal.

    El ruido agregado siempre tiene una media de cero, pero tiene una desviación estándar configurable.

    Declaración

    public struct GaussianNoise<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • GaussianDropout multiplica la entrada con el ruido muestreada a partir de una distribución normal con media 1,0.

    Debido a que esta es una capa de regularización, solo está activa durante el tiempo de entrenamiento. Durante la inferencia, GaussianDropout pasa a través de la entrada no modificado.

    Declaración

    public struct GaussianDropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de deserción alfa.

    Alfa deserción es una Dropout que mantiene la media y la varianza de las entradas a sus valores originales, con el fin de asegurar la propiedad de auto-normalización, incluso después de esta deserción. Alpha Dropout se adapta bien a las unidades lineales exponenciales escaladas al configurar de forma aleatoria las activaciones al valor de saturación negativo.

    Fuente: Auto-Normalización Redes Neuronales: https://arxiv.org/abs/1706.02515

    Declaración

    @frozen
public struct AlphaDropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de incrustación.

    Embedding es efectivamente una tabla de búsqueda que mapea los índices de un vocabulario fijo a representaciones vectoriales de tamaño fijo (denso), por ejemplo [[0], [3]] -> [[0.25, 0.1], [0.6, -0.2]] .

    Declaración

    public struct Embedding<Scalar> : Module where Scalar : TensorFlowFloatingPoint

  • Un struct vacío que representa vacía TangentVector es para capas sin parámetros.

    Declaración

    public struct EmptyTangentVector: EuclideanDifferentiable, VectorProtocol, ElementaryFunctions,
  PointwiseMultiplicative, KeyPathIterable

  • Par de primer y segundo momento (es decir, media y varianza).

    Nota

    Esto es necesario porque los tipos de tuplas no son diferenciables.

    Declaración

    public struct Moments<Scalar> : Differentiable where Scalar : TensorFlowFloatingPoint

  • Una capa de dilatación morfológica 2-D

    Esta capa devuelve la dilatación morfágica del tensor de entrada con los filtros proporcionados.

    Declaración

    @frozen
public struct Dilation2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa de erosión morfológica bidimensional

    Esta capa devuelve la erosión morfágica del tensor de entrada con los filtros proporcionados.

    Declaración

    @frozen
public struct Erosion2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una selección perezosa de elementos, en un orden determinado, de alguna colección base.

    Declaración

    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

  • Una colección de los cortes contiguos más larga que no se solapan de algunos Base colección, a partir de su primer elemento, y que tiene algunos longitud máxima fija.

    Los elementos de esta colección, a excepción de la última, todos tienen un count de batchSize , a menos que Base.count % batchSize !=0 , en cuyo caso el último lote es count es base.count % batchSize.

    Declaración

    public struct Slices<Base> where Base : Collection
    extension Slices: Collection

  • Una capa de normalización por lotes.

    Normaliza las activaciones de la capa anterior en cada lote, es decir, se aplica una transformación que mantiene la activación cerca media a 0 y la activación desviación estándar cerca de 1 .

    Referencia: Lote Normalización: La aceleración de Deep Red de Formación mediante la reducción de Covarianza de cambio interno .

    Declaración

    @frozen
public struct BatchNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa que aplica la normalización de la capa sobre un mini lote de entradas.

    Referencia: Capa de Normalización .

    Declaración

    @frozen
public struct LayerNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa que aplica la normalización de grupo sobre un minigolote de entradas.

    Referencia: Grupo Normalización .

    Declaración

    @frozen
public struct GroupNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Una capa que aplica la normalización de instancias sobre un minigolote de entradas.

    Referencia: Instancia Normalización: el ingrediente que falta para Fast estilización .

    Declaración

    @frozen
public struct InstanceNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint

  • Estado de un solo paso de un solo peso dentro de un optimizador.

    Declaración

    public struct OptimizerWeightStepState

  • Estado global accede a través de StateAccessor .

    Declaración

    public struct OptimizerState

  • [String: Float] pero los elementos se puede acceder como si fueran miembros.

    Declaración

    @dynamicMemberLookup
public struct HyperparameterDictionary

  • Un optimizador que trabaja en un solo grupo de parámetros.

    Declaración

    public struct ParameterGroupOptimizer

  • Una envoltura de tipo seguro alrededor de un Int valor de índice para optimizador valores locales.

    Declaración

    public struct LocalAccessor

  • Una envoltura de tipo seguro en torno a un Int valor del índice de optimizador valores globales.

    Declaración

    public struct GlobalAccessor

  • Una envoltura de tipo seguro alrededor de un Int valor de índice para los valores de estado optimizador.

    Declaración

    public struct StateAccessor

  • Construye una ParameterGroupOptimizer . Esto se usa esencialmente al nivel de un solo peso en el modelo. Un mapeo de grupos de parámetros seleccionados por ( [Bool] a ParameterGroupOptimizer) define el optimizador final.

    Declaración

    public struct ParameterGroupOptimizerBuilder

  • Una capa de agrupación máxima para datos temporales.

    Declaración

    @frozen
public struct MaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación máxima para datos espaciales.

    Declaración

    @frozen
public struct MaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación máxima para datos espaciales o espacio-temporales.

    Declaración

    @frozen
public struct MaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación promedio para datos temporales.

    Declaración

    @frozen
public struct AvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación promedio para datos espaciales.

    Declaración

    @frozen
public struct AvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación promedio para datos espaciales o espacio-temporales.

    Declaración

    @frozen
public struct AvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación promedio global para datos temporales.

    Declaración

    @frozen
public struct GlobalAvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación promedio global para datos espaciales.

    Declaración

    @frozen
public struct GlobalAvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación promedio global para datos espaciales y espacio-temporales.

    Declaración

    @frozen
public struct GlobalAvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación máxima global para datos temporales.

    Declaración

    @frozen
public struct GlobalMaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación máxima global para datos espaciales.

    Declaración

    @frozen
public struct GlobalMaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación máxima global para datos espaciales y espacio-temporales.

    Declaración

    @frozen
public struct GlobalMaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de agrupación máxima fraccionada para datos espaciales. Nota: FractionalMaxPool no tiene una aplicación XLA, y por lo tanto puede tener consecuencias en el rendimiento.

    Declaración

    @frozen
public struct FractionalMaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • PythonObject representa un objeto en Python y soporta las operaciones de búsqueda miembro dinámico. Cualquier miembro de acceso como object.foo dinámicamente solicitará la ejecución de Python para un miembro con el nombre especificado en este objeto.

    PythonObject se pasa hacia y regresó de todas las llamadas de función de Python y referencias miembros. Admite operadores aritméticos y de comparación estándar de Python.

    Internamente, PythonObject se implementa como un puntero de referencia contado a un Python C API PyObject .

    Declaración

    @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 PythonObject envoltorio que permite lanzar llamadas a métodos. Las excepciones producidas por las funciones de Python se reflejan como errores de Swift y se lanzan.

    Nota

    Es intencional que ThrowingPythonObject no tiene la @dynamicCallable atributo porque la sintaxis de llamada no es intuitivo: x.throwing(arg1, arg2, ...) . Los métodos todavía serán nombrados dynamicallyCall hasta nuevo análisis / diseño.

    Declaración

    public struct ThrowingPythonObject

  • Un PythonObject envoltorio que permite accesos miembros. Las operaciones de acceso devuelven un miembro Optional resultado. Cuando el acceso falla, el fallo nil se devuelve.

    Declaración

    @dynamicMemberLookup
public struct CheckingPythonObject

  • Una interfaz para Python.

    PythonInterface permite la interacción con Python. Se puede usar para importar módulos y acceder dinámicamente a tipos y funciones incorporados de Python.

    Nota

    No es la intención de PythonInterface a ser inicializado directamente. En su lugar, utilice la instancia global de PythonInterface llamada Python .

    Declaración

    @dynamicMemberLookup
public struct PythonInterface

  • Declaración

    public struct PythonLibrary

  • Un generador de números aleatorios de tipo borrado.

    El AnyRandomNumberGenerator tipo hacia adelante las operaciones de generación de números aleatorios para un generador de números aleatorios subyacente, ocultando su tipo específico subyacente.

    Declaración

    public struct AnyRandomNumberGenerator : RandomNumberGenerator

  • Una implementación de SeedableRandomNumberGenerator usando ARC4.

    ARC4 es un cifrado de flujo que genera un flujo de bytes pseudoaleatorio. Este PRNG usa la semilla como clave.

    ARC4 se describe en Schneier, B., "Criptografía aplicada: protocolos, algoritmos y código fuente en C", segunda edición, 1996.

    Un generador individual no es seguro para subprocesos, pero los distintos generadores no comparten el estado. Los datos aleatorios generados son de alta calidad, pero no son adecuados para aplicaciones criptográficas.

    Declaración

    @frozen
public struct ARC4RandomNumberGenerator : SeedableRandomNumberGenerator

  • Una implementación de SeedableRandomNumberGenerator usando Threefry. Salmon y col. SC 2011. números aleatorios paralelos: tan fácil como 1, 2, 3. http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

    Esta estructura implementa un PRNG Threefry2x32 de 20 rondas. Debe sembrarse con un valor de 64 bits.

    Un generador individual no es seguro para subprocesos, pero los distintos generadores no comparten el estado. Los datos aleatorios generados son de alta calidad, pero no son adecuados para aplicaciones criptográficas.

    Declaración

    public struct ThreefryRandomNumberGenerator : SeedableRandomNumberGenerator

  • Una implementación de SeedableRandomNumberGenerator usando Philox. Salmon y col. SC 2011. números aleatorios paralelos: tan fácil como 1, 2, 3. http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

    Esta estructura implementa un PRNG Philox4x32 de 10 rondas. Debe sembrarse con un valor de 64 bits.

    Un generador individual no es seguro para subprocesos, pero los distintos generadores no comparten el estado. Los datos aleatorios generados son de alta calidad, pero no son adecuados para aplicaciones criptográficas.

    Declaración

    public struct PhiloxRandomNumberGenerator : SeedableRandomNumberGenerator

  • Declaración

    @frozen
public struct UniformIntegerDistribution<T> : RandomDistribution where T : FixedWidthInteger

  • Declaración

    @frozen
public struct UniformFloatingPointDistribution<T: BinaryFloatingPoint>: RandomDistribution
where T.RawSignificand: FixedWidthInteger

  • Declaración

    @frozen
public struct NormalDistribution<T: BinaryFloatingPoint>: RandomDistribution
where T.RawSignificand: FixedWidthInteger

  • Declaración

    @frozen
public struct BetaDistribution : RandomDistribution

  • Una entrada a una red neuronal recurrente.

    Declaración

    public struct RNNCellInput<Input, State> : Differentiable where Input : Differentiable, State : Differentiable
    extension RNNCellInput: EuclideanDifferentiable
where Input: EuclideanDifferentiable, State: EuclideanDifferentiable

  • Una salida a una red neuronal recurrente.

    Declaración

    public struct RNNCellOutput<Output, State> : Differentiable where Output : Differentiable, State : Differentiable
    extension RNNCellOutput: EuclideanDifferentiable
where Output: EuclideanDifferentiable, State: EuclideanDifferentiable

  • Una celda RNN básica.

    Declaración

    public struct BasicRNNCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint

  • Una celda LSTM.

    Declaración

    public struct LSTMCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint

  • Una celda GRU.

    Declaración

    public struct GRUCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint

  • Declaración

    public struct RecurrentLayer<Cell> : Layer where Cell : RecurrentLayerCell
    extension RecurrentLayer: Equatable where Cell: Equatable
    extension RecurrentLayer: AdditiveArithmetic where Cell: AdditiveArithmetic

  • Declaración

    public struct BidirectionalRecurrentLayer<Cell: RecurrentLayerCell>: Layer
where Cell.TimeStepOutput: Mergeable

  • Una capa que compone secuencialmente otras dos o más capas.

    Ejemplos:

    • Construya un modelo simple de perceptrón de 2 capas para 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)
 }
    • Cree un codificador automático para 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)
}

    Declaración

    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

  • Declaración

    @_functionBuilder
public struct LayerBuilder

  • ShapedArray es una matriz multidimensional. Tiene una forma, que tiene tipo [Int] y define las dimensiones de la matriz, y utiliza un TensorBuffer internamente como de almacenamiento.

    Declaración

    @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

  • Una rebanada contiguos de una ShapedArray o ShapedArraySlice ejemplo.

    ShapedArraySlice permite una rápida, operaciones eficientes en cortes contiguos de ShapedArray casos. ShapedArraySlice casos no tienen su propio almacenamiento. En su lugar, ofrece una vista sobre el almacenamiento de su base ShapedArray . ShapedArraySlice puede representar dos tipos diferentes de rebanadas: conjuntos de elementos y subconjuntos.

    Conjuntos de elementos son elementos subdimensional de un ShapedArray : su rango es uno menos que la de su base. Element rebanadas de matriz se obtienen mediante la indexación de un ShapedArray ejemplo con un singular Int32 índice.

    Por ejemplo:

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

    Submatrices son un intervalo contiguo de los elementos en un ShapedArray . El rango de un subarreglo es el mismo que el de su base, pero su dimensión principal es el recuento del rango de corte. Rebanadas subarreglo se obtienen mediante la indexación de un ShapedArray con un Range<Int32> que representa un rango de elementos (en la dimensión principal). Métodos como prefix(:) y suffix(:) que internamente índice con una gama también producen submatriz.

    Por ejemplo:

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

    Declaración

    @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 es una matriz multidimensional cuyos elementos son String s.

    Declaración

    @frozen
public struct StringTensor
    extension StringTensor: TensorGroup

  • TensorHandle es el tipo utilizado por ops. Incluye un Scalar tipo, que internals compilador puede utilizar para determinar los tipos de datos de parámetros cuando se extraen en un programa de tensor.

    Declaración

    public struct TensorHandle<Scalar> where Scalar : _TensorFlowDataTypeCompatible
    extension TensorHandle: TensorGroup

  • Declaración

    public struct ResourceHandle
    extension ResourceHandle: TensorGroup

  • Declaración

    public struct VariantHandle
    extension VariantHandle: TensorGroup

  • Estructura que representa la forma de un tensor.

    TensorShape es una envoltura fina alrededor de una matriz de enteros que representan dimensiones de forma. Todos los tipos de tensores utilizan TensorShape para representar a su forma.

    Declaración

    @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 aproxima [WritableKeyPath<Base, Tensor<Float>] , pero es más eficiente. Esto es útil para escribir optimizadores genéricos que desean mapear los gradientes, los pesos existentes y un índice que se puede usar para encontrar pesos almacenados de forma auxiliar. Esto es un poco más eficiente (~ 2x) pero podría ser mejor porque compensa gastos generales ligeramente más altos (desreferencia del puntero adicional) por no tener que hacer el trabajo O (profundidad_de_árbol) que se requiere con una lista simple para rastrear cada KeyPath individual.

    Declaración

    public struct TensorVisitorPlan<Base>

  • Una capa de muestreo superior para entradas 1-D.

    Declaración

    @frozen
public struct UpSampling1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de muestreo superior para entradas 2-D.

    Declaración

    @frozen
public struct UpSampling2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Una capa de muestreo superior para entradas 3D.

    Declaración

    @frozen
public struct UpSampling3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint

  • Recopila contadores de predicción correctos y totales de pérdidas.

    Declaración

    public struct HostStatistics