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

टेन्सर

@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: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol 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

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

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

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

    ध्यान दें

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

    घोषणा

    public let handle: TensorHandle<Scalar>
  • घोषणा

    public init(handle: TensorHandle<Scalar>)
  • एक rank- की दी गई आयाम unpacks R एकाधिक rank- में टेन्सर (R-1) tensors। इस टेंसर से N टेंसर्स को अनपैक करते हैं, इसे axis डायमेंशन के साथ जोड़कर, जहां N इस टेंसर के आकार से अनुमान लगाया जाता है। उदाहरण के लिए, आकार [A, B, C, D] साथ एक टेंसर दिया गया:

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

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

    शर्त लगाना

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

    घोषणा

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

    पैरामीटर

    axis

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

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

    अरैस्टेड टेनर्स युक्त एरे।

  • एक स्पर्शक को कई दसियों में विभाजित करता है। दसियों को छोटे axis में count में आयाम axis साथ विभाजित किया जाता है। इसके लिए आवश्यक है कि 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 प्रदान की गई [-rank, rank) rank है।

    घोषणा

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

    पैरामीटर

    count

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

    axis

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

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

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

  • एक स्पर्शक को कई दसियों में विभाजित करता है। टेंसर को आकार में विभाजित किया गया है। sizes.shape[0] टुकड़े। i -th टुकड़ा के आकार का आयाम आकार axis अलावा इस टेंसर के समान आकार 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 प्रदान की गई [-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] बार दोहराया जाता है। उदाहरण के लिए, [2] [abcdabcd] निर्माण [abcdabcd] [abcd] [2] करता है।

    शर्त लगाना

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

    शर्त लगाना

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

    शर्त लगाना

    multiples सभी स्केल गैर-नकारात्मक होने चाहिए।

    घोषणा

    @differentiable(wrt: self)
    public func tiled(multiples: [Int]) -> Tensor
  • एक टाइल वाले टेंसर को लौटाता है, जो इस टेंसर को टाइल करके निर्मित होता है।

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

    शर्त लगाना

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

    शर्त लगाना

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

    घोषणा

    @differentiable(wrt: self)
    public func tiled(multiples: Tensor<Int32>) -> Tensor
  • निर्दिष्ट 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 N = self.rank

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

    ध्यान दें

    CPU पर, यदि कोई आउट-ऑफ-रेंज इंडेक्स पाया जाता है, तो एक त्रुटि है। GPU पर, यदि एक आउट-ऑफ-रेंज इंडेक्स पाया जाता है, तो एक 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 , जबकि बैच आयामों के अनुरूप पहले batchDimensionCount आयामों की अनदेखी करते हैं। इकट्ठा पहले गैर-बैच आयाम के साथ किया जाता है।

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

    शर्त लगाना

    axis रेंज में होना चाहिए -rank..<rank , जबकि batchDimensionCount से अधिक या बराबर 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] i th true प्रवेश mask (पंक्ति-प्रमुख क्रम) है।

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

    शर्त लगाना

    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) टेंसर में प्रविष्टियां द्वारा डायनामिक टेंसर (self.rank - K + 1) हैं जो mask में true वैल्यू के अनुरूप होते mask

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

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

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

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

    घोषणा

    public func nonZeroIndices() -> Tensor<Int64>

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

    आकार के साथ एक (num_true, rank(condition))

  • घोषणा

    @differentiable(wrt: self)
    public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor
  • घोषणा

    @differentiable(wrt: self)
    public func broadcasted(to shape: TensorShape) -> Tensor
  • निर्दिष्ट Tensor के समान आकार में प्रसारण करें।

    शर्त लगाना

    प्रसारण के लिए निर्दिष्ट आकार संगत होना चाहिए।

    घोषणा

    @differentiable(wrt: self)
    public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • घोषणा

    public static func .= (lhs: inout Tensor, rhs: Tensor)
  • प्रत्येक आयाम के लिए निचले और ऊपरी सीमा द्वारा निर्धारित टैंसर से एक टुकड़ा निकालता है।

    घोषणा

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

    पैरामीटर

    lowerBounds

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

    upperBounds

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

  • घोषणा

    @differentiable(wrt: self)
    public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor
  • घोषणा

    @differentiable(wrt: self)
    public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor
  • घोषणा

    @differentiable(wrt: self)
    public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }
  • जाँचता है कि axes का प्रत्येक तत्व self धुरी को दर्शाता है, और अन्यथा निदान के साथ कार्यक्रम को रोक देता है।

    घोषणा

    func ensureValid(
      axes: Tensor<Int32>,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • जाँचता है कि axes का प्रत्येक तत्व self धुरी को दर्शाता है, और अन्यथा निदान के साथ कार्यक्रम को रोक देता है।

    घोषणा

    func ensureValid(
      axes: [Int],
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • जाँचता है कि k self की एक धुरी को दर्शाता है, और अन्यथा निदान के साथ कार्यक्रम को रोक देता है।

    घोषणा

    func ensureValid(
      axis k: Int,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • घोषणा

    public init<BatchSamples: Collection>(collating samples: BatchSamples)
    where BatchSamples.Element == Self
  • दिए गए Device पर other की एक प्रति बनाता है।

    घोषणा

    public init(copying other: Tensor, to device: Device)
  • निर्दिष्ट आकार और एकल, दोहराया स्केलर मान के साथ एक टेंसर बनाता है।

    घोषणा

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

    पैरामीटर

    shape

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

    repeatedValue

    दोहराने के लिए स्केलर मान।

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

    घोषणा

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

    पैरामीटर

    repeatedValue

    दोहराने के लिए स्केलर मान।

    shape

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

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

    घोषणा

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
  • टेंसरों की एक सरणी से एक टेंसर बनाता है (जो खुद स्केलर हो सकता है)।

    घोषणा

    @differentiable
    public init(_ elements: [Tensor])
  • ढेर tensors साथ, axis , आयाम रैंक एक वर्तमान टेंसर, और में प्रत्येक टेन्सर की तुलना में अधिक के साथ एक नया टेन्सर में 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 प्रदान की गई [-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] परिणाम का आकार [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:) कर रहे हैं, तो Tensor.init(stacking:alongAxis:) का उपयोग करने पर विचार करें।

    शर्त लगाना

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

    शर्त लगाना

    axis सीमा [-rank, rank) में होनी चाहिए, जहां rank प्रदान की गई [-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 }
  • रिटर्न की एक प्रति self करने के लिए परिवर्तित Scalar शारीरिक अदिश प्रकार।

    घोषणा

    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 के बराबर है और false true तो true है।

    घोषणा

    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)
  • स्केलर से 1D टेंसर बनाता है।

    घोषणा

    @differentiable
    public init(_ scalars: [Scalar], on device: Device = .default)
  • स्केलर से 1D टेंसर बनाता है।

    घोषणा

    public init<C: RandomAccessCollection>(
      _ 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: RandomAccessCollection>(
      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 यदि तत्व गणना दो बार edgeElementCount से अधिक हो।

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

    घोषणा

    public var fullDescription: String { get }
  • घोषणा

    public var playgroundDescription: Any { get }
  • घोषणा

    public var customMirror: Mirror { 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)
  • घोषणा

    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 तत्व-वार की गणना करके बूलियन lhs < rhs

    घोषणा

    public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs <= rhs तत्व-वार की गणना करके बूलियन lhs <= rhs

    घोषणा

    public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs > rhs तत्व-वार की गणना करके बूलियन lhs > rhs एक टेंसर को लौटाता है।

    घोषणा

    public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs >= rhs तत्व-वार की गणना करके बूलियन lhs >= rhs

    घोषणा

    public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs < rhs तत्व के lhs < rhs से गणना करके बूलियन lhs < rhs

    ध्यान दें

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

    घोषणा

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs <= rhs तत्व-वार की गणना करके बूलियन lhs <= rhs

    ध्यान दें

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

    घोषणा

    public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs > rhs तत्व-वार की गणना करके बूलियन lhs > rhs एक टेंसर को लौटाता है।

    ध्यान दें

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

    घोषणा

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs >= rhs तत्व-वार की गणना करके बूलियन lhs >= rhs

    ध्यान दें

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

    घोषणा

    public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs < rhs तत्व के lhs < rhs से गणना करके बूलियन lhs < rhs

    ध्यान दें

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

    घोषणा

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • lhs <= rhs तत्व-वार की गणना करके बूलियन lhs <= rhs

    ध्यान दें

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

    घोषणा

    public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • lhs > rhs तत्व-वार की गणना करके बूलियन lhs > rhs एक टेंसर को लौटाता है।

    ध्यान दें

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

    घोषणा

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • lhs >= rhs तत्व-वार की गणना करके बूलियन lhs >= rhs

    ध्यान दें

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

    घोषणा

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

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

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

    ध्यान दें

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

    घोषणा

    public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • गणना करने वाले lhs != rhs द्वारा बूलियन lhs != rhs एक टेंसर को lhs != rhs तत्व-वार।

    ध्यान दें

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

    घोषणा

    public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • lhs == rhs तत्व-वार की गणना करके बूलियन lhs == rhs एक टेंसर को लौटाता है।

    ध्यान दें

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

    घोषणा

    public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • गणना करने वाले lhs != rhs द्वारा बूलियन lhs != rhs एक टेंसर को lhs != rhs तत्व-वार।

    ध्यान दें

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

    घोषणा

    public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • lhs == rhs तत्व-वार की गणना करके बूलियन lhs == rhs एक टेंसर को लौटाता है।

    ध्यान दें

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

    घोषणा

    public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • गणना करने वाले lhs != rhs द्वारा बूलियन 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)

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

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

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

    घोषणा

    public init(_ other: Tensor<Bool>)
  • किसी अन्य Tensor से तत्व-वार रूपांतरण करें।

    घोषणा

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

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

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

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

    घोषणा

    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-D टेंसर बनाता है जो एक प्रारंभिक मूल्य से एक अनुक्रम का प्रतिनिधित्व करता है, लेकिन इसमें शामिल नहीं है, एक अंतिम मूल्य, निर्दिष्ट राशि से कदम।

    घोषणा

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

    पैरामीटर

    start

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

    end

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

    stride

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

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

    घोषणा

    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 पर बनाया गया axis (डिफ़ॉल्ट रूप से, नई अक्ष अंत में संलग्न है)।

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

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

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

    घोषणा

    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 lowerBound बीच एक समान वितरण से बेतरतीब ढंग से नमूनाकरण स्केलर मूल्यों के साथ एक टेंसर बनाता है।

    घोषणा

    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

    The seed value.

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Creates a tensor with the specified shape, randomly sampling scalar values from a uniform distribution between lowerBound and upperBound .

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    lowerBound

    The lower bound of the distribution.

    upperBound

    The upper bound of the distribution.

    seed

    The seed value.

  • Creates a tensor with the specified shape, randomly sampling scalar values from a normal distribution.

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    mean

    The mean of the distribution.

    standardDeviation

    The standard deviation of the distribution.

    seed

    The seed value.

  • Creates a tensor with the specified shape, randomly sampling scalar values from a truncated Normal distribution.

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    mean

    The mean of the distribution.

    standardDeviation

    The standard deviation of the distribution.

    seed

    The seed value.

Available where `Scalar`: `TensorFlowIndex`

  • Creates a tensor by drawing samples from a categorical distribution.

    Declaration

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

    Parameters

    randomCategorialLogits

    2-D Tensor with shape [batchSize, classCount] . Each slice [i, :] represents the unnormalized log probabilities for all classes.

    sampleCount

    0-D. Number of independent samples to draw for each row slice.

    seed

    The seed value.

    Return Value

    2-D Tensor with shape [batchSize, sampleCount] . Each slice [i, :] contains the drawn class labels with range [0, classCount) .

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Creates a tensor with the specified shape by performing Glorot (Xavier) uniform initialization.

    It draws random samples from a uniform distribution between -limit and limit generated by the default random number generator, where limit is sqrt(6 / (fanIn + fanOut)) and fanIn / fanOut represent the number of input and output features multiplied by the receptive field size.

    Reference: “Understanding the difficulty of training deep feedforward neural networks”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates a tensor with the specified shape by performing Glorot (Xavier) normal initialization.

    It draws random samples from a truncated normal distribution centered on 0 with standard deviation sqrt(2 / (fanIn + fanOut)) generated by the default random number generator, where fanIn / fanOut represent the number of input and output features multiplied by the receptive field size.

    Reference: “Understanding the difficulty of training deep feedforward neural networks”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates a tensor with the specified shape by performing He (Kaiming) uniform initialization.

    It draws random samples from a uniform distribution between -limit and limit generated by the default random number generator, where limit is sqrt(6 / fanIn) and fanIn represents the number of input features multiplied by the receptive field size.

    Reference: “Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates a tensor with the specified shape by performing He (Kaiming) normal initialization.

    It draws random samples from a truncated normal distribution centered on 0 with standard deviation sqrt(2 / fanIn)) generated by the default random number generator, where fanIn represents the number of input features multiplied by the receptive field size.

    Reference: “Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates a tensor with the specified shape by performing LeCun uniform initialization.

    It draws random samples from a uniform distribution between -limit and limit generated by the default random number generator, where limit is sqrt(3 / fanIn) and fanIn represents the number of input features multiplied by the receptive field size.

    Reference: “Efficient BackProp”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates a tensor with the specified shape by performing LeCun normal initialization.

    It draws random samples from a truncated normal distribution centered on 0 with standard deviation sqrt(1 / fanIn) generated by the default random number generator, where fanIn represents the number of input features multiplied by the receptive field size.

    Reference: “Efficient BackProp”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates an orthogonal matrix or tensor.

    If the shape of the tensor to initialize is two-dimensional, it is initialized with an orthogonal matrix obtained from the QR decomposition of a matrix of random numbers drawn from a normal distribution. If the matrix has fewer rows than columns then the output will have orthogonal rows. Otherwise, the output will have orthogonal columns.

    If the shape of the tensor to initialize is more than two-dimensional, a matrix of shape [shape[0] * ... * shape[rank - 2], shape[rank - 1]] is initialized. The matrix is subsequently reshaped to give a tensor of the desired shape.

    Declaration

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

    Parameters

    shape

    The shape of the tensor.

    gain

    A multiplicative factor to apply to the orthogonal tensor.

    seed

    A tuple of two integers to seed the random number generator.

Available where `Scalar`: `TensorFlowNumeric`

  • Returns the [batched] diagonal part of a [batched] tensor. For the tensor instance of the shape [..., M, N] , the output is a tensor of the shape [..., K] , where K equals min(N, M) .

    For example:

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

    Declaration

    @differentiable
    public func diagonalPart() -> Tensor
  • Constructs a [batched] diagonal array. For the tensor instance of the shape [..., M] , the output is a tensor of the shape [..., M, M] .

    For example:

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

    Declaration

    @differentiable
    public func diagonal() -> Tensor
  • Returns self with new diagonal values, given that self is an optionally batched matrix.

    The returned tensor has the same shape and values as self , except for the specified diagonals of the innermost matrices which are overwritten by the values in diagonal .

    Parameter diagonal: A tensor with rank rank - 1 representing the new diagonal values.

    Declaration

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

    @differentiable(wrt: self)
    public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor
  • Returns a copy of a innermost tensor defined by a central band boundaries. The output is a tensor of the same shape as the instance [..., :, :] .

    For example:

    // '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]]
    

    Declaration

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

    Parameters

    subdiagonalCount

    The number of subdiagonals to keep. If negative, keep entire lower triangle.

    superdiagonalCount

    The number of superdiagonals to keep. If negative, keep entire upper triangle.

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns the QR decomposition of each inner matrix in the tensor, a tensor with inner orthogonal matrices q and a tensor with inner upper triangular matrices r , such that the tensor is equal to matmul(q, r) .

    Declaration

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

    Parameters

    fullMatrices

    If true , compute full-sized q and r . Otherwise compute only the leading min(shape[rank - 1], shape[rank - 2]) columns of q .

  • Returns the singular value decomposition of self , given that self is an optionally batched matrix.

    The singular value decomposition (SVD) of the optionally batched matrix self is values s , u , and v , such that:

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

    self must be a tensor with shape […, M, N] . Let K = min(M, N)`.

    Precondition

    self must be a tensor with shape [..., M, N] .

    Declaration

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

    Parameters

    computeUV

    If true , the left and right singular vectors are computed and returned as u and v , respectively. If false , nil values are returned as u and v .

    fullMatrices

    If true , u and v respectively have shapes [..., M, M] and [..., N, N] . If false , u and v respectively have shapes [..., M, K] and [..., K, N] . Ignored when computeUV is false.

    Return Value

    • s: The singular values, with shape [..., K] . Within each vector, the singular values are sorted in descending order.
    • u: The left singular vectors.
    • v: The right singular vectors.
  • The square root of x .

    For real types, if x is negative the result is .nan . For complex types there is a branch cut on the negative real axis.

    Declaration

    @differentiable
    public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
  • The cosine of x , interpreted as an angle in radians.

    Declaration

    @differentiable
    public static func cos(_ x: `Self`) -> Tensor<Scalar>
  • The sine of x , interpreted as an angle in radians.

    Declaration

    @differentiable
    public static func sin(_ x: `Self`) -> Tensor<Scalar>
  • The tangent of x , interpreted as an angle in radians.

    Declaration

    @differentiable
    public static func tan(_ x: `Self`) -> Tensor<Scalar>
  • The inverse cosine of x in radians.

    Declaration

    @differentiable
    public static func acos(_ x: `Self`) -> Tensor<Scalar>
  • The inverse sine of x in radians.

    Declaration

    @differentiable
    public static func asin(_ x: `Self`) -> Tensor<Scalar>
  • The inverse tangent of x in radians.

    Declaration

    @differentiable
    public static func atan(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic cosine of x .

    Declaration

    @differentiable
    public static func cosh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic sine of x .

    Declaration

    @differentiable
    public static func sinh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic tangent of x .

    Declaration

    @differentiable
    public static func tanh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic cosine of x .

    Declaration

    @differentiable
    public static func acosh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic sine of x .

    Declaration

    @differentiable
    public static func asinh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic tangent of x .

    Declaration

    @differentiable
    public static func atanh(_ x: `Self`) -> Tensor<Scalar>
  • The exponential function applied to x , or e**x .

    Declaration

    @differentiable
    public static func exp(_ x: `Self`) -> Tensor<Scalar>
  • Two raised to to power x .

    Declaration

    @differentiable
    public static func exp2(_ x: `Self`) -> Tensor<Scalar>
  • Ten raised to to power x .

    Declaration

    @differentiable
    public static func exp10(_ x: `Self`) -> Tensor<Scalar>
  • exp(x) - 1 evaluated so as to preserve accuracy close to zero.

    Declaration

    @differentiable
    public static func expm1(_ x: `Self`) -> Tensor<Scalar>
  • The natural logarithm of x .

    Declaration

    @differentiable
    public static func log(_ x: `Self`) -> Tensor<Scalar>
  • The base-two logarithm of x .

    Declaration

    @differentiable
    public static func log2(_ x: `Self`) -> Tensor<Scalar>
  • The base-ten logarithm of x .

    Declaration

    @differentiable
    public static func log10(_ x: `Self`) -> Tensor<Scalar>
  • log(1 + x) evaluated so as to preserve accuracy close to zero.

    Declaration

    @differentiable
    public static func log1p(_ x: `Self`) -> Tensor<Scalar>
  • exp(y log(x)) computed without loss of intermediate precision.

    For real types, if x is negative the result is NaN, even if y has an integral value. For complex types, there is a branch cut on the negative real axis.

    Declaration

    @differentiable
    public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
  • x raised to the n th power.

    The product of n copies of x .

    Declaration

    @differentiable
    public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • The n th root of x .

    For real types, if x is negative and n is even, the result is NaN. For complex types, there is a branch cut along the negative real axis.

    Declaration

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

    public typealias VectorSpaceScalar = Float
  • Declaration

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

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

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

Available where `Scalar`: `Numeric`

  • Adds the scalar to every scalar of the tensor and produces the sum.

    Declaration

    @differentiable
    public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
  • Adds the scalar to every scalar of the tensor and produces the sum.

    Declaration

    @differentiable
    public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference.

    Declaration

    @differentiable
    public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference

    Declaration

    @differentiable
    public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
  • Adds two tensors and stores the result in the left-hand-side variable.

    Note

    += supports broadcasting.

    Declaration

    public static func += (lhs: inout Tensor, rhs: Tensor)
  • Adds the scalar to every scalar of the tensor and stores the result in the left-hand-side variable.

    Declaration

    public static func += (lhs: inout Tensor, rhs: Scalar)
  • Subtracts the second tensor from the first and stores the result in the left-hand-side variable.

    Note

    -= supports broadcasting.

    Declaration

    public static func -= (lhs: inout Tensor, rhs: Tensor)
  • Subtracts the scalar from every scalar of the tensor and stores the result in the left-hand-side variable.

    Declaration

    public static func -= (lhs: inout Tensor, rhs: Scalar)
  • Returns the tensor produced by multiplying the two tensors.

    Note

    * supports broadcasting.

    Declaration

    @differentiable
    public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the tensor by multiplying it with every scalar of the tensor.

    Declaration

    @differentiable
    public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
  • Multiplies the scalar with every scalar of the tensor and produces the product.

    Declaration

    @differentiable
    public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
  • Multiplies two tensors and stores the result in the left-hand-side variable.

    Note

    *= supports broadcasting.

    Declaration

    public static func *= (lhs: inout Tensor, rhs: Tensor)
  • Multiplies the tensor with the scalar, broadcasting the scalar, and stores the result in the left-hand-side variable.

    Declaration

    public static func *= (lhs: inout Tensor, rhs: Scalar)
  • Returns the quotient of dividing the first tensor by the second.

    Note

    / supports broadcasting.

    Declaration

    @differentiable
    public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the scalar by the tensor, broadcasting the scalar.

    Declaration

    @differentiable
    public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the tensor by the scalar, broadcasting the scalar.

    Declaration

    @differentiable
    public static func / (lhs: Tensor, rhs: Scalar) -> Tensor
  • Divides the first tensor by the second and stores the quotient in the left-hand-side variable.

    Declaration

    public static func /= (lhs: inout Tensor, rhs: Tensor)
  • Divides the tensor by the scalar, broadcasting the scalar, and stores the quotient in the left-hand-side variable.

    Declaration

    public static func /= (lhs: inout Tensor, rhs: Scalar)
  • Returns the remainder of dividing the first tensor by the second.

    Note

    % supports broadcasting.

    Declaration

    public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the remainder of dividing the tensor by the scalar, broadcasting the scalar.

    Declaration

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
  • Returns the remainder of dividing the scalar by the tensor, broadcasting the scalar.

    Declaration

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor
  • Divides the first tensor by the second and stores the remainder in the left-hand-side variable.

    Declaration

    public static func %= (lhs: inout Tensor, rhs: Tensor)
  • Divides the tensor by the scalar and stores the remainder in the left-hand-side variable.

    Declaration

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

Available where `Scalar` == `Bool`

  • Returns !self element-wise.

    Declaration

    public func elementsLogicalNot() -> Tensor
  • Returns self && other element-wise.

    Note

    && supports broadcasting.

    Declaration

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor
  • Returns self && other element-wise, broadcasting other .

    Declaration

    public func elementsLogicalAnd(_ other: Scalar) -> Tensor
  • Returns self || other element-wise.

    Declaration

    public func elementsLogicalOr(_ other: Tensor) -> Tensor
  • Returns self || other element-wise, broadcasting other .

    Declaration

    public func elementsLogicalOr(_ other: Scalar) -> Tensor

Available where `Scalar`: `TensorFlowNumeric`

  • Returns max(min(self, max), min) .

    Declaration

    @differentiable
    public func clipped(min: Tensor, max: Tensor) -> Tensor
  • Returns max(min(self, max), min) .

    Declaration

    @differentiable(wrt: (self, min)
    ) public func clipped(min: Tensor, max: Scalar) -> Tensor
  • Returns max(min(self, max), min) .

    Declaration

    @differentiable(wrt: (self, max)
    ) public func clipped(min: Scalar, max: Tensor) -> Tensor
  • Returns max(min(self, max), min) .

    Declaration

    @differentiable(wrt: self)
    public func clipped(min: Scalar, max: Scalar) -> Tensor

Available where `Scalar`: `SignedNumeric`

  • Returns the negation of the specified tensor element-wise.

    Declaration

    @differentiable
    public prefix static func - (rhs: Tensor) -> Tensor

Available where `Scalar`: `Numeric`

  • Declaration

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns a boolean tensor indicating which elements of x are finite.

    Declaration

    public var isFinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are infinite.

    Declaration

    public var isInfinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are NaN-valued.

    Declaration

    public var isNaN: Tensor<Bool> { get }

Available where `Scalar` == `Bool`

  • Returns true if all scalars are equal to true . Otherwise, returns false .

    Declaration

    public func all() -> Bool
  • Returns true if any scalars are equal to true . Otherwise, returns false .

    Declaration

    public func any() -> Bool
  • Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Performs a logical AND operation along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Performs a logical OR operation along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

Available where `Scalar`: `Numeric` & `Comparable`

  • Declaration

    @differentiable
    public func min() -> Tensor
  • Declaration

    @differentiable
    public func max() -> Tensor
  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the indices of the maximum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the indices of the minimum values along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the index of the maximum value of the flattened scalars.

    Declaration

    public func argmax() -> Tensor<Int32>
  • Returns the index of the minimum value of the flattened scalars.

    Declaration

    public func argmin() -> Tensor<Int32>

Available where `Scalar`: `Numeric`

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func sum() -> Tensor
  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func product() -> Tensor
  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank...rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func mean() -> Tensor
  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

    @differentiable(wrt: self)
    public func variance() -> Tensor
  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

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

    By setting the exclusive argument to true , an exclusive cumulative sum is performed instead:

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

    By setting the reverse argument to true , the cumulative sum is performed in the opposite direction:

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

  • Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

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

    By setting the exclusive argument to true , an exclusive cumulative sum is performed instead:

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

    By setting the reverse argument to true , the cumulative sum is performed in the opposite direction:

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis.rank must be 0 .

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

  • Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

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

    By setting the exclusive argument to true , an exclusive cumulative product is performed instead:

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

    By setting the reverse argument to true , the cumulative product is performed in the opposite direction:

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

  • Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

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

    By setting the exclusive argument to true , an exclusive cumulative product is performed instead:

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

    By setting the reverse argument to true , the cumulative product is performed in the opposite direction:

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must have rank 0 .

    Precondition

    axis must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of all elements in this tensor. Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func standardDeviation() -> Tensor
  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum()) . The result is a scalar.

    This function is more numerically stable than computing log(exp(self).sum()) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Declaration

    @differentiable(wrt: self)
    public func logSumExp() -> Tensor
  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Precondition

    axes must have rank 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor's elements.

    Declaration

    @differentiable(wrt: self)
    public func moments() -> Moments<Scalar>
  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Precondition

    axes must have rank 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func moments(alongAxes axes: Int...) -> Moments<Scalar>

    Parameters

    axes

    The dimensions to reduce.

Available where `Scalar`: `Numeric`

  • Performs matrix multiplication between two tensors and produces the result.

    Declaration

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Declaration

    static func vjpInitDeviceAndPrecisionLike(
      _ value: Scalar,
      deviceAndPrecisionLike tensor: Tensor
    ) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))
  • Returns a tensor computed from batch-normalizing the input along the specified axis.

    Specifically, returns (self - mu) / (var + epsilon) * gamma + beta where mu and var are respectively the mean and variance of self along axis .

    Declaration

    @differentiable(wrt: (self, offset, scale)
    public func batchNormalized(
      alongAxis axis: Int,
      offset: Tensor = Tensor(0),
      scale: Tensor = Tensor(1),
      epsilon: Scalar = 0.001
    ) -> Tensor

    Parameters

    axis

    The batch dimension.

    offset

    The offset, also known as beta.

    scale

    The scale, also known as gamma.

    epsilon

    A small value added to the denominator for numerical stability.

  • Declaration

    @derivative
    init(shape: scalars)

Available where `Scalar`: `Equatable`

  • Declaration

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

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

Available where `Scalar`: `Codable`

  • Declaration

    public func encode(to encoder: Encoder) throws
  • Declaration

    public init(from decoder: Decoder) throws

Available where `Scalar`: `Numeric`

  • The scalar zero tensor.

  • Declaration

    public static var zero: Tensor { get }
  • Adds two tensors and produces their sum.

    Note

    + supports broadcasting.

    Declaration

    @differentiable
    public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
  • Subtracts one tensor from another and produces their difference.

    Note

    - supports broadcasting.

    Declaration

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

    The scalar one tensor.

    Declaration

    public static var one: Tensor { get }
  • Returns the element-wise reciprocal of self .

    Declaration

    public var reciprocal: Tensor { get }
  • Multiplies two tensors element-wise and produces their product.

    Note

    .* supports broadcasting.

    Declaration

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Declaration

    public typealias TangentVector = Tensor