कार्यों

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

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

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

  • उम्मीदों और पूर्वानुमानों के बीच कुलबैक-लीब्लर डाइवर्जेंस (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
  • दिए गए क्लोजर को उस संदर्भ में कहते हैं जिसमें दिए गए सीखने के चरण को छोड़कर वर्तमान संदर्भ के समान सब कुछ है।

    घोषणा

    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 को दिखाई देता है
    • "/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 संचालन निर्दिष्ट प्रकार के डिवाइस पर निष्पादित किया जाना है।

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

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

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

    घोषणा

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • रिटर्न एक समारोह है कि निर्दिष्ट आकार के लिए 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]

  • रिटर्न समाधान 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 = bx के रूप में ही आकार है b

  • एल 1 नुकसान के बीच की गणना expected है और predictedloss = 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

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

  • एल 2 नुकसान के बीच की गणना expected है और predictedloss = 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 और expectedloss = 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 और expectedloss = 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 और expectedloss = 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 और expectedloss = 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

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

  • के बीच की गणना करता है Kullback-Leibler विचलन नुकसान expected है और predictedloss = 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 :

    घोषणा

    @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
  • तत्व के अनुसार निर्दिष्ट टेंसर का सॉफ्टप्लस लौटाता है। विशेष रूप से, 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
  • रिटर्न 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>
  • रिटर्न के बीच कोज्या दूरी 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 , एक निश्चित पूलिंग क्षेत्र गणना ग्राफ में एक 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
  • की एक प्रति रिटर्न 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
  • 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
  • Builds a SGD based per-weight optimizer.

    घोषणा

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • 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
  • Generates a new random seed for TensorFlow.

    घोषणा

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    घोषणा

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    घोषणा

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    घोषणा

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    घोषणा

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    घोषणा

    @differentiable
    public func stack<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • घोषणा

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    घोषणा

    public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
  • घोषणा

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    घोषणा

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