@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
3extension 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]
उत्पन्न होता है।शर्त लगाना
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]
उत्पन्न होता है।शर्त लगाना
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
निर्दिष्ट आकार और एकल, दोहराए गए स्केलर मान के साथ एक टेंसर बनाता है।
घोषणा
@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 }
घोषणा
@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>
बूलियन मानों का एक टेंसर लौटाता है जो दर्शाता है कि
self
के तत्वother
के तत्वों के लगभग बराबर हैं या नहीं।शर्त लगाना
self
औरother
का आकार एक जैसा होना चाहिए।घोषणा
public func elementsAlmostEqual( _ other: Tensor, tolerance: Scalar = Scalar.ulpOfOne.squareRoot() ) -> Tensor<Bool>
यदि
self
के सभी तत्वother
के सभी तत्वों के लगभग बराबर हैं तो यहtrue
लौटाता है।शर्त लगाना
self
औरother
का आकार एक जैसा होना चाहिए।घोषणा
public func isAlmostEqual( to other: Tensor, tolerance: Scalar = Scalar.ulpOfOne.squareRoot() ) -> Bool
इस टेंसर के लिए एक क्रॉस प्रतिकृति योग चलाता है। योग में भाग लेने वाले प्रत्येक अन्य उपकरण पर समान क्रॉस प्रतिकृति योग होना चाहिए।
घोषणा
public mutating mutating func crossReplicaSum(_ scale: Double)
घोषणा
@derivative init(repeating: shape)
Bool
टेंसर से तत्व-वार प्रकार का रूपांतरण करें।घोषणा
public init(_ other: Tensor<Bool>)
किसी अन्य
Tensor
से तत्व-वार रूपांतरण करें।घोषणा
@differentiable public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
घोषणा
@derivative init(_: <<error type>>)
घोषणा
@derivative init(stacking: alongAxis)
घोषणा
@derivative init(concatenating: alongAxis)
सभी अदिशों को शून्य पर सेट करके एक टेंसर बनाता है।
घोषणा
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
है, एक नई आंतरिकतम धुरी।
एक 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
सकारात्मक होनी चाहिए.
निर्दिष्ट आकार के साथ एक टेंसर बनाता है,
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
बीज का मूल्य.
निर्दिष्ट आकार के साथ एक टेंसर बनाता है,
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
बीज का मूल्य.
श्रेणीबद्ध वितरण से नमूने खींचकर एक टेंसर बनाता है।
घोषणा
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)
के साथ खींचे गए क्लास लेबल होते हैं।
ग्लोरोट (जेवियर) एकसमान आरंभीकरण करके निर्दिष्ट आकार के साथ एक टेंसर बनाता है।
यह डिफ़ॉल्ट यादृच्छिक संख्या जनरेटर द्वारा उत्पन्न
-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
रखने के लिए सुपरडायगोनल्स की संख्या. यदि नकारात्मक है, तो संपूर्ण ऊपरी त्रिभुज रखें।
टेंसर में प्रत्येक आंतरिक मैट्रिक्स का क्यूआर अपघटन लौटाता है, आंतरिक ऑर्थोगोनल मैट्रिक्स
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: सही एकवचन सदिश।
- s: आकार के साथ एकवचन मान
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)
!self
तत्व-वार लौटाता है।घोषणा
public func elementsLogicalNot() -> Tensor
self && other
तत्व-वार लौटाता है।टिप्पणी
&&
प्रसारण का समर्थन करता है।घोषणा
public func elementsLogicalAnd(_ other: Tensor) -> Tensor
self && other
तत्व-वार लौटाता है,other
प्रसारित करता है।घोषणा
public func elementsLogicalAnd(_ other: Scalar) -> Tensor
self || other
तत्व-वार.घोषणा
public func elementsLogicalOr(_ other: Tensor) -> Tensor
self || other
तत्व-वार,other
प्रसारण।घोषणा
public func elementsLogicalOr(_ other: Scalar) -> Tensor
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
तत्व-वार निर्दिष्ट टेंसर का निषेधन लौटाता है।
घोषणा
@differentiable public prefix static func - (rhs: Tensor) -> Tensor
घोषणा
@differentiable(wrt: self) public func squared() -> Tensor
एक बूलियन टेंसर लौटाता है जो दर्शाता है कि
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
इंगित करता है कि संचयी उत्पाद को उल्टे क्रम में निष्पादित करना है या नहीं।
प्रतिलाभ की मात्रा
संचयी उत्पाद संचालन का परिणाम.
निर्दिष्ट अक्षों के अनुदिश तत्वों का मानक विचलन लौटाता है। कम किए गए आयामों को मान
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
घोषणा
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 func encode(to encoder: Encoder) throws
घोषणा
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
घोषणा
public typealias TangentVector = Tensor
घोषणा
public var zeroTangentVectorInitializer: () -> TangentVector { get }
एक एनोटेशन जोड़ता है.
नोट: केवल X10 समर्थित है. अन्य बैकएंड के लिए, संशोधित
self
लौटाया जाता है।घोषणा
@differentiable(wrt: self) public func annotate(_ annotation: String) -> Tensor<Scalar>
पैरामीटर
annotation
एनोटेशन जोड़ा जाना है.
प्रतिलाभ की मात्रा
एनोटेटेड टेंसर.
घोषणा
@derivative func vjpAnnotate(_ annotation: String) -> ( value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar> )