टेन्सर

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
3
extension Tensor: CustomStringConvertible
extension Tensor: ExpressibleByArrayLiteral
10एन-
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: CustomReflectable
प्लेसहोल्डर9 एल10एन-प्लेसहोल्डर10 एल10एन-प्लेसहोल्डर11 एल10एन-
extension Tensor: TensorGroup
extension Tensor: TensorProtocol
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: Codable where Scalar: Codable
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

तत्वों की एक बहुआयामी सरणी जो संभावित उच्च आयामों के लिए वैक्टर और मैट्रिक्स का सामान्यीकरण है।

सामान्य पैरामीटर Scalar टेंसर में स्केलर के प्रकार का वर्णन करता है (जैसे Int32 , Float , आदि)।

  • अंतर्निहित TensorHandle .

    टिप्पणी

    उपयोगकर्ता परिभाषित ऑप्स की अनुमति देने के लिए handle सार्वजनिक है, लेकिन सामान्य रूप से इसका उपयोग नहीं किया जाना चाहिए।

    घोषणा

    public let handle: TensorHandle<Scalar>

  • घोषणा

    public init(handle: TensorHandle<Scalar>)

  • रैंक R टेंसर के दिए गए आयाम को कई रैंक- (R-1) टेंसर में खोलता है। इस टेंसर से N टेंसर को axis आयाम के साथ चिपकाकर अनपैक करता है, जहां N अनुमान इस टेंसर के आकार से लगाया जाता है। उदाहरण के लिए, [A, B, C, D] आकार वाला एक टेंसर दिया गया है:

    • यदि axis == 0 है तो लौटाए गए सरणी में i -th टेंसर स्लाइस self[i, :, :, :] है और उस सरणी में प्रत्येक टेंसर का आकार [B, C, D] होगा। (ध्यान दें कि Tensor.split(numSplits:alongAxis) , या Tensor.split(sizes:alongAxis) के विपरीत, साथ में अनपैक किया गया आयाम चला गया है।
    • यदि axis == 1 है तो लौटाए गए सरणी में i -th टेंसर स्लाइस value[:, i, :, :] और उस सरणी में प्रत्येक टेंसर का आकार [A, C, D] होगा।
    • वगैरह।

    यह Tensor.init(stacking:alongAxis:) के विपरीत है।

    शर्त लगाना

    axis [-rank, rank) सीमा में होना चाहिए, जहां rank प्रदान किए गए टेंसर की रैंक है।

    घोषणा

    @differentiable
public func unstacked(alongAxis axis: Int = 0) -> [Tensor]

    पैरामीटर

    axis

    वह आयाम जिसके अनुसार ढेर खोलना है। नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

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

    अनस्टैक्ड टेंसर युक्त सारणी।

  • एक टेंसर को अनेक टेंसरों में विभाजित करता है। टेंसर को आयाम axis के साथ छोटे-छोटे count में विभाजित किया जाता है। इसके लिए आवश्यक है कि count shape[axis] समान रूप से विभाजित करे।

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

    // 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors along dimension 1:
let parts = value.split(count: 3, alongAxis: 1)
parts[0] // has shape [5, 10]
parts[1] // has shape [5, 10]
parts[2] // has shape [5, 10]

    शर्त लगाना

    count आयाम axis के आकार को समान रूप से विभाजित करना चाहिए।

    शर्त लगाना

    axis [-rank, rank) सीमा में होना चाहिए, जहां rank प्रदान किए गए टेंसर की रैंक है।

    घोषणा

    @differentiable
public func split(count: Int, alongAxis axis: Int = 0) -> [Tensor]

    पैरामीटर

    count

    बनाए जाने वाले विभाजनों की संख्या.

    axis

    वह आयाम जिसके साथ इस टेंसर को विभाजित करना है। नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

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

    एक सारणी जिसमें टेंसर भाग होता है।

  • एक टेंसर को अनेक टेंसरों में विभाजित करता है। टेंसर को sizes.shape[0] टुकड़ों में विभाजित किया गया है। i वें टुकड़े का आकार इस टेंसर के समान है, आयाम axis छोड़कर जहां आकार sizes[i] ।

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

    // 'value' is a tensor with shape [5, 30]
// Split 'value' into 3 tensors with sizes [4, 15, 11] along dimension 1:
let parts = value.split(sizes: Tensor<Int32>([4, 15, 11]), alongAxis: 1)
parts[0] // has shape [5, 4]
parts[1] // has shape [5, 15]
parts[2] // has shape [5, 11]

    शर्त लगाना

    sizes के मानों को आयाम axis के आकार तक जोड़ना चाहिए।

    शर्त लगाना

    axis [-rank, rank) सीमा में होना चाहिए, जहां rank प्रदान किए गए टेंसर की रैंक है।

    घोषणा

    @differentiable(wrt: self)
public func split(sizes: Tensor<Int32>, alongAxis axis: Int = 0) -> [Tensor]

    पैरामीटर

    sizes

    1-डी टेंसर जिसमें प्रत्येक विभाजन का आकार होता है।

    axis

    वह आयाम जिसके अनुसार इस टेंसर को विभाजित करना है। नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

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

    टेंसर भागों से युक्त सारणी।

  • घोषणा

    @differentiable(wrt: self)
public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]

  • इस टेंसर को टाइल करके निर्मित एक टाइल वाला टेंसर लौटाता है।

    यह कंस्ट्रक्टर इस टेंसर को multiples बार दोहराकर एक नया टेंसर बनाता है। निर्मित टेंसर के i 'वें आयाम self.shape[i] * multiples[i] तत्व हैं, और इस टेंसर के मानों को i 'वें आयाम के साथ multiples[i] बार दोहराया जाता है। उदाहरण के लिए, [abcd] [2] से टाइल करने से [abcdabcd] उत्पन्न होता है।

    शर्त लगाना

    गुणजों की अपेक्षित rank 1 होनी चाहिए।

    शर्त लगाना

    multiples का आकार [tensor.rank] होना चाहिए।

    शर्त लगाना

    multiples में सभी अदिश राशियाँ गैर-ऋणात्मक होनी चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func tiled(multiples: [Int]) -> Tensor

  • इस टेंसर को टाइल करके निर्मित एक टाइल वाला टेंसर लौटाता है।

    यह कंस्ट्रक्टर इस टेंसर को multiples बार दोहराकर एक नया टेंसर बनाता है। निर्मित टेंसर के i 'वें आयाम self.shape[i] * multiples[i] तत्व हैं, और इस टेंसर के मानों को i 'वें आयाम के साथ multiples[i] बार दोहराया जाता है। उदाहरण के लिए, [abcd] [2] से टाइल करने से [abcdabcd] उत्पन्न होता है।

    शर्त लगाना

    गुणजों की अपेक्षित rank 1 होनी चाहिए।

    शर्त लगाना

    multiples का आकार [tensor.rank] होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func tiled(multiples: Tensor<Int32>) -> Tensor

  • निर्दिष्ट Tensor के आकार को पुनः आकार दें।

    शर्त लगाना

    अदिशों की संख्या नए आकार से मेल खाती है।

    घोषणा

    @differentiable(wrt: self)
public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar

  • निर्दिष्ट आकार में पुनः आकार दें.

    शर्त लगाना

    अदिशों की संख्या नए आकार से मेल खाती है।

    घोषणा

    @differentiable(wrt: self)
public func reshaped(to newShape: TensorShape) -> Tensor

  • किसी आकृति का प्रतिनिधित्व करने वाले निर्दिष्ट Tensor को पुनः आकार दें।

    शर्त लगाना

    अदिशों की संख्या नए आकार से मेल खाती है।

    घोषणा

    @differentiable(wrt: self)
public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor

  • पंक्ति-प्रमुख क्रम में, टेंसर की एक प्रति को 1-डी Tensor में लौटाएँ।

    घोषणा

    @differentiable(wrt: self)
public func flattened() -> Tensor

  • निर्दिष्ट आकार सूचकांकों पर डाले गए 1 के आयाम के साथ एक आकार-विस्तारित Tensor लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func expandingShape(at axes: Int...) -> Tensor

  • निर्दिष्ट आकार सूचकांकों पर डाले गए 1 के आयाम के साथ एक आकार-विस्तारित Tensor लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func expandingShape(at axes: [Int]) -> Tensor

  • 1 के अग्रणी आयाम के साथ रैंक-उठाया गया Tensor लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func rankLifted() -> Tensor

  • टेंसर के आकार से आकार 1 के निर्दिष्ट आयामों को हटा देता है। यदि कोई आयाम निर्दिष्ट नहीं है, तो आकार 1 के सभी आयाम हटा दिए जाएंगे।

    घोषणा

    @differentiable(wrt: self)
public func squeezingShape(at axes: Int...) -> Tensor

  • टेंसर के आकार से आकार 1 के निर्दिष्ट आयामों को हटा देता है। यदि कोई आयाम निर्दिष्ट नहीं है, तो आकार 1 के सभी आयाम हटा दिए जाएंगे।

    घोषणा

    @differentiable(wrt: self)
public func squeezingShape(at axes: [Int]) -> Tensor

  • निर्दिष्ट क्रम में क्रमपरिवर्तित आयामों के साथ, एक ट्रांसपोज़्ड टेंसर लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func transposed(permutation: Tensor<Int32>) -> Tensor

  • निर्दिष्ट क्रम में क्रमपरिवर्तित आयामों के साथ, एक ट्रांसपोज़्ड टेंसर लौटाता है।

    घोषणा

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor

  • निर्दिष्ट क्रम में क्रमपरिवर्तित आयामों के साथ, एक ट्रांसपोज़्ड टेंसर लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func transposed(permutation: [Int]) -> Tensor

  • निर्दिष्ट क्रम में क्रमपरिवर्तित आयामों के साथ, एक ट्रांसपोज़्ड टेंसर लौटाता है।

    घोषणा

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: [Int]) -> Tensor

  • निर्दिष्ट क्रम में क्रमपरिवर्तित आयामों के साथ, एक ट्रांसपोज़्ड टेंसर लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func transposed(permutation: Int...) -> Tensor

  • निर्दिष्ट क्रम में क्रमपरिवर्तित आयामों के साथ, एक ट्रांसपोज़्ड टेंसर लौटाता है।

    घोषणा

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Int...) -> Tensor

  • उल्टे क्रम में क्रमपरिवर्तित आयामों के साथ एक ट्रांसपोज़्ड टेंसर लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func transposed() -> Tensor

  • निर्दिष्ट आयामों को उलट कर एक टेंसर लौटाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    शर्त लगाना

    axes में कोई दोहराव नहीं होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func reversed(inAxes axes: Tensor<Int32>) -> Tensor

  • निर्दिष्ट आयामों को उलट कर एक टेंसर लौटाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    शर्त लगाना

    axes में कोई दोहराव नहीं होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func reversed(inAxes axes: [Int]) -> Tensor

  • निर्दिष्ट आयामों को उलट कर एक टेंसर लौटाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    शर्त लगाना

    axes में कोई दोहराव नहीं होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func reversed(inAxes axes: Int...) -> Tensor

  • निर्दिष्ट अक्ष के अनुदिश एक संयोजित टेंसर लौटाता है।

    शर्त लगाना

    निर्दिष्ट अक्ष को छोड़कर, टेंसर के आयाम समान होने चाहिए।

    शर्त लगाना

    अक्ष -rank..<rank श्रेणी में होना चाहिए।

    घोषणा

    @differentiable
public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor

  • संयोजन संचालिका.

    टिप्पणी

    ++ एक कस्टम ऑपरेटर है जो स्विफ्ट में मौजूद नहीं है, लेकिन हास्केल/स्कैला में मौजूद है। इसका जोड़ कोई मामूली भाषा परिवर्तन नहीं है और विवादास्पद हो सकता है। ++ के अस्तित्व/नामकरण पर बाद के एपीआई डिज़ाइन चरण के दौरान चर्चा की जाएगी।

    घोषणा

    @differentiable
public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor

  • axis आयाम के साथ indices पर इनपुट के स्लाइस इकट्ठा करके एक टेंसर लौटाता है

    0-डी (स्केलर) indices के लिए:

    result[p_0,          ..., p_{axis-1},
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices,
     p_{axis + 1}, ..., p_{N-1}]

    1-डी (वेक्टर) indices के लिए:

    result[p_0,          ..., p_{axis-1},
       i,
       p_{axis + 1}, ..., p_{N-1}] =
self[p_0,          ..., p_{axis-1},
     indices[i],
     p_{axis + 1}, ..., p_{N-1}]

    सामान्य स्थिति में, एक परिणामी टेंसर उत्पन्न होता है जहां:

    result[p_0,             ..., p_{axis-1},
       i_{batch\_dims}, ..., i_{M-1},
       p_{axis + 1},    ..., p_{N-1}] =
self[p_0,             ..., p_{axis-1},
     indices[i_0,     ..., i_{M-1}],
     p_{axis + 1},    ..., p_{N-1}]

    जहां N = self.rank और M = indices.rank ।

    परिणामी टेंसर का आकार है: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...]

    टिप्पणी

    सीपीयू पर, यदि आउट-ऑफ़-रेंज इंडेक्स पाया जाता है, तो एक त्रुटि उत्पन्न होती है। जीपीयू पर, यदि आउट-ऑफ़-रेंज इंडेक्स पाया जाता है, तो संबंधित आउटपुट मानों में 0 संग्रहीत किया जाता है।

    शर्त लगाना

    axis [-rank, rank) की सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func gathering<Index: TensorFlowIndex>(
  atIndices indices: Tensor<Index>,
  alongAxis axis: Int = 0
) -> Tensor

    पैरामीटर

    indices

    इकट्ठा करने के लिए सूचकांक शामिल हैं।

    axis

    आयाम जिसके साथ इकट्ठा करना है. नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

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

    एकत्रित टेंसर.

  • axis आयाम के साथ indices पर इस टेंसर के स्लाइस लौटाता है, जबकि बैच आयामों के अनुरूप पहले batchDimensionCount आयामों को अनदेखा करता है। एकत्रीकरण पहले गैर-बैच आयाम के साथ किया जाता है।

    gathering के समान कार्यक्षमता निष्पादित करता है, सिवाय इसके कि परिणामी टेंसर आकार अब shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...]

    शर्त लगाना

    axis -rank..<rank सीमा में होना चाहिए, साथ ही batchDimensionCount से अधिक या उसके बराबर होना चाहिए।

    शर्त लगाना

    batchDimensionCount indices.rank से कम होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func batchGathering<Index: TensorFlowIndex>(
  atIndices indices: Tensor<Index>,
  alongAxis axis: Int = 1,
  batchDimensionCount: Int = 1
) -> Tensor

    पैरामीटर

    indices

    इकट्ठा करने के लिए सूचकांक शामिल हैं।

    axis

    आयाम जिसके साथ इकट्ठा करना है. नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

    batchDimensionCount

    अनदेखा करने योग्य अग्रणी बैच आयामों की संख्या.

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

    एकत्रित टेंसर.

  • इनपुट पर दिए गए बूलियन मास्क को लागू करने के बाद मान एकत्रित करके एक टेंसर लौटाता है।

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

    // 1-D example
// tensor is [0, 1, 2, 3]
// mask is [true, false, true, false]
tensor.gathering(where: mask) // is [0, 2]

// 2-D example
// tensor is [[1, 2], [3, 4], [5, 6]]
// mask is [true, false, true]
tensor.gathering(where: mask) // is [[1, 2], [5, 6]]

    सामान्य तौर पर, 0 < mask.rank = K <= tensor.rank , और mask का आकार tensor के आकार के पहले K आयामों से मेल खाना चाहिए। फिर हमारे पास है: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] जहां [i1, ..., iK] mask (पंक्ति-प्रमुख क्रम) की i वीं true प्रविष्टि है।

    axis उपयोग mask के साथ किया जा सकता है ताकि उस अक्ष को इंगित किया जा सके जिससे मास्क लगाना है। उस स्थिति में, axis + mask.rank <= tensor.rank और mask 's shape must match the first टेंसर के आकार dimensions of the मेल खाना चाहिए।

    शर्त लगाना

    mask एक अदिश राशि नहीं हो सकता: mask.rank != 0 ।

    घोषणा

    @differentiable(wrt: self)
public func gathering(where mask: Tensor<Bool>, alongAxis axis: Int = 0) -> Tensor

    पैरामीटर

    mask

    केडी बूलियन टेंसर, जहां K <= self.rank ।

    axis

    0-डी पूर्णांक टेंसर self में अक्ष को मास्क करने के लिए दर्शाता है, जहां K + axis <= self.rank ।

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

    (self.rank - K + 1) mask में true मानों के अनुरूप इस टेंसर में प्रविष्टियों द्वारा आयामी टेंसर पॉप्युलेट किया गया।

  • इस टेंसर में गैर-शून्य/सही मानों का स्थान लौटाता है।

    निर्देशांक 2-डी टेंसर में लौटाए जाते हैं जहां पहला आयाम (पंक्तियाँ) गैर-शून्य तत्वों की संख्या का प्रतिनिधित्व करता है, और दूसरा आयाम (स्तंभ) गैर-शून्य तत्वों के निर्देशांक का प्रतिनिधित्व करता है। ध्यान रखें कि आउटपुट टेंसर का आकार इस टेंसर में कितने वास्तविक मान हैं, इसके आधार पर भिन्न हो सकता है। सूचकांक पंक्ति-प्रमुख क्रम में आउटपुट होते हैं।

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

    // 'input' is [[true, false], [true, false]]
// 'input' has 2 true values and so the output has 2 rows.
// 'input' has rank of 2, and so the second dimension of the output has size 2.
input.nonZeroIndices() // is [[0, 0], [1, 0]]

// 'input' is [[[ true, false], [ true, false]],
//             [[false,  true], [false,  true]],
//             [[false, false], [false,  true]]]
// 'input' has 5 true values and so the output has 5 rows.
// 'input' has rank 3, and so the second dimension of the output has size 3.
input.nonZeroIndices() // is [[0, 0, 0],
                       //     [0, 1, 0],
                       //     [1, 0, 1],
                       //     [1, 1, 1],
                       //     [2, 1, 1]]

    घोषणा

    public func nonZeroIndices() -> Tensor<Int64>

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

    आकार (num_true, rank(condition)) वाला एक टेंसर।

  • घोषणा

    @differentiable(wrt: self)
public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor

  • घोषणा

    @differentiable(wrt: self)
public func broadcasted(to shape: TensorShape) -> Tensor

  • निर्दिष्ट Tensor के समान आकार में प्रसारित करें।

    शर्त लगाना

    निर्दिष्ट आकार प्रसारण के लिए अनुकूल होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar

  • घोषणा

    public static func .= (lhs: inout Tensor, rhs: Tensor)

  • प्रत्येक आयाम के लिए निचली और ऊपरी सीमा द्वारा परिभाषित टेंसर से एक टुकड़ा निकालता है।

    घोषणा

    @differentiable(wrt: self)
public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor

    पैरामीटर

    lowerBounds

    प्रत्येक आयाम पर निचली सीमाएँ।

    upperBounds

    प्रत्येक आयाम पर ऊपरी सीमा.

  • घोषणा

    @differentiable(wrt: self)
public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor

  • घोषणा

    @differentiable(wrt: self)
public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor

  • घोषणा

    @differentiable(wrt: self)
public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }

  • जाँचता है कि axes का प्रत्येक तत्व self की धुरी को दर्शाता है, और अन्यथा डायग्नोस्टिक के साथ प्रोग्राम को रोक देता है।

    घोषणा

    func ensureValid(
  axes: Tensor<Int32>,
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • जाँचता है कि axes का प्रत्येक तत्व self की धुरी को दर्शाता है, और अन्यथा डायग्नोस्टिक के साथ प्रोग्राम को रोक देता है।

    घोषणा

    func ensureValid(
  axes: [Int],
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • जाँचता है कि k self की धुरी को दर्शाता है, और अन्यथा डायग्नोस्टिक के साथ प्रोग्राम को रोक देता है।

    घोषणा

    func ensureValid(
  axis k: Int,
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • घोषणा

    public init<BatchSamples: Collection>(collating samples: BatchSamples)
where BatchSamples.Element == Self

  • दिए गए Device पर other की एक प्रति बनाता है।

    घोषणा

    public init(copying other: Tensor, to device: Device)

  • निर्दिष्ट आकार और एकल, दोहराए गए स्केलर मान के साथ एक टेंसर बनाता है।

    घोषणा

    @available(*, deprecated, renamed: "init(repeating:shape:﹚")
public init(shape: TensorShape, repeating repeatedValue: Scalar)

    पैरामीटर

    shape

    टेंसर के आयाम.

    repeatedValue

    दोहराने योग्य अदिश मान.

  • निर्दिष्ट आकार और एकल, दोहराए गए स्केलर मान के साथ एक टेंसर बनाता है।

    घोषणा

    @differentiable
public init(
  repeating repeatedValue: Scalar, shape: TensorShape,
  on device: Device = .default
)

    पैरामीटर

    repeatedValue

    दोहराने योग्य अदिश मान.

    shape

    टेंसर के आयाम.

  • दिए गए स्केलर को सभी आयामों 1 के साथ दिए गए रैंक पर प्रसारित करके एक टेंसर बनाता है।

    घोषणा

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)

  • टेंसरों की एक श्रृंखला (जो स्वयं अदिश राशि हो सकती है) से एक टेंसर बनाता है।

    घोषणा

    @differentiable
public init(_ elements: [Tensor])

  • axis आयाम के साथ tensors एक नए टेंसर में ढेर करता है, जिसकी रैंक वर्तमान टेंसर से एक अधिक होती है और प्रत्येक टेंसर tensors में होता है।

    यह देखते हुए कि सभी tensors आकार [A, B, C] है, और tensors.count = N , तो:

    • यदि axis == 0 तो परिणामी टेंसर का आकार [N, A, B, C] होगा।
    • यदि axis == 1 है तो परिणामी टेंसर का आकार [A, N, B, C] होगा।
    • वगैरह।

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

    // 'x' is [1, 4]
// 'y' is [2, 5]
// 'z' is [3, 6]
Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]

    यह Tensor.unstacked(alongAxis:) के विपरीत है।

    शर्त लगाना

    सभी टेंसरों का आकार समान होना चाहिए।

    शर्त लगाना

    axis [-rank, rank) सीमा में होना चाहिए, जहां rank प्रदान किए गए टेंसर की रैंक है।

    घोषणा

    @differentiable
public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)

    पैरामीटर

    tensors

    स्टैक करने के लिए टेंसर.

    axis

    आयाम जिसके अनुदिश ढेर लगाना है. नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

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

    स्टैक्ड टेंसर.

  • axis आयाम के साथ tensors जोड़ता है।

    यह देखते हुए कि tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , तो संयोजित परिणाम का आकार होता है [D0, D1, ... Raxis, ...Dn] , जहां Raxis = sum(Daxis(i)) । अर्थात्, इनपुट टेंसर से डेटा axis आयाम के साथ जुड़ जाता है।

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

    // t1 is [[1, 2, 3], [4, 5, 6]]
// t2 is [[7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

// t3 has shape [2, 3]
// t4 has shape [2, 3]
Tensor(concatenating: [t3, t4]) // has shape [4, 3]
Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]

    टिप्पणी

    यदि आप एक नई धुरी के साथ जुड़ रहे हैं तो Tensor.init(stacking:alongAxis:) का उपयोग करने पर विचार करें।

    शर्त लगाना

    सभी टेंसरों की रैंक समान होनी चाहिए और axis को छोड़कर सभी आयाम समान होने चाहिए।

    शर्त लगाना

    axis [-rank, rank) सीमा में होना चाहिए, जहां rank प्रदान किए गए टेंसर की रैंक है।

    घोषणा

    @differentiable
public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)

    पैरामीटर

    tensors

    संयोजित करने के लिए टेंसर.

    axis

    आयाम जिसके साथ जोड़ना है. नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

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

    संयोजित टेंसर.

  • इस टेंसर के तत्वों को उन गलियों में other तत्वों से बदल देता है जहां mask true है।

    शर्त लगाना

    self और other आकार एक जैसा होना चाहिए। यदि self और other अदिश हैं, तो mask भी अदिश होना चाहिए। यदि self और other की रैंक 1 से अधिक या उसके बराबर है, तो mask आकार या तो self के समान होना चाहिए या 1-डी Tensor होना चाहिए जैसे कि mask.scalarCount == self.shape[0] ।

    घोषणा

    @differentiable(wrt: (self, other)
) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor

  • यदि भौतिक अदिश प्रकार की परिशुद्धता कम हो जाती है तो यह सत्य लौटाता है।

    वर्तमान में, कम परिशुद्धता वाले भौतिक अदिश प्रकारों में केवल BFloat16 शामिल है।

    घोषणा

    public var isReducedPrecision: Bool { get }

  • दिए गए टेंसर के समान डिवाइस और परिशुद्धता के साथ एक स्केलर को टेंसर में बढ़ावा देता है।

    घोषणा

    @differentiable
public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)

  • BFloat16 भौतिक स्केलर प्रकार में परिवर्तित self की एक प्रति लौटाता है।

    घोषणा

    public var toReducedPrecision: `Self` { get }

  • Scalar भौतिक स्केलर प्रकार में परिवर्तित self की एक प्रति लौटाता है।

    घोषणा

    public var toFullPrecision: `Self` { get }

  • Tensor के आयामों की संख्या।

    घोषणा

    public var rank: Int { get }

  • Tensor का आकार.

    घोषणा

    public var shape: TensorShape { get }

  • Tensor में अदिशों की संख्या.

  • घोषणा

    public var scalarCount: Int { get }

  • टेंसर की रैंक, Tensor<Int32> के रूप में दर्शायी जाती है।

    घोषणा

    public var rankTensor: Tensor<Int32> { get }

  • टेंसर के आयाम, Tensor<Int32> के रूप में दर्शाए गए हैं।

    घोषणा

    public var shapeTensor: Tensor<Int32> { get }

  • टेंसर में अदिशों की संख्या, Tensor<Int32> के रूप में दर्शायी जाती है।

    घोषणा

    public var scalarCountTensor: Tensor<Int32> { get }

  • यदि rank 0 के बराबर है तो true लौटाता है और अन्यथा false ।

    घोषणा

    public var isScalar: Bool { get }

  • यदि rank 0 के बराबर है और अन्यथा nil तो एकल अदिश तत्व लौटाता है।

    घोषणा

    public var scalar: Scalar? { get }

  • अदिश आकार में पुनः आकार देना.

    शर्त लगाना

    टेंसर में बिल्कुल एक अदिश राशि होती है।

    घोषणा

    @differentiable
public func scalarized() -> Scalar

  • घोषणा

    public var array: ShapedArray<Scalar> { get }

  • घोषणा

    @differentiable
public var scalars: [Scalar] { get }

  • एक अदिश मान से 0-डी टेंसर बनाता है।

    घोषणा

    @differentiable
public init(_ value: Scalar, on device: Device = .default)

  • स्केलर से 1डी टेंसर बनाता है।

    घोषणा

    @differentiable
public init(_ scalars: [Scalar], on device: Device = .default)

  • स्केलर से 1डी टेंसर बनाता है।

    घोषणा

    public init<C: Collection>(
  _ vector: C, on device: Device = .default
) where C.Element == Scalar

  • पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।

    शर्त लगाना

    आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।

    घोषणा

    @differentiable
public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)

    पैरामीटर

    shape

    टेंसर का आकार.

    scalars

    टेंसर की अदिश सामग्री.

  • पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।

    शर्त लगाना

    आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।

    घोषणा

    public init(
  shape: TensorShape,
  scalars: UnsafeBufferPointer<Scalar>,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर का आकार.

    scalars

    टेंसर की अदिश सामग्री.

  • पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।

    शर्त लगाना

    आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।

  • पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।

    शर्त लगाना

    आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।

    घोषणा

    public init<C: Collection>(
  shape: TensorShape, scalars: C, on device: Device = .default
) where C.Element == Scalar

    पैरामीटर

    shape

    टेंसर का आकार.

    scalars

    टेंसर की अदिश सामग्री.

  • किसी सरणी के तत्वों का प्रकार शाब्दिक।

    घोषणा

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

  • दिए गए तत्वों के साथ आरंभीकृत एक टेंसर बनाता है।

    घोषणा

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)

  • टेंसर का एक पाठ्य प्रतिनिधित्व।

    टिप्पणी

    सभी स्केलर दिखाने वाले गैर-सुंदर-मुद्रित विवरण के लिए fullDescription उपयोग करें।

    घोषणा

    public var description: String { get }

  • टेंसर का एक पाठ्य प्रतिनिधित्व। यदि summarize सत्य है और तत्वों की संख्या edgeElementCount से दोगुनी है, तो एक सारांशित विवरण लौटाता है।

    घोषणा

    public func description(
  lineWidth: Int = 80,
  edgeElementCount: Int = 3,
  summarizing: Bool = false
) -> String

    पैरामीटर

    lineWidth

    मुद्रण के लिए अधिकतम लाइन चौड़ाई. प्रति पंक्ति मुद्रित करने के लिए स्केलरों की संख्या निर्धारित करने के लिए उपयोग किया जाता है।

    edgeElementCount

    दीर्घवृत्त के माध्यम से सारांशीकरण से पहले और बाद में मुद्रित करने के लिए तत्वों की अधिकतम संख्या ( ... )।

    summarizing

    यदि सत्य है, तो विवरण को संक्षेप में प्रस्तुत करें यदि तत्वों की संख्या edgeElementCount से दोगुनी है।

  • टेंसर का एक पूर्ण, गैर-सुंदर-मुद्रित पाठ्य प्रतिनिधित्व, सभी स्केलर दिखाता है।

    घोषणा

    public var fullDescription: String { get }

  • घोषणा

    public var playgroundDescription: Any { get }

  • घोषणा

    public var customMirror: Mirror { get }

  • इस टेंसर का वर्णन करने वाले एनोटेशन।

    घोषणा

    public var annotations: String { get }

  • एनोटेशन के लिए एक उपनाम.

    घोषणा

    public var summary: String { get }

  • घोषणा

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)

  • घोषणा

    public init<C: RandomAccessCollection>(
  _handles: C
) where C.Element: _AnyTensorHandle

  • घोषणा

    public init(_ array: ShapedArray<Scalar>, on device: Device = .default)

  • घोषणा

    init(_xla: XLATensor)

  • घोषणा

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

  • घोषणा

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

  • घोषणा

    var xlaTensor: XLATensor { get }
उपलब्ध है जहां `स्केलर`: `संख्यात्मक`
उपलब्ध है जहां `स्केलर`: `संख्यात्मक` और `तुलनीय`

  • lhs < rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    घोषणा

    public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>

  • lhs <= rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    घोषणा

    public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>

  • lhs > rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    घोषणा

    public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>

  • तत्व-वार lhs >= rhs गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    घोषणा

    public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>

  • lhs < rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .< प्रसारण का समर्थन करता है।

    घोषणा

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • lhs <= rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .<= प्रसारण का समर्थन करता है।

    घोषणा

    public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • lhs > rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .> प्रसारण का समर्थन करता है।

    घोषणा

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • तत्व-वार lhs >= rhs गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .>= प्रसारण का समर्थन करता है।

    घोषणा

    public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • lhs < rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .< प्रसारण का समर्थन करता है।

    घोषणा

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

  • lhs <= rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .<= प्रसारण का समर्थन करता है।

    घोषणा

    public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

  • lhs > rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .> प्रसारण का समर्थन करता है।

    घोषणा

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

  • तत्व-वार lhs >= rhs गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .>= प्रसारण का समर्थन करता है।

    घोषणा

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
उपलब्ध है जहां `अदिश`: `समतुल्य`

  • lhs == rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .== प्रसारण का समर्थन करता है।

    घोषणा

    public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>

  • तत्व-वार lhs != rhs गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .!= प्रसारण का समर्थन करता है.

    घोषणा

    public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>

  • lhs == rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .== प्रसारण का समर्थन करता है।

    घोषणा

    public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • तत्व-वार lhs != rhs गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .!= प्रसारण का समर्थन करता है.

    घोषणा

    public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>

  • lhs == rhs तत्व-वार गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .== प्रसारण का समर्थन करता है।

    घोषणा

    public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

  • तत्व-वार lhs != rhs गणना करके बूलियन स्केलर का एक टेंसर लौटाता है।

    टिप्पणी

    .!= प्रसारण का समर्थन करता है.

    घोषणा

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
उपलब्ध है जहां `स्केलर`: `टेन्सरफ्लोफ्लोटिंगपॉइंट` और `इक्वेटेबल`

  • बूलियन मानों का एक टेंसर लौटाता है जो दर्शाता है कि self के तत्व other के तत्वों के लगभग बराबर हैं या नहीं।

    शर्त लगाना

    self और other का आकार एक जैसा होना चाहिए।

    घोषणा

    public func elementsAlmostEqual(
  _ other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Tensor<Bool>
उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • यदि self के सभी तत्व other के सभी तत्वों के लगभग बराबर हैं तो यह true लौटाता है।

    शर्त लगाना

    self और other का आकार एक जैसा होना चाहिए।

    घोषणा

    public func isAlmostEqual(
  to other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
उपलब्ध है जहां `स्केलर`: `टेन्सरफ्लोन्यूमेरिक`

  • इस टेंसर के लिए एक क्रॉस प्रतिकृति योग चलाता है। योग में भाग लेने वाले प्रत्येक अन्य उपकरण पर समान क्रॉस प्रतिकृति योग होना चाहिए।

    घोषणा

    public mutating mutating func crossReplicaSum(_ scale: Double)
उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`
उपलब्ध है जहां `स्केलर`: `संख्यात्मक`

  • Bool टेंसर से तत्व-वार प्रकार का रूपांतरण करें।

    घोषणा

    public init(_ other: Tensor<Bool>)

  • किसी अन्य Tensor से तत्व-वार रूपांतरण करें।

    घोषणा

    @differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`
उपलब्ध है जहां `स्केलर`: `संख्यात्मक`

  • सभी अदिशों को शून्य पर सेट करके एक टेंसर बनाता है।

    घोषणा

    public init(zeros shape: TensorShape, on device: Device = .default)

    पैरामीटर

    shape

    टेंसर का आकार.

  • सभी अदिशों को एक पर सेट करके एक टेंसर बनाता है।

    घोषणा

    public init(ones shape: TensorShape, on device: Device = .default)

    पैरामीटर

    shape

    टेंसर का आकार.

  • सभी स्केलरों को शून्य पर सेट करके एक टेंसर बनाता है जिसका आकार और प्रकार दिए गए टेंसर के समान होता है।

    घोषणा

    public init(zerosLike other: Tensor)

    पैरामीटर

    other

    टेन्सर जिसका आकार और डेटा प्रकार उपयोग करना है।

  • सभी स्केलरों को एक पर सेट करके एक टेंसर बनाता है जिसका आकार और प्रकार दिए गए टेंसर के समान होता है।

    घोषणा

    public init(onesLike other: Tensor)

    पैरामीटर

    other

    टेन्सर जिसका आकार और डेटा प्रकार उपयोग करना है।

  • एक 1-डी टेंसर बनाता है जो शुरुआती मान से अंतिम मान तक के अनुक्रम का प्रतिनिधित्व करता है, लेकिन निर्दिष्ट राशि से आगे बढ़ते हुए, अंतिम मान को शामिल नहीं करता है।

    घोषणा

    public init(
  rangeFrom start: Scalar, to end: Scalar, stride: Scalar,
  on device: Device = .default
)

    पैरामीटर

    start

    अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला start है।

    end

    अनुक्रम को सीमित करने के लिए एक अंतिम मान. end कभी भी परिणामी अनुक्रम का एक तत्व नहीं है।

    stride

    प्रत्येक पुनरावृत्ति के साथ कदम दर कदम बढ़ने वाली राशि। stride सकारात्मक होनी चाहिए.

  • एक 1-डी टेंसर बनाता है जो शुरुआती मान से अंतिम मान तक के अनुक्रम का प्रतिनिधित्व करता है, लेकिन निर्दिष्ट राशि से आगे बढ़ते हुए, अंतिम मान को शामिल नहीं करता है।

    घोषणा

    public init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>)

    पैरामीटर

    start

    अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला start है।

    end

    अनुक्रम को सीमित करने के लिए एक अंतिम मान. end कभी भी परिणामी अनुक्रम का एक तत्व नहीं है।

    stride

    प्रत्येक पुनरावृत्ति के साथ कदम दर कदम बढ़ने वाली राशि। stride सकारात्मक होनी चाहिए.

  • दिए गए सूचकांकों पर एक-हॉट टेंसर बनाता है। indices द्वारा दर्शाए गए स्थान मान onValue (डिफ़ॉल्ट रूप से 1 ) लेते हैं, जबकि अन्य सभी स्थान मान offValue मान (डिफ़ॉल्ट रूप से 0 ) लेते हैं। यदि इनपुट indices रैंक n है, तो नए टेंसर की रैंक n+1 होगी। नया अक्ष आयाम axis पर बनाया जाता है (डिफ़ॉल्ट रूप से, नया अक्ष अंत में जोड़ा जाता है)।

    यदि indices एक अदिश राशि है, तो नए टेंसर का आकार लंबाई depth का एक वेक्टर होगा।

    यदि indices लंबाई features का एक वेक्टर है, तो आउटपुट आकार होगा: विशेषताएं x गहराई, यदि अक्ष == -1 गहराई x विशेषताएं, यदि अक्ष == 0

    यदि indices आकार [batch, features] के साथ एक मैट्रिक्स (बैच) है, तो आउटपुट आकार होगा: बैच x फीचर्स x गहराई, यदि अक्ष == -1 बैच x गहराई x फीचर्स, यदि अक्ष == 1 गहराई x बैच x फीचर्स , यदि अक्ष == 0

    घोषणा

    public init(
  oneHotAtIndices indices: Tensor<Int32>,
  depth: Int,
  onValue: Scalar = 1,
  offValue: Scalar = 0,
  axis: Int = -1
)

    पैरामीटर

    indices

    सूचकांकों का एक Tensor ।

    depth

    एक अदिश राशि जो एक गर्म आयाम की गहराई को परिभाषित करती है।

    onValue

    indices में कुछ सूचकांक द्वारा निर्दिष्ट स्थान पर मूल्य को परिभाषित करने वाला एक स्केलर।

    offValue

    एक अदिश राशि उस स्थान पर मान को परिभाषित करती है जिसे indices में किसी भी सूचकांक द्वारा संदर्भित नहीं किया जाता है।

    axis

    भरने की धुरी. डिफ़ॉल्ट -1 है, एक नई आंतरिकतम धुरी।

उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • एक 1-डी टेंसर बनाता है जो शुरुआती मान से लेकर अंतिम मान तक के अनुक्रम का प्रतिनिधित्व करता है, जो निर्दिष्ट मानों की संख्या उत्पन्न करने के लिए समान रूप से स्थित होता है।

    घोषणा

    public init(
  linearSpaceFrom start: Scalar, to end: Scalar, count: Int, on device: Device = .default
)

    पैरामीटर

    start

    अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला start है।

    end

    अनुक्रम को सीमित करने के लिए एक अंतिम मान. end परिणामी अनुक्रम का अंतिम तत्व है।

    count

    परिणामी अनुक्रम में मानों की संख्या. count सकारात्मक होनी चाहिए.

  • एक 1-डी टेंसर बनाता है जो शुरुआती मान से लेकर अंतिम मान तक के अनुक्रम का प्रतिनिधित्व करता है, जो निर्दिष्ट मानों की संख्या उत्पन्न करने के लिए समान रूप से स्थित होता है।

    शर्त लगाना

    start , to , और count एकल स्केलर मान वाले टेंसर होने चाहिए।

    घोषणा

    public init(linearSpaceFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, count: Tensor<Int32>)

    पैरामीटर

    start

    अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला start है।

    end

    अनुक्रम को सीमित करने के लिए एक अंतिम मान. end परिणामी अनुक्रम का अंतिम तत्व है।

    count

    परिणामी अनुक्रम में मानों की संख्या. count सकारात्मक होनी चाहिए.

उपलब्ध है जहां `स्केलर`: `TensorFlowIndex`

  • निर्दिष्ट आकार के साथ एक टेंसर बनाता है, lowerBound और upperBound के बीच एक समान वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है।

    घोषणा

    public init(
  randomUniform shape: TensorShape,
  lowerBound: Tensor<Scalar>? = nil,
  upperBound: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    lowerBound

    वितरण की निचली सीमा.

    upperBound

    वितरण की ऊपरी सीमा.

    seed

    बीज का मूल्य.

उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • निर्दिष्ट आकार के साथ एक टेंसर बनाता है, lowerBound और upperBound के बीच एक समान वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है।

    घोषणा

    public init(
  randomUniform shape: TensorShape,
  lowerBound: Tensor<Scalar>? = nil,
  upperBound: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    lowerBound

    वितरण की निचली सीमा.

    upperBound

    वितरण की ऊपरी सीमा.

    seed

    बीज का मूल्य.

  • सामान्य वितरण से अदिश मानों का बेतरतीब ढंग से नमूना लेकर, निर्दिष्ट आकार के साथ एक टेंसर बनाता है।

    घोषणा

    public init(
  randomNormal shape: TensorShape,
  mean: Tensor<Scalar>? = nil,
  standardDeviation: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    mean

    वितरण का माध्य.

    standardDeviation

    वितरण का मानक विचलन.

    seed

    बीज का मूल्य.

  • निर्दिष्ट आकार के साथ एक टेंसर बनाता है, एक काटे गए सामान्य वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है।

    घोषणा

    public init(
  randomTruncatedNormal shape: TensorShape,
  mean: Tensor<Scalar>? = nil,
  standardDeviation: Tensor<Scalar>? = nil,
  seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    mean

    वितरण का माध्य.

    standardDeviation

    वितरण का मानक विचलन.

    seed

    बीज का मूल्य.

उपलब्ध है जहां `स्केलर`: `TensorFlowIndex`

  • श्रेणीबद्ध वितरण से नमूने खींचकर एक टेंसर बनाता है।

    घोषणा

    public init<T: TensorFlowFloatingPoint>(
  randomCategorialLogits: Tensor<T>,
  sampleCount: Int32,
  seed: TensorFlowSeed = Context.local.randomSeed
)

    पैरामीटर

    randomCategorialLogits

    आकार के साथ 2-डी टेंसर [batchSize, classCount] । प्रत्येक स्लाइस [i, :] सभी वर्गों के लिए असामान्य लॉग संभावनाओं का प्रतिनिधित्व करता है।

    sampleCount

    0-डी. प्रत्येक पंक्ति स्लाइस के लिए निकाले जाने वाले स्वतंत्र नमूनों की संख्या।

    seed

    बीज का मूल्य.

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

    आकार के साथ 2-डी टेंसर [batchSize, sampleCount] । प्रत्येक स्लाइस [i, :] में रेंज [0, classCount) के साथ खींचे गए क्लास लेबल होते हैं।

उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • ग्लोरोट (जेवियर) एकसमान आरंभीकरण करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।

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

    संदर्भ: "गहरे फीडफॉरवर्ड तंत्रिका नेटवर्क के प्रशिक्षण की कठिनाई को समझना"

    घोषणा

    public init(
  glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    seed

    बीज का मूल्य.

  • ग्लोरोट (ज़ेवियर) सामान्य आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।

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

    संदर्भ: "गहरे फीडफॉरवर्ड तंत्रिका नेटवर्क के प्रशिक्षण की कठिनाई को समझना"

    घोषणा

    public init(
  glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    seed

    बीज का मूल्य.

  • He (Kaiming) एकसमान आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।

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

    संदर्भ: "रेक्टिफायर्स में गहराई से उतरना: इमेजनेट वर्गीकरण पर मानव-स्तर के प्रदर्शन को पार करना"

    घोषणा

    public init(
  heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    seed

    बीज का मूल्य.

  • हे (काइमिंग) सामान्य आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।

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

    संदर्भ: "रेक्टिफायर्स में गहराई से उतरना: इमेजनेट वर्गीकरण पर मानव-स्तर के प्रदर्शन को पार करना"

    घोषणा

    public init(
  heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    seed

    बीज का मूल्य.

  • LeCun एकसमान आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।

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

    संदर्भ: "कुशल बैकप्रॉप"

    घोषणा

    public init(
  leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    seed

    बीज का मूल्य.

  • LeCun सामान्य आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।

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

    संदर्भ: "कुशल बैकप्रॉप"

    घोषणा

    public init(
  leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
  on device: Device = .default
)

    पैरामीटर

    shape

    टेंसर के आयाम.

    seed

    बीज का मूल्य.

  • एक ऑर्थोगोनल मैट्रिक्स या टेंसर बनाता है।

    यदि प्रारंभ करने के लिए टेंसर का आकार द्वि-आयामी है, तो इसे सामान्य वितरण से खींची गई यादृच्छिक संख्याओं के मैट्रिक्स के क्यूआर अपघटन से प्राप्त ऑर्थोगोनल मैट्रिक्स के साथ प्रारंभ किया जाता है। यदि मैट्रिक्स में स्तंभों की तुलना में कम पंक्तियाँ हैं तो आउटपुट में ऑर्थोगोनल पंक्तियाँ होंगी। अन्यथा, आउटपुट में ऑर्थोगोनल कॉलम होंगे।

    यदि आरंभ करने के लिए टेंसर का आकार द्वि-आयामी से अधिक है, तो आकार का एक मैट्रिक्स [shape[0] * ... * shape[rank - 2], shape[rank - 1]] आरंभ किया जाता है। वांछित आकार का टेंसर देने के लिए मैट्रिक्स को बाद में दोबारा आकार दिया जाता है।

    घोषणा

    public init(
  orthogonal shape: TensorShape,
  gain: Tensor<Scalar> = Tensor<Scalar>(1),
  seed: TensorFlowSeed = Context.local.randomSeed
)

    पैरामीटर

    shape

    टेंसर का आकार.

    gain

    ऑर्थोगोनल टेंसर पर लागू होने वाला एक गुणक कारक।

    seed

    यादृच्छिक संख्या जनरेटर को सीड करने के लिए दो पूर्णांकों का एक टुपल।

उपलब्ध है जहां `स्केलर`: `टेन्सरफ्लोन्यूमेरिक`

  • [बैच] टेंसर का [बैच] विकर्ण भाग लौटाता है। आकृति के टेंसर उदाहरण के लिए [..., M, N] , आउटपुट आकृति का एक टेंसर है [..., K] , जहां K min(N, M) के बराबर है।

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

    // 't' is [[1, 0, 0, 0]
//         [0, 2, 0, 0]
//         [0, 0, 3, 0]
//         [0, 0, 0, 4]]
t.diagonalPart()
// [1, 2, 3, 4]

    घोषणा

    @differentiable
public func diagonalPart() -> Tensor

  • एक [बैच] विकर्ण सरणी का निर्माण करता है। आकृति के टेंसर उदाहरण के लिए [..., M] , आउटपुट आकृति का एक टेंसर है [..., M, M] ।

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

    // 't' is [1, 2, 3, 4]

t.diagonal()
// [[1, 0, 0, 0]
//  [0, 2, 0, 0]
//  [0, 0, 3, 0]
//  [0, 0, 0, 4]]

    घोषणा

    @differentiable
public func diagonal() -> Tensor

  • नए विकर्ण मानों के साथ self लौटाता है, यह देखते हुए कि self एक वैकल्पिक रूप से बैच किया गया मैट्रिक्स है।

    लौटाए गए टेंसर का आकार और मान self के समान है, अंतरतम मैट्रिक्स के निर्दिष्ट विकर्णों को छोड़कर जो diagonal में मानों द्वारा अधिलेखित हैं।

    पैरामीटर विकर्ण: रैंक rank - 1 के साथ एक टेंसर नए विकर्ण मानों का प्रतिनिधित्व करता है।

    घोषणा

    public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor

  • घोषणा

    @differentiable(wrt: self)
public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor

  • केंद्रीय बैंड सीमाओं द्वारा परिभाषित अंतरतम टेंसर की एक प्रति लौटाता है। आउटपुट उदाहरण के समान आकार का एक टेंसर है [..., :, :] ।

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

    // 't' is [[ 0,  1,  2, 3]
//         [-1,  0,  1, 2]
//         [-2, -1,  0, 1]
//         [-3, -2, -1, 0]]

t.bandPart(1, -1)
// [[ 0,  1,  2, 3]
//  [-1,  0,  1, 2]
//  [ 0, -1,  0, 1]
//  [ 0,  0, -1, 0]]

t.bandPart(2, 1)
// [[ 0,  1,  0, 0]
//  [-1,  0,  1, 0]
//  [-2, -1,  0, 1]
//  [ 0, -2, -1, 0]]

    घोषणा

    @differentiable
public func bandPart(subdiagonalCount: Int, superdiagonalCount: Int) -> Tensor

    पैरामीटर

    subdiagonalCount

    रखने के लिए उपविकर्णों की संख्या. यदि नकारात्मक है, तो संपूर्ण निचला त्रिभुज रखें।

    superdiagonalCount

    रखने के लिए सुपरडायगोनल्स की संख्या. यदि नकारात्मक है, तो संपूर्ण ऊपरी त्रिभुज रखें।

उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • टेंसर में प्रत्येक आंतरिक मैट्रिक्स का क्यूआर अपघटन लौटाता है, आंतरिक ऑर्थोगोनल मैट्रिक्स q के साथ एक टेंसर और आंतरिक ऊपरी त्रिकोणीय मैट्रिक्स r के साथ एक टेंसर, जैसे कि टेंसर matmul(q, r) के बराबर है।

    घोषणा

    public func qrDecomposition(fullMatrices: Bool = false) -> (
  q: Tensor<Scalar>, r: Tensor<Scalar>
)

    पैरामीटर

    fullMatrices

    यदि true , तो पूर्ण आकार q और r की गणना करें। अन्यथा q के केवल अग्रणी min(shape[rank - 1], shape[rank - 2]) कॉलम की गणना करें।

  • self का एकल मान अपघटन लौटाता है, यह देखते हुए कि self एक वैकल्पिक रूप से बैच किया गया मैट्रिक्स है।

    वैकल्पिक रूप से बैच किए गए मैट्रिक्स self का एकवचन मूल्य अपघटन (एसवीडी) मान s , u , और v है, जैसे कि:

    self[..., :, :] = u[..., :, :] • s[..., :, :].diagonal() • v[..., :, :].transposed()`

    self must be a tensor with shape […, M, N] . Let K = न्यूनतम(M, N)`।

    शर्त लगाना

    self आकार वाला एक टेंसर होना चाहिए [..., M, N] ।

    घोषणा

    public func svd(computeUV: Bool = true, fullMatrices: Bool = false) -> (
  s: Tensor<Scalar>, u: Tensor<Scalar>?, v: Tensor<Scalar>?
)

    पैरामीटर

    computeUV

    यदि true , तो बाएँ और दाएँ एकवचन वैक्टर की गणना की जाती है और क्रमशः u और v के रूप में लौटाया जाता है। यदि false , nil मान u और v के रूप में लौटाए जाते हैं।

    fullMatrices

    यदि true , तो u और v आकृतियाँ क्रमशः [..., M, M] और [..., N, N] हैं। यदि false , तो u और v क्रमशः आकार [..., M, K] और [..., K, N] हैं। computeUV गलत होने पर नजरअंदाज कर दिया गया।

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

    • s: आकार के साथ एकवचन मान [..., K] । प्रत्येक वेक्टर के भीतर, एकवचन मानों को अवरोही क्रम में क्रमबद्ध किया जाता है।
    • यू: बायां एकवचन सदिश।
    • v: सही एकवचन सदिश।

  • x का वर्गमूल.

    वास्तविक प्रकारों के लिए, यदि x ऋणात्मक है तो परिणाम .nan है। जटिल प्रकारों के लिए ऋणात्मक वास्तविक अक्ष पर एक शाखा काटी जाती है।

    घोषणा

    @differentiable
public static func sqrt(_ x: `Self`) -> Tensor<Scalar>

  • x की कोज्या, रेडियन में एक कोण के रूप में व्याख्या की गई।

    घोषणा

    @differentiable
public static func cos(_ x: `Self`) -> Tensor<Scalar>

  • x की ज्या, रेडियन में एक कोण के रूप में व्याख्या की गई।

    घोषणा

    @differentiable
public static func sin(_ x: `Self`) -> Tensor<Scalar>

  • x की स्पर्शरेखा, रेडियन में एक कोण के रूप में व्याख्या की गई।

    घोषणा

    @differentiable
public static func tan(_ x: `Self`) -> Tensor<Scalar>

  • रेडियन में x का व्युत्क्रम कोज्या.

    घोषणा

    @differentiable
public static func acos(_ x: `Self`) -> Tensor<Scalar>

  • रेडियन में x की व्युत्क्रम ज्या.

    घोषणा

    @differentiable
public static func asin(_ x: `Self`) -> Tensor<Scalar>

  • रेडियन में x का व्युत्क्रम स्पर्शरेखा।

    घोषणा

    @differentiable
public static func atan(_ x: `Self`) -> Tensor<Scalar>

  • x की अतिपरवलयिक कोज्या।

    घोषणा

    @differentiable
public static func cosh(_ x: `Self`) -> Tensor<Scalar>

  • x की अतिशयोक्तिपूर्ण ज्या।

    घोषणा

    @differentiable
public static func sinh(_ x: `Self`) -> Tensor<Scalar>

  • x की अतिशयोक्तिपूर्ण स्पर्शरेखा।

    घोषणा

    @differentiable
public static func tanh(_ x: `Self`) -> Tensor<Scalar>

  • x की व्युत्क्रम अतिपरवलयिक कोज्या।

    घोषणा

    @differentiable
public static func acosh(_ x: `Self`) -> Tensor<Scalar>

  • x की व्युत्क्रम अतिपरवलयिक ज्या।

    घोषणा

    @differentiable
public static func asinh(_ x: `Self`) -> Tensor<Scalar>

  • x का व्युत्क्रम अतिशयोक्तिपूर्ण स्पर्शरेखा।

    घोषणा

    @differentiable
public static func atanh(_ x: `Self`) -> Tensor<Scalar>

  • घातीय फ़ंक्शन x , या e**x पर लागू होता है।

    घोषणा

    @differentiable
public static func exp(_ x: `Self`) -> Tensor<Scalar>

  • दो को घात x तक बढ़ाया गया।

    घोषणा

    @differentiable
public static func exp2(_ x: `Self`) -> Tensor<Scalar>

  • दस को x घात तक बढ़ाया गया।

    घोषणा

    @differentiable
public static func exp10(_ x: `Self`) -> Tensor<Scalar>

  • exp(x) - 1 का मूल्यांकन किया गया ताकि सटीकता को शून्य के करीब रखा जा सके।

    घोषणा

    @differentiable
public static func expm1(_ x: `Self`) -> Tensor<Scalar>

  • x का प्राकृतिक लघुगणक।

    घोषणा

    @differentiable
public static func log(_ x: `Self`) -> Tensor<Scalar>

  • x का आधार-दो लघुगणक।

    घोषणा

    @differentiable
public static func log2(_ x: `Self`) -> Tensor<Scalar>

  • x का आधार-दस लघुगणक।

    घोषणा

    @differentiable
public static func log10(_ x: `Self`) -> Tensor<Scalar>

  • log(1 + x) मूल्यांकन किया गया ताकि सटीकता को शून्य के करीब रखा जा सके।

    घोषणा

    @differentiable
public static func log1p(_ x: `Self`) -> Tensor<Scalar>

  • exp(y log(x)) की गणना मध्यवर्ती परिशुद्धता के नुकसान के बिना की गई।

    वास्तविक प्रकारों के लिए, यदि x ऋणात्मक है तो परिणाम NaN है, भले ही y का एक अभिन्न मान हो। जटिल प्रकारों के लिए, नकारात्मक वास्तविक अक्ष पर एक शाखा काटी जाती है।

    घोषणा

    @differentiable
public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>

  • x n घात तक बढ़ाया गया।

    x की n प्रतियों का गुणनफल।

    घोषणा

    @differentiable
public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>

  • x का n वाँ मूल।

    वास्तविक प्रकारों के लिए, यदि x ऋणात्मक है और n सम है, तो परिणाम NaN है। जटिल प्रकारों के लिए, नकारात्मक वास्तविक अक्ष के साथ एक शाखा काटी जाती है।

    घोषणा

    @differentiable
public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>

  • घोषणा

    public typealias VectorSpaceScalar = Float

  • घोषणा

    public func scaled(by scale: Float) -> Tensor<Scalar>

  • घोषणा

    public func adding(_ scalar: Float) -> Tensor<Scalar>

  • घोषणा

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
उपलब्ध है जहां `स्केलर`: `संख्यात्मक`

  • टेंसर के प्रत्येक अदिश में अदिश जोड़ता है और योग उत्पन्न करता है।

    घोषणा

    @differentiable
public static func + (lhs: Scalar, rhs: Tensor) -> Tensor

  • टेंसर के प्रत्येक अदिश में अदिश जोड़ता है और योग उत्पन्न करता है।

    घोषणा

    @differentiable
public static func + (lhs: Tensor, rhs: Scalar) -> Tensor

  • टेंसर के प्रत्येक अदिश से अदिश को घटाता है और अंतर उत्पन्न करता है।

    घोषणा

    @differentiable
public static func - (lhs: Scalar, rhs: Tensor) -> Tensor

  • टेंसर के प्रत्येक अदिश से अदिश को घटाता है और अंतर उत्पन्न करता है

    घोषणा

    @differentiable
public static func - (lhs: Tensor, rhs: Scalar) -> Tensor

  • दो टेंसर जोड़ता है और परिणाम को बाईं ओर के वेरिएबल में संग्रहीत करता है।

    टिप्पणी

    += प्रसारण का समर्थन करता है।

    घोषणा

    public static func += (lhs: inout Tensor, rhs: Tensor)

  • टेंसर के प्रत्येक स्केलर में स्केलर जोड़ता है और परिणाम को बाईं ओर के चर में संग्रहीत करता है।

    घोषणा

    public static func += (lhs: inout Tensor, rhs: Scalar)

  • पहले टेंसर से दूसरे टेंसर को घटाता है और परिणाम को बाईं ओर के वेरिएबल में संग्रहीत करता है।

    टिप्पणी

    -= प्रसारण का समर्थन करता है.

    घोषणा

    public static func -= (lhs: inout Tensor, rhs: Tensor)

  • टेंसर के प्रत्येक स्केलर से स्केलर को घटाता है और परिणाम को बाईं ओर के चर में संग्रहीत करता है।

    घोषणा

    public static func -= (lhs: inout Tensor, rhs: Scalar)

  • दो टेंसर को गुणा करके उत्पन्न टेंसर लौटाता है।

    टिप्पणी

    * प्रसारण का समर्थन करता है।

    घोषणा

    @differentiable
public static func * (lhs: Tensor, rhs: Tensor) -> Tensor

  • टेंसर को टेंसर के प्रत्येक स्केलर से गुणा करके लौटाता है।

    घोषणा

    @differentiable
public static func * (lhs: Scalar, rhs: Tensor) -> Tensor

  • टेंसर के प्रत्येक अदिश के साथ अदिश को गुणा करता है और उत्पाद उत्पन्न करता है।

    घोषणा

    @differentiable
public static func * (lhs: Tensor, rhs: Scalar) -> Tensor

  • दो टेंसरों को गुणा करता है और परिणाम को बाईं ओर के चर में संग्रहीत करता है।

    टिप्पणी

    *= प्रसारण का समर्थन करता है।

    घोषणा

    public static func *= (lhs: inout Tensor, rhs: Tensor)

  • स्केलर को स्केलर से गुणा करता है, स्केलर को प्रसारित करता है, और परिणाम को बाईं ओर के चर में संग्रहीत करता है।

    घोषणा

    public static func *= (lhs: inout Tensor, rhs: Scalar)

  • पहले टेंसर को दूसरे से विभाजित करने का भागफल लौटाता है।

    टिप्पणी

    / प्रसारण का समर्थन करता है।

    घोषणा

    @differentiable
public static func / (lhs: Tensor, rhs: Tensor) -> Tensor

  • स्केलर को प्रसारित करते हुए, टेंसर द्वारा स्केलर को विभाजित करने का भागफल लौटाता है।

    घोषणा

    @differentiable
public static func / (lhs: Scalar, rhs: Tensor) -> Tensor

  • स्केलर को प्रसारित करते हुए टेंसर को स्केलर से विभाजित करने का भागफल लौटाता है।

    घोषणा

    @differentiable
public static func / (lhs: Tensor, rhs: Scalar) -> Tensor

  • पहले टेंसर को दूसरे टेंसर से विभाजित करता है और भागफल को बाईं ओर के वेरिएबल में संग्रहीत करता है।

    घोषणा

    public static func /= (lhs: inout Tensor, rhs: Tensor)

  • स्केलर द्वारा टेन्सर को विभाजित करता है, स्केलर को प्रसारित करता है, और भागफल को बाईं ओर के चर में संग्रहीत करता है।

    घोषणा

    public static func /= (lhs: inout Tensor, rhs: Scalar)

  • पहले टेंसर को दूसरे से विभाजित करने पर शेषफल लौटाता है।

    टिप्पणी

    % प्रसारण का समर्थन करता है।

    घोषणा

    public static func % (lhs: Tensor, rhs: Tensor) -> Tensor

  • स्केलर को प्रसारित करते हुए, स्केलर द्वारा टेन्सर को विभाजित करने का शेषफल लौटाता है।

    घोषणा

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor

  • स्केलर को प्रसारित करते हुए, टेंसर द्वारा स्केलर को विभाजित करने का शेष भाग लौटाता है।

    घोषणा

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor

  • पहले टेंसर को दूसरे से विभाजित करता है और शेष को बाईं ओर के वेरिएबल में संग्रहीत करता है।

    घोषणा

    public static func %= (lhs: inout Tensor, rhs: Tensor)

  • टेंसर को अदिश से विभाजित करता है और शेष को बायीं ओर के चर में संग्रहीत करता है।

    घोषणा

    public static func %= (lhs: inout Tensor, rhs: Scalar)
उपलब्ध है जहां `स्केलर` == `बूल`
उपलब्ध है जहां `स्केलर`: `टेन्सरफ्लोन्यूमेरिक`
उपलब्ध है जहां `स्केलर`: `SignedNumeric`

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

    घोषणा

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
उपलब्ध है जहां `स्केलर`: `संख्यात्मक`

  • घोषणा

    @differentiable(wrt: self)
public func squared() -> Tensor
उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • एक बूलियन टेंसर लौटाता है जो दर्शाता है कि x के कौन से तत्व परिमित हैं।

    घोषणा

    public var isFinite: Tensor<Bool> { get }

  • एक बूलियन टेंसर लौटाता है जो दर्शाता है कि x के कौन से तत्व अनंत हैं।

    घोषणा

    public var isInfinite: Tensor<Bool> { get }

  • एक बूलियन टेंसर लौटाता है जो दर्शाता है कि x के कौन से तत्व NaN-मूल्य वाले हैं।

    घोषणा

    public var isNaN: Tensor<Bool> { get }
उपलब्ध है जहां `स्केलर` == `बूल`

  • यदि सभी अदिश राशियाँ true के बराबर हैं तो true लौटाता है। अन्यथा, false रिटर्न देता है।

    घोषणा

    public func all() -> Bool

  • यदि कोई अदिश राशि true के बराबर है तो true लौटाता है। अन्यथा, false रिटर्न देता है।

    घोषणा

    public func any() -> Bool

  • निर्दिष्ट अक्षों के साथ एक तार्किक AND ऑपरेशन निष्पादित करता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func all(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ एक तार्किक AND ऑपरेशन निष्पादित करता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func any(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ एक तार्किक AND ऑपरेशन निष्पादित करता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func all(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ एक तार्किक OR ऑपरेशन निष्पादित करता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func any(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

उपलब्ध है जहां `स्केलर`: `संख्यात्मक` और `तुलनीय`

  • घोषणा

    @differentiable
public func min() -> Tensor

  • घोषणा

    @differentiable
public func max() -> Tensor

  • निर्दिष्ट अक्षों के साथ अधिकतम मान लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ अधिकतम मान लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func max(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ अधिकतम मान लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func max(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ न्यूनतम मान लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ न्यूनतम मान लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func min(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ न्यूनतम मान लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func min(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ अधिकतम मानों के सूचकांक लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ न्यूनतम मानों के सूचकांक लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश न्यूनतम लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func min(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश न्यूनतम लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func min(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश न्यूनतम लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func min(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश न्यूनतम लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func max(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश न्यूनतम लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func max(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश न्यूनतम लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func max(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • चपटे अदिशों के अधिकतम मान का सूचकांक लौटाता है।

    घोषणा

    public func argmax() -> Tensor<Int32>

  • चपटे अदिशों के न्यूनतम मान का सूचकांक लौटाता है।

    घोषणा

    public func argmin() -> Tensor<Int32>
उपलब्ध है जहां `स्केलर`: `संख्यात्मक`

  • निर्दिष्ट अक्षों के अनुदिश योग लौटाता है. कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश योग लौटाता है. कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func sum(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश योग लौटाता है. कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func sum(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • घोषणा

    @differentiable(wrt: self)
public func sum() -> Tensor

  • निर्दिष्ट अक्षों के अनुदिश योग लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func sum(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश योग लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func sum(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश योग लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func sum(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ उत्पाद लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ उत्पाद लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func product(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ उत्पाद लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func product(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • घोषणा

    @differentiable(wrt: self)
public func product() -> Tensor

  • निर्दिष्ट अक्षों के साथ उत्पाद लौटाता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func product(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ उत्पाद लौटाता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func product(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ उत्पाद लौटाता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    public func product(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश अंकगणितीय माध्य लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश अंकगणितीय माध्य लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func mean(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश अंकगणितीय माध्य लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank...rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func mean(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • घोषणा

    @differentiable(wrt: self)
public func mean() -> Tensor

  • निर्दिष्ट अक्षों के अनुदिश अंकगणितीय माध्य लौटाता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func mean(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश अंकगणितीय माध्य लौटाता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func mean(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश अंकगणितीय माध्य लौटाता है। कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func mean(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश विचरण लौटाता है. कम किए गए आयाम हटा दिए जाते हैं. बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश विचरण लौटाता है. कम किए गए आयाम हटा दिए जाते हैं. बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func variance(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश विचरण लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है। बेसेल का सुधार लागू नहीं होता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func variance(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • घोषणा

    @differentiable(wrt: self)
public func variance() -> Tensor

  • निर्दिष्ट अक्षों के अनुदिश विचरण लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है। बेसेल का सुधार लागू नहीं होता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func variance(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश विचरण लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है। बेसेल का सुधार लागू नहीं होता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func variance(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश विचरण लौटाता है. कम किए गए आयामों को मान 1 के साथ बरकरार रखा गया है। बेसेल का सुधार लागू नहीं होता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func variance(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्ष के साथ इस टेंसर का संचयी योग लौटाता है। डिफ़ॉल्ट रूप से, यह फ़ंक्शन एक समावेशी संचयी योग करता है जिसका अर्थ है कि इनपुट का पहला तत्व आउटपुट के पहले तत्व के समान है:

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])

    exclusive तर्क को true पर सेट करके, इसके बजाय एक विशिष्ट संचयी योग निष्पादित किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])

    reverse तर्क को true पर सेट करके, संचयी योग विपरीत दिशा में किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
    Tensor<Float>([a + b + c, a + b, a])

    यह परिणामी टेंसर को अलग से उलटने की तुलना में अधिक कुशल है।

    शर्त लगाना

    axis -rank..<rank श्रेणी में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func cumulativeSum(
  alongAxis axis: Int,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

    पैरामीटर

    axis

    अक्ष जिसके साथ संचयी योग संचालन करना है।

    exclusive

    इंगित करता है कि एक विशेष संचयी योग निष्पादित करना है या नहीं।

    reverse

    इंगित करता है कि संचयी योग को उल्टे क्रम में निष्पादित करना है या नहीं।

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

    संचयी योग संक्रिया का परिणाम.

  • निर्दिष्ट अक्ष के साथ इस टेंसर का संचयी योग लौटाता है। डिफ़ॉल्ट रूप से, यह फ़ंक्शन एक समावेशी संचयी योग करता है जिसका अर्थ है कि इनपुट का पहला तत्व आउटपुट के पहले तत्व के समान है:

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])

    exclusive तर्क को true पर सेट करके, इसके बजाय एक विशिष्ट संचयी योग निष्पादित किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])

    reverse तर्क को true पर सेट करके, संचयी योग विपरीत दिशा में किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
    Tensor<Float>([a + b + c, a + b, a])

    यह परिणामी टेंसर को अलग से उलटने की तुलना में अधिक कुशल है।

    शर्त लगाना

    axis.rank 0 होना चाहिए।

    शर्त लगाना

    axis -rank..<rank श्रेणी में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func cumulativeSum(
  alongAxis axis: Tensor<Int32>,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

    पैरामीटर

    axis

    अक्ष जिसके साथ संचयी योग संचालन करना है।

    exclusive

    इंगित करता है कि एक विशेष संचयी योग निष्पादित करना है या नहीं।

    reverse

    इंगित करता है कि संचयी योग को उल्टे क्रम में निष्पादित करना है या नहीं।

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

    संचयी योग संक्रिया का परिणाम.

  • निर्दिष्ट अक्ष के साथ इस टेंसर का संचयी उत्पाद लौटाता है। डिफ़ॉल्ट रूप से, यह फ़ंक्शन एक समावेशी संचयी उत्पाद निष्पादित करता है जिसका अर्थ है कि इनपुट का पहला तत्व आउटपुट के पहले तत्व के समान है:

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])

    exclusive तर्क को true पर सेट करके, इसके बजाय एक विशिष्ट संचयी उत्पाद निष्पादित किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])

    reverse तर्क को true पर सेट करके, संचयी उत्पाद विपरीत दिशा में किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
    Tensor<Float>([a * b * c, a * b, a])

    यह परिणामी टेंसर को अलग से उलटने की तुलना में अधिक कुशल है।

    शर्त लगाना

    axis -rank..<rank श्रेणी में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func cumulativeProduct(
  alongAxis axis: Int,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

    पैरामीटर

    axis

    वह धुरी जिसके साथ संचयी उत्पाद संचालन करना है।

    exclusive

    इंगित करता है कि एक विशिष्ट संचयी उत्पाद निष्पादित करना है या नहीं।

    reverse

    इंगित करता है कि संचयी उत्पाद को उल्टे क्रम में निष्पादित करना है या नहीं।

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

    संचयी उत्पाद संचालन का परिणाम.

  • निर्दिष्ट अक्ष के साथ इस टेंसर का संचयी उत्पाद लौटाता है। डिफ़ॉल्ट रूप से, यह फ़ंक्शन एक समावेशी संचयी उत्पाद निष्पादित करता है जिसका अर्थ है कि इनपुट का पहला तत्व आउटपुट के पहले तत्व के समान है:

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])

    exclusive तर्क को true पर सेट करके, इसके बजाय एक विशिष्ट संचयी उत्पाद निष्पादित किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])

    reverse तर्क को true पर सेट करके, संचयी उत्पाद विपरीत दिशा में किया जाता है:

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
    Tensor<Float>([a * b * c, a * b, a])

    यह परिणामी टेंसर को अलग से उलटने की तुलना में अधिक कुशल है।

    शर्त लगाना

    axis रैंक 0 होनी चाहिए।

    शर्त लगाना

    axis -rank..<rank श्रेणी में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func cumulativeProduct(
  alongAxis axis: Tensor<Int32>,
  exclusive: Bool = false,
  reverse: Bool = false
) -> Tensor

    पैरामीटर

    axis

    वह धुरी जिसके साथ संचयी उत्पाद संचालन करना है।

    exclusive

    इंगित करता है कि एक विशिष्ट संचयी उत्पाद निष्पादित करना है या नहीं।

    reverse

    इंगित करता है कि संचयी उत्पाद को उल्टे क्रम में निष्पादित करना है या नहीं।

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

    संचयी उत्पाद संचालन का परिणाम.

उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • निर्दिष्ट अक्षों के अनुदिश तत्वों का मानक विचलन लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश तत्वों का मानक विचलन लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश तत्वों का मानक विचलन लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func standardDeviation(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • इस टेंसर में सभी तत्वों का मानक विचलन लौटाता है। बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func standardDeviation() -> Tensor

  • निर्दिष्ट अक्षों के अनुदिश तत्वों का मानक विचलन लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश तत्वों का मानक विचलन लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func standardDeviation(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के अनुदिश तत्वों का मानक विचलन लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल का सुधार लागू नहीं होता.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func standardDeviation(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • रिटर्न log(exp(self).sum(squeezingAxes: axes)) । कम किए गए आयाम हटा दिए जाते हैं.

    यह फ़ंक्शन सीधे log(exp(self).sum(squeezingAxes: axes)) गणना करने की तुलना में संख्यात्मक रूप से अधिक स्थिर है। यह बड़े इनपुट के exp की गणना के कारण होने वाले ओवरफ्लो और छोटे इनपुट के log की गणना के कारण होने वाले अंडरफ्लो से बचाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • रिटर्न log(exp(self).sum(squeezingAxes: axes)) । कम किए गए आयाम हटा दिए जाते हैं.

    यह फ़ंक्शन सीधे log(exp(self).sum(squeezingAxes: axes)) गणना करने की तुलना में संख्यात्मक रूप से अधिक स्थिर है। यह बड़े इनपुट के exp की गणना के कारण होने वाले ओवरफ्लो और छोटे इनपुट के log की गणना के कारण होने वाले अंडरफ्लो से बचाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • रिटर्न log(exp(self).sum(squeezingAxes: axes)) । कम किए गए आयाम हटा दिए जाते हैं.

    यह फ़ंक्शन सीधे log(exp(self).sum(squeezingAxes: axes)) गणना करने की तुलना में संख्यात्मक रूप से अधिक स्थिर है। यह बड़े इनपुट के exp की गणना के कारण होने वाले ओवरफ्लो और छोटे इनपुट के log की गणना के कारण होने वाले अंडरफ्लो से बचाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func logSumExp(squeezingAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • log(exp(self).sum()) लौटाता है। परिणाम एक अदिश राशि है.

    यह फ़ंक्शन सीधे log(exp(self).sum()) गणना करने की तुलना में संख्यात्मक रूप से अधिक स्थिर है। यह बड़े इनपुट के exp की गणना के कारण होने वाले ओवरफ्लो और छोटे इनपुट के log की गणना के कारण होने वाले अंडरफ्लो से बचाता है।

    घोषणा

    @differentiable(wrt: self)
public func logSumExp() -> Tensor

  • रिटर्न log(exp(self).sum(alongAxes: axes)) । कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है।

    यह फ़ंक्शन सीधे log(exp(self).sum(alongAxes: axes)) गणना करने की तुलना में संख्यात्मक रूप से अधिक स्थिर है। यह बड़े इनपुट के exp की गणना के कारण होने वाले ओवरफ्लो और छोटे इनपुट के log की गणना के कारण होने वाले अंडरफ्लो से बचाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • रिटर्न log(exp(self).sum(alongAxes: axes)) । कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है।

    यह फ़ंक्शन सीधे log(exp(self).sum(alongAxes: axes)) गणना करने की तुलना में संख्यात्मक रूप से अधिक स्थिर है। यह बड़े इनपुट के exp की गणना के कारण होने वाले ओवरफ्लो और छोटे इनपुट के log की गणना के कारण होने वाले अंडरफ्लो से बचाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func logSumExp(alongAxes axes: [Int]) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • रिटर्न log(exp(self).sum(alongAxes: axes)) । कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है।

    यह फ़ंक्शन सीधे log(exp(self).sum(alongAxes: axes)) गणना करने की तुलना में संख्यात्मक रूप से अधिक स्थिर है। यह बड़े इनपुट के exp की गणना के कारण होने वाले ओवरफ्लो और छोटे इनपुट के log की गणना के कारण होने वाले अंडरफ्लो से बचाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func logSumExp(alongAxes axes: Int...) -> Tensor

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ इस टेंसर का माध्य और विचरण लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes रैंक 1 होनी चाहिए।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ इस टेंसर का माध्य और विचरण लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ इस टेंसर का माध्य और विचरण लौटाता है। कम किए गए आयाम हटा दिए जाते हैं.

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • इस टेंसर के तत्वों का माध्य और विचरण लौटाता है।

    घोषणा

    @differentiable(wrt: self)
public func moments() -> Moments<Scalar>

  • निर्दिष्ट अक्षों के साथ इस टेंसर का माध्य और विचरण लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है।

    शर्त लगाना

    axes रैंक 1 होनी चाहिए।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ इस टेंसर का माध्य और विचरण लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

  • निर्दिष्ट अक्षों के साथ इस टेंसर का माध्य और विचरण लौटाता है। कम किए गए आयामों को मान 1 के साथ बनाए रखा जाता है।

    शर्त लगाना

    axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
public func moments(alongAxes axes: Int...) -> Moments<Scalar>

    पैरामीटर

    axes

    आयाम कम करने के लिए.

उपलब्ध है जहां `स्केलर`: `संख्यात्मक`

  • दो टेंसरों के बीच मैट्रिक्स गुणन करता है और परिणाम उत्पन्न करता है।

    घोषणा

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`

  • घोषणा

    static func vjpInitDeviceAndPrecisionLike(
  _ value: Scalar,
  deviceAndPrecisionLike tensor: Tensor
) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))

  • निर्दिष्ट अक्ष के साथ इनपुट को बैच-सामान्यीकृत करने से गणना किया गया टेंसर लौटाता है।

    विशेष रूप से, रिटर्न (self - mu) / (var + epsilon) * gamma + beta जहां mu और var क्रमशः axis के साथ self का माध्य और विचरण हैं।

    घोषणा

    @differentiable(wrt: (self, offset, scale)
public func batchNormalized(
  alongAxis axis: Int,
  offset: Tensor = Tensor(0),
  scale: Tensor = Tensor(1),
  epsilon: Scalar = 0.001
) -> Tensor

    पैरामीटर

    axis

    बैच आयाम.

    offset

    ऑफसेट, जिसे बीटा भी कहा जाता है।

    scale

    स्केल, जिसे गामा भी कहा जाता है।

    epsilon

    संख्यात्मक स्थिरता के लिए हर में एक छोटा मान जोड़ा गया।

  • अंतिम अक्ष के साथ दो टेंसरों को जोड़ता है।

    घोषणा

    @differentiable
public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

  • दो मान जोड़ता है और उनका योग उत्पन्न करता है।

    घोषणा

    @differentiable
public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

  • औसत दो मान.

    घोषणा

    @differentiable
public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

  • दो मानों को गुणा करता है.

    घोषणा

    @differentiable
public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

  • दो मानों को ढेर करें.

    घोषणा

    @differentiable
public static func stack(_ lhs: Tensor, _ rhs: Tensor) -> Tensor

  • घोषणा

    @derivative
init(shape: scalars)
उपलब्ध है जहां `अदिश`: `समतुल्य`

  • घोषणा

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

  • घोषणा

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
उपलब्ध है जहां `स्केलर`: `कोडेबल`
उपलब्ध है जहां `स्केलर`: `संख्यात्मक`

  • अदिश शून्य टेंसर.

  • घोषणा

    public static var zero: Tensor { get }

  • दो टेंसर जोड़ता है और उनका योग उत्पन्न करता है।

    टिप्पणी

    + प्रसारण का समर्थन करता है।

    घोषणा

    @differentiable
public static func + (lhs: Tensor, rhs: Tensor) -> Tensor

  • एक टेंसर को दूसरे से घटाता है और उनका अंतर उत्पन्न करता है।

    टिप्पणी

    - प्रसारण का समर्थन करता है।

    घोषणा

    @differentiable
public static func - (lhs: Tensor, rhs: Tensor) -> Tensor

  • अदिश एक टेंसर.

    घोषणा

    public static var one: Tensor { get }

  • self का तत्व-वार व्युत्क्रम लौटाता है।

    घोषणा

    public var reciprocal: Tensor { get }

  • दो टेंसरों को तत्व-वार गुणा करता है और उनका उत्पाद तैयार करता है।

    टिप्पणी

    .* प्रसारण का समर्थन करता है।

    घोषणा

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
उपलब्ध है जहां `स्केलर`: `TensorFlowFloatingPoint`