संरचनाएं

निम्नलिखित संरचनाएँ विश्व स्तर पर उपलब्ध हैं।

  • समान तत्व प्रकार वाले दो अनुक्रमों का संयोजन।

    घोषणा

    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

  • किसी संग्रह पर घुमाया गया दृश्य.

    घोषणा

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

  • घोषणा

    public struct AnyDifferentiable : Differentiable

  • एक प्रकार से मिटाया गया व्युत्पन्न मान.

    AnyDerivative प्रकार अपने संचालन को एक मनमाने ढंग से अंतर्निहित आधार व्युत्पन्न मूल्य पर अग्रेषित करता है जो Differentiable और AdditiveArithmetic के अनुरूप होता है, अंतर्निहित मूल्य की विशिष्टताओं को छिपाता है।

    घोषणा

    @frozen
public struct AnyDerivative : Differentiable & AdditiveArithmetic

  • तत्वों की एक बहुआयामी सरणी जो संभावित उच्च आयामों के लिए वैक्टर और मैट्रिक्स का सामान्यीकरण है।

    सामान्य पैरामीटर Scalar टेंसर में स्केलर के प्रकार का वर्णन करता है (जैसे Int32 , Float , आदि)।

    घोषणा

    @frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
    extension Tensor: Collatable
    extension Tensor: CopyableToDevice
    extension Tensor: AnyTensor
    extension Tensor: ExpressibleByArrayLiteral
    14 एल10
    extension Tensor: CustomPlaygroundDisplayConvertible
    extension Tensor: CustomStringConvertible
    15 एल
    extension Tensor: CustomReflectable
    16 एल10एन-प्लेसहोल्डर17 एल10
    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

  • एक पुलबैक फ़ंक्शन जो दो Tensors को प्रसारित करने का स्थानान्तरण करता है।

    घोषणा

    public struct BroadcastingPullback

  • एक संदर्भ जो परतों जैसे गहन शिक्षण एपीआई द्वारा उपयोग की जाने वाली थ्रेड-स्थानीय प्रासंगिक जानकारी संग्रहीत करता है।

    वर्तमान थ्रेड-स्थानीय संदर्भ को पुनः प्राप्त करने के लिए Context.local उपयोग करें।

    उदाहरण:

    • वर्तमान सीखने के चरण को प्रशिक्षण के लिए सेट करें ताकि इनपुट पर लागू होने पर BatchNorm जैसी परतें माध्य और भिन्नता की गणना कर सकें।
      Context.local.learningPhase = .training
    • वर्तमान सीखने के चरण को अनुमान पर सेट करें ताकि Dropout जैसी परतें इनपुट पर लागू होने पर इकाइयों को न छोड़ें।
      Context.local.learningPhase = .inference

    घोषणा

    public struct Context

  • एक 1-डी कनवल्शन परत (उदाहरण के लिए समय-श्रृंखला पर अस्थायी कनवल्शन)।

    यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़ती है।

    घोषणा

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

  • एक 2-डी कनवल्शन परत (जैसे छवियों पर स्थानिक कनवल्शन)।

    यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़ती है।

    घोषणा

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

  • छवियों पर स्थानिक/स्थानिक-लौकिक कनवल्शन के लिए एक 3-डी कनवल्शन परत।

    यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़ती है।

    घोषणा

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

  • एक 1-डी ट्रांसपोज़्ड कन्वोल्यूशन परत (उदाहरण के लिए छवियों पर टेम्पोरल ट्रांसपोज़्ड कन्वोल्यूशन)।

    यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ ट्रांसपोज़-कन्वॉल्व होता है।

    घोषणा

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

  • एक 2-डी ट्रांसपोज़्ड कनवल्शन परत (जैसे छवियों पर स्थानिक ट्रांसपोज़्ड कनवल्शन)।

    यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ ट्रांसपोज़-कन्वॉल्व होता है।

    घोषणा

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

  • एक 3-डी ट्रांसपोज़्ड कनवल्शन परत (जैसे छवियों पर स्थानिक ट्रांसपोज़्ड कनवल्शन)।

    यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ ट्रांसपोज़-कन्वॉल्व होता है।

    घोषणा

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

  • एक 2-डी गहराईवार कनवल्शन परत।

    यह परत अलग-अलग कन्वोल्यूशन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़े होते हैं।

    घोषणा

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

  • अस्थायी आयाम में शून्य-पैडिंग जोड़ने के लिए एक परत।

    घोषणा

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

  • स्थानिक आयामों में शून्य-पैडिंग जोड़ने के लिए एक परत।

    घोषणा

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

  • स्थानिक/स्थानिक-लौकिक आयामों में शून्य-पैडिंग जोड़ने के लिए एक परत।

    घोषणा

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

  • एक 1-डी वियोज्य कनवल्शन परत।

    यह परत एक गहराई से कनवल्शन करती है जो चैनलों पर अलग-अलग कार्य करती है और इसके बाद एक बिंदुवार कनवल्शन होता है जो चैनलों को मिलाता है।

    घोषणा

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

  • एक 2-डी वियोज्य कनवल्शन परत।

    यह परत एक गहराई से कनवल्शन करती है जो चैनलों पर अलग-अलग कार्य करती है और इसके बाद एक बिंदुवार कनवल्शन होता है जो चैनलों को मिलाता है।

    घोषणा

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

  • एक चपटी परत.

    एक समतल परत बैच आकार को प्रभावित किए बिना लागू करने पर इनपुट को समतल कर देती है।

    घोषणा

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

  • एक नयी आकार देने वाली परत.

    घोषणा

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

  • एक परत जो एक कस्टम भिन्न फ़ंक्शन को संलग्न करती है।

    घोषणा

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

  • एक TensorFlow गतिशील प्रकार मान जिसे TensorFlowScalar के अनुरूप प्रकारों से बनाया जा सकता है।

    घोषणा

    public struct TensorDataType : Equatable

  • घोषणा

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

  • तत्वों के संभावित बड़े समूह का प्रतिनिधित्व करता है।

    एक Dataset उपयोग तत्व टेंसर के संग्रह के रूप में इनपुट पाइपलाइन का प्रतिनिधित्व करने के लिए किया जा सकता है।

    घोषणा

    @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

  • वह प्रकार जो डेटासेट के तत्वों पर पुनरावृत्ति की अनुमति देता है।

    घोषणा

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

  • एक 2-ट्यूपल जैसी संरचना जो TensorGroup के अनुरूप है जो TensorGroup के अनुरूप 2 प्रकार के टुपल का प्रतिनिधित्व करती है।

    घोषणा

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

  • सघन रूप से जुड़ी हुई तंत्रिका नेटवर्क परत।

    Dense ऑपरेशन activation(matmul(input, weight) + bias) लागू करता है, जहां weight एक वजन मैट्रिक्स है, bias एक पूर्वाग्रह वेक्टर है, और activation एक तत्व-वार सक्रियण फ़ंक्शन है।

    यह परत 2-डी बायस मैट्रिसेस के साथ 3-डी वेट टेंसर का भी समर्थन करती है। इस मामले में दोनों के पहले आयाम को बैच आकार के रूप में माना जाता है जो input के पहले आयाम के साथ संरेखित होता है और matmul(_:_:) ऑपरेशन के बैच संस्करण का उपयोग किया जाता है, इस प्रकार प्रत्येक तत्व के लिए एक अलग वजन और पूर्वाग्रह का उपयोग किया जाता है इनपुट बैच में.

    घोषणा

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

  • एक उपकरण जिस पर Tensor आवंटित किया जा सकता है।

    घोषणा

    public struct Device
    extension Device: Equatable
    extension Device: CustomStringConvertible

  • एक ड्रॉपआउट परत.

    ड्रॉपआउट में प्रशिक्षण समय के दौरान प्रत्येक अपडेट पर इनपुट इकाइयों के एक अंश को बेतरतीब ढंग से 0 पर सेट करना शामिल है, जो ओवरफिटिंग को रोकने में मदद करता है।

    घोषणा

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

  • GaussianNoise सामान्य वितरण से नमूना शोर जोड़ता है।

    जोड़े गए शोर का माध्य हमेशा शून्य होता है, लेकिन इसमें एक विन्यास योग्य मानक विचलन होता है।

    घोषणा

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

  • GaussianDropout माध्य 1.0 के साथ सामान्य वितरण से लिए गए शोर के साथ इनपुट को गुणा करता है।

    क्योंकि यह एक नियमितीकरण परत है, यह केवल प्रशिक्षण समय के दौरान सक्रिय होती है। अनुमान के दौरान, GaussianDropout असंशोधित इनपुट से गुजरता है।

    घोषणा

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

  • एक अल्फ़ा ड्रॉपआउट परत.

    अल्फा ड्रॉपआउट एक Dropout है जो इस ड्रॉपआउट के बाद भी स्व-सामान्यीकरण संपत्ति को सुनिश्चित करने के लिए इनपुट के माध्य और भिन्नता को उनके मूल मूल्यों पर रखता है। सक्रियण को नकारात्मक संतृप्ति मान पर बेतरतीब ढंग से सेट करके अल्फा ड्रॉपआउट स्केल्ड एक्सपोनेंशियल रैखिक इकाइयों के लिए अच्छी तरह से फिट बैठता है।

    स्रोत: स्व-सामान्यीकरण तंत्रिका नेटवर्क: https://arxiv.org/abs/1706.02515

    घोषणा

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

  • एक एम्बेडिंग परत.

    Embedding प्रभावी रूप से एक लुकअप तालिका है जो एक निश्चित शब्दावली से निश्चित आकार (घने) वेक्टर प्रतिनिधित्व में सूचकांकों को मैप करती है, उदाहरण के लिए [[0], [3]] -> [[0.25, 0.1], [0.6, -0.2]]

    घोषणा

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

  • पैरामीटर रहित परतों के लिए खाली TangentVector प्रतिनिधित्व करने वाली एक खाली संरचना।

    घोषणा

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

  • पहले और दूसरे क्षणों की जोड़ी (यानी, माध्य और विचरण)।

    टिप्पणी

    इसकी आवश्यकता है क्योंकि टुपल प्रकार भिन्न नहीं होते हैं।

    घोषणा

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

  • एक 2-डी रूपात्मक फैलाव परत

    यह परत दिए गए फ़िल्टर के साथ इनपुट टेंसर के रूपात्मक फैलाव को लौटाती है

    घोषणा

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

  • एक 2-डी रूपात्मक क्षरण परत

    यह परत प्रदान किए गए फ़िल्टर के साथ इनपुट टेंसर के रूपात्मक क्षरण को लौटाती है

    घोषणा

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

  • कुछ आधार संग्रह से, दिए गए क्रम में तत्वों का एक आलसी चयन।

    घोषणा

    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

  • कुछ Base संग्रह के सबसे लंबे गैर-अतिव्यापी सन्निहित स्लाइस का एक संग्रह, जो इसके पहले तत्व से शुरू होता है, और कुछ निश्चित अधिकतम लंबाई रखता है।

    इस संग्रह के तत्वों में, अंतिम को छोड़कर, सभी में batchSize की count होती है, जब तक कि Base.count % batchSize !=0 न हो, उस स्थिति में अंतिम बैच की count base.count % batchSize.

    घोषणा

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

  • एक बैच सामान्यीकरण परत.

    प्रत्येक बैच में पिछली परत की सक्रियता को सामान्य करता है, यानी एक परिवर्तन लागू करता है जो औसत सक्रियण को 0 के करीब और सक्रियण मानक विचलन को 1 के करीब बनाए रखता है।

    संदर्भ: बैच सामान्यीकरण: आंतरिक सहसंयोजक बदलाव को कम करके गहन नेटवर्क प्रशिक्षण में तेजी लाना ।

    घोषणा

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

  • एक परत जो इनपुट के एक मिनी-बैच पर परत सामान्यीकरण लागू करती है।

    संदर्भ: परत सामान्यीकरण ।

    घोषणा

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

  • एक परत जो इनपुट के एक मिनी-बैच पर समूह सामान्यीकरण लागू करती है।

    संदर्भ: समूह सामान्यीकरण ।

    घोषणा

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

  • एक परत जो इनपुट के एक मिनी-बैच पर इंस्टेंस सामान्यीकरण लागू करती है।

    संदर्भ: इंस्टेंस नॉर्मलाइज़ेशन: द मिसिंग इंग्रीडिएंट फॉर फ़ास्ट स्टाइलाइज़ेशन ।

    घोषणा

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

  • एक ऑप्टिमाइज़र के अंदर एक वज़न के एक चरण के लिए बताएं।

    घोषणा

    public struct OptimizerWeightStepState

  • StateAccessor के माध्यम से वैश्विक स्थिति तक पहुँचा जा सकता है।

    घोषणा

    public struct OptimizerState

  • [String: Float] लेकिन तत्वों तक ऐसे पहुंचा जा सकता है मानो वे सदस्य हों।

    घोषणा

    @dynamicMemberLookup
public struct HyperparameterDictionary

  • एक ऑप्टिमाइज़र जो एकल पैरामीटर समूह पर काम करता है।

    घोषणा

    public struct ParameterGroupOptimizer

  • ऑप्टिमाइज़र स्थानीय मानों के लिए Int इंडेक्स मान के चारों ओर एक प्रकार-सुरक्षित आवरण।

    घोषणा

    public struct LocalAccessor

  • ऑप्टिमाइज़र वैश्विक मूल्यों के लिए Int इंडेक्स मान के चारों ओर एक प्रकार-सुरक्षित आवरण।

    घोषणा

    public struct GlobalAccessor

  • ऑप्टिमाइज़र स्थिति मानों के लिए Int इंडेक्स मान के चारों ओर एक प्रकार-सुरक्षित आवरण।

    घोषणा

    public struct StateAccessor

  • एक ParameterGroupOptimizer बनाता है। इसका उपयोग अनिवार्य रूप से मॉडल में एकल भार के स्तर पर किया जाता है। ( [Bool] से पैरामीटरग्रुपऑप्टिमाइज़र) द्वारा चयनित पैरामीटर समूहों से मैपिंग अंतिम ऑप्टिमाइज़र को परिभाषित करती है।

    घोषणा

    public struct ParameterGroupOptimizerBuilder

  • अस्थायी डेटा के लिए एक अधिकतम पूलिंग परत।

    घोषणा

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

  • स्थानिक डेटा के लिए अधिकतम पूलिंग परत।

    घोषणा

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

  • स्थानिक या स्थानिक-लौकिक डेटा के लिए एक अधिकतम पूलिंग परत।

    घोषणा

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

  • अस्थायी डेटा के लिए एक औसत पूलिंग परत।

    घोषणा

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

  • स्थानिक डेटा के लिए एक औसत पूलिंग परत।

    घोषणा

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

  • स्थानिक या स्थानिक-लौकिक डेटा के लिए एक औसत पूलिंग परत।

    घोषणा

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

  • अस्थायी डेटा के लिए एक वैश्विक औसत पूलिंग परत।

    घोषणा

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

  • स्थानिक डेटा के लिए एक वैश्विक औसत पूलिंग परत।

    घोषणा

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

  • स्थानिक और स्थानिक-लौकिक डेटा के लिए एक वैश्विक औसत पूलिंग परत।

    घोषणा

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

  • अस्थायी डेटा के लिए एक वैश्विक अधिकतम पूलिंग परत।

    घोषणा

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

  • स्थानिक डेटा के लिए एक वैश्विक अधिकतम पूलिंग परत।

    घोषणा

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

  • स्थानिक और स्थानिक-लौकिक डेटा के लिए एक वैश्विक अधिकतम पूलिंग परत।

    घोषणा

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

  • स्थानिक डेटा के लिए एक आंशिक अधिकतम पूलिंग परत। ध्यान दें: FractionalMaxPool में XLA कार्यान्वयन नहीं है, और इस प्रकार प्रदर्शन पर प्रभाव पड़ सकता है।

    घोषणा

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

  • PythonObject Python में एक ऑब्जेक्ट का प्रतिनिधित्व करता है और गतिशील सदस्य लुकअप का समर्थन करता है। object.foo जैसा कोई भी सदस्य एक्सेस इस ऑब्जेक्ट में निर्दिष्ट नाम वाले सदस्य के लिए गतिशील रूप से पायथन रनटाइम का अनुरोध करेगा।

    PythonObject को सभी Python फ़ंक्शन कॉल और सदस्य संदर्भों से पास और वापस किया जाता है। यह मानक पायथन अंकगणित और तुलना ऑपरेटरों का समर्थन करता है।

    आंतरिक रूप से, PythonObject Python C API PyObject के संदर्भ-गणना सूचक के रूप में कार्यान्वित किया जाता है।

    घोषणा

    @dynamicCallable
@dynamicMemberLookup
public struct PythonObject
    extension PythonObject : CustomStringConvertible
    extension PythonObject : CustomPlaygroundDisplayConvertible
    प्लेसहोल्डर
    extension PythonObject : CustomReflectable
    extension PythonObject : PythonConvertible, ConvertibleFromPython
    106
    extension PythonObject : Strideable
    extension PythonObject : SignedNumeric
    extension PythonObject : Equatable, Comparable
    108 एल10एन-प्लेसहोल्डर109 एल10
    extension PythonObject : Hashable
    extension PythonObject : MutableCollection
    extension PythonObject : Sequence
    extension PythonObject : ExpressibleByBooleanLiteral, ExpressibleByIntegerLiteral,
ExpressibleByFloatLiteral, ExpressibleByStringLiteral
    extension PythonObject : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral

  • एक PythonObject रैपर जो विधि कॉल फेंकने में सक्षम बनाता है। पायथन फ़ंक्शंस द्वारा उत्पन्न अपवाद स्विफ्ट त्रुटियों के रूप में परिलक्षित होते हैं और फेंक दिए जाते हैं।

    टिप्पणी

    यह जानबूझकर किया गया है कि ThrowingPythonObject @dynamicCallable विशेषता नहीं है क्योंकि कॉल सिंटैक्स अनजान है: x.throwing(arg1, arg2, ...) आगे की चर्चा/डिज़ाइन तक विधियों को अभी भी dynamicallyCall नाम दिया जाएगा।

    घोषणा

    public struct ThrowingPythonObject

  • एक PythonObject रैपर जो सदस्य पहुंच को सक्षम बनाता है। सदस्य पहुंच संचालन एक Optional परिणाम लौटाता है। जब सदस्य पहुंच विफल हो जाती है, तो nil लौटा दिया जाता है।

    घोषणा

    @dynamicMemberLookup
public struct CheckingPythonObject

  • पायथन के लिए एक इंटरफ़ेस।

    PythonInterface Python के साथ इंटरेक्शन की अनुमति देता है। इसका उपयोग मॉड्यूल आयात करने और पायथन निर्मित प्रकारों और कार्यों को गतिशील रूप से एक्सेस करने के लिए किया जा सकता है।

    टिप्पणी

    PythonInterface सीधे आरंभ करने का इरादा नहीं है। इसके बजाय, कृपया PythonInterface के Python नामक वैश्विक उदाहरण का उपयोग करें।

    घोषणा

    @dynamicMemberLookup
public struct PythonInterface

  • घोषणा

    public struct PythonLibrary

  • एक प्रकार से मिटाया गया यादृच्छिक संख्या जनरेटर।

    AnyRandomNumberGenerator प्रकार अपने विशिष्ट अंतर्निहित प्रकार को छिपाते हुए, यादृच्छिक संख्या उत्पन्न करने वाले कार्यों को एक अंतर्निहित यादृच्छिक संख्या जनरेटर की ओर अग्रेषित करता है।

    घोषणा

    public struct AnyRandomNumberGenerator : RandomNumberGenerator

  • ARC4 का उपयोग करके SeedableRandomNumberGenerator का कार्यान्वयन।

    ARC4 एक स्ट्रीम सिफर है जो बाइट्स की छद्म-यादृच्छिक स्ट्रीम उत्पन्न करता है। यह पीआरएनजी बीज को अपनी कुंजी के रूप में उपयोग करता है।

    ARC4 का वर्णन श्नीयर, बी, "एप्लाइड क्रिप्टोग्राफी: प्रोटोकॉल, एल्गोरिदम, और सोर्स कोड इन सी", द्वितीय संस्करण, 1996 में किया गया है।

    एक व्यक्तिगत जनरेटर थ्रेड-सुरक्षित नहीं है, लेकिन अलग-अलग जनरेटर स्थिति साझा नहीं करते हैं। उत्पन्न यादृच्छिक डेटा उच्च गुणवत्ता वाला है, लेकिन क्रिप्टोग्राफ़िक अनुप्रयोगों के लिए उपयुक्त नहीं है।

    घोषणा

    @frozen
public struct ARC4RandomNumberGenerator : SeedableRandomNumberGenerator

  • थ्रीफ्राई का उपयोग करके SeedableRandomNumberGenerator का कार्यान्वयन। सैल्मन एट अल. एससी 2011. समानांतर यादृच्छिक संख्याएँ: 1, 2, 3 जितनी आसान। http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

    यह संरचना 20-राउंड थ्रीफ्राई2x32 पीआरएनजी लागू करती है। इसे 64-बिट मान के साथ सीड किया जाना चाहिए।

    एक व्यक्तिगत जनरेटर थ्रेड-सुरक्षित नहीं है, लेकिन अलग-अलग जनरेटर स्थिति साझा नहीं करते हैं। उत्पन्न यादृच्छिक डेटा उच्च गुणवत्ता वाला है, लेकिन क्रिप्टोग्राफ़िक अनुप्रयोगों के लिए उपयुक्त नहीं है।

    घोषणा

    public struct ThreefryRandomNumberGenerator : SeedableRandomNumberGenerator

  • फिलॉक्स का उपयोग करके SeedableRandomNumberGenerator का कार्यान्वयन। सैल्मन एट अल. एससी 2011. समानांतर यादृच्छिक संख्याएँ: 1, 2, 3 जितनी आसान। http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

    यह संरचना 10-राउंड फिलोक्स4x32 पीआरएनजी लागू करती है। इसे 64-बिट मान के साथ सीड किया जाना चाहिए।

    एक व्यक्तिगत जनरेटर थ्रेड-सुरक्षित नहीं है, लेकिन अलग-अलग जनरेटर स्थिति साझा नहीं करते हैं। उत्पन्न यादृच्छिक डेटा उच्च गुणवत्ता वाला है, लेकिन क्रिप्टोग्राफ़िक अनुप्रयोगों के लिए उपयुक्त नहीं है।

    घोषणा

    public struct PhiloxRandomNumberGenerator : SeedableRandomNumberGenerator

  • घोषणा

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

  • घोषणा

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

  • घोषणा

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

  • घोषणा

    @frozen
public struct BetaDistribution : RandomDistribution

  • आवर्ती तंत्रिका नेटवर्क के लिए एक इनपुट।

    घोषणा

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

  • आवर्ती तंत्रिका नेटवर्क के लिए एक आउटपुट।

    घोषणा

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

  • एक बुनियादी आरएनएन सेल।

    घोषणा

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

  • एक LSTM सेल.

    घोषणा

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

  • एक GRU सेल.

    घोषणा

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

  • घोषणा

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

  • घोषणा

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

  • एक परत जो क्रमिक रूप से दो या दो से अधिक अन्य परतें बनाती है।

    उदाहरण:

    • MNIST के लिए एक सरल 2-लेयर परसेप्ट्रॉन मॉडल बनाएं:
    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)
 }
    • 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)
}

    घोषणा

    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

  • घोषणा

    @_functionBuilder
public struct LayerBuilder

  • ShapedArray एक बहुआयामी सरणी है। इसका एक आकार है, जिसका प्रकार [Int] है और यह सरणी आयामों को परिभाषित करता है, और भंडारण के रूप में आंतरिक रूप से TensorBuffer उपयोग करता है।

    घोषणा

    @frozen
public struct ShapedArray<Scalar> : _ShapedArrayProtocol
    143
    extension ShapedArray: CustomStringConvertible
    extension ShapedArray: RandomAccessCollection, MutableCollection
    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

  • ShapedArray या ShapedArraySlice उदाहरण का एक सन्निहित टुकड़ा।

    ShapedArraySlice , ShapedArray उदाहरणों के सन्निहित स्लाइस पर तेज, कुशल संचालन को सक्षम बनाता है। ShapedArraySlice इंस्टेंसेस का अपना भंडारण नहीं होता है। इसके बजाय, वे अपने बेस ShapedArray के भंडारण पर एक दृश्य प्रदान करते हैं। ShapedArraySlice दो अलग-अलग प्रकार के स्लाइस का प्रतिनिधित्व कर सकता है: तत्व सरणी और उपसरणी।

    तत्व सारणी एक ShapedArray के उपआयामी तत्व हैं: उनकी रैंक उनके आधार से एक कम है। एलीमेंट ऐरे स्लाइस एक ShapedArray इंस्टेंस को एक एकल Int32 इंडेक्स के साथ अनुक्रमित करके प्राप्त किए जाते हैं।

    उदाहरण के लिए:

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

    सबरेज़ एक ShapedArray में तत्वों की एक सन्निहित श्रेणी है। एक उपसरणी की रैंक उसके आधार के समान होती है, लेकिन इसका प्रमुख आयाम स्लाइस रेंज की गिनती है। सबरे स्लाइस को एक ShapedArray एक Range<Int32> के साथ अनुक्रमित करके प्राप्त किया जाता है जो तत्वों की एक श्रृंखला (अग्रणी आयाम में) का प्रतिनिधित्व करता है। prefix(:) और suffix(:) जैसी विधियाँ जो एक सीमा के साथ आंतरिक रूप से अनुक्रमित होती हैं, उपसरणी भी उत्पन्न करती हैं।

    उदाहरण के लिए:

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

    घोषणा

    @frozen
public struct ShapedArraySlice<Scalar> : _ShapedArrayProtocol
    एल
    extension ShapedArraySlice: CustomStringConvertible
    extension ShapedArraySlice: RandomAccessCollection, MutableCollection
    extension ShapedArraySlice: CustomPlaygroundDisplayConvertible
    एल10एन-प्लेसहोल्डर157 एल
    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 एक बहुआयामी सरणी है जिसके तत्व String s हैं।

    घोषणा

    @frozen
public struct StringTensor
    extension StringTensor: TensorGroup

  • TensorHandle ऑप्स द्वारा उपयोग किया जाने वाला प्रकार है। इसमें एक Scalar प्रकार शामिल है, जिसका उपयोग कंपाइलर आंतरिक पैरामीटर के डेटाटाइप को निर्धारित करने के लिए कर सकते हैं जब उन्हें टेंसर प्रोग्राम में निकाला जाता है।

    घोषणा

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

  • घोषणा

    public struct ResourceHandle
    extension ResourceHandle: TensorGroup

  • घोषणा

    public struct VariantHandle
    extension VariantHandle: TensorGroup

  • एक टेन्सर के आकार का प्रतिनिधित्व करने वाली संरचना।

    TensorShape पूर्णांकों की एक सरणी के चारों ओर एक पतला आवरण है जो आकार आयामों का प्रतिनिधित्व करता है। सभी टेंसर प्रकार अपने आकार को दर्शाने के लिए TensorShape उपयोग करते हैं।

    घोषणा

    @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 अनुमानित है [WritableKeyPath<Base, Tensor<Float>] लेकिन अधिक कुशल है। यह जेनेरिक ऑप्टिमाइज़र लिखने के लिए उपयोगी है जो ग्रेडिएंट्स, मौजूदा वज़न और एक इंडेक्स पर मैप करना चाहते हैं जिसका उपयोग सहायक रूप से संग्रहीत वज़न खोजने के लिए किया जा सकता है। यह थोड़ा अधिक कुशल (~2x) है, लेकिन यह बेहतर हो सकता है क्योंकि यह O(depth_of_tree) कार्य नहीं करने के लिए थोड़ा अधिक ओवरहेड्स (अतिरिक्त सूचक डीरेफ़रेंस) का व्यापार करता है, जो प्रत्येक व्यक्तिगत कीपाथ को ट्रैक करने के लिए एक सादे सूची के साथ आवश्यक है।

    घोषणा

    public struct TensorVisitorPlan<Base>

  • 1-डी इनपुट के लिए एक अपसैंपलिंग परत।

    घोषणा

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

  • 2-डी इनपुट के लिए एक अपसैंपलिंग परत।

    घोषणा

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

  • 3-डी इनपुट के लिए एक अपसैंपलिंग परत।

    घोषणा

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

  • सही पूर्वानुमान काउंटर और हानि योग एकत्रित करता है।

    घोषणा

    public struct HostStatistics