फ़ंक्शन

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

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

    घोषणा 

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

    पैरामीटर

    predicted

    तंत्रिका नेटवर्क से अनुमानित आउटपुट।

    expected

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

  • पूर्वानुमानों और अपेक्षाओं के बीच 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

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

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

    घोषणा 

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

    पैरामीटर

    predicted

    तंत्रिका नेटवर्क से अनुमानित आउटपुट।

    expected

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

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

    घोषणा 

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

    पैरामीटर

    predicted

    तंत्रिका नेटवर्क से अनुमानित आउटपुट।

    expected

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

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

    घोषणा 

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

    पैरामीटर

    predicted

    तंत्रिका नेटवर्क से अनुमानित आउटपुट।

    expected

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

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

    घोषणा 

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

    पैरामीटर

    predicted

    तंत्रिका नेटवर्क से अनुमानित आउटपुट।

    expected

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

  • अपेक्षाओं और भविष्यवाणियों के बीच कुल्बैक-लीबलर विचलन (केएल विचलन) लौटाता है। दो वितरणों p और q देखते हुए, KL विचलन 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

  • दिए गए समापन को एक ऐसे संदर्भ में कॉल करता है जिसमें दिए गए सीखने के चरण को छोड़कर सब कुछ वर्तमान संदर्भ के समान है।

    घोषणा 

    public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R

    पैरामीटर

    context

    एक संदर्भ जिसे क्लोजर से पहले सेट किया जाएगा और क्लोजर वापस आने के बाद उसे बहाल किया जाएगा।

    body

    एक अशक्त समापन. यदि क्लोजर में रिटर्न वैल्यू है, तो उस वैल्यू का उपयोग withContext(_:_:) फ़ंक्शन के रिटर्न वैल्यू के रूप में भी किया जाता है।

    वापसी मूल्य

    body क्लोजर का रिटर्न वैल्यू, यदि कोई हो।

  • दिए गए समापन को एक ऐसे संदर्भ में कॉल करता है जिसमें दिए गए सीखने के चरण को छोड़कर सब कुछ वर्तमान संदर्भ के समान है।

    घोषणा 

    public func withLearningPhase<R>(
  _ learningPhase: LearningPhase,
  _ body: () throws -> R
) rethrows -> R

    पैरामीटर

    learningPhase

    एक सीखने का चरण जिसे क्लोजर से पहले सेट किया जाएगा और क्लोजर वापस आने के बाद उसे बहाल किया जाएगा।

    body

    एक अशक्त समापन. यदि क्लोजर में रिटर्न वैल्यू है, तो उस वैल्यू का उपयोग withLearningPhase(_:_:) फ़ंक्शन के रिटर्न वैल्यू के रूप में भी किया जाता है।

    वापसी मूल्य

    body क्लोजर का रिटर्न वैल्यू, यदि कोई हो।

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

    घोषणा 

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

    पैरामीटर

    randomSeed

    एक यादृच्छिक बीज जिसे बंद होने से पहले सेट किया जाएगा और बंद होने के बाद वापस बुलाया जाएगा और बहाल किया जाएगा।

    body

    एक अशक्त समापन. यदि क्लोजर में रिटर्न वैल्यू है, तो उस वैल्यू का उपयोग withRandomSeedForTensorFlow(_:_:) फ़ंक्शन के रिटर्न वैल्यू के रूप में भी किया जाता है।

    वापसी मूल्य

    body क्लोजर का रिटर्न वैल्यू, यदि कोई हो।

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

    घोषणा 

    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 सुनिश्चित करता है कि सभी लाइव टेंसर (डिवाइस पर यदि उपलब्ध कराए गए हैं) शेड्यूल किए गए हैं और चल रहे हैं। यदि प्रतीक्षा को सत्य पर सेट किया गया है, तो यह कॉल गणना पूरी होने तक ब्लॉक हो जाती है।

    घोषणा 

    public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

  • घोषणा 

    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

  • घोषणा 

    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

  • घोषणा 

    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

  • घोषणा 

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

  • घोषणा 

    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

  • घोषणा 

    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

  • किसी फ़ंक्शन को उसके पुलबैक में पुन: संगणित करें, जिसे पारंपरिक स्वचालित विभेदन में "चेकपॉइंटिंग" के रूप में जाना जाता है।

    घोषणा 

    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 को दिखाई देता है
    • "/जॉब:लोकलहोस्ट/रेप्लिका:0/टास्क:0/डिवाइस:जीपीयू:1": आपकी मशीन के दूसरे जीपीयू का पूर्णतः योग्य नाम जो टेन्सरफ्लो को दिखाई देता है।

    घोषणा 

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

    पैरामीटर

    name

    डिवाइस का नाम।

    body

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

  • एक क्लोजर निष्पादित करता है, जिससे 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

    यदि true है, तो किसी छवि का डाउनसैंपलिंग करते समय एंटी-अलियासिंग फ़िल्टर का उपयोग करें।

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

    शर्त लगाना

    छवियों की रैंक 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

    छवियों का नया आकार.

  • निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स और पैडिंग के साथ 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>

  • एक फ़ंक्शन लौटाता है जो निर्दिष्ट आकार के लिए ग्लोरोट (ज़ेवियर) समान आरंभीकरण करके एक टेंसर बनाता है, डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न -limit और limit के बीच एक समान वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है, जहां सीमा sqrt(6 / (fanIn + fanOut)) है sqrt(6 / (fanIn + fanOut)) , और fanIn / fanOut यदि मौजूद है, तो ग्रहणशील क्षेत्र द्वारा गुणा किए गए इनपुट और आउटपुट सुविधाओं की संख्या का प्रतिनिधित्व करते हैं।

    घोषणा 

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • एक फ़ंक्शन लौटाता है जो निर्दिष्ट आकार के लिए ग्लोरोट (जेवियर) सामान्य आरंभीकरण करके एक टेंसर बनाता है, मानक विचलन sqrt(2 / (fanIn + fanOut)) के साथ 0 पर केंद्रित एक काटे गए सामान्य वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है, जहां fanIn / fanOut यदि मौजूद है तो ग्रहणशील क्षेत्र के आकार से गुणा किए गए इनपुट और आउटपुट सुविधाओं की संख्या का प्रतिनिधित्व करें।

    घोषणा 

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • एक फ़ंक्शन लौटाता है जो निर्दिष्ट आकार के लिए हे (काइमिंग) समान आरंभीकरण करके एक टेंसर बनाता है, -limit और limit के बीच एक समान वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है, जो डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न होता है, जहां सीमा sqrt(6 / fanIn) है sqrt(6 / fanIn) , और fanIn मौजूद होने पर ग्रहणशील क्षेत्र द्वारा गुणा किए गए इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है।

    घोषणा 

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • एक फ़ंक्शन लौटाता है जो निर्दिष्ट आकार के लिए हे (काइमिंग) सामान्य आरंभीकरण करके एक टेंसर बनाता है, मानक विचलन sqrt(2 / fanIn) के साथ 0 पर केंद्रित एक काटे गए सामान्य वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है, जहां fanIn इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है यदि मौजूद हो तो ग्रहणशील क्षेत्र के आकार से गुणा किया जाता है।

    घोषणा 

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • एक फ़ंक्शन लौटाता है जो निर्दिष्ट आकार के लिए LeCun समान आरंभीकरण करके एक टेंसर बनाता है, -limit और limit के बीच एक समान वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है, जो डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न होता है, जहां सीमा sqrt(3 / fanIn) है, और fanIn , यदि मौजूद है, तो ग्रहणशील क्षेत्र द्वारा गुणा किए गए इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है।

    घोषणा 

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • एक फ़ंक्शन लौटाता है जो निर्दिष्ट आकार के लिए LeCun सामान्य आरंभीकरण करके एक टेंसर बनाता है, मानक विचलन sqrt(1 / fanIn) के साथ 0 पर केंद्रित एक काटे गए सामान्य वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है, जहां fanIn द्वारा गुणा किए गए इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है ग्रहणशील क्षेत्र का आकार, यदि मौजूद हो।

    घोषणा 

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • एक फ़ंक्शन लौटाता है जो एक काटे गए सामान्य वितरण से उसके सभी मानों को यादृच्छिक रूप से प्रारंभ करके एक टेंसर बनाता है। उत्पन्न मान औसत mean और मानक विचलन मानक standardDeviation के साथ एक सामान्य वितरण का पालन करते हैं, सिवाय इसके कि जिन मानों का परिमाण माध्य से दो मानक विचलन से अधिक है, उन्हें हटा दिया जाता है और पुन: नमूना लिया जाता है।

    घोषणा 

    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 आयाम वर्ग मैट्रिक्स बनाते हैं।

    इनपुट सममित और सकारात्मक निश्चित होना चाहिए। इस ऑपरेशन के लिए इनपुट के केवल निचले-त्रिकोणीय भाग का उपयोग किया जाएगा। ऊपरी त्रिकोणीय भाग नहीं पढ़ा जायेगा।

    आउटपुट इनपुट के समान आकार का एक टेंसर है जिसमें सभी इनपुट सबमैट्रिसेस के लिए चॉलेस्की डीकंपोजिशन शामिल है [..., :, :] ।

    घोषणा 

    @differentiable
public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

    पैरामीटर

    input

    आकार का एक टेंसर [..., M, M] ।

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

    शर्त लगाना

    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

    इनपुट त्रिकोणीय गुणांक मैट्रिक्स, Ax = b में A प्रतिनिधित्व करता है।

    rhs

    दाईं ओर के मान, Ax = b में b प्रतिनिधित्व करते हैं।

    lower

    क्या matrix निचला त्रिकोणीय ( true ) है या ऊपरी त्रिकोणीय ( false ) है। डिफ़ॉल्ट मान true है ।

    adjoint

    यदि true , तो matrix के बजाय matrix के जोड़ से हल करें। मूल मूल्य false है ।

    वापसी मूल्य

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

  • expected और predicted के बीच L1 हानि की गणना करता है। 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

    गणना किए गए तत्व-वार हानि मूल्यों पर लागू होने वाली कटौती।

  • expected और predicted के बीच L2 हानि की गणना करता है। 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(_:) अपरिभाषित है।

    घोषणा 

    @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

    गणना किए गए तत्व-वार हानि मूल्यों पर लागू होने वाली कटौती।

  • 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

    गणना किए गए तत्व-वार हानि मूल्यों पर लागू होने वाली कटौती।

  • पूर्वानुमान त्रुटि की अतिपरवलयिक कोज्या के लघुगणक की गणना करता है। 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

    गणना किए गए तत्व-वार हानि मूल्यों पर लागू होने वाली कटौती।

  • अनुमानित और अपेक्षित के बीच पॉइसन हानि की गणना करता है। पॉइसन हानि 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

    गणना किए गए तत्व-वार हानि मूल्यों पर लागू होने वाली कटौती।

  • 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

    गणना किए गए तत्व-वार हानि मूल्यों पर लागू होने वाली कटौती।

  • लॉगिट और लेबल के बीच विरल सॉफ्टमैक्स क्रॉस एन्ट्रॉपी (श्रेणीबद्ध क्रॉस एन्ट्रॉपी) की गणना करता है। जब दो या दो से अधिक लेबल वर्ग हों तो इस क्रॉसेंट्रॉपी हानि फ़ंक्शन का उपयोग करें। हम उम्मीद करते हैं कि लेबल पूर्णांक के रूप में प्रदान किए जाएंगे। logits के लिए प्रति फीचर # classes फ़्लोटिंग पॉइंट मान और 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 :

    घोषणा 

    @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

  • तत्व-वार निर्दिष्ट टेंसर का आधार-दस लघुगणक लौटाता है।

    घोषणा 

    @differentiable
public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • तत्व-वार 1 + x का लघुगणक लौटाता है।

    घोषणा 

    @differentiable
public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • संख्यात्मक रूप से स्थिर दृष्टिकोण का उपयोग करके 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

  • तत्व-वार 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

  • तत्व-वार निर्दिष्ट टेंसर का सॉफ्टप्लस लौटाता है। विशेष रूप से, 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

  • अंतिम अक्ष के साथ निर्दिष्ट टेंसर का सॉफ्टमैक्स लौटाता है। विशेष रूप से, exp(x) / exp(x).sum(alongAxes: -1) की गणना करता है।

    घोषणा 

    @differentiable
public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • निर्दिष्ट अक्ष के साथ निर्दिष्ट टेंसर का सॉफ्टमैक्स लौटाता है। विशेष रूप से, 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

  • एक घातीय रैखिक इकाई लागू करके एक टेंसर लौटाता है। विशेष रूप से, यदि < 0 है तो exp(x) - 1 गणना करता है, अन्यथा x गणना करता है। एक्सपोनेंशियल लीनियर यूनिट्स (ईएलयू) द्वारा तेज़ और सटीक डीप नेटवर्क लर्निंग देखें

    घोषणा 

    @differentiable
public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • तत्व-वार निर्दिष्ट टेंसर की गॉसियन एरर लीनियर यूनिट (GELU) सक्रियता लौटाता है।

    विशेष रूप से, gelu xP(X <= x) का अनुमान लगाता है, जहां P(X <= 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

  • 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>

  • SeLU सक्रियण फ़ंक्शन को लागू करके एक टेंसर लौटाता है, अर्थात् 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

  • मिश सक्रियण फ़ंक्शन, अर्थात् x * tanh(softplus(x)) लागू करके एक टेंसर लौटाता है।

    स्रोत: "मिश: एक स्व-नियमित गैर-मोनोटोनिक तंत्रिका सक्रियण फ़ंक्शन" 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>

  • 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>

  • निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड और पैडिंग के साथ 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

    फैलाव कारक.

  • निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स और पैडिंग के साथ 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

    इनपुट के प्रत्येक आयाम के लिए फैलाव कारक।

  • निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स और पैडिंग के साथ 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

    इनपुट के प्रत्येक आयाम के लिए फैलाव कारक।

  • निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स, पैडिंग और फैलाव के साथ 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

    इनपुट के प्रत्येक आयाम के लिए फैलाव कारक।

  • निर्दिष्ट इनपुट, फ़िल्टर, स्ट्राइड्स और पैडिंग के साथ 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

    ऑपरेशन के लिए पैडिंग.

  • निर्दिष्ट फ़िल्टर आकार, स्ट्राइड्स और पैडिंग के साथ 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

    ऑपरेशन के लिए पैडिंग.

  • निर्दिष्ट फ़िल्टर आकार, स्ट्राइड्स और पैडिंग के साथ 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

    ऑपरेशन के लिए पैडिंग.

  • निर्दिष्ट फ़िल्टर आकार, स्ट्राइड्स और पैडिंग के साथ 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

    ऑपरेशन के लिए पैडिंग.

  • निर्दिष्ट फ़िल्टर आकार, स्ट्राइड्स और पैडिंग के साथ 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

    ऑपरेशन के लिए पैडिंग.

  • निर्दिष्ट पूलिंग अनुपात के साथ 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 पर सेट किया जाता है, तो गणना ग्राफ़ में एक फ्रैक्शनलमैक्सपूल2डी नोड पर पुनरावृत्ति करते समय एक निश्चित पूलिंग क्षेत्र का उपयोग किया जाएगा।

    seed

    एक वैकल्पिक Int64 . डिफ़ॉल्ट 0 है। यदि गैर-शून्य पर सेट किया जाता है, तो यादृच्छिक संख्या जनरेटर को दिए गए बीज द्वारा सीड किया जाता है।

    seed2

    एक वैकल्पिक Int64 . डिफ़ॉल्ट 0 है। बीज टकराव से बचने के लिए दूसरा बीज।

  • input की एक प्रति लौटाता है जहां गहराई आयाम से मानों को स्थानिक ब्लॉकों में ऊंचाई और चौड़ाई आयामों में ले जाया जाता है।

    उदाहरण के लिए, आकार का इनपुट दिया गया है [1, 2, 2, 1] , डेटा_फॉर्मेट = "एनएचडब्ल्यूसी" और ब्लॉक_साइज़ = 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 के ब्लॉक_आकार के लिए, आकार का निम्नलिखित टेंसर लौटाएगा [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

  • input की एक प्रति लौटाता है जहां ऊंचाई और चौड़ाई आयामों से मान गहराई आयाम में ले जाया जाता है।

    उदाहरण के लिए, आकार का इनपुट दिया गया है [1, 2, 2, 1] , डेटा_फॉर्मेट = "एनएचडब्ल्यूसी" और ब्लॉक_साइज़ = 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 के ब्लॉक_आकार के लिए, आकार का निम्नलिखित टेंसर लौटाएगा [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 द्वारा विभाज्य होनी चाहिए।

    शर्त लगाना

    इनपुट की चौड़ाई b द्वारा विभाज्य होनी चाहिए।

    घोषणा 

    @differentiable(wrt: input)
public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • लार्स ( 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

  • एक SGD आधारित प्रति-वजन ऑप्टिमाइज़र बनाता है।

    घोषणा 

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

  • वजन क्षय के साथ एडम के लिए प्रति-वजन अनुकूलक बनाता है।

    संदर्भ: "एडम - स्टोकेस्टिक ऑप्टिमाइज़ेशन के लिए एक विधि"

    घोषणा 

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

  • Tensorflow के लिए एक नया यादृच्छिक बीज उत्पन्न करता है।

    घोषणा 

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

  • दो मूल्यों को समेटता है।

    घोषणा 

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

  • दो मूल्यों को जोड़ता है और उनकी राशि का उत्पादन करता है।

    घोषणा 

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

  • औसत दो मूल्यों।

    घोषणा 

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

  • दो मूल्यों को गुणा करता है।

    घोषणा 

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

  • दो मूल्यों को ढेर करें।

    घोषणा 

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

  • घोषणा 

    public func PrintX10Metrics()

  • प्रशिक्षण और परीक्षण आँकड़ों की एक सूची का एक स्ट्रिंग सारांश बनाता है।

    घोषणा 

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

  • घोषणा 

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

  • एन थ्रेड्स पर एक फ़ंक्शन मैप करता है।

    घोषणा 

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