7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें

संरचनाओं

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

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

    घोषणा

    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 (जैसे टेन्सर में scalars के प्रकार का वर्णन 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
    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
  • एक पुलबैक समारोह है कि दो प्रसारण की पक्षांतरित करता 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 तत्व tensors के संग्रह के रूप में एक इनपुट पाइपलाइन का प्रतिनिधित्व करने के लिए इस्तेमाल किया जा सकता है।

    घोषणा

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

    घोषणा

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

    घोषणा

    public struct Device
    extension Device: Equatable
    extension Device: CustomStringConvertible
  • एक ड्रॉपआउट परत।

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

    घोषणा

    @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
  • एक खाली struct खाली प्रतिनिधित्व करने TangentVector parameterless परतों के लिए है।

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

    ध्यान दें

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

    घोषणा

    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 संग्रह, अपना पहला तत्व के साथ शुरू, और कुछ तय अधिकतम लंबाई है।

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

    घोषणा

    public struct Slices<Base> where Base : Collection
    extension Slices: Collection
  • बैच सामान्यीकरण परत।

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

    संदर्भ: बैच सामान्यीकरण: आंतरिक covariate शिफ्ट को कम करना द्वारा दीप नेटवर्क प्रशिक्षण त्वरित

    घोषणा

    @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
  • एक परत जो इनपुट के मिनी-बैच पर इंस्टेंस सामान्यीकरण लागू करती है।

    संदर्भ: उदाहरण सामान्यीकरण: फास्ट stylization के लिए लापता घटक

    घोषणा

    @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
  • स्थानिक या स्थानिक-अस्थायी डेटा के लिए एक अधिकतम पूलिंग परत।

    घोषणा

    @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 गतिशील इस वस्तु में निर्दिष्ट नाम के साथ एक सदस्य के लिए अजगर क्रम का अनुरोध करेंगे।

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

    आंतरिक रूप से, PythonObject एक अजगर सी एपीआई के लिए एक संदर्भ बार गणना सूचक के रूप में कार्यान्वित किया जाता है 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
    extension PythonObject : Hashable
    extension PythonObject : MutableCollection
    extension PythonObject : Sequence
    extension PythonObject : ExpressibleByBooleanLiteral, ExpressibleByIntegerLiteral,
    ExpressibleByFloatLiteral, ExpressibleByStringLiteral
    extension PythonObject : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral
  • एक 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 ARC4 का उपयोग कर।

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

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

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

    घोषणा

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

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

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

    घोषणा

    public struct ThreefryRandomNumberGenerator : SeedableRandomNumberGenerator
  • के एक कार्यान्वयन SeedableRandomNumberGenerator Philox का उपयोग कर। सैल्मन एट अल। अनुसूचित जाति 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
  • एक जीआरयू सेल।

    घोषणा

    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
    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
  • एक का एक सन्निहित टुकड़ा ShapedArray या ShapedArraySlice उदाहरण।

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

    तत्व सरणियों एक की subdimensional तत्व हैं 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]].
    

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

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

        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
    extension ShapedArraySlice: Codable where Scalar: Codable
  • StringTensor एक बहु-आयामी सरणी जिसका तत्व हैं है String रों।

    घोषणा

    @frozen
    public struct StringTensor
    extension StringTensor: TensorGroup
  • TensorHandle ऑप्स द्वारा इस्तेमाल किया प्रकार है। यह एक भी शामिल है Scalar प्रकार है, जो संकलक internals मापदंडों के डेटाटाइप्स निर्धारित करने के लिए जब वे एक टेन्सर कार्यक्रम में निकाले जाते हैं का उपयोग कर सकते हैं।

    घोषणा

    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