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

कार्यों

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

l1नुकसान (अनुमानित: अपेक्षित :)

पूर्वानुमानों और अपेक्षाओं के बीच L1 हानि लौटाता है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l1Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

l2Loss (अनुमानित: अपेक्षित :)

पूर्वानुमानों और अपेक्षाओं के बीच L2 हानि लौटाता है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l2Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

हिंजलॉस (अनुमानित: अपेक्षित :)

पूर्वानुमानों और अपेक्षाओं के बीच हिंग हानि लौटाता है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

चुकताHingeLoss (अनुमानित: अपेक्षित :)

पूर्वानुमानों और अपेक्षाओं के बीच चुकता हिंज हानि लौटाता है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

श्रेणीबद्धHingeLoss(अनुमानित:अपेक्षित :)

पूर्वानुमानों और अपेक्षाओं के बीच श्रेणीबद्ध हिंज हानि लौटाता है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

logCoshLoss (अनुमानित: अपेक्षित :)

भविष्यवाणियों और अपेक्षाओं के बीच त्रुटि के अतिपरवलयिक कोज्या का लघुगणक देता है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

poissonLoss (अनुमानित: अपेक्षित :)

पूर्वानुमानों और अपेक्षाओं के बीच पॉइसन हानि लौटाता है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

kullbackLeiblerDivergence(अनुमानित:अपेक्षित :)

उम्मीदों और पूर्वानुमानों के बीच कुलबैक-लीब्लर डाइवर्जेंस (KL डाइवर्जेंस) देता है। यह देखते हुए दो वितरण p और q , केएल विचलन की गणना करता है p * log(p / q) ।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

सॉफ्टमैक्स क्रॉसएन्ट्रॉपी (लॉगिट्स: संभावनाएं :)

लॉग और लेबल के बीच सॉफ्टमैक्स क्रॉस एन्ट्रॉपी (श्रेणीबद्ध क्रॉस एन्ट्रॉपी) देता है।

घोषणा

@differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  probabilities: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`logits`	एक तंत्रिका नेटवर्क से एक-गर्म एन्कोडेड आउटपुट।
`labels`	सही आउटपुट के सूचकांक (शून्य-अनुक्रमित)।

सिग्मॉइडक्रॉसएन्ट्रॉपी (लॉगिट्स: लेबल्स :)

लॉग और लेबल के बीच सिग्मॉइड क्रॉस एन्ट्रॉपी (बाइनरी क्रॉस एन्ट्रॉपी) देता है।

घोषणा

@differentiable(wrt: logits)
@differentiable(wrt: (logits, labels)
public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`logits`	एक तंत्रिका नेटवर्क का अनस्केल्ड आउटपुट।
`labels`	सही आउटपुट के अनुरूप पूर्णांक मान।

पहचान(_:)
निर्दिष्ट टेंसर के समान आकार और स्केलर के साथ एक टेंसर लौटाता है।
घोषणा
@differentiable public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

withRandomSeedForTensorFlow(_:_:)

दिए गए बंद को उस संदर्भ में कॉल करें जिसमें दिए गए यादृच्छिक बीज को छोड़कर वर्तमान संदर्भ के समान सब कुछ है।

घोषणा

public func withRandomSeedForTensorFlow<R>(
  _ randomSeed: TensorFlowSeed,
  _ body: () throws -> R
) rethrows -> R

मापदंडों

`randomSeed`	एक यादृच्छिक बीज जिसे बंद होने से पहले सेट किया जाएगा, बंद होने के बाद कॉल किया जाएगा और बहाल किया जाएगा।
`body`	एक अशक्त बंद। बंद की वापसी मान है, तो है कि मूल्य भी की वापसी मान के रूप में प्रयोग किया जाता है `withRandomSeedForTensorFlow(_:_:)` कार्य करते हैं।

प्रतिलाभ की मात्रा

वापसी मान, यदि कोई हो, के body बंद।

RandomNumberGeneratorForTensorFlow के साथ (_:_ :)

दिए गए क्लोजर को उस संदर्भ में कॉल करता है जिसमें दिए गए यादृच्छिक संख्या जनरेटर को छोड़कर वर्तमान संदर्भ के समान सब कुछ है।

घोषणा

public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>(
  _ randomNumberGenerator: inout G,
  _ body: () throws -> R
) rethrows -> R

मापदंडों

`randomNumberGenerator`	एक यादृच्छिक संख्या जनरेटर जिसे बंद होने से पहले सेट किया जाएगा, कॉल किया जाएगा और क्लोजर रिटर्न के बाद बहाल किया जाएगा।
`body`	एक अशक्त बंद। बंद की वापसी मान है, तो है कि मूल्य भी की वापसी मान के रूप में प्रयोग किया जाता है `withRandomNumberGeneratorForTensorFlow(_:_:)` कार्य करते हैं।

प्रतिलाभ की मात्रा

वापसी मान, यदि कोई हो, के body बंद।

ज़िप (_:_ :)

घोषणा

public func zip<T: TensorGroup, U: TensorGroup>(
  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
) -> Dataset<Zip2TensorGroup<T, U>>

LazyTensorBarrier (पर: डिवाइस: प्रतीक्षा करें :)
LazyTensorBarrier सुनिश्चित करता है कि सभी लाइव टेंसर (उपलब्ध होने पर डिवाइस पर) शेड्यूल और चल रहे हैं। यदि प्रतीक्षा को सत्य पर सेट किया जाता है, तो यह कॉल गणना पूर्ण होने तक अवरुद्ध हो जाती है।
घोषणा
public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

valueWithGradient (पर: में :)

घोषणा

public func valueWithGradient<T, R>(
  at x: T,
  in f: @differentiable (T) -> Tensor<R>
) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient(at:_:in:)

घोषणा

public func valueWithGradient<T, U, R>(
  at x: T,
  _ y: U,
  in f: @differentiable (T, U) -> Tensor<R>
) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient(at:_:_:in:)

घोषणा

public func valueWithGradient<T, U, V, R>(
  at x: T,
  _ y: U,
  _ z: V,
  in f: @differentiable (T, U, V) -> Tensor<R>
) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient (की :)

घोषणा

public func valueWithGradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient (की :)

घोषणा

public func valueWithGradient<T, U, R>(
  of f: @escaping @differentiable (T, U) -> Tensor<R>
) -> (T, U) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient (की :)

घोषणा

public func valueWithGradient<T, U, V, R>(
  of f: @escaping @differentiable (T, U, V) -> Tensor<R>
) -> (T, U, V) -> (
  value: Tensor<R>,
  gradient: (T.TangentVector, U.TangentVector, V.TangentVector)
)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

ढाल (पर: में :)

घोषणा

public func gradient<T, R>(
  at x: T,
  in f: @differentiable (T) -> Tensor<R>
) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

ढाल (पर: _: में :)

घोषणा

public func gradient<T, U, R>(
  at x: T,
  _ y: U,
  in f: @differentiable (T, U) -> Tensor<R>
) -> (T.TangentVector, U.TangentVector)
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

ढाल (पर:_:_:में :)

घोषणा

public func gradient<T, U, V, R>(
  at x: T,
  _ y: U,
  _ z: V,
  in f: @differentiable (T, U, V) -> Tensor<R>
) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

ढाल (की :)

घोषणा

public func gradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

ढाल (की :)

घोषणा

public func gradient<T, U, R>(
  of f: @escaping @differentiable (T, U) -> Tensor<R>
) -> (T, U) -> (T.TangentVector, U.TangentVector)
where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint

ढाल (की :)

घोषणा

public func gradient<T, U, V, R>(
  of f: @escaping @differentiable (T, U, V) -> Tensor<R>
) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector)
where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

withRecomputationInPullbacks(_:)
एक फ़ंक्शन को इसके पुलबैक में पुनर्गणना करें, जिसे पारंपरिक स्वचालित भेदभाव में "चेकपॉइंटिंग" के रूप में जाना जाता है।
घोषणा
public func withRecomputationInPullbacks<T, U>( _ body: @escaping @differentiable (T) -> U ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable

डिफरेंशियल फंक्शन (से :)

वेक्टर-जैकोबियन उत्पाद फ़ंक्शन से एक अलग फ़ंक्शन बनाएं।

घोषणा

public func differentiableFunction<T : Differentiable, R : Differentiable>(
  from vjp: @escaping (T)
           -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
) -> @differentiable (T) -> R

डिफरेंशियल फंक्शन (से :)

वेक्टर-जैकोबियन उत्पाद फ़ंक्शन से एक अलग फ़ंक्शन बनाएं।

घोषणा

public func differentiableFunction<T, U, R>(
  from vjp: @escaping (T, U)
           -> (value: R, pullback: (R.TangentVector)
             -> (T.TangentVector, U.TangentVector))
) -> @differentiable (T, U) -> R

बिना व्युत्पन्न (पर :)
रिटर्न x एक पहचान समारोह की तरह। जब एक संदर्भ में, जहां में इस्तेमाल x के संबंध में अलग-अलग किया जा रहा है, इस समारोह में किसी भी व्युत्पन्न का उत्पादन नहीं होगा x ।
घोषणा
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
बिना व्युत्पन्न (पर: में :)
दिए गए बंद पर लागू होता है body के लिए x । जब एक संदर्भ में, जहां में इस्तेमाल x के संबंध में अलग-अलग किया जा रहा है, इस समारोह में किसी भी व्युत्पन्न का उत्पादन नहीं होगा x ।
घोषणा
@_semantics("autodiff.nonvarying") public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R

डिवाइस के साथ (_:_:प्रदर्शन :)

एक क्लोजर निष्पादित करता है, जिससे TensorFlow संचालन एक विशिष्ट प्रकार के डिवाइस पर चलता है।

घोषणा

public func withDevice<R>(
  _ kind: DeviceKind,
  _ index: UInt = 0,
  perform body: () throws -> R
) rethrows -> R

मापदंडों

`kind`	TensorFlow संचालन को चलाने के लिए एक प्रकार का उपकरण।
`index`	ऑप्स को चलाने के लिए डिवाइस।
`body`	एक क्लोजर जिसका TensorFlow संचालन निर्दिष्ट प्रकार के डिवाइस पर निष्पादित किया जाना है।

डिवाइस के साथ (नाम: प्रदर्शन :)

एक विशिष्ट नाम वाले डिवाइस पर TensorFlow संचालन चलाने के लिए, एक क्लोजर निष्पादित करता है।

डिवाइस के नाम के कुछ उदाहरण:

"/ डिवाइस: सीपीयू: 0": आपकी मशीन का सीपीयू।
“/GPU:0”: आपकी मशीन के पहले GPU के लिए शॉर्ट-हैंड नोटेशन जो TensorFlow को दिखाई देता है
"/job:localhost/replica:0/task:0/device:GPU:1": आपकी मशीन के दूसरे GPU का पूरी तरह से योग्य नाम जो TensorFlow को दिखाई देता है।

घोषणा

public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R

मापदंडों

`name`	डिवाइस का नाम।
`body`	एक क्लोजर जिसका TensorFlow संचालन निर्दिष्ट प्रकार के डिवाइस पर निष्पादित किया जाना है।

withDefaultDevice (प्रदर्शन :)

एक क्लोजर निष्पादित करता है, जिससे TensorFlow को किसी भी डिवाइस पर TensorFlow संचालन करने की अनुमति मिलती है। यह डिफ़ॉल्ट प्लेसमेंट व्यवहार को पुनर्स्थापित करना चाहिए।

घोषणा

public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R

मापदंडों

body

एक क्लोजर जिसका TensorFlow संचालन निर्दिष्ट प्रकार के डिवाइस पर निष्पादित किया जाना है।

आकार बदलें (छवियां: आकार: विधि: एंटीअलियास :)

निर्दिष्ट विधि का उपयोग करके छवियों का आकार बदलें।

शर्त लगाना

छवियों रैंक होना आवश्यक है 3 या 4 ।

शर्त लगाना

आकार सकारात्मक होना चाहिए।

घोषणा

@differentiable(wrt: images)
public func resize(
  images: Tensor<Float>,
  size: (newHeight: Int, newWidth: Int),
  method: ResizeMethod = .bilinear,
  antialias: Bool = false
) -> Tensor<Float>

मापदंडों

`images`	4 डी `Tensor` आकार के `[batch, height, width, channels]` या 3-डी `Tensor` आकार के `[height, width, channels]` ।
`size`	छवियों का नया आकार।
`method`	आकार बदलने की विधि। डिफ़ॉल्ट मान है `.bilinear` ।
`antialias`	Iff `true` है, जब एक छवि downsampling एक विरोधी aliasing फिल्टर का उपयोग करें।

आकार बदलें (छवियां: आकार: संरेखित करें :)

क्षेत्र प्रक्षेप का उपयोग करके छवियों का आकार बदलें।

शर्त लगाना

छवियों रैंक होना आवश्यक है 3 या 4 ।

शर्त लगाना

आकार सकारात्मक होना चाहिए।

घोषणा

public func resizeArea<Scalar: TensorFlowNumeric>(
  images: Tensor<Scalar>,
  size: (newHeight: Int, newWidth: Int),
  alignCorners: Bool = false
) -> Tensor<Float>

मापदंडों

`images`	4 डी `Tensor` आकार के `[batch, height, width, channels]` या 3-डी `Tensor` आकार के `[height, width, channels]` ।
`size`	छवियों का नया आकार।

dilation2D (_: फ़िल्टर: स्ट्राइड्स: दरें: पैडिंग :)

निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स और पैडिंग के साथ 2-डी फैलाव देता है।

शर्त लगाना

input रैंक होना आवश्यक है 4 ।

शर्त लगाना

filter रैंक होना आवश्यक है 3 ।

घोषणा

@differentiable(wrt: (input, filter)
public func dilation2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filter`	फैलाव फिल्टर।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग
`rates`	इनपुट के प्रत्येक आयाम के लिए फैलाव दर।

कटाव २ डी (_: फ़िल्टर: स्ट्राइड्स: दरें: पैडिंग :)

निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स और पैडिंग के साथ 2-डी अपरदन लौटाता है।

शर्त लगाना

input रैंक होना आवश्यक है 4 ।

शर्त लगाना

filter रैंक 3 होना आवश्यक है।

घोषणा

@differentiable(wrt: (input, filter)
public func erosion2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filter`	क्षरण फिल्टर।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग
`rates`	इनपुट के प्रत्येक आयाम के लिए फैलाव दर।

शून्य ()
एक फ़ंक्शन देता है जो अपने सभी मानों को शून्य में प्रारंभ करके एक टेंसर बनाता है।
घोषणा
public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
निरंतर प्रारंभकर्ता (मान :)
एक फ़ंक्शन देता है जो अपने सभी मानों को दिए गए मान पर प्रारंभ करके एक टेंसर बनाता है।
घोषणा
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
निरंतर प्रारंभकर्ता (मान :)
एक फ़ंक्शन देता है जो प्रदान किए गए मान पर प्रारंभ करके एक टेंसर बनाता है। ध्यान दें कि दिए गए मान प्रसारण समर्थित नहीं है।
घोषणा
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
ग्लोरोटयूनिफॉर्म (बीज :)
रिटर्न एक समारोह है कि निर्दिष्ट आकार के लिए Glorot (जेवियर) प्रदर्शन वर्दी आरंभीकरण, बेतरतीब ढंग से जो समान वितरण से अदिश मूल्यों नमूने के द्वारा एक टेन्सर बनाता -limit और limit , डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर, जहां सीमा नहीं है द्वारा उत्पन्न sqrt(6 / (fanIn + fanOut)) , और fanIn / fanOut इनपुट की संख्या का प्रतिनिधित्व करते हैं और उत्पादन करता है, तो वर्तमान, ग्रहणशील क्षेत्र से गुणा की सुविधा है।
घोषणा
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
GlorotNormal(बीज :)
रिटर्न एक समारोह है कि निर्दिष्ट आकार के लिए Glorot (जेवियर) प्रदर्शन सामान्य प्रारंभ, बेतरतीब ढंग से एक छोटा कर दिया सामान्य वितरण से अदिश मूल्यों नमूने के द्वारा एक टेन्सर बनाता है पर केंद्रित 0 मानक विचलन के साथ sqrt(2 / (fanIn + fanOut)) है, जहां fanIn / fanOut इनपुट और आउटपुट सुविधाओं की संख्या को ग्रहणशील क्षेत्र के आकार से गुणा करें, यदि मौजूद हो।
घोषणा
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
वह वर्दी (बीज :)
रिटर्न एक समारोह है कि, वह (Kaiming) निर्दिष्ट आकार के लिए एक समान आरंभीकरण प्रदर्शन बेतरतीब ढंग से जो समान वितरण से अदिश मूल्यों नमूने के द्वारा एक टेन्सर बनाता -limit और limit , डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर, जहां सीमा नहीं है द्वारा उत्पन्न sqrt(6 / fanIn) , और fanIn ग्रहणशील क्षेत्र से गुणा इनपुट सुविधाओं की संख्या, यदि वर्तमान प्रतिनिधित्व करता है।
घोषणा
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
सामान्य (बीज :)
रिटर्न एक समारोह है कि वह, निर्दिष्ट आकार के लिए (Kaiming) सामान्य प्रारंभ प्रदर्शन बेतरतीब ढंग से एक छोटा कर दिया सामान्य वितरण से अदिश मूल्यों नमूने के द्वारा एक टेन्सर बनाता है पर केंद्रित 0 मानक विचलन के साथ sqrt(2 / fanIn) , जहां fanIn इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है ग्रहणशील क्षेत्र के आकार से गुणा करें, यदि मौजूद हो।
घोषणा
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunUniform(बीज :)
रिटर्न एक समारोह है कि निर्दिष्ट आकार के लिए LeCun वर्दी प्रारंभ करते समय, बेतरतीब ढंग से जो समान वितरण से अदिश मूल्यों नमूने के द्वारा एक टेन्सर बनाता -limit और limit डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर, जहां सीमा नहीं है द्वारा उत्पन्न, sqrt(3 / fanIn) , और fanIn अगर मौजूद है, ग्रहणशील क्षेत्र से गुणा इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है।
घोषणा
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunNormal(बीज :)
रिटर्न एक समारोह है कि निर्दिष्ट आकार के लिए LeCun सामान्य प्रारंभ करते समय, बेतरतीब ढंग से एक छोटा कर दिया सामान्य वितरण से अदिश मूल्यों नमूने के द्वारा एक टेन्सर बनाता है पर केंद्रित 0 मानक विचलन के साथ sqrt(1 / fanIn) , जहां fanIn इनपुट की संख्या का प्रतिनिधित्व करता है से गुणा सुविधाएँ ग्रहणशील क्षेत्र का आकार, यदि मौजूद हो।
घोषणा
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
छोटा किया गया सामान्य प्रारंभकर्ता (माध्य: मानक विचलन: बीज :)
एक फ़ंक्शन देता है जो एक टेंसर बनाता है, इसके सभी मूल्यों को एक छोटे से सामान्य वितरण से यादृच्छिक रूप से प्रारंभ करता है। उत्पन्न मूल्यों मतलब के साथ एक सामान्य वितरण का पालन mean और मानक विचलन standardDeviation , कि मूल्यों जिसका परिमाण से अधिक माध्य से दो मानक गिरा दिया और resampled रहे हैं को छोड़कर।
घोषणा
public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>( mean: Tensor<Scalar> = Tensor<Scalar>(0), standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1), seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
मापदंडों
mean
सामान्य वितरण का माध्य।
standardDeviation
सामान्य वितरण का मानक विचलन।
प्रतिलाभ की मात्रा
एक छोटा सामान्य पैरामीटर प्रारंभकर्ता फ़ंक्शन।

==(_:_ :)

घोषणा

public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool

आंख (पंक्ति गणना: कॉलम गणना: बैच आकार: चालू :)

एक पहचान मैट्रिक्स या मैट्रिक्स का एक बैच देता है।

घोषणा

public func eye<Scalar: Numeric>(
  rowCount: Int,
  columnCount: Int? = nil,
  batchShape: [Int] = [],
  on device: Device = .default
) -> Tensor<Scalar>

मापदंडों

`rowCount`	प्रत्येक बैच मैट्रिक्स में पंक्तियों की संख्या।
`columnCount`	प्रत्येक बैच मैट्रिक्स में स्तंभों की संख्या।
`batchShape`	लौटाए गए टेंसर के प्रमुख बैच आयाम।

ट्रेस (_ :)
वैकल्पिक रूप से बैच किए गए मैट्रिक्स के ट्रेस की गणना करता है। ट्रेस प्रत्येक आंतरिक-अधिकांश मैट्रिक्स के मुख्य विकर्ण के साथ योग है।
इनपुट आकार के साथ एक टेन्सर है [..., M, N] । उत्पादन आकार के साथ एक टेन्सर है [...] ।
शर्त लगाना
matrix आकार के साथ एक टेन्सर होना चाहिए [..., M, N] ।
घोषणा
@differentiable(wrt: matrix) public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
मापदंडों
matrix
आकार का एक टेन्सर [..., M, N] ।
चोल्स्की(_:)
एक या अधिक वर्ग आव्यूहों का चोल्स्की अपघटन लौटाता है।
इनपुट आकार का एक टेन्सर है [..., M, M] जिसका भीतरी सबसे 2 आयामों वर्ग मैट्रिक्स के रूप में।
इनपुट सममित और सकारात्मक निश्चित होना चाहिए। इस ऑपरेशन के लिए इनपुट के केवल निचले-त्रिकोणीय भाग का उपयोग किया जाएगा। ऊपरी-त्रिकोणीय भाग नहीं पढ़ा जाएगा।
उत्पादन सभी इनपुट submatrices के लिए Cholesky decompositions युक्त इनपुट के रूप में एक ही आकार का एक टेन्सर है [..., :, :] ।
घोषणा
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
मापदंडों
input
आकार का एक टेन्सर [..., M, M] ।

त्रिकोणीय समाधान (मैट्रिक्स: rhs: निचला: आसन्न :)

रिटर्न समाधान x रेखीय समीकरण प्रणाली के द्वारा प्रतिनिधित्व Ax = b ।

शर्त लगाना

matrix आकार के साथ एक टेन्सर होना चाहिए [..., M, M] ।

शर्त लगाना

rhs आकार के साथ एक टेन्सर होना चाहिए [..., M, K] ।

घोषणा

@differentiable
public func triangularSolve<T: TensorFlowFloatingPoint>(
  matrix: Tensor<T>,
  rhs: Tensor<T>,
  lower: Bool = true,
  adjoint: Bool = false
) -> Tensor<T>

मापदंडों

`matrix`	इनपुट त्रिकोणीय गुणांक मैट्रिक्स, का प्रतिनिधित्व `A` में `Ax = b` ।
`rhs`	दाएँ हाथ की ओर मूल्यों का प्रतिनिधित्व `b` में `Ax = b` ।
`lower`	चाहे `matrix` कम त्रिकोणीय (है `true` ) या ऊपरी त्रिकोणीय ( `false` )। डिफ़ॉल्ट मान है `true` ।
`adjoint`	अगर `true` , की adjoint साथ हल `matrix` के बजाय `matrix` । डिफ़ॉल्ट मान है `false` ।

प्रतिलाभ की मात्रा

समाधान x रेखीय समीकरण प्रणाली के द्वारा प्रतिनिधित्व Ax = b । x के रूप में ही आकार है b ।

l1नुकसान (अनुमानित: अपेक्षित: कमी :)

एल 1 नुकसान के बीच की गणना expected है और predicted । loss = reduction(abs(expected - predicted))

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l1Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

l2Loss (अनुमानित: अपेक्षित: कमी :)

एल 2 नुकसान के बीच की गणना expected है और predicted । loss = reduction(square(expected - predicted))

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l2Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

माध्य निरपेक्ष त्रुटि (अनुमानित: अपेक्षित :)

लेबल और भविष्यवाणियों के बीच पूर्ण अंतर के माध्य की गणना करता है। loss = mean(abs(expected - predicted))

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

माध्य वर्ग त्रुटि (अनुमानित: अपेक्षित :)

लेबल और पूर्वानुमानों के बीच त्रुटियों के वर्गों के माध्य की गणना करता है। loss = mean(square(expected - predicted))

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanSquaredError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

माध्य वर्ग लॉगरिदमिक त्रुटि (अनुमानित: अपेक्षित :)

के बीच मतलब वर्ग लघुगणक त्रुटि की गणना predicted और expected loss = square(log(expected) - log(predicted))

ध्यान दें

नकारात्मक टेन्सर प्रविष्टियों में आबद्ध किया जाएगा 0 , अपरिभाषित लघुगणक व्यवहार से बचने के लिए के रूप में log(_:) नकारात्मक reals के लिए अपरिभाषित है।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

माध्य पूर्ण प्रतिशत त्रुटि (अनुमानित: अपेक्षित :)

मतलब पूर्ण प्रतिशत त्रुटि के बीच की गणना predicted और expected । loss = 100 * mean(abs((expected - predicted) / abs(expected)))

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।

हिंजलॉस (अनुमानित: अपेक्षित: कमी :)

के बीच काज नुकसान की गणना predicted और expected । loss = reduction(max(0, 1 - predicted * expected)) expected मूल्यों 1 होने की उम्मीद है -1 या।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

चुकताHingeLoss (अनुमानित: अपेक्षित: कमी :)

के बीच वर्ग काज नुकसान की गणना predicted और expected । loss = reduction(square(max(0, 1 - predicted * expected))) expected मूल्यों होने की उम्मीद कर रहे हैं 1 -1 या।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

श्रेणीबद्ध हिंगलॉस (अनुमानित: अपेक्षित: कमी :)

के बीच स्पष्ट काज नुकसान की गणना predicted और expected । loss = maximum(negative - positive + 1, 0) जहां negative = max((1 - expected) * predicted) और positive = sum(predicted * expected)

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

logCoshLoss (अनुमानित: अपेक्षित: कमी :)

भविष्यवाणी त्रुटि के अतिपरवलयिक कोज्या के लघुगणक की गणना करता है। logcosh = log((exp(x) + exp(-x))/2) , x है त्रुटि predicted - expected

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

poissonLoss (अनुमानित: अपेक्षित: कमी :)

भविष्यवाणी की है और उम्मीद प्वासों नुकसान के बीच प्वासों नुकसान की गणना के तत्वों का मध्यमान है Tensor predicted - expected * log(predicted) ।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

kullbackLeiblerDivergence(अनुमानित: अपेक्षित: कमी :)

के बीच की गणना करता है Kullback-Leibler विचलन नुकसान expected है और predicted । loss = reduction(expected * log(expected / predicted))

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

सॉफ्टमैक्स क्रॉसएन्ट्रॉपी (लॉगिट्स: लेबल्स: कमी :)

लॉग और लेबल के बीच विरल सॉफ्टमैक्स क्रॉस एन्ट्रापी (श्रेणीबद्ध क्रॉस एन्ट्रापी) की गणना करता है। दो या अधिक लेबल वर्ग होने पर इस क्रॉसेंट्रॉपी हानि फ़ंक्शन का उपयोग करें। हम उम्मीद करते हैं कि लेबल को पूर्णांक के रूप में प्रदान किया जाएगा। वहाँ होना चाहिए # classes चल सुविधा प्रति बिंदु मूल्यों के लिए logits के लिए और सुविधा प्रति एक भी चल बिन्दु मूल्य expected ।

घोषणा

@differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Int32>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`logits`	एक तंत्रिका नेटवर्क से एक-गर्म एन्कोडेड आउटपुट।
`labels`	सही आउटपुट के सूचकांक (शून्य-अनुक्रमित)।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

सॉफ्टमैक्स क्रॉसएन्ट्रॉपी (लॉगिट्स: संभावनाएं: कमी :)

लॉग और लेबल के बीच विरल सॉफ्टमैक्स क्रॉस एन्ट्रापी (श्रेणीबद्ध क्रॉस एन्ट्रापी) की गणना करता है। दो या अधिक लेबल वर्ग होने पर इस क्रॉसेंट्रॉपी हानि फ़ंक्शन का उपयोग करें। हम उम्मीद करते हैं लेबल एक में प्रदान की उपलब्ध कराई जाने वाली one_hot प्रतिनिधित्व। वहाँ होना चाहिए # classes चल सुविधा प्रति अंक मान।

घोषणा

@differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  probabilities: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`logits`	एक तंत्रिका नेटवर्क से अनस्केल्ड लॉग संभावनाएं।
`probabilities`	संभाव्यता मान जो सही आउटपुट के अनुरूप हैं। प्रत्येक पंक्ति एक मान्य प्रायिकता बंटन होनी चाहिए।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

सिग्मॉइडक्रॉसएन्ट्रॉपी (लॉगिट: लेबल: कमी :)

लॉग और लेबल के बीच सिग्मॉइड क्रॉस एन्ट्रॉपी (बाइनरी क्रॉस एन्ट्रॉपी) की गणना करता है। इस क्रॉस-एन्ट्रॉपी हानि का उपयोग तब करें जब केवल दो लेबल वर्ग हों (0 और 1 माना जाता है)। प्रत्येक उदाहरण के लिए, प्रति पूर्वानुमान एक एकल फ़्लोटिंग-पॉइंट मान होना चाहिए।

घोषणा

@differentiable(wrt: logits)
@differentiable(wrt: (logits, labels)
public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

मापदंडों

`logits`	एक तंत्रिका नेटवर्क का अनस्केल्ड आउटपुट।
`labels`	सही आउटपुट के अनुरूप पूर्णांक मान।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

ह्यूबरलॉस (अनुमानित: अपेक्षित: डेल्टा: कमी :)

के बीच ह्यूबर नुकसान की गणना predicted और expected ।

के लिए प्रत्येक मान x में error = expected - predicted :

0.5 * x^2 यदि |x| <= δ ।
0.5 * δ^2 + δ * (|x| - δ) अन्यथा।
स्रोत: विकिपीडिया लेख ।

घोषणा

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func huberLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  delta: Scalar,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

मापदंडों

`predicted`	तंत्रिका नेटवर्क से अनुमानित आउटपुट।
`expected`	अपेक्षित मान, यानी लक्ष्य, जो सही आउटपुट के अनुरूप हों।
`delta`	एक फ्लोटिंग पॉइंट स्केलर उस बिंदु का प्रतिनिधित्व करता है जहां ह्यूबर लॉस फ़ंक्शन द्विघात से रैखिक में बदलता है।
`reduction`	गणना किए गए तत्व-वार हानि मूल्यों पर लागू करने के लिए कटौती।

पेट (_ :)
तत्व-वार निर्दिष्ट टेंसर का निरपेक्ष मान लौटाता है।
घोषणा
@differentiable public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
लॉग(_:)
तत्व-वार निर्दिष्ट टेंसर का प्राकृतिक लघुगणक लौटाता है।
घोषणा
@differentiable public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
लॉग २ (_ :)
तत्व-वार निर्दिष्ट टेंसर का आधार-दो लघुगणक लौटाता है।
घोषणा
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
लॉग10(_:)
तत्व-वार निर्दिष्ट टेंसर का आधार-दस लघुगणक लौटाता है।
घोषणा
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log1p(_:)
रिटर्न के लघुगणक 1 + x तत्व के लिहाज से।
घोषणा
@differentiable public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log1mexp(_:)
रिटर्न log(1 - exp(x)) एक संख्यानुसार स्थिर दृष्टिकोण का उपयोग कर।
ध्यान दें
: दृष्टिकोण के समीकरण 7 में दिखाया गया है https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf ।
घोषणा
@differentiable public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
पाप (_ :)
तत्व-वार निर्दिष्ट टेंसर की ज्या लौटाता है।
घोषणा
@differentiable public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
कॉस(_:)
तत्व-वार निर्दिष्ट टेंसर की कोज्या लौटाता है।
घोषणा
@differentiable public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
तन (_ :)
तत्व-वार निर्दिष्ट टेंसर की स्पर्शरेखा लौटाता है।
घोषणा
@differentiable public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
सिंह (_ :)
तत्व-वार निर्दिष्ट टेंसर की अतिपरवलयिक ज्या लौटाता है।
घोषणा
@differentiable public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
कोष (_ :)
तत्व के अनुसार निर्दिष्ट टेंसर की हाइपरबोलिक कोसाइन लौटाता है।
घोषणा
@differentiable public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
तन (_ :)
तत्व-वार निर्दिष्ट टेंसर की अतिपरवलयिक स्पर्शरेखा लौटाता है।
घोषणा
@differentiable public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
एकोस (_ :)
तत्व-वार निर्दिष्ट टेंसर की प्रतिलोम कोज्या लौटाता है।
घोषणा
@differentiable public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
जैसे की(_:)
तत्व-वार निर्दिष्ट टेंसर की प्रतिलोम ज्या लौटाता है।
घोषणा
@differentiable public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
एक भूरा(_:)
तत्व-वार निर्दिष्ट टेंसर की प्रतिलोम स्पर्शरेखा लौटाता है।
घोषणा
@differentiable public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
एकोश (_ :)
तत्व-वार निर्दिष्ट टेंसर की प्रतिलोम अतिपरवलयिक कोज्या लौटाता है।
घोषणा
@differentiable public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
असिन (_ :)
तत्व-वार निर्दिष्ट टेंसर की प्रतिलोम अतिपरवलयिक ज्या लौटाता है।
घोषणा
@differentiable public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
अतन्ह (_ :)
तत्व-वार निर्दिष्ट टेंसर की प्रतिलोम अतिपरवलयिक स्पर्शरेखा लौटाता है।
घोषणा
@differentiable public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
वर्ग (_ :)
तत्व के अनुसार निर्दिष्ट टेंसर का वर्गमूल लौटाता है।
घोषणा
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
आरएसक्यूआरटी (_ :)
तत्व-वार निर्दिष्ट टेंसर का व्युत्क्रम वर्गमूल लौटाता है।
घोषणा
@differentiable public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
क्स्प (_ :)
तत्व-वार निर्दिष्ट टेंसर का घातांक लौटाता है।
घोषणा
@differentiable public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
क्स्प २ (_ :)
निर्दिष्ट टेंसर तत्व-वार की शक्ति के लिए उठाए गए दो लौटाता है।
घोषणा
@differentiable public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
क्स्प १० (_ :)
निर्दिष्ट टेंसर तत्व-वार की शक्ति के लिए बढ़ा हुआ दस लौटाता है।
घोषणा
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
expm1(_:)
रिटर्न के घातीय x - 1 तत्व के लिहाज से।
घोषणा
@differentiable public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
गोल(_:)
तत्व-वार निर्दिष्ट टेंसर के मानों को निकटतम पूर्णांक में लौटाता है।
घोषणा
@differentiable public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
छत (_ :)
तत्व-वार निर्दिष्ट टेंसर की सीमा लौटाता है।
घोषणा
@differentiable public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
मंज़िल(_:)
तत्व के अनुसार निर्दिष्ट टेंसर का फर्श लौटाता है।
घोषणा
@differentiable public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
संकेत(_:)
तत्व-वार निर्दिष्ट टेंसर के संकेत का संकेत देता है। विशेष रूप से, गणना करता है y = sign(x) = -1 यदि x < 0 ; 0 यदि x == 0 ; 1 यदि x > 0 ।
घोषणा
@differentiable public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
सिग्मॉइड (_ :)
तत्व-वार निर्दिष्ट टेंसर का सिग्मॉइड लौटाता है। विशेष रूप से, गणना करता है 1 / (1 + exp(-x))
घोषणा
@differentiable public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
लॉगसिग्मॉइड(_:)
तत्व-वार निर्दिष्ट टेंसर का लॉग-सिग्मॉइड लौटाता है। विशेष रूप से, log(1 / (1 + exp(-x))) संख्यात्मक स्थिरता के लिए, हम का उपयोग -softplus(-x) ।
घोषणा
@differentiable public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
सॉफ्टप्लस (_ :)
तत्व के अनुसार निर्दिष्ट टेंसर का सॉफ्टप्लस लौटाता है। विशेष रूप से, computes log(exp(features) + 1) ।
घोषणा
@differentiable public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
सॉफ्टसाइन (_ :)
तत्व के अनुसार निर्दिष्ट टेंसर का सॉफ्टसाइन लौटाता है। विशेष रूप से, गणना करता है features/ (abs(features) + 1) ।
घोषणा
@differentiable public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
सॉफ्टमैक्स (_ :)
अंतिम अक्ष के साथ निर्दिष्ट टेंसर का सॉफ्टमैक्स लौटाता है। विशेष रूप से, computes exp(x) / exp(x).sum(alongAxes: -1) ।
घोषणा
@differentiable public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
सॉफ्टमैक्स (_: अक्ष के साथ :)
निर्दिष्ट अक्ष के साथ निर्दिष्ट टेंसर का सॉफ्टमैक्स लौटाता है। विशेष रूप से, computes exp(x) / exp(x).sum(alongAxes: axis) ।
घोषणा
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
लॉग सॉफ्टमैक्स (_ :)
निर्दिष्ट टेंसर तत्व-वार का लॉग-सॉफ्टमैक्स लौटाता है।
घोषणा
@differentiable public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
एलु (_ :)
एक घातांक रैखिक इकाई लागू करके एक टेंसर देता है। विशेष रूप से, computes exp(x) - 1 यदि <0, x अन्यथा। देखें घातीय रैखिक इकाइयों द्वारा तेज़ और सटीक दीप नेटवर्क लर्निंग (ELUS)
घोषणा
@differentiable public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
गेलु(_:)
निर्दिष्ट टेंसर तत्व-वार गॉसियन एरर लीनियर यूनिट (GELU) एक्टिवेशन लौटाता है।
विशेष रूप से, gelu का अनुमान लगाती है xP(X <= x) है, जहां P(X <= x) स्टैंडर्ड गाऊसी संचयी बंटन कंप्यूटिंग द्वारा, है: एक्स * [0.5 * (1 + tanh [√ (2 / π) * (x + 0.044715 * x^3)])]।
देखें गाऊसी त्रुटि रैखिक इकाइयों ।
घोषणा
@differentiable public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
रेलु (_ :)
निर्दिष्ट टेंसर तत्व-वार में ReLU सक्रियण फ़ंक्शन को लागू करके एक टेंसर लौटाता है। विशेष रूप से, गणना करता है max(0, x) ।
घोषणा
@differentiable public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
रेलु6(_:)
रिटर्न ReLU6 सक्रियण समारोह, अर्थात् लगाने से एक टेन्सर min(max(0, x), 6) ।
घोषणा
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
लीकीरेलू (_: अल्फा :)
लीक हुए ReLU सक्रियण फ़ंक्शन को निर्दिष्ट टेंसर तत्व-वार पर लागू करके एक टेंसर लौटाता है। विशेष रूप से, गणना करता है max(x, x * alpha) ।
घोषणा
@differentiable(wrt: x) public func leakyRelu<T: TensorFlowFloatingPoint>( _ x: Tensor<T>, alpha: Double = 0.2 ) -> Tensor<T>
सेलु (_ :)
रिटर्न सेलु सक्रियण समारोह लगाने से एक टेन्सर, अर्थात् scale * alpha * (exp(x) - 1) यदि x < 0 , और scale * x अन्यथा।
ध्यान दें
इसे वेरिएंस स्केलिंग लेयर इनिशियलाइज़र्स के साथ उपयोग करने के लिए डिज़ाइन किया गया है। देखें स्व सामान्य तंत्रिका नेटवर्क और जानकारी के लिए।
घोषणा
@differentiable public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
स्वाश (_ :)
रिटर्न बेंत की मार सक्रियण समारोह, अर्थात् लगाने से एक टेन्सर x * sigmoid(x) ।
स्रोत: (। रामचंद्रन एट अल 2017) "सक्रियण कार्य के लिए सर्च कर रहे हैं" https://arxiv.org/abs/1710.05941
घोषणा
@differentiable public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
हार्डसिग्मॉइड (_ :)
रिटर्न कठिन अवग्रह सक्रियण समारोह, अर्थात् लगाने से एक टेन्सर Relu6(x+3)/6 ।
स्रोत: "MobileNetV3 के लिए सर्च कर रहे हैं" (। हावर्ड एट अल -2019) https://arxiv.org/abs/1905.02244
घोषणा
@differentiable public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
हार्डस्विश (_ :)
रिटर्न, कठिन बेंत की मार सक्रियण समारोह को लागू करने अर्थात् द्वारा एक टेन्सर x * Relu6(x+3)/6 ।
स्रोत: "MobileNetV3 के लिए सर्च कर रहे हैं" (। हावर्ड एट अल -2019) https://arxiv.org/abs/1905.02244
घोषणा
@differentiable public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
मिश (_ :)
रिटर्न mish सक्रियण समारोह, अर्थात् लगाने से एक टेन्सर x * tanh(softplus(x))
स्रोत: "Mish: एक स्व नियमित गैर monotonic तंत्रिका सक्रियण फंक्शन" https://arxiv.org/abs/1908.08681
घोषणा
@differentiable public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
पाउ (_:_ :)
पहले टेंसर की शक्ति को दूसरे टेंसर में लौटाता है।
घोषणा
@differentiable public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
पाउ (_:_ :)
स्केलर को प्रसारित करते हुए, स्केलर की शक्ति को टेंसर को लौटाता है।
घोषणा
@differentiable(wrt: rhs) public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
पाउ (_:_ :)
स्केलर को प्रसारित करते हुए, स्केलर को टेंसर की शक्ति लौटाता है।
घोषणा
@differentiable(wrt: lhs) public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
पाउ (_:_ :)
स्केलर को प्रसारित करते हुए, स्केलर को टेंसर की शक्ति लौटाता है।
घोषणा
@differentiable public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
जड़(_:_:)
तत्व के लिहाज से रिटर्न n टेन्सर की वें जड़।
घोषणा
@differentiable public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
चुकता अंतर (_:_ :)
रिटर्न के बीच अंतर वर्ग x और y ।
घोषणा
@differentiable public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
प्रतिलाभ की मात्रा
(x - y) ^ 2 ।
अधिकतम (_:_ :)
तत्व-वार अधिकतम दो टेंसर लौटाता है।
ध्यान दें
max समर्थन करता है प्रसारण।
घोषणा
@differentiable public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
अधिकतम (_:_ :)
स्केलर को प्रसारित करते हुए, स्केलर और टेंसर का तत्व-वार अधिकतम लौटाता है।
घोषणा
@differentiable(wrt: rhs) public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
अधिकतम (_:_ :)
स्केलर को प्रसारित करते हुए, स्केलर और टेंसर का तत्व-वार अधिकतम लौटाता है।
घोषणा
@differentiable(wrt: lhs) public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
मिनट (_:_ :)
तत्व-वार न्यूनतम दो टेंसर लौटाता है।
ध्यान दें
min प्रसारण समर्थन करता है।
घोषणा
@differentiable public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
मिनट (_:_ :)
स्केलर को प्रसारित करते हुए, स्केलर और टेंसर का तत्व-वार न्यूनतम लौटाता है।
घोषणा
@differentiable(wrt: rhs) public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
मिनट (_:_ :)
स्केलर को प्रसारित करते हुए, स्केलर और टेंसर का तत्व-वार न्यूनतम लौटाता है।
घोषणा
@differentiable(wrt: lhs) public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

कोसाइनसमानता(_:_ :)

रिटर्न के बीच कोज्या समानता x और y ।

घोषणा

@differentiable
public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

cosineDistance(_:_:)
रिटर्न के बीच कोज्या दूरी x और y । कोसाइन दूरी के रूप में परिभाषित किया गया है 1 - cosineSimilarity(x, y) ।
घोषणा
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
मटमुल (_: स्थानांतरित:_: स्थानांतरित :)
एक और टेंसर के साथ मैट्रिक्स गुणा करता है और परिणाम उत्पन्न करता है।
घोषणा
@differentiable public func matmul<Scalar: Numeric>( _ lhs: Tensor<Scalar>, transposed transposeLhs: Bool = false, _ rhs: Tensor<Scalar>, transposed transposeRhs: Bool = false ) -> Tensor<Scalar>

conv1D (_: फ़िल्टर: स्ट्राइड: पैडिंग: फैलाव :)

निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड और पैडिंग के साथ 1-डी कनवल्शन लौटाता है।

शर्त लगाना

input रैंक होना आवश्यक है 3 ।

शर्त लगाना

filter रैंक 3 होना आवश्यक है।

घोषणा

@differentiable(wrt: (input, filter)
public func conv1D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  stride: Int = 1,
  padding: Padding = .valid,
  dilation: Int = 1
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filter`	कनवल्शन फिल्टर।
`stride`	स्लाइडिंग फिल्टर की स्ट्राइड।
`padding`	ऑपरेशन के लिए पैडिंग।
`dilation`	फैलाव कारक।

conv2D (_: फ़िल्टर: स्ट्राइड्स: पैडिंग: फैलाव :)

निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड और पैडिंग के साथ 2-डी कनवल्शन लौटाता है।

शर्त लगाना

input रैंक होना आवश्यक है 4 ।

शर्त लगाना

filter रैंक 4 होना आवश्यक है।

घोषणा

@differentiable(wrt: (input, filter)
public func conv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filter`	कनवल्शन फिल्टर।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग
`dilations`	इनपुट के प्रत्येक आयाम के लिए फैलाव कारक।

transposedConv2D (_: आकार: फ़िल्टर: स्ट्राइड्स: पैडिंग: फैलाव :)

निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड और पैडिंग के साथ 2-डी ट्रांसपोज़्ड कनवल्शन लौटाता है।

शर्त लगाना

input रैंक होना आवश्यक है 4 ।

शर्त लगाना

filter रैंक 4 होना आवश्यक है।

घोषणा

@differentiable(wrt: (input, filter)
public func transposedConv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  shape: [Int64],
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`shape`	डीकोनवोल्यूशन ऑपरेशन का आउटपुट आकार।
`filter`	कनवल्शन फिल्टर।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग
`dilations`	इनपुट के प्रत्येक आयाम के लिए फैलाव कारक।

conv3D (_: फ़िल्टर: स्ट्राइड्स: पैडिंग: फैलाव :)

निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स, पैडिंग और फैलाव के साथ 3-डी कनवल्शन लौटाता है।

शर्त लगाना

input रैंक होना आवश्यक है 5 ।

शर्त लगाना

filter रैंक 5 होना आवश्यक है।

घोषणा

@differentiable(wrt: (input, filter)
public func conv3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1)
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filter`	कनवल्शन फिल्टर।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग।
`dilations`	इनपुट के प्रत्येक आयाम के लिए फैलाव कारक।

गहराई के अनुसारConv2D (_: फ़िल्टर: स्ट्राइड्स: पैडिंग :)

निर्दिष्ट इनपुट, फिल्टर, स्ट्राइड्स और पैडिंग के साथ 2-डी डेप्थवाइज कनवल्शन लौटाता है।

शर्त लगाना

input रैंक 4 होना आवश्यक है।

शर्त लगाना

filter रैंक 4 होना आवश्यक है।

घोषणा

@differentiable(wrt: (input, filter)
public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filter`	डेप्थवाइज कनवल्शन फिल्टर।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग।

maxPool2D (_: फ़िल्टर आकार: स्ट्राइड्स: पैडिंग :)

निर्दिष्ट फ़िल्टर आकार, स्ट्राइड और पैडिंग के साथ 2-डी अधिकतम पूलिंग देता है।

घोषणा

@differentiable(wrt: input)
public func maxPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int),
  strides: (Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filterSize`	पूलिंग कर्नेल के आयाम।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग।

maxPool3D (_: फ़िल्टर आकार: स्ट्राइड्स: पैडिंग :)

निर्दिष्ट फ़िल्टर आकार, स्ट्राइड और पैडिंग के साथ 3-डी अधिकतम पूलिंग देता है।

घोषणा

@differentiable(wrt: input)
public func maxPool3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int, Int),
  strides: (Int, Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filterSize`	पूलिंग कर्नेल के आयाम।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग।

avgPool2D (_: फ़िल्टर आकार: स्ट्राइड्स: पैडिंग :)

निर्दिष्ट फ़िल्टर आकार, स्ट्राइड और पैडिंग के साथ 2-डी औसत पूलिंग देता है।

घोषणा

@differentiable(wrt: input)
public func avgPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int),
  strides: (Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filterSize`	पूलिंग कर्नेल के आयाम।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग।

avgPool3D (_: फ़िल्टर आकार: स्ट्राइड्स: पैडिंग :)

निर्दिष्ट फ़िल्टर आकार, स्ट्राइड और पैडिंग के साथ एक 3-डी औसत पूलिंग देता है।

घोषणा

@differentiable(wrt: input)
public func avgPool3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filterSize: (Int, Int, Int, Int, Int),
  strides: (Int, Int, Int, Int, Int),
  padding: Padding
) -> Tensor<Scalar>

मापदंडों

`input`	इनपुट।
`filterSize`	पूलिंग कर्नेल के आयाम।
`strides`	इनपुट के प्रत्येक आयाम के लिए स्लाइडिंग फ़िल्टर के चरण।
`padding`	ऑपरेशन के लिए पैडिंग।

भिन्नात्मकMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2:)

निर्दिष्ट पूलिंग अनुपात के साथ 2-डी आंशिक अधिकतम पूलिंग देता है।

नोट: fractionalMaxPool एक XLA कार्यान्वयन नहीं है, और इस तरह प्रदर्शन प्रभाव हो सकता है।

घोषणा

@differentiable(wrt: input)
public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  poolingRatio: (Double, Double, Double, Double),
  pseudoRandom: Bool = false,
  overlapping: Bool = false,
  deterministic: Bool = false,
  seed: Int64 = 0,
  seed2: Int64 = 0
) -> Tensor<Scalar>

मापदंडों

`input`	एक टेंसर। आकार के साथ 4 डी `[batch, height, width, channels]` ।
`poolingRatio`	की एक सूची `Doubles` । के प्रत्येक आयाम के लिए अनुपात पूलिंग `input` , वर्तमान में केवल पंक्ति और स्तंभ आयाम का समर्थन करता है और> = 1.0 होना चाहिए।
`pseudoRandom`	एक वैकल्पिक `Bool` । करने के लिए चूक `false` । करने के लिए सेट जब `true` , पूलिंग अनुक्रम एक कूट-यादृच्छिक फैशन में, एक यादृच्छिक फैशन में उत्पन्न करता है अन्यथा।
`overlapping`	एक वैकल्पिक `Bool` । करने के लिए चूक `false` । जब करने के लिए सेट `true` , इसका मतलब है जब पूलिंग, आसन्न पूलिंग कोशिकाओं की सीमा पर हुई मानों दोनों कोशिकाओं द्वारा किया जाता है।
`deterministic`	एक वैकल्पिक `Bool` । सेट करने के लिए जब `true` , एक निश्चित पूलिंग क्षेत्र गणना ग्राफ में एक fractionalMaxPool2D नोड पर इस्तेमाल किया जाएगा जब बार-बार दोहराना।
`seed`	एक वैकल्पिक `Int64` । करने के लिए चूक `0` । यदि गैर-शून्य पर सेट किया जाता है, तो दिए गए बीज द्वारा यादृच्छिक संख्या जनरेटर को सीड किया जाता है।
`seed2`	एक वैकल्पिक `Int64` । करने के लिए चूक `0` । बीज की टक्कर से बचने के लिए दूसरा बीज।

गहराई से अंतरिक्ष (_: ब्लॉक आकार :)
की एक प्रति रिटर्न input जहां गहराई आयाम से मूल्यों ऊंचाई और चौड़ाई आयामों को स्थानिक ब्लॉक में ले जाया जाता है।
उदाहरण के लिए, आकार की एक इनपुट दिया [1, 2, 2, 1] , data_format = "NHWC" और block_size = 2:
```
x = [[[[1], [2]],
      [[3], [4]]]]
```
इस आपरेशन इच्छा उत्पादन आकार का एक टेन्सर [1, 1, 1, 4] :
```
[[[[1, 2, 3, 4]]]]
```
यहाँ, इनपुट 1 का एक बैच है और प्रत्येक बैच तत्व आकार [2, 2, 1] , इसी उत्पादन एक भी तत्व होगा (यानी चौड़ाई और ऊंचाई दोनों 1) और 4 चैनलों की गहराई होगा (1 * ब्लॉक_साइज़ * ब्लॉक_साइज़)। उत्पादन तत्व आकार है [1, 1, 4] ।
बड़ा गहराई, आकार के साथ यहां एक इनपुट टेन्सर के लिए [1, 2, 2, 3] , जैसे
```
x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]
```
इस आपरेशन, 2 की block_size के लिए, आकार के निम्नलिखित टेन्सर वापस आ जाएगी [1, 1, 1, 12]
```
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
```
इसी प्रकार, आकार के निम्नलिखित इनपुट के लिए [1 4 4 1] , और 2 के एक ब्लॉक का आकार:
```
x = [[[[1],   [2],  [5],  [6]],
      [[3],   [4],  [7],  [8]],
      [[9],  [10], [13],  [14]],
      [[11], [12], [15],  [16]]]]
```
ऑपरेटर आकार के निम्नलिखित टेन्सर वापस आ जाएगी [1 2 2 4] :
```
x = [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]
```
शर्त लगाना
input.rank == 4 && b >= 2 ।
शर्त लगाना
सुविधाओं की संख्या के वर्ग से भाज्य होना चाहिए b ।
घोषणा
@differentiable(wrt: input) public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
spaceToDepth(_:blockSize :)
की एक प्रति रिटर्न input जहां ऊंचाई और चौड़ाई आयामों से मूल्यों को गहराई आयाम करने के लिए ले जाया जाता है।
उदाहरण के लिए, आकार की एक इनपुट दिया [1, 2, 2, 1] , data_format = "NHWC" और block_size = 2:
```
x = [[[[1], [2]],
      [[3], [4]]]]
```
इस आपरेशन इच्छा उत्पादन आकार का एक टेन्सर [1, 1, 1, 4] :
```
[[[[1, 2, 3, 4]]]]
```
यहाँ, इनपुट 1 का एक बैच है और प्रत्येक बैच तत्व आकार [2, 2, 1] , इसी उत्पादन एक भी तत्व होगा (यानी चौड़ाई और ऊंचाई दोनों 1) और 4 चैनलों की गहराई होगा (1 * ब्लॉक_साइज़ * ब्लॉक_साइज़)। उत्पादन तत्व आकार है [1, 1, 4] ।
बड़ा गहराई, आकार के साथ यहां एक इनपुट टेन्सर के लिए [1, 2, 2, 3] , जैसे
```
x = [[[[1, 2, 3], [4, 5, 6]],
      [[7, 8, 9], [10, 11, 12]]]]
```
This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]
```
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
```
Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:
```
x = [[[[1],   [2],  [5],  [6]],
      [[3],   [4],  [7],  [8]],
      [[9],  [10], [13],  [14]],
      [[11], [12], [15],  [16]]]]
```
the operator will return the following tensor of shape [1 2 2 4] :
```
x = [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]
```
Precondition
input.rank == 4 && b >= 2 .
Precondition
The height of the input must be divisible by b .
Precondition
The width of the input must be divisible by b .
घोषणा
@differentiable(wrt: input) public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

makeLARS(learningRate:momentum:trustCoefficient:nesterov:epsilon:weightDecay:)

Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

घोषणा

public func makeLARS(
  learningRate: Float = 0.01,
  momentum: Float = 0.9,
  trustCoefficient: Float = 0.001,
  nesterov: Bool = false,
  epsilon: Float = 0.0,
  weightDecay: Float = 0.0
) -> ParameterGroupOptimizer

makeSGD(learningRate:momentum:weightDecay:nesterov:)

Builds a SGD based per-weight optimizer.

घोषणा

public func makeSGD(
  learningRate: Float = 0.01,
  momentum: Float = 0,
  weightDecay: Float = 0,
  nesterov: Bool = false
) -> ParameterGroupOptimizer

makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon:)

Builds a per-weight optimizer for Adam with weight decay.

Reference: “Adam - A Method for Stochastic Optimization”

घोषणा

public func makeAdam(
  learningRate: Float = 0.01,
  beta1: Float = 0.9,
  beta2: Float = 0.999,
  weightDecayRate: Float = 0.01,
  epsilon: Float = 1e-6
) -> ParameterGroupOptimizer

randomSeedForTensorFlow(using:)

Generates a new random seed for TensorFlow.

घोषणा

public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed

concatenate(_:_:)

Concatenates two values.

घोषणा

@differentiable
public func concatenate<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

sum(_:_:)

Adds two values and produces their sum.

घोषणा

@differentiable
public func sum<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

average(_:_:)

Averages two values.

घोषणा

@differentiable
public func average<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

multiply(_:_:)

Multiplies two values.

घोषणा

@differentiable
public func multiply<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

stack(_:_:)

Stack two values.

घोषणा

@differentiable
public func stack<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

PrintX10Metrics()
घोषणा
public func PrintX10Metrics()

formatStatistics(_:)

Creates a string summary of a list of training and testing stats.

घोषणा

public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

formatStatistics(train:test:)

घोषणा

public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
  -> String

runOnNThreads(_:_:)

Maps a function over n threads.

घोषणा

public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]

`context`	एक संदर्भ जिसे बंद करने से पहले सेट किया जाएगा, बंद होने के बाद कॉल किया जाता है और बहाल किया जाता है।
`body`	एक अशक्त बंद। बंद की वापसी मान है, तो है कि मूल्य भी की वापसी मान के रूप में प्रयोग किया जाता है `withContext(_:_:)` कार्य करते हैं।

`learningPhase`	एक सीखने का चरण जिसे बंद करने से पहले सेट किया जाएगा, उसे बंद करने के बाद वापस बुलाया जाएगा और बहाल किया जाएगा।
`body`	एक अशक्त बंद। बंद की वापसी मान है, तो है कि मूल्य भी की वापसी मान के रूप में प्रयोग किया जाता है `withLearningPhase(_:_:)` कार्य करते हैं।

`mean`	सामान्य वितरण का माध्य।
`standardDeviation`	सामान्य वितरण का मानक विचलन।