GitHub
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

संरचनाएं

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

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

    घोषणा

    426a80cb2
    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 - 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
    extension Tensor: CustomStringConvertible
    extension Tensor: CustomPlaygroundDisplayConvertible
    63dd8a8244
    extension Tensor: TensorGroup
    extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
    extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
    4c888886448888448888448888448888464884
  • एक पुलबैक फंक्शन जो दो 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-D वियोज्य दृढ़ परत।

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

    घोषणा

    @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 प्रकारों के एक tuple का प्रतिनिधित्व TensorGroup

    घोषणा

    @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(_:_:) के बैच संस्करण के साथ matmul(_:_:) ऑपरेशन का उपयोग किया जाता है, इस प्रकार प्रत्येक तत्व के लिए एक अलग वजन और पूर्वाग्रह का उपयोग किया जाता है। इनपुट बैच में

    घोषणा

    @frozen
    public struct Dense<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • एक उपकरण जिस पर Tensor s आवंटित किया जा सकता है।

    घोषणा

    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 s का प्रतिनिधित्व करने वाला एक खाली TangentVector

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

    ध्यान दें

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

    घोषणा

    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] द्वारा ParameterGroupOptimizer) के लिए चुने गए पैरामीटर समूहों से एक मानचित्रण अंतिम अनुकूलक को परिभाषित करता है।

    घोषणा

    public struct ParameterGroupOptimizerBuilder
  • लौकिक डेटा के लिए एक अधिकतम पूलिंग परत।

    घोषणा

    @frozen
    public struct MaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • स्थानिक डेटा के लिए एक अधिकतम पूलिंग परत।

    घोषणा

    @frozen
    public struct MaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • स्थानिक या spatio- अस्थायी डेटा के लिए एक अधिकतम पूलिंग परत।

    घोषणा

    @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 , पायथन में एक वस्तु का प्रतिनिधित्व करता है और डायनेमिक सदस्य लुकअप का समर्थन करता है। object.foo तरह किसी भी सदस्य का उपयोग object.foo गतिशील रूप से इस ऑब्जेक्ट में निर्दिष्ट नाम के साथ एक सदस्य के लिए पायथन रनटाइम का अनुरोध करेगा।

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

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

    घोषणा

    @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
    ebb10e03f
    extension PythonObject : MutableCollection
    extension PythonObject : Sequence
    extension PythonObject : ExpressibleByBooleanLiteral, ExpressibleByIntegerLiteral,
    ExpressibleByFloatLiteral, ExpressibleByStringLiteral
    0db 1db 1db1
  • PythonObject आवरण जो विधि कॉल को फेंकने में सक्षम बनाता है। पायथन कार्यों द्वारा निर्मित अपवाद स्विफ्ट त्रुटियों के रूप में परिलक्षित होते हैं और फेंके जाते हैं।

    ध्यान दें

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

    घोषणा

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

    घोषणा

    @dynamicMemberLookup
    public struct CheckingPythonObject
  • पायथन के लिए एक इंटरफ़ेस।

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

    ध्यान दें

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

    घोषणा

    @dynamicMemberLookup
    public struct PythonInterface
  • घोषणा

    public struct PythonLibrary
  • एक प्रकार का मिटाया हुआ यादृच्छिक संख्या जनरेटर।

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

    घोषणा

    public struct AnyRandomNumberGenerator : RandomNumberGenerator
  • SeedableRandomNumberGenerator का उपयोग कर SeedableRandomNumberGenerator का कार्यान्वयन।

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

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

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

    घोषणा

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

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

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

    घोषणा

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

    यह संरचना 10-राउंड Philox4x32 PRNG को लागू करती है। इसे 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
  • एक परत जो क्रमिक रूप से दो या अधिक परतों की रचना करती है।

    उदाहरण:

    • 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 के लिए एक Autoencoder बनाएँ:
    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
    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
    c858f9b39
    extension ShapedArray: Codable where Scalar: Codable
  • ShapedArray या ShapedArraySlice उदाहरण का एक सन्निहित टुकड़ा।

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

    तत्व सरणियाँ एक 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 में तत्वों की एक सन्निहित सीमा है। एक सबर्रे का रैंक उसके आधार के समान है, लेकिन इसका प्रमुख आयाम स्लाइस रेंज की गिनती है। सबर्रे स्लाइस एक Range<Int32> साथ एक ShapedArray अनुक्रमित करके प्राप्त किए जाते हैं जो तत्वों की एक सीमा (अग्रणी आयाम में) का प्रतिनिधित्व करता है। 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: 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
    cc19380506
  • 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 (डेप्थ_ऑफ_ट्री) कार्य करने के लिए थोड़े उच्च ओवरहेड्स (अतिरिक्त पॉइंटर डेरेफेरेंस) को बंद कर देता है, जो प्रत्येक व्यक्ति कीपैड को ट्रैक करने के लिए एक सादे सूची के साथ आवश्यक है।

    घोषणा

    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