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

टेन्सर

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar

extension Tensor: Collatable

extension Tensor: CopyableToDevice

extension Tensor: AnyTensor

extension Tensor: ExpressibleByArrayLiteral

extension Tensor: CustomStringConvertible

extension Tensor: CustomPlaygroundDisplayConvertible

extension Tensor: CustomReflectable

extension Tensor: TensorProtocol

extension Tensor: TensorGroup

extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint

extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint

extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint

extension Tensor: Equatable where Scalar: Equatable

extension Tensor: Codable where Scalar: Codable

extension Tensor: AdditiveArithmetic where Scalar: Numeric

extension Tensor: PointwiseMultiplicative where Scalar: Numeric

extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint

extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

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

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

सँभालना
अंतर्निहित TensorHandle .
टिप्पणी
उपयोगकर्ता परिभाषित ऑप्स की अनुमति देने के लिए handle सार्वजनिक है, लेकिन सामान्य रूप से इसका उपयोग नहीं किया जाना चाहिए।
घोषणा
public let handle: TensorHandle<Scalar>

init(हैंडल:)

घोषणा

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

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

वापसी मूल्य

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

विभाजित(गिनती:alongAxis:)

एक टेंसर को अनेक टेंसरों में विभाजित करता है। टेंसर को आयाम 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
उलटा(inAxes:)
निर्दिष्ट आयामों को उलट कर एक टेंसर लौटाता है।
शर्त लगाना
axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।
शर्त लगाना
axes में कोई दोहराव नहीं होना चाहिए।
घोषणा
@differentiable(wrt: self) public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
उलटा(inAxes:)
निर्दिष्ट आयामों को उलट कर एक टेंसर लौटाता है।
शर्त लगाना
axes में प्रत्येक मान -rank..<rank सीमा में होना चाहिए।
शर्त लगाना
axes में कोई दोहराव नहीं होना चाहिए।
घोषणा
@differentiable(wrt: self) public func reversed(inAxes axes: [Int]) -> Tensor
उलटा(inAxes:)
निर्दिष्ट आयामों को उलट कर एक टेंसर लौटाता है।
शर्त लगाना
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 )

init(संकलन:)

घोषणा

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

init(प्रतिलिपि:से:)
दिए गए Device पर other की एक प्रति बनाता है।
घोषणा
public init(copying other: Tensor, to device: Device)
init(आकार:दोहराना:)
निर्दिष्ट आकार और एकल, दोहराए गए स्केलर मान के साथ एक टेंसर बनाता है।
घोषणा
@available(*, deprecated, renamed: "init(repeating:shape:﹚") public init(shape: TensorShape, repeating repeatedValue: Scalar)
पैरामीटर
shape
टेंसर के आयाम.
repeatedValue
दोहराने योग्य अदिश मान.
init(दोहराते हुए:आकार:पर:)
निर्दिष्ट आकार और एकल, दोहराए गए स्केलर मान के साथ एक टेंसर बनाता है।
घोषणा
@differentiable public init( repeating repeatedValue: Scalar, shape: TensorShape, on device: Device = .default )
पैरामीटर
repeatedValue
दोहराने योग्य अदिश मान.
shape
टेंसर के आयाम.
init(प्रसारण:रैंक:पर:)
दिए गए स्केलर को सभी आयामों 1 के साथ दिए गए रैंक पर प्रसारित करके एक टेंसर बनाता है।
घोषणा
public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
इस में(_:)
टेंसरों की एक श्रृंखला (जो स्वयं अदिश राशि हो सकती है) से एक टेंसर बनाता है।
घोषणा
@differentiable public init(_ elements: [Tensor])

init(स्टैकिंग:alongAxis:)

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`	आयाम जिसके अनुदिश ढेर लगाना है. नकारात्मक मूल्य चारों ओर लपेटे रहते हैं।

वापसी मूल्य

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

init(संबद्ध:alongAxis:)

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
isReducedPrecision
यदि भौतिक अदिश प्रकार की परिशुद्धता कम हो जाती है तो यह सत्य लौटाता है।
वर्तमान में, कम परिशुद्धता वाले भौतिक अदिश प्रकारों में केवल BFloat16 शामिल है।
घोषणा
public var isReducedPrecision: Bool { get }
init(_:deviceAndPrecisionLike:)
दिए गए टेंसर के समान डिवाइस और परिशुद्धता के साथ एक स्केलर को टेंसर में बढ़ावा देता है।
घोषणा
@differentiable public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
toReducedPrecision
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 }

init(_:पर:)
एक अदिश मान से 0-डी टेंसर बनाता है।
घोषणा
@differentiable public init(_ value: Scalar, on device: Device = .default)
init(_:पर:)
स्केलर से 1डी टेंसर बनाता है।
घोषणा
@differentiable public init(_ scalars: [Scalar], on device: Device = .default)

init(_:पर:)

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

घोषणा

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

init(आकार:स्केलर:पर:)
पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।
शर्त लगाना
आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।
घोषणा
@differentiable public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)
पैरामीटर
shape
टेंसर का आकार.
scalars
टेंसर की अदिश सामग्री.
init(आकार:स्केलर:पर:)
पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।
शर्त लगाना
आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।
घोषणा
public init( shape: TensorShape, scalars: UnsafeBufferPointer<Scalar>, on device: Device = .default )
पैरामीटर
shape
टेंसर का आकार.
scalars
टेंसर की अदिश सामग्री.
init(आकार:स्केलर:toReducedPrecision:directlyOn:)
पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।
शर्त लगाना
आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।
init(आकार:स्केलर:पर:)
पंक्ति-प्रमुख क्रम में निर्दिष्ट आकार और सन्निहित अदिशों के साथ एक टेंसर बनाता है।
शर्त लगाना
आकृति के आयामों का गुणनफल अदिशों की संख्या के बराबर होना चाहिए।
घोषणा
public init<C: Collection>( shape: TensorShape, scalars: C, on device: Device = .default ) where C.Element == Scalar
पैरामीटर
shape
टेंसर का आकार.
scalars
टेंसर की अदिश सामग्री.
ArrayLiteralElement
किसी सरणी के तत्वों का प्रकार शाब्दिक।
घोषणा
public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
init(arrayLiteral:)
दिए गए तत्वों के साथ आरंभीकृत एक टेंसर बनाता है।
घोषणा
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 }
irText
खेल का मैदानविवरण
घोषणा
public var playgroundDescription: Any { get }
कस्टममिरर
घोषणा
public var customMirror: Mirror { get }
एनोटेशन
इस टेंसर का वर्णन करने वाले एनोटेशन।
घोषणा
public var annotations: String { get }
सारांश
एनोटेशन के लिए एक उपनाम.
घोषणा
public var summary: String { get }

init(_owning:)

घोषणा

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

init(_handles:)

घोषणा

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

init(_:पर:)

घोषणा

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

init(_xla:)
घोषणा
init(_xla: XLATensor)

init(_xlaHandle:)

घोषणा

init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

xlaहैंडल

घोषणा

var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

xlaTensor
घोषणा
var xlaTensor: XLATensor { get }

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

अप्रसारित(आकार देने के लिए:)

घोषणा

@differentiable(wrt: self)
public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor

अप्रसारित(जैसे:)

घोषणा

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

अप्रसारित(को:)

घोषणा

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

पैडिंगमोड
एक मोड जो यह निर्धारित करता है कि टेंसर को कैसे गद्देदार बनाया जाए।
घोषणा
public enum PaddingMode
गद्देदार(आकार के लिए:साथ:)
निर्दिष्ट पैडिंग आकारों के अनुसार स्थिरांक के साथ गद्देदार टेंसर लौटाता है।
घोषणा
@differentiable(wrt: self) public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0) -> Tensor
गद्देदार(आकार के लिए:मोड:)
निर्दिष्ट पैडिंग आकार और मोड के अनुसार एक गद्देदार टेंसर लौटाता है।
घोषणा
@differentiable(wrt: self) public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor

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

.<(_:_:)
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>

उपलब्ध है जहां `स्केलर`: `टेन्सरफ्लोफ्लोटिंगपॉइंट` और `इक्वेटेबल`

elementAlmostEqual(_:सहनशीलता:)
बूलियन मानों का एक टेंसर लौटाता है जो दर्शाता है कि 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`

init(दोहराते हुए:)
घोषणा
@derivative init(repeating: shape)

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

इस में(_:)
Bool टेंसर से तत्व-वार प्रकार का रूपांतरण करें।
घोषणा
public init(_ other: Tensor<Bool>)

इस में(_:)

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

घोषणा

@differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar

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

इस में(_:)
घोषणा
@derivative init(_: <<error type>>)
init(स्टैकिंग:)
घोषणा
@derivative init(stacking: alongAxis)

init(संबद्ध:)

घोषणा

@derivative
init(concatenating: alongAxis)

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

init(शून्य:पर:)
सभी अदिशों को शून्य पर सेट करके एक टेंसर बनाता है।
घोषणा
public init(zeros shape: TensorShape, on device: Device = .default)
पैरामीटर
shape
टेंसर का आकार.
init(ones:on:)
सभी अदिशों को एक पर सेट करके एक टेंसर बनाता है।
घोषणा
public init(ones shape: TensorShape, on device: Device = .default)
पैरामीटर
shape
टेंसर का आकार.
init(शून्यलाइक:)
सभी स्केलरों को शून्य पर सेट करके एक टेंसर बनाता है जिसका आकार और प्रकार दिए गए टेंसर के समान होता है।
घोषणा
public init(zerosLike other: Tensor)
पैरामीटर
other
टेन्सर जिसका आकार और डेटा प्रकार उपयोग करना है।
init(onesLike:)
सभी स्केलरों को एक पर सेट करके एक टेंसर बनाता है जिसका आकार और प्रकार दिए गए टेंसर के समान होता है।
घोषणा
public init(onesLike other: Tensor)
पैरामीटर
other
टेन्सर जिसका आकार और डेटा प्रकार उपयोग करना है।

init(रेंजफ्रॉम:टू:स्ट्राइड:ऑन:)

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

घोषणा

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

पैरामीटर

`start`	अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला `start` है।
`end`	अनुक्रम को सीमित करने के लिए एक अंतिम मान. `end` कभी भी परिणामी अनुक्रम का एक तत्व नहीं है।
`stride`	प्रत्येक पुनरावृत्ति के साथ कदम दर कदम बढ़ने वाली राशि। `stride` सकारात्मक होनी चाहिए.

init(रेंजफ्रॉम:टू:स्ट्राइड:)

घोषणा

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

पैरामीटर

`start`	अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला `start` है।
`end`	अनुक्रम को सीमित करने के लिए एक अंतिम मान. `end` कभी भी परिणामी अनुक्रम का एक तत्व नहीं है।
`stride`	प्रत्येक पुनरावृत्ति के साथ कदम दर कदम बढ़ने वाली राशि। `stride` सकारात्मक होनी चाहिए.

init(oneHotAtIndices:गहराई:onValue:offValue:axis:)

दिए गए सूचकांकों पर एक-हॉट टेंसर बनाता है। 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`

init(linearSpaceFrom:to:count:on:)

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

घोषणा

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

पैरामीटर

`start`	अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला `start` है।
`end`	अनुक्रम को सीमित करने के लिए एक अंतिम मान. `end` परिणामी अनुक्रम का अंतिम तत्व है।
`count`	परिणामी अनुक्रम में मानों की संख्या. `count` सकारात्मक होनी चाहिए.

init(linearSpaceFrom:to:count:)

शर्त लगाना

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

घोषणा

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

पैरामीटर

`start`	अनुक्रम के लिए उपयोग किया जाने वाला आरंभिक मान. यदि अनुक्रम में कोई मान है, तो पहला `start` है।
`end`	अनुक्रम को सीमित करने के लिए एक अंतिम मान. `end` परिणामी अनुक्रम का अंतिम तत्व है।
`count`	परिणामी अनुक्रम में मानों की संख्या. `count` सकारात्मक होनी चाहिए.

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

init(randomUniform:lowerBound:upperBound:seed:on:)

निर्दिष्ट आकार के साथ एक टेंसर बनाता है, 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`

init(randomUniform:lowerBound:upperBound:seed:on:)

घोषणा

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`	बीज का मूल्य.

init (यादृच्छिक सामान्य: माध्य: मानक विचलन: बीज: पर:)
सामान्य वितरण से अदिश मानों का बेतरतीब ढंग से नमूना लेकर, निर्दिष्ट आकार के साथ एक टेंसर बनाता है।
घोषणा
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
बीज का मूल्य.
init (randomTruncatedNormal: माध्य: मानक विचलन: बीज: पर:)
निर्दिष्ट आकार के साथ एक टेंसर बनाता है, एक काटे गए सामान्य वितरण से यादृच्छिक रूप से स्केलर मानों का नमूना लेता है।
घोषणा
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`

init(randomCategorialLogits:sampleCount:seed:)

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

घोषणा

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`

init(glorotUniform:seed:on:)
ग्लोरोट (जेवियर) एकसमान आरंभीकरण करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।
यह डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न -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
बीज का मूल्य.
init(glorotNormal:seed:on:)
ग्लोरोट (ज़ेवियर) सामान्य आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।
यह डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न मानक विचलन sqrt(2 / (fanIn + fanOut)) के साथ 0 पर केंद्रित एक काटे गए सामान्य वितरण से यादृच्छिक नमूने खींचता है, जहां fanIn / fanOut ग्रहणशील क्षेत्र द्वारा गुणा किए गए इनपुट और आउटपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है। आकार।
संदर्भ: "गहरे फीडफॉरवर्ड तंत्रिका नेटवर्क के प्रशिक्षण की कठिनाई को समझना"
घोषणा
public init( glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
पैरामीटर
shape
टेंसर के आयाम.
seed
बीज का मूल्य.
init(heवर्दी:बीज:पर:)
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
बीज का मूल्य.
init(heNormal:seed:on:)
हे (काइमिंग) सामान्य आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।
यह डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न मानक विचलन sqrt(2 / fanIn)) के साथ 0 पर केंद्रित एक काटे गए सामान्य वितरण से यादृच्छिक नमूने खींचता है, जहां fanIn ग्रहणशील क्षेत्र के आकार से गुणा किए गए इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है।
संदर्भ: "रेक्टिफायर्स में गहराई से उतरना: इमेजनेट वर्गीकरण पर मानव-स्तर के प्रदर्शन को पार करना"
घोषणा
public init( heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
पैरामीटर
shape
टेंसर के आयाम.
seed
बीज का मूल्य.
init(leCunUniform:seed:on:)
LeCun एकसमान आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।
यह डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न -limit और limit बीच एक समान वितरण से यादृच्छिक नमूने खींचता है, जहां limit sqrt(3 / fanIn) है और fanIn ग्रहणशील क्षेत्र के आकार से गुणा किए गए इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है।
संदर्भ: "कुशल बैकप्रॉप"
घोषणा
public init( leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
पैरामीटर
shape
टेंसर के आयाम.
seed
बीज का मूल्य.
init(leCunNormal:seed:on:)
LeCun सामान्य आरंभीकरण निष्पादित करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।
यह डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न मानक विचलन sqrt(1 / fanIn) के साथ 0 पर केंद्रित एक काटे गए सामान्य वितरण से यादृच्छिक नमूने खींचता है, जहां fanIn ग्रहणशील क्षेत्र के आकार से गुणा किए गए इनपुट सुविधाओं की संख्या का प्रतिनिधित्व करता है।
संदर्भ: "कुशल बैकप्रॉप"
घोषणा
public init( leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed, on device: Device = .default )
पैरामीटर
shape
टेंसर के आयाम.
seed
बीज का मूल्य.

init (ऑर्थोगोनल: लाभ: बीज:)

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

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

यदि आरंभ करने के लिए टेंसर का आकार द्वि-आयामी से अधिक है, तो आकार का एक मैट्रिक्स [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`

qrDecomposition(fullMatrices:)

टेंसर में प्रत्येक आंतरिक मैट्रिक्स का क्यूआर अपघटन लौटाता है, आंतरिक ऑर्थोगोनल मैट्रिक्स 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]) कॉलम की गणना करें।

svd(computeUV:fullMatrices:)

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: सही एकवचन सदिश।

sqrt(_:)
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>
exp2(_:)
दो को घात x तक बढ़ाया गया।
घोषणा
@differentiable public static func exp2(_ x: `Self`) -> Tensor<Scalar>
exp10(_:)
दस को x घात तक बढ़ाया गया।
घोषणा
@differentiable public static func exp10(_ x: `Self`) -> Tensor<Scalar>
expm1(_:)
exp(x) - 1 मूल्यांकन किया गया ताकि सटीकता को शून्य के करीब रखा जा सके।
घोषणा
@differentiable public static func expm1(_ x: `Self`) -> Tensor<Scalar>
लकड़ी का लट्ठा(_:)
x का प्राकृतिक लघुगणक।
घोषणा
@differentiable public static func log(_ x: `Self`) -> Tensor<Scalar>

लॉग2(_:)

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

घोषणा

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

लॉग10(_:)

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

घोषणा

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

लॉग1पी(_:)
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>
POW (_: _ :)
x n th शक्ति के लिए उठाया।
x की n प्रतियों का उत्पाद।
घोषणा
@differentiable public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
जड़(_:_:)
x की n वें जड़।
वास्तविक प्रकारों के लिए, यदि x नकारात्मक है और n भी है, तो परिणाम नैन है। जटिल प्रकारों के लिए, नकारात्मक वास्तविक अक्ष के साथ एक शाखा कट जाती है।
घोषणा
@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)

उपलब्ध है जहाँ `स्केलर` ==` बूल`

elementsLogicalNot ()
रिटर्न !self एलिमेंट-वार।
घोषणा
public func elementsLogicalNot() -> Tensor
ElementsLogicaland (_ :)
self && other तत्व-वार रिटर्न।
टिप्पणी
&& प्रसारण का समर्थन करता है।
घोषणा
public func elementsLogicalAnd(_ other: Tensor) -> Tensor
ElementsLogicaland (_ :)
self && other तत्व-वार रिटर्न, other प्रसारण।
घोषणा
public func elementsLogicalAnd(_ other: Scalar) -> Tensor
ElementsLogicalor (_ :)
self || other तत्व-वार।
घोषणा
public func elementsLogicalOr(_ other: Tensor) -> Tensor
ElementsLogicalor (_ :)
self || other तत्व-वार, प्रसारण other ।
घोषणा
public func elementsLogicalOr(_ other: Scalar) -> Tensor

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

क्लिप्ड (मिन: मैक्स :)
max(min(self, max), min) रिटर्न।
घोषणा
@differentiable public func clipped(min: Tensor, max: Tensor) -> Tensor
क्लिप्ड (मिन: मैक्स :)
max(min(self, max), min) रिटर्न।
घोषणा
@differentiable(wrt: (self, min) ) public func clipped(min: Tensor, max: Scalar) -> Tensor
क्लिप्ड (मिन: मैक्स :)
max(min(self, max), min) रिटर्न।
घोषणा
@differentiable(wrt: (self, max) ) public func clipped(min: Scalar, max: Tensor) -> Tensor
क्लिप्ड (मिन: मैक्स :)
max(min(self, max), min) रिटर्न।
घोषणा
@differentiable(wrt: self) public func clipped(min: Scalar, max: Scalar) -> Tensor

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

-(_ :)
निर्दिष्ट टेंसर तत्व-वार की उपेक्षा करता है।
घोषणा
@differentiable public prefix static func - (rhs: Tensor) -> Tensor

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

चुकता ()

घोषणा

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

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

isfinite
एक बूलियन टेंसर देता है जो दर्शाता है कि x के कौन से तत्व परिमित हैं।
घोषणा
public var isFinite: Tensor<Bool> { get }
isinfinite
एक बूलियन टेंसर देता है जो दर्शाता है कि x के कौन से तत्व अनंत हैं।
घोषणा
public var isInfinite: Tensor<Bool> { get }
इस्नान
एक बूलियन टेंसर देता है जो दर्शाता है कि x के कौन से तत्व नान-मूल्यवान हैं।
घोषणा
public var isNaN: Tensor<Bool> { get }

उपलब्ध है जहाँ `स्केलर` ==` बूल`

सभी()
यदि सभी स्केलर true के बराबर हैं, तो यह true । अन्यथा, false लौटते हैं।
घोषणा
public func all() -> Bool
कोई भी()
यदि कोई स्केलर true के बराबर है, तो true । अन्यथा, false लौटते हैं।
घोषणा
public func any() -> Bool
सभी (निचोड़ने वाले) :)
निर्दिष्ट अक्षों के साथ एक तार्किक और संचालन करता है। कम आयाम हटा दिए जाते हैं।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
public func all(squeezingAxes axes: Int...) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
कोई भी (निचोड़नाक्सैक्स :)
निर्दिष्ट अक्षों के साथ एक तार्किक और संचालन करता है। कम आयाम हटा दिए जाते हैं।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
public func any(squeezingAxes axes: Int...) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
सभी (साथक्स :)
निर्दिष्ट अक्षों के साथ एक तार्किक और संचालन करता है। कम आयामों को मान 1 के साथ बनाए रखा जाता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
public func all(alongAxes axes: Int...) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
कोई भी (साथ में :)
निर्दिष्ट अक्षों के साथ एक तार्किक या संचालन करता है। कम आयामों को मान 1 के साथ बनाए रखा जाता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
public func any(alongAxes axes: Int...) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।

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

min ()

घोषणा

@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
कम करने के लिए आयाम।
argmax (निचोड़ने केैक्सिस :)
निर्दिष्ट अक्षों के साथ अधिकतम मानों के सूचकांकों को लौटाता है। कम आयाम हटा दिए जाते हैं।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>
पैरामीटर
axes
कम करने के लिए आयाम।
argmin (निचोड़नाक्सिस :)
निर्दिष्ट अक्षों के साथ न्यूनतम मूल्यों के सूचकांकों को लौटाता है। कम आयाम हटा दिए जाते हैं।
शर्त लगाना
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
कम करने के लिए आयाम।
argmax ()
चपटा स्केलर के अधिकतम मूल्य का सूचकांक लौटाता है।
घोषणा
public func argmax() -> Tensor<Int32>
argmin ()
चपटा स्केलर के न्यूनतम मूल्य का सूचकांक लौटाता है।
घोषणा
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
कम करने के लिए आयाम।

Cumulativesum (साथक्सिस: एक्सक्लूसिव: रिवर्स :)

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

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`	इंगित करता है कि उलट क्रम में संचयी राशि का प्रदर्शन करना है या नहीं।

वापसी मूल्य

संचयी योग ऑपरेशन का परिणाम।

Cumulativesum (साथक्सिस: एक्सक्लूसिव: रिवर्स :)

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`

StandardDeviation (निचोड़ने वाले (:)
निर्दिष्ट अक्षों के साथ तत्वों के मानक विचलन को लौटाता है। कम आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल के सुधार को लागू नहीं करता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
StandardDeviation (निचोड़ने वाले (:)
निर्दिष्ट अक्षों के साथ तत्वों के मानक विचलन को लौटाता है। कम आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल के सुधार को लागू नहीं करता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
StandardDeviation (निचोड़ने वाले (:)
निर्दिष्ट अक्षों के साथ तत्वों के मानक विचलन को लौटाता है। कम आयामों को मान 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
StandardDeviation (साथक्स :)
निर्दिष्ट अक्षों के साथ तत्वों के मानक विचलन को लौटाता है। कम आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल के सुधार को लागू नहीं करता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
StandardDeviation (साथक्स :)
निर्दिष्ट अक्षों के साथ तत्वों के मानक विचलन को लौटाता है। कम आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल के सुधार को लागू नहीं करता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: [Int]) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
StandardDeviation (साथक्स :)
निर्दिष्ट अक्षों के साथ तत्वों के मानक विचलन को लौटाता है। कम आयामों को मान 1 के साथ बनाए रखा जाता है। बेसेल के सुधार को लागू नहीं करता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func standardDeviation(alongAxes axes: Int...) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
logsumexp (निचोड़नाक्सैक्स :)
रिटर्न log(exp(self).sum(squeezingAxes: axes)) । कम आयाम हटा दिए जाते हैं।
यह फ़ंक्शन कंप्यूटिंग log(exp(self).sum(squeezingAxes: axes)) की तुलना में अधिक संख्यात्मक रूप से स्थिर है। यह छोटे इनपुट के log की गणना के कारण बड़े इनपुट और अंडरफ्लो के exp की गणना के कारण होने वाले ओवरफ्लो से बचता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
logsumexp (निचोड़नाक्सैक्स :)
रिटर्न log(exp(self).sum(squeezingAxes: axes)) । कम आयाम हटा दिए जाते हैं।
यह फ़ंक्शन कंप्यूटिंग log(exp(self).sum(squeezingAxes: axes)) की तुलना में अधिक संख्यात्मक रूप से स्थिर है। यह छोटे इनपुट के log की गणना के कारण बड़े इनपुट और अंडरफ्लो के exp की गणना के कारण होने वाले ओवरफ्लो से बचता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: [Int]) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
logsumexp (निचोड़नाक्सैक्स :)
रिटर्न log(exp(self).sum(squeezingAxes: axes)) । कम आयाम हटा दिए जाते हैं।
यह फ़ंक्शन कंप्यूटिंग log(exp(self).sum(squeezingAxes: axes)) की तुलना में अधिक संख्यात्मक रूप से स्थिर है। यह छोटे इनपुट के log की गणना के कारण बड़े इनपुट और अंडरफ्लो के exp की गणना के कारण होने वाले ओवरफ्लो से बचता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func logSumExp(squeezingAxes axes: Int...) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
logsumexp ()
रिटर्न log(exp(self).sum()) । परिणाम एक स्केलर है।
यह फ़ंक्शन कंप्यूटिंग log(exp(self).sum()) की तुलना में अधिक संख्यात्मक रूप से स्थिर है। यह छोटे इनपुट के log की गणना के कारण बड़े इनपुट और अंडरफ्लो के exp की गणना के कारण होने वाले ओवरफ्लो से बचता है।
घोषणा
@differentiable(wrt: self) public func logSumExp() -> Tensor
logsumexp (साथक्स :)
रिटर्न log(exp(self).sum(alongAxes: axes)) । कम आयामों को मान 1 के साथ बनाए रखा जाता है।
यह फ़ंक्शन कंप्यूटिंग log(exp(self).sum(alongAxes: axes)) की तुलना में अधिक संख्यात्मक रूप से स्थिर है। यह छोटे इनपुट के log की गणना के कारण बड़े इनपुट और अंडरफ्लो के exp की गणना के कारण होने वाले ओवरफ्लो से बचता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
logsumexp (साथक्स :)
रिटर्न log(exp(self).sum(alongAxes: axes)) । कम आयामों को मान 1 के साथ बनाए रखा जाता है।
यह फ़ंक्शन कंप्यूटिंग log(exp(self).sum(alongAxes: axes)) की तुलना में अधिक संख्यात्मक रूप से स्थिर है। यह छोटे इनपुट के log की गणना के कारण बड़े इनपुट और अंडरफ्लो के exp की गणना के कारण होने वाले ओवरफ्लो से बचता है।
शर्त लगाना
axes में प्रत्येक मान रेंज -rank..<rank में होना चाहिए।
घोषणा
@differentiable(wrt: self) public func logSumExp(alongAxes axes: [Int]) -> Tensor
पैरामीटर
axes
कम करने के लिए आयाम।
logsumexp (साथक्स :)
रिटर्न log(exp(self).sum(alongAxes: axes)) । कम आयामों को मान 1 के साथ बनाए रखा जाता है।
यह फ़ंक्शन कंप्यूटिंग log(exp(self).sum(alongAxes: axes)) की तुलना में अधिक संख्यात्मक रूप से स्थिर है। यह छोटे इनपुट के log की गणना के कारण बड़े इनपुट और अंडरफ्लो के exp की गणना के कारण होने वाले ओवरफ्लो से बचता है।
शर्त लगाना
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`

vjpinitdeviceandprecisionlike

घोषणा

static func vjpInitDeviceAndPrecisionLike(
  _ value: Scalar,
  deviceAndPrecisionLike tensor: Tensor
) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))

Batchnormalized (साथक्सिस: ऑफसेट: स्केल: एप्सिलॉन :)

निर्दिष्ट अक्ष के साथ इनपुट को बैच-नॉर्मलाइज़िंग से गणना किए गए एक टेंसर को लौटाता है।

विशेष रूप से, रिटर्न (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`	संख्यात्मक स्थिरता के लिए भाजक में एक छोटा मूल्य जोड़ा गया।

concatenate (_: _ :)
अंतिम अक्ष के साथ दो टेंसर्स को समेटता है।
घोषणा
@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

init (आकार :)
घोषणा
@derivative init(shape: scalars)

उपलब्ध है जहाँ `स्केलर`:` इक्वेटेबल`

== (_: _ :)

घोषणा

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

! = (_: _ :)

घोषणा

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

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

एनकोड (:)

घोषणा

public func encode(to encoder: Encoder) throws

init (से :)

घोषणा

public init(from decoder: Decoder) throws

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

शून्य
स्केलर शून्य टेंसर।
शून्य
घोषणा
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`

स्पर्शरेखावेक्टर
घोषणा
public typealias TangentVector = Tensor
जीरो टैंगेंट वेक्टर इनिशियलाइज़र
घोषणा
public var zeroTangentVectorInitializer: () -> TangentVector { get }
एनोटेट (_ :)
एक एनोटेशन जोड़ता है।
नोट: केवल X10 समर्थित है। अन्य बैकेंड के लिए, umodified self वापस कर दिया जाता है।
घोषणा
@differentiable(wrt: self) public func annotate(_ annotation: String) -> Tensor<Scalar>
पैरामीटर
annotation
एनोटेशन जोड़ा जाना है।
वापसी मूल्य
एनोटेट टेंसर।

vjpannotate (_ :)

घोषणा

@derivative
func vjpAnnotate(_ annotation: String) -> (
  value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar>
)

`lowerBounds`	प्रत्येक आयाम पर निचली सीमाएँ।
`upperBounds`	प्रत्येक आयाम पर ऊपरी सीमा.

`shape`	टेंसर के आयाम.
`repeatedValue`	दोहराने योग्य अदिश मान.

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

`shape`	टेंसर के आयाम.
`mean`	वितरण का माध्य.
`standardDeviation`	वितरण का मानक विचलन.
`seed`	बीज का मूल्य.