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

संरचनाएं

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

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

घोषणा

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

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
रूपांतरण1D
एक 1-डी कनवल्शन परत (उदाहरण के लिए समय-श्रृंखला पर अस्थायी कनवल्शन)।
यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़ती है।
घोषणा
@frozen public struct Conv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
Conv2D
एक 2-डी कनवल्शन परत (जैसे छवियों पर स्थानिक कनवल्शन)।
यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़ती है।
घोषणा
@frozen public struct Conv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
Conv3D
छवियों पर स्थानिक/स्थानिक-लौकिक कनवल्शन के लिए एक 3-डी कनवल्शन परत।
यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़ती है।
घोषणा
@frozen public struct Conv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
ट्रांसपोज़्डकॉन्व1डी
एक 1-डी ट्रांसपोज़्ड कन्वोल्यूशन परत (उदाहरण के लिए छवियों पर टेम्पोरल ट्रांसपोज़्ड कन्वोल्यूशन)।
यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ ट्रांसपोज़-कन्वॉल्व होता है।
घोषणा
@frozen public struct TransposedConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
ट्रांसपोज़्डकॉन्व2डी
एक 2-डी ट्रांसपोज़्ड कनवल्शन परत (जैसे छवियों पर स्थानिक ट्रांसपोज़्ड कनवल्शन)।
यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ ट्रांसपोज़-कन्वॉल्व होता है।
घोषणा
@frozen public struct TransposedConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
ट्रांसपोज़्डकॉन्व3डी
एक 3-डी ट्रांसपोज़्ड कनवल्शन परत (जैसे छवियों पर स्थानिक ट्रांसपोज़्ड कनवल्शन)।
यह परत एक कनवल्शन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ ट्रांसपोज़-कन्वॉल्व होता है।
घोषणा
@frozen public struct TransposedConv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
गहराईवारConv2D
एक 2-डी गहराईवार कनवल्शन परत।
यह परत अलग-अलग कन्वोल्यूशन फ़िल्टर बनाती है जो आउटपुट के टेंसर का उत्पादन करने के लिए परत इनपुट के साथ जुड़े होते हैं।
घोषणा
@frozen public struct DepthwiseConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
जीरोपैडिंग1डी
अस्थायी आयाम में शून्य-पैडिंग जोड़ने के लिए एक परत।
घोषणा
public struct ZeroPadding1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
जीरोपैडिंग2डी
स्थानिक आयामों में शून्य-पैडिंग जोड़ने के लिए एक परत।
घोषणा
public struct ZeroPadding2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
जीरोपैडिंग3डी
स्थानिक/स्थानिक-लौकिक आयामों में शून्य-पैडिंग जोड़ने के लिए एक परत।
घोषणा
public struct ZeroPadding3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
वियोज्यConv1D
एक 1-डी वियोज्य कनवल्शन परत।
यह परत एक गहराई से कनवल्शन करती है जो चैनलों पर अलग-अलग कार्य करती है और इसके बाद एक बिंदुवार कनवल्शन होता है जो चैनलों को मिलाता है।
घोषणा
@frozen public struct SeparableConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
वियोज्यConv2D
एक 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

बीफ्लोट16

घोषणा

@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
Zip2TensorGroup
एक 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
EmptyTangentवेक्टर
पैरामीटर रहित परतों के लिए खाली TangentVector का प्रतिनिधित्व करने वाली एक खाली संरचना।
घोषणा
public struct EmptyTangentVector: EuclideanDifferentiable, VectorProtocol, ElementaryFunctions, PointwiseMultiplicative, KeyPathIterable
लम्हें
पहले और दूसरे क्षणों की जोड़ी (यानी, माध्य और विचरण)।
टिप्पणी
इसकी आवश्यकता है क्योंकि टुपल प्रकार भिन्न नहीं होते हैं।
घोषणा
public struct Moments<Scalar> : Differentiable where Scalar : TensorFlowFloatingPoint
फैलाव2डी
एक 2-डी रूपात्मक फैलाव परत
यह परत प्रदान किए गए फ़िल्टर के साथ इनपुट टेंसर के रूपात्मक फैलाव को लौटाती है
घोषणा
@frozen public struct Dilation2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
कटाव2डी
एक 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
मैक्सपूल1डी
अस्थायी डेटा के लिए एक अधिकतम पूलिंग परत।
घोषणा
@frozen public struct MaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
मैक्सपूल2डी
स्थानिक डेटा के लिए अधिकतम पूलिंग परत।
घोषणा
@frozen public struct MaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
मैक्सपूल3डी
स्थानिक या स्थानिक-लौकिक डेटा के लिए एक अधिकतम पूलिंग परत।
घोषणा
@frozen public struct MaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
औसतपूल1डी
अस्थायी डेटा के लिए एक औसत पूलिंग परत।
घोषणा
@frozen public struct AvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
औसतपूल2डी
स्थानिक डेटा के लिए एक औसत पूलिंग परत।
घोषणा
@frozen public struct AvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
औसतपूल3डी
स्थानिक या स्थानिक-लौकिक डेटा के लिए एक औसत पूलिंग परत।
घोषणा
@frozen public struct AvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
ग्लोबलएवीजीपूल1डी
अस्थायी डेटा के लिए एक वैश्विक औसत पूलिंग परत।
घोषणा
@frozen public struct GlobalAvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
ग्लोबलएवीजीपूल2डी
स्थानिक डेटा के लिए एक वैश्विक औसत पूलिंग परत।
घोषणा
@frozen public struct GlobalAvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
GlobalAvgPool3D
स्थानिक और स्थानिक-लौकिक डेटा के लिए एक वैश्विक औसत पूलिंग परत।
घोषणा
@frozen public struct GlobalAvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
ग्लोबलमैक्सपूल1डी
अस्थायी डेटा के लिए एक वैश्विक अधिकतम पूलिंग परत।
घोषणा
@frozen public struct GlobalMaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
ग्लोबलमैक्सपूल2डी
स्थानिक डेटा के लिए एक वैश्विक अधिकतम पूलिंग परत।
घोषणा
@frozen public struct GlobalMaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
ग्लोबलमैक्सपूल3डी
स्थानिक और स्थानिक-लौकिक डेटा के लिए एक वैश्विक अधिकतम पूलिंग परत।
घोषणा
@frozen public struct GlobalMaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
फ्रैक्शनलमैक्सपूल2डी
स्थानिक डेटा के लिए एक आंशिक अधिकतम पूलिंग परत। ध्यान दें: 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
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 विशेषता नहीं है क्योंकि कॉल सिंटैक्स अनजान है: x.throwing(arg1, arg2, ...) आगे की चर्चा/डिज़ाइन तक विधियों को अभी भी dynamicallyCall नाम दिया जाएगा।
घोषणा
public struct ThrowingPythonObject
PythonObject की जाँच करना
एक PythonObject रैपर जो सदस्य पहुंच को सक्षम बनाता है। सदस्य पहुंच परिचालन एक Optional परिणाम लौटाता है। जब सदस्य पहुंच विफल हो जाती है, nil लौटा दिया जाता है।
घोषणा
@dynamicMemberLookup public struct CheckingPythonObject
पायथनइंटरफ़ेस
पायथन के लिए एक इंटरफ़ेस।
PythonInterface Python के साथ इंटरेक्शन की अनुमति देता है। इसका उपयोग मॉड्यूल आयात करने और पायथन निर्मित प्रकारों और कार्यों को गतिशील रूप से एक्सेस करने के लिए किया जा सकता है।
टिप्पणी
PythonInterface सीधे आरंभ करने का इरादा नहीं है। इसके बजाय, कृपया PythonInterface के Python नामक वैश्विक उदाहरण का उपयोग करें।
घोषणा
@dynamicMemberLookup public struct PythonInterface
पायथनलाइब्रेरी
घोषणा
public struct PythonLibrary
AnyRandomNumberGenerator
एक प्रकार से मिटाया गया यादृच्छिक संख्या जनरेटर।
AnyRandomNumberGenerator प्रकार अपने विशिष्ट अंतर्निहित प्रकार को छिपाते हुए, यादृच्छिक संख्या उत्पन्न करने वाले कार्यों को एक अंतर्निहित यादृच्छिक संख्या जनरेटर की ओर अग्रेषित करता है।
घोषणा
public struct AnyRandomNumberGenerator : RandomNumberGenerator
ARC4RandomNumberGenerator
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
PhiloxRandomNumberGenerator
फिलॉक्स का उपयोग करके SeedableRandomNumberGenerator का कार्यान्वयन। सैल्मन एट अल. एससी 2011. समानांतर यादृच्छिक संख्याएँ: 1, 2, 3 जितनी आसान। http://www.thesalmons.org/john/random123/papers/random123sc11.pdf
यह संरचना 10-राउंड फिलोक्स4x32 पीआरएनजी लागू करती है। इसे 64-बिट मान के साथ सीड किया जाना चाहिए।
एक व्यक्तिगत जनरेटर थ्रेड-सुरक्षित नहीं है, लेकिन अलग-अलग जनरेटर स्थिति साझा नहीं करते हैं। उत्पन्न यादृच्छिक डेटा उच्च गुणवत्ता वाला है, लेकिन क्रिप्टोग्राफ़िक अनुप्रयोगों के लिए उपयुक्त नहीं है।
घोषणा
public struct PhiloxRandomNumberGenerator : SeedableRandomNumberGenerator

UniformIntegerDistribution

घोषणा

@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

LSTMCell

एक LSTM सेल.

घोषणा

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

GRUCell

एक 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

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 इंस्टेंसेस का अपना भंडारण नहीं होता है। इसके बजाय, वे अपने बेस 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]].
```
Subarrays एक 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: 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 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डी
1-डी इनपुट के लिए एक अपसैंपलिंग परत।
घोषणा
@frozen public struct UpSampling1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
अपसैंपलिंग2डी
2-डी इनपुट के लिए एक अपसैंपलिंग परत।
घोषणा
@frozen public struct UpSampling2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
अपसैंपलिंग3डी
3-डी इनपुट के लिए एक अपसैंपलिंग परत।
घोषणा
@frozen public struct UpSampling3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
मेज़बानसांख्यिकी
सही पूर्वानुमान काउंटर और हानि योग एकत्रित करता है।
घोषणा
public struct HostStatistics