টেনসর

@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: Equatable where Scalar: Equatable
extension Tensor: TensorProtocol
extension Tensor: TensorGroup
l10n-
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
-
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Codable where Scalar: Codable
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

উপাদানগুলির একটি বহুমাত্রিক বিন্যাস যা সম্ভাব্য উচ্চ মাত্রায় ভেক্টর এবং ম্যাট্রিক্সের সাধারণীকরণ।

জেনেরিক প্যারামিটার Scalar টেনসরের স্কেলারের ধরন বর্ণনা করে (যেমন Int32 , Float , ইত্যাদি)।

  • অন্তর্নিহিত TensorHandle ।

    বিঃদ্রঃ

    handle ব্যবহারকারীর সংজ্ঞায়িত অপ্স মঞ্জুরি দেওয়ার জন্য সর্বজনীন, কিন্তু সাধারণত ব্যবহার করা উচিত নয়।

    ঘোষণা

    public let handle: TensorHandle<Scalar>

  • ঘোষণা

    public init(handle: TensorHandle<Scalar>)

  • একটি র‌্যাঙ্ক- R টেনসরের প্রদত্ত মাত্রাকে একাধিক র‌্যাঙ্ক- (R-1) টেনসরে আনপ্যাক করে। এই টেনসর থেকে N টেনসরগুলিকে axis মাত্রা বরাবর চিপ করে আনপ্যাক করে, যেখানে এই টেনসরের আকৃতি থেকে N অনুমান করা হয়। উদাহরণস্বরূপ, আকৃতি [A, B, C, D] সহ একটি টেনসর দেওয়া হয়েছে:

    • যদি axis == 0 হয় তাহলে রিটার্ন করা অ্যারের i -th টেনসর হল স্লাইস self[i, :, :, :] এবং সেই অ্যারের প্রতিটি টেনসরের আকৃতি থাকবে [B, C, D] । (মনে রাখবেন যে প্যাক করা ডাইমেনশনটি চলে গেছে, Tensor.split(numSplits:alongAxis) বা Tensor.split(sizes:alongAxis) এর বিপরীতে।
    • যদি axis == 1 হয়, তাহলে প্রত্যাবর্তিত অ্যারের i -th টেনসর হল স্লাইস value[:, i, :, :] এবং সেই অ্যারের প্রতিটি টেনসরের আকৃতি হবে [A, C, D] ।
    • ইত্যাদি।

    এটি Tensor.init(stacking:alongAxis:) এর বিপরীত।

    পূর্বশর্ত

    axis অবশ্যই [-rank, rank) রেঞ্জের মধ্যে থাকতে হবে, যেখানে rank হল প্রদত্ত টেনসরের র‌্যাঙ্ক।

    ঘোষণা

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

    পরামিতি

    axis

    ডাইমেনশন যার সাথে আনস্ট্যাক করতে হবে। নেতিবাচক মান চারপাশে মোড়ানো.

    ফেরত মূল্য

    আনস্ট্যাকড টেনসর ধারণকারী অ্যারে।

  • একটি টেনসরকে একাধিক টেনসরে বিভক্ত করে। টেনসরটি মাত্রা axis বরাবর বিভক্ত হয়ে ছোট টেনসর count । এর জন্য প্রয়োজন যে count সমানভাবে shape[axis] ভাগ করে।

    উদাহরণ স্বরূপ:

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

    পূর্বশর্ত

    count অবশ্যই মাত্রা axis আকার সমানভাবে ভাগ করতে হবে।

    পূর্বশর্ত

    axis অবশ্যই [-rank, rank) রেঞ্জের মধ্যে থাকতে হবে, যেখানে rank হল প্রদত্ত টেনসরের র‌্যাঙ্ক।

    ঘোষণা

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

    পরামিতি

    count

    তৈরি করার জন্য বিভাজনের সংখ্যা।

    axis

    এই টেনসরকে বিভক্ত করার জন্য যে মাত্রা। নেতিবাচক মান চারপাশে মোড়ানো.

    ফেরত মূল্য

    টেনসর অংশ ধারণকারী একটি অ্যারে।

  • একটি টেনসরকে একাধিক টেনসরে বিভক্ত করে। টেনসর sizes.shape[0] বিভক্ত হয়। i -th অংশের আকৃতিটি এই টেনসরের মতো একই আকার ধারণ করে ব্যতীত মাত্রা axis বরাবর যেখানে আকারটি sizes[i] ।

    উদাহরণ স্বরূপ:

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

    পূর্বশর্ত

    sizes মানগুলি অবশ্যই মাত্রা axis আকারের সাথে যোগ করতে হবে৷

    পূর্বশর্ত

    axis অবশ্যই [-rank, rank) রেঞ্জের মধ্যে থাকতে হবে, যেখানে rank হল প্রদত্ত টেনসরের র‌্যাঙ্ক।

    ঘোষণা

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

    পরামিতি

    sizes

    প্রতিটি বিভাজনের আকার ধারণকারী 1-D টেনসর।

    axis

    ডাইমেনশন যার সাথে এই টেনসরকে বিভক্ত করতে হবে। নেতিবাচক মান চারপাশে মোড়ানো.

    ফেরত মূল্য

    টেনসর অংশ সমন্বিত অ্যারে।

  • ঘোষণা

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

  • এই টেনসর টাইল করে নির্মিত একটি টাইলযুক্ত টেনসর প্রদান করে।

    এই কনস্ট্রাক্টর এই টেনসরকে multiples প্রতিলিপি করে একটি নতুন টেনসর তৈরি করে। নির্মিত টেনসরের i ডাইমেনশনে self.shape[i] * multiples[i] উপাদান রয়েছে এবং এই টেনসরের মানগুলি i ডাইমেনশন বরাবর multiples[i] প্রতিলিপি করা হয়। উদাহরণস্বরূপ, [abcd] দ্বারা [2] টাইলিং করলে [abcdabcd] উৎপন্ন হয়।

    পূর্বশর্ত

    গুণিতকের প্রত্যাশিত rank অবশ্যই 1 হতে হবে।

    পূর্বশর্ত

    multiples আকৃতি অবশ্যই [tensor.rank] হতে হবে।

    পূর্বশর্ত

    multiples সব স্কেলার অ-নেতিবাচক হতে হবে.

    ঘোষণা

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

  • এই টেনসর টাইল করে নির্মিত একটি টাইলযুক্ত টেনসর প্রদান করে।

    এই কনস্ট্রাক্টর এই টেনসরকে multiples প্রতিলিপি করে একটি নতুন টেনসর তৈরি করে। নির্মিত টেনসরের i ডাইমেনশনে self.shape[i] * multiples[i] উপাদান রয়েছে এবং এই টেনসরের মানগুলি i ডাইমেনশন বরাবর multiples[i] প্রতিলিপি করা হয়। উদাহরণস্বরূপ, [abcd] দ্বারা [2] টাইলিং করলে [abcdabcd] উৎপন্ন হয়।

    পূর্বশর্ত

    গুণিতকের প্রত্যাশিত rank অবশ্যই 1 হতে হবে।

    পূর্বশর্ত

    multiples আকৃতি অবশ্যই [tensor.rank] হতে হবে।

    ঘোষণা

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

  • নির্দিষ্ট Tensor আকারে পুনরায় আকার দিন।

    পূর্বশর্ত

    স্কেলারের সংখ্যা নতুন আকৃতির সাথে মেলে।

    ঘোষণা

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

  • নির্দিষ্ট আকারে পুনরায় আকার দিন।

    পূর্বশর্ত

    স্কেলারের সংখ্যা নতুন আকৃতির সাথে মেলে।

    ঘোষণা

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

  • একটি আকৃতির প্রতিনিধিত্বকারী নির্দিষ্ট Tensor পুনরায় আকার দিন।

    পূর্বশর্ত

    স্কেলারের সংখ্যা নতুন আকৃতির সাথে মেলে।

    ঘোষণা

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

  • সারি-মেজর ক্রমে 1-ডি Tensor ভেঙে পড়া টেনসরের একটি অনুলিপি ফেরত দিন।

    ঘোষণা

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

  • নির্দিষ্ট আকৃতির সূচকে 1 এর মাত্রা সন্নিবেশিত করে একটি আকৃতি-প্রসারিত Tensor প্রদান করে।

    ঘোষণা

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

  • নির্দিষ্ট আকৃতির সূচকে 1 এর মাত্রা সন্নিবেশিত করে একটি আকৃতি-প্রসারিত Tensor প্রদান করে।

    ঘোষণা

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

  • 1-এর অগ্রবর্তী মাত্রা সহ একটি র‌্যাঙ্ক-উত্তোলিত Tensor প্রদান করে।

    ঘোষণা

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

  • একটি টেনসরের আকৃতি থেকে আকার 1 এর নির্দিষ্ট মাত্রা সরিয়ে দেয়। যদি কোন মাত্রা নির্দিষ্ট করা না থাকে, তাহলে আকার 1 এর সমস্ত মাত্রা সরানো হবে।

    ঘোষণা

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

  • একটি টেনসরের আকৃতি থেকে আকার 1 এর নির্দিষ্ট মাত্রা সরিয়ে দেয়। যদি কোন মাত্রা নির্দিষ্ট করা না থাকে, তাহলে আকার 1 এর সমস্ত মাত্রা সরানো হবে।

    ঘোষণা

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

  • একটি ট্রান্সপোজড টেনসর প্রদান করে, যার মাত্রা নির্দিষ্ট ক্রমে অনুমতি দেওয়া হয়।

    ঘোষণা

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

  • একটি ট্রান্সপোজড টেনসর প্রদান করে, যার মাত্রা নির্দিষ্ট ক্রমে অনুমতি দেওয়া হয়।

    ঘোষণা

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

  • একটি ট্রান্সপোজড টেনসর প্রদান করে, যার মাত্রা নির্দিষ্ট ক্রমে অনুমতি দেওয়া হয়।

    ঘোষণা

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

  • একটি ট্রান্সপোজড টেনসর প্রদান করে, যার মাত্রা নির্দিষ্ট ক্রমে অনুমতি দেওয়া হয়।

    ঘোষণা

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

  • একটি ট্রান্সপোজড টেনসর প্রদান করে, যার মাত্রা নির্দিষ্ট ক্রমে অনুমতি দেওয়া হয়।

    ঘোষণা

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

  • একটি ট্রান্সপোজড টেনসর প্রদান করে, যার মাত্রা নির্দিষ্ট ক্রমে অনুমতি দেওয়া হয়।

    ঘোষণা

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

  • একটি ট্রান্সপোজড টেনসর ফেরত দেয়, যার মাত্রা বিপরীত ক্রমে অনুমতি দেওয়া হয়।

    ঘোষণা

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

  • উল্টানো নির্দিষ্ট মাত্রা সহ একটি টেনসর প্রদান করে।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    পূর্বশর্ত

    axes কোন ডুপ্লিকেশন থাকতে হবে।

    ঘোষণা

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

  • উল্টানো নির্দিষ্ট মাত্রা সহ একটি টেনসর প্রদান করে।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    পূর্বশর্ত

    axes কোন ডুপ্লিকেশন থাকতে হবে।

    ঘোষণা

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

  • উল্টানো নির্দিষ্ট মাত্রা সহ একটি টেনসর প্রদান করে।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    পূর্বশর্ত

    axes কোন ডুপ্লিকেশন থাকতে হবে।

    ঘোষণা

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

  • নির্দিষ্ট অক্ষ বরাবর একটি সংযুক্ত টেনসর প্রদান করে।

    পূর্বশর্ত

    নির্দিষ্ট অক্ষ ব্যতীত টেনসরগুলির অবশ্যই একই মাত্রা থাকতে হবে।

    পূর্বশর্ত

    অক্ষটি অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

  • সংযোগ অপারেটর।

    বিঃদ্রঃ

    ++ হল একটি কাস্টম অপারেটর যা সুইফটে নেই, কিন্তু হাসকেল/স্কালাতে আছে। এটির সংযোজন একটি তুচ্ছ ভাষা পরিবর্তন নয় এবং বিতর্কিত হতে পারে। পরবর্তী API ডিজাইন পর্বে ++ এর অস্তিত্ব/নামকরণ নিয়ে আলোচনা করা হবে।

    ঘোষণা

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

  • axis মাত্রা বরাবর indices ইনপুটের স্লাইস সংগ্রহ করে একটি টেনসর প্রদান করে

    0-D (স্কেলার) 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-D (ভেক্টর) indices জন্য:

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

    সাধারণ ক্ষেত্রে, একটি ফলস্বরূপ টেনসর তৈরি করে যেখানে:

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

    যেখানে N = self.rank এবং M = indices.rank ।

    ফলস্বরূপ টেনসরের আকৃতি হল: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...]

    বিঃদ্রঃ

    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 মাত্রার সাথে সঙ্গতিপূর্ণ প্রথম batchDimensionCount উপেক্ষা করার সময় অক্ষের মাত্রা বরাবর indices এই টেনসরের স্লাইস ফেরত দেয়। সংগ্রহ প্রথম নন-ব্যাচ মাত্রা বরাবর সঞ্চালিত হয়.

    gathering অনুরূপ কার্যকারিতা সম্পাদন করে, ব্যতীত যে টেনসরের আকৃতিটি এখন shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...]

    পূর্বশর্ত

    axis অবশ্যই -rank..<rank , batchDimensionCount চেয়ে বড় বা সমান।

    পূর্বশর্ত

    batchDimensionCount অবশ্যই indices.rank থেকে কম হতে হবে।

    ঘোষণা

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

    পরামিতি

    indices

    সংগ্রহ করার জন্য সূচক রয়েছে।

    axis

    মাত্রা যা বরাবর জড়ো করা. নেতিবাচক মান চারপাশে মোড়ানো.

    batchDimensionCount

    অগ্রগণ্য ব্যাচের মাত্রা উপেক্ষা করার জন্য সংখ্যা।

    ফেরত মূল্য

    সংগৃহীত টেনসর।

  • ইনপুটে প্রদত্ত বুলিয়ান মাস্ক প্রয়োগ করার পরে মানগুলি সংগ্রহ করে একটি টেনসর প্রদান করে।

    উদাহরণ স্বরূপ:

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

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

    সাধারণভাবে, 0 < mask.rank = K <= tensor.rank , এবং mask আকৃতি অবশ্যই tensor আকৃতির প্রথম K মাত্রার সাথে মেলে। তারপর আমাদের আছে: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] যেখানে [i1, ..., iK] হল mask i প্রবেশ (সারি-প্রধান ক্রম) true

    axis mask সাথে ব্যবহার করা যেতে পারে অক্ষ থেকে মুখোশের জন্য নির্দেশ করতে। সেক্ষেত্রে, axis + mask.rank <= tensor.rank এবং mask 's shape must match the first অক্ষ + mask.rank dimensions of the সাথে মিলবে।

    পূর্বশর্ত

    mask একটি স্কেলার হতে পারে না: mask.rank != 0 ।

    ঘোষণা

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

    পরামিতি

    mask

    KD বুলিয়ান টেনসর, যেখানে K <= self.rank ।

    axis

    0-D পূর্ণসংখ্যা টেনসর self থেকে মুখোশের মধ্যে অক্ষের প্রতিনিধিত্ব করে, যেখানে K + axis <= self.rank ।

    ফেরত মূল্য

    (self.rank - K + 1) -মাত্রিক টেনসর mask true মানগুলির সাথে সম্পর্কিত এই টেনসরের এন্ট্রি দ্বারা জনবহুল।

  • এই টেনসরে অ-শূন্য/সত্য মানগুলির অবস্থানগুলি প্রদান করে।

    স্থানাঙ্কগুলি একটি 2-ডি টেনসরে ফেরত দেওয়া হয় যেখানে প্রথম মাত্রা (সারি) অ-শূন্য উপাদানগুলির সংখ্যা প্রতিনিধিত্ব করে এবং দ্বিতীয় মাত্রা (কলাম) অ-শূন্য উপাদানগুলির স্থানাঙ্কগুলিকে উপস্থাপন করে। মনে রাখবেন যে আউটপুট টেনসরের আকার এই টেনসরে কতগুলি সত্য মান রয়েছে তার উপর নির্ভর করে পরিবর্তিত হতে পারে। সূচকগুলি সারি-প্রধান ক্রমে আউটপুট হয়।

    উদাহরণ স্বরূপ:

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

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

    ঘোষণা

    public func nonZeroIndices() -> Tensor<Int64>

    ফেরত মূল্য

    আকৃতি সহ একটি টেনসর (num_true, rank(condition)) ।

  • ঘোষণা

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

  • ঘোষণা

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

  • নির্দিষ্ট Tensor মতো একই আকারে সম্প্রচার করুন।

    পূর্বশর্ত

    নির্দিষ্ট আকৃতি অবশ্যই সম্প্রচারের জন্য সামঞ্জস্যপূর্ণ হতে হবে।

    ঘোষণা

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

  • ঘোষণা

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

  • প্রতিটি মাত্রার জন্য নিম্ন এবং উপরের সীমানা দ্বারা সংজ্ঞায়িত টেনসর থেকে একটি স্লাইস বের করে।

    ঘোষণা

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

    পরামিতি

    lowerBounds

    প্রতিটি মাত্রায় নিম্ন সীমানা।

    upperBounds

    প্রতিটি মাত্রায় উপরের সীমানা।

  • ঘোষণা

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

  • ঘোষণা

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

  • ঘোষণা

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

  • চেক করে যে axes প্রতিটি উপাদান self এর একটি অক্ষকে নির্দেশ করে, এবং অন্যথায় একটি ডায়াগনস্টিক দিয়ে প্রোগ্রামটিকে থামায়।

    ঘোষণা

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

  • চেক করে যে axes প্রতিটি উপাদান self এর একটি অক্ষকে নির্দেশ করে, এবং অন্যথায় একটি ডায়াগনস্টিক দিয়ে প্রোগ্রামটিকে থামায়।

    ঘোষণা

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

  • চেক করে যে k self এর একটি অক্ষকে নির্দেশ করে, এবং অন্যথায় একটি ডায়াগনস্টিক দিয়ে প্রোগ্রামটিকে থামায়।

    ঘোষণা

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

  • ঘোষণা

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

  • প্রদত্ত Device other একটি অনুলিপি তৈরি করে।

    ঘোষণা

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

  • নির্দিষ্ট আকৃতি এবং একটি একক, পুনরাবৃত্তি স্কেলার মান সহ একটি টেনসর তৈরি করে।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    repeatedValue

    পুনরাবৃত্তি করার জন্য স্কেলার মান।

  • নির্দিষ্ট আকৃতি এবং একটি একক, পুনরাবৃত্তি স্কেলার মান সহ একটি টেনসর তৈরি করে।

    ঘোষণা

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

    পরামিতি

    repeatedValue

    পুনরাবৃত্তি করার জন্য স্কেলার মান।

    shape

    টেনসরের মাত্রা।

  • প্রদত্ত স্কেলারকে একটি প্রদত্ত র‍্যাঙ্কে সম্প্রচার করে একটি টেনসর তৈরি করে যার সমস্ত মাত্রা 1।

    ঘোষণা

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

  • টেনসরের একটি অ্যারে থেকে একটি টেনসর তৈরি করে (যা নিজেরাই স্কেলার হতে পারে)।

    ঘোষণা

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

  • স্ট্যাক 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 হল প্রদত্ত টেনসরের র‌্যাঙ্ক।

    ঘোষণা

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

    পরামিতি

    tensors

    স্ট্যাক করার জন্য টেনসর।

    axis

    ডাইমেনশন যা বরাবর স্ট্যাক করতে হবে। নেতিবাচক মান চারপাশে মোড়ানো.

    ফেরত মূল্য

    স্তুপীকৃত টেনসর।

  • axis মাত্রা বরাবর tensors সংযুক্ত করে।

    প্রদত্ত যে tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , তাহলে সংযুক্ত ফলাফলের আকৃতি আছে [D0, D1, ... Raxis, ...Dn] , যেখানে Raxis = sum(Daxis(i)) । অর্থাৎ, ইনপুট টেনসর থেকে ডেটা axis মাত্রা বরাবর যুক্ত হয়।

    উদাহরণ স্বরূপ:

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

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

    বিঃদ্রঃ

    আপনি যদি একটি নতুন অক্ষ বরাবর সংযুক্ত হন তাহলে Tensor.init(stacking:alongAxis:) ব্যবহার করার কথা বিবেচনা করুন।

    পূর্বশর্ত

    সমস্ত টেনসরের একই র‌্যাঙ্ক থাকতে হবে এবং axis ব্যতীত সমস্ত মাত্রা সমান হতে হবে।

    পূর্বশর্ত

    axis অবশ্যই [-rank, rank) রেঞ্জের মধ্যে থাকতে হবে, যেখানে rank হল প্রদত্ত টেনসরের র‌্যাঙ্ক।

    ঘোষণা

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

    পরামিতি

    tensors

    একত্রিত করার জন্য টেনসর।

    axis

    মাত্রা যার সাথে একত্রিত করতে হবে। নেতিবাচক মান চারপাশে মোড়ানো.

    ফেরত মূল্য

    সংযুক্ত টেনসর।

  • এই টেনসরের উপাদানগুলিকে other লেনের সাথে প্রতিস্থাপন করে যেখানে mask true ।

    পূর্বশর্ত

    self এবং other একই আকৃতি থাকতে হবে। যদি self এবং other স্কেলার হয়, তাহলে mask স্কেলার হতে হবে। যদি self এবং other র্যাঙ্ক 1 এর থেকে বেশি বা সমান হয়, তাহলে mask অবশ্যই self মতো একই আকার থাকতে হবে বা 1-ডি Tensor হতে হবে যেমন mask.scalarCount == self.shape[0] ।

    ঘোষণা

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

  • প্রকৃত স্কেলার টাইপ নির্ভুলতা হ্রাস করা হলে সত্য দেখায়।

    বর্তমানে, হ্রাসকৃত নির্ভুল শারীরিক স্কেলারের মধ্যে শুধুমাত্র BFloat16 অন্তর্ভুক্ত রয়েছে।

    ঘোষণা

    public var isReducedPrecision: Bool { get }

  • প্রদত্ত টেনসরের মতো একই ডিভাইস এবং নির্ভুলতা সহ একটি টেনসরে একটি স্কেলার প্রচার করে।

    ঘোষণা

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

  • BFloat16 ফিজিক্যাল স্কেলার টাইপে রূপান্তরিত self এর একটি কপি ফেরত দেয়।

    ঘোষণা

    public var toReducedPrecision: `Self` { get }

  • Scalar ভৌত স্কেলার প্রকারে রূপান্তরিত self এর একটি অনুলিপি প্রদান করে।

    ঘোষণা

    public var toFullPrecision: `Self` { get }

  • Tensor মাত্রার সংখ্যা।

    ঘোষণা

    public var rank: Int { get }

  • Tensor আকৃতি।

    ঘোষণা

    public var shape: TensorShape { get }

  • Tensor স্কেলারের সংখ্যা।

  • ঘোষণা

    public var scalarCount: Int { get }

  • টেনসরের র‍্যাঙ্ক, Tensor<Int32> হিসাবে উপস্থাপিত।

    ঘোষণা

    public var rankTensor: Tensor<Int32> { get }

  • টেনসরের মাত্রা, Tensor<Int32> হিসাবে উপস্থাপিত।

    ঘোষণা

    public var shapeTensor: Tensor<Int32> { get }

  • টেনসরে স্কেলারের সংখ্যা, Tensor<Int32> হিসাবে উপস্থাপিত।

    ঘোষণা

    public var scalarCountTensor: Tensor<Int32> { get }

  • rank 0 এর সমান হলে true এবং অন্যথায় false প্রদান করে।

    ঘোষণা

    public var isScalar: Bool { get }

  • rank 0 এর সমান এবং অন্যথায় nil হলে একক স্কেলার উপাদান প্রদান করে।

    ঘোষণা

    public var scalar: Scalar? { get }

  • স্কেলারে পুনরায় আকার দিন।

    পূর্বশর্ত

    টেনসরের ঠিক একটি স্কেলার আছে।

    ঘোষণা

    @differentiable
public func scalarized() -> Scalar

  • ঘোষণা

    public var array: ShapedArray<Scalar> { get }

  • ঘোষণা

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

  • একটি স্কেলার মান থেকে একটি 0-D টেনসর তৈরি করে।

    ঘোষণা

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

  • স্কেলার থেকে একটি 1D টেনসর তৈরি করে।

    ঘোষণা

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

  • স্কেলার থেকে একটি 1D টেনসর তৈরি করে।

    ঘোষণা

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

  • সারি-প্রধান ক্রমে নির্দিষ্ট আকৃতি এবং সংলগ্ন স্কেলার সহ একটি টেনসর তৈরি করে।

    পূর্বশর্ত

    আকৃতির মাত্রার গুণফলকে স্কেলার সংখ্যার সমান হতে হবে।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের আকৃতি।

    scalars

    টেনসরের স্কেলার বিষয়বস্তু।

  • সারি-প্রধান ক্রমে নির্দিষ্ট আকৃতি এবং সংলগ্ন স্কেলার সহ একটি টেনসর তৈরি করে।

    পূর্বশর্ত

    আকৃতির মাত্রার গুণফলকে স্কেলার সংখ্যার সমান হতে হবে।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের আকৃতি।

    scalars

    টেনসরের স্কেলার বিষয়বস্তু।

  • সারি-প্রধান ক্রমে নির্দিষ্ট আকৃতি এবং সংলগ্ন স্কেলার সহ একটি টেনসর তৈরি করে।

    পূর্বশর্ত

    আকৃতির মাত্রার গুণফলকে স্কেলার সংখ্যার সমান হতে হবে।

  • সারি-প্রধান ক্রমে নির্দিষ্ট আকৃতি এবং সংলগ্ন স্কেলার সহ একটি টেনসর তৈরি করে।

    পূর্বশর্ত

    আকৃতির মাত্রার গুণফলকে স্কেলার সংখ্যার সমান হতে হবে।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের আকৃতি।

    scalars

    টেনসরের স্কেলার বিষয়বস্তু।

  • একটি অ্যারের আক্ষরিক উপাদানের ধরন।

    ঘোষণা

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

  • প্রদত্ত উপাদানগুলির সাথে প্রাথমিক একটি টেনসর তৈরি করে।

    ঘোষণা

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

  • টেনসরের একটি পাঠ্য উপস্থাপনা।

    বিঃদ্রঃ

    সমস্ত স্কেলার দেখানো একটি অ-সুন্দর-মুদ্রিত বিবরণের জন্য fullDescription ব্যবহার করুন।

    ঘোষণা

    public var description: String { get }

  • টেনসরের একটি পাঠ্য উপস্থাপনা। summarize সত্য হলে এবং উপাদানের সংখ্যা edgeElementCount দ্বিগুণ বেশি হলে একটি সংক্ষিপ্ত বিবরণ প্রদান করে।

    ঘোষণা

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

    পরামিতি

    lineWidth

    প্রিন্ট করার জন্য সর্বোচ্চ লাইন প্রস্থ। প্রতি লাইনে প্রিন্ট করার জন্য স্কেলারের সংখ্যা নির্ধারণ করতে ব্যবহৃত হয়।

    edgeElementCount

    উপবৃত্ত ( ... ) এর মাধ্যমে সংক্ষিপ্তকরণের আগে এবং পরে প্রিন্ট করার জন্য সর্বাধিক সংখ্যক উপাদান।

    summarizing

    সত্য হলে, উপাদানের সংখ্যা দ্বিগুণ edgeElementCount ছাড়িয়ে গেলে বিবরণ সংক্ষিপ্ত করুন।

  • টেনসরের একটি সম্পূর্ণ, অ-সুন্দর-মুদ্রিত পাঠ্য উপস্থাপনা, যা সমস্ত স্কেলার দেখাচ্ছে।

    ঘোষণা

    public var fullDescription: String { get }

  • ঘোষণা

    public var playgroundDescription: Any { get }

  • ঘোষণা

    public var customMirror: Mirror { get }

  • এই টেনসর বর্ণনাকারী টীকা।

    ঘোষণা

    public var annotations: String { get }

  • টীকাগুলির জন্য একটি উপনাম৷

    ঘোষণা

    public var summary: String { get }

  • ঘোষণা

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

  • ঘোষণা

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

  • ঘোষণা

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

  • ঘোষণা

    init(_xla: XLATensor)

  • ঘোষণা

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

  • ঘোষণা

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

  • ঘোষণা

    var xlaTensor: XLATensor { get }
উপলব্ধ যেখানে `Scalar`: `Numeric`
উপলব্ধ যেখানে `Scalar`: `সংখ্যাসূচক` এবং `তুলনীয়`

  • lhs < rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    ঘোষণা

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

  • lhs <= rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    ঘোষণা

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

  • lhs > rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    ঘোষণা

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

  • lhs >= rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    ঘোষণা

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

  • lhs < rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .< সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs <= rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .<= সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs > rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .> সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs >= rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .>= সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs < rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .< সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs <= rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .<= সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs > rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .> সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs >= rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .>= সম্প্রচার সমর্থন করে।

    ঘোষণা

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
যেখানে `Scalar`: `Equitable` পাওয়া যায়

  • lhs == rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .== সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs != rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .!= সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs == rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .== সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs != rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .!= সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs == rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .== সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • lhs != rhs উপাদান-ভিত্তিক গণনা করে বুলিয়ান স্কেলারের একটি টেনসর প্রদান করে।

    বিঃদ্রঃ

    .!= সম্প্রচার সমর্থন করে।

    ঘোষণা

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
যেখানে `Scalar`: `TensorFlowFloatingPoint` এবং `Equatable` পাওয়া যায়

  • বুলিয়ান মানগুলির একটি টেনসর প্রদান করে যা নির্দেশ করে যে self এর উপাদানগুলি other উপাদানগুলির প্রায় সমান কিনা৷

    পূর্বশর্ত

    self এবং other একই আকৃতি হতে হবে.

    ঘোষণা

    public func elementsAlmostEqual(
  _ other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Tensor<Bool>
যেখানে `Scalar`: `TensorFlowFloatingPoint` পাওয়া যায়

  • self সমস্ত উপাদান other উপাদানগুলির সাথে প্রায় সমান হলে true ফেরত দেয়৷

    পূর্বশর্ত

    self এবং other একই আকৃতি হতে হবে.

    ঘোষণা

    public func isAlmostEqual(
  to other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
উপলব্ধ যেখানে `Scalar`: `TensorFlowNumeric`

  • এই টেনসরের জন্য একটি ক্রস রেপ্লিকা যোগফল চালায়। একই ক্রস রেপ্লিকা যোগফল যোগফলের অংশগ্রহণকারী অন্যান্য ডিভাইসগুলির প্রতিটিতে ঘটতে হবে।

    ঘোষণা

    public mutating mutating func crossReplicaSum(_ scale: Double)
যেখানে `Scalar`: `TensorFlowFloatingPoint` পাওয়া যায়
উপলব্ধ যেখানে `Scalar`: `Numeric`

  • একটি Bool টেনসর থেকে একটি উপাদান-ভিত্তিক টাইপ রূপান্তর সম্পাদন করুন।

    ঘোষণা

    public init(_ other: Tensor<Bool>)

  • অন্য Tensor থেকে একটি উপাদান-ভিত্তিক রূপান্তর সম্পাদন করুন।

    ঘোষণা

    @differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
যেখানে `Scalar`: `TensorFlowFloatingPoint` পাওয়া যায়
উপলব্ধ যেখানে `Scalar`: `Numeric`

  • শূন্যে সেট করা সমস্ত স্কেলার সহ একটি টেনসর তৈরি করে।

    ঘোষণা

    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 তৈরি করা হয় (ডিফল্টরূপে, নতুন অক্ষ শেষে যুক্ত করা হয়)।

    indices একটি স্কেলার হলে, নতুন টেনসরের আকৃতি হবে দৈর্ঘ্যের depth একটি ভেক্টর।

    যদি indices দৈর্ঘ্যের features একটি ভেক্টর হয় তবে আউটপুট আকার হবে: বৈশিষ্ট্য x গভীরতা, যদি অক্ষ == -1 গভীরতা x বৈশিষ্ট্য, যদি অক্ষ == 0

    যদি indices আকৃতি [batch, features] সহ একটি ম্যাট্রিক্স (ব্যাচ) হয় তবে আউটপুট আকার হবে: ব্যাচ x বৈশিষ্ট্য x গভীরতা, যদি অক্ষ == -1 ব্যাচ x গভীরতা x বৈশিষ্ট্য, যদি অক্ষ == 1 গভীরতা x ব্যাচ x বৈশিষ্ট্য , অক্ষ == 0 হলে

    ঘোষণা

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

    পরামিতি

    indices

    সূচকের একটি Tensor ।

    depth

    একটি স্কেলার একটি গরম মাত্রার গভীরতা নির্ধারণ করে।

    onValue

    একটি স্কেলার সূচকে কিছু indices দ্বারা উল্লেখিত অবস্থানের মান নির্ধারণ করে।

    offValue

    একটি স্কেলার একটি অবস্থানে মান নির্ধারণ করে যা indices কোনো সূচক দ্বারা উল্লেখ করা হয় না।

    axis

    অক্ষ পূরণ করতে. ডিফল্ট হল -1 , একটি নতুন অভ্যন্তরীণ-সবচেয়ে অক্ষ।

যেখানে `Scalar`: `TensorFlowFloatingPoint` পাওয়া যায়

  • একটি 1-D টেনসর তৈরি করে যা একটি প্রারম্ভিক মান থেকে একটি ক্রম প্রতিনিধিত্ব করে, একটি শেষ মান পর্যন্ত এবং সমেত, নির্দিষ্ট করা মানগুলির সংখ্যা তৈরি করতে সমানভাবে ফাঁক করে৷

    ঘোষণা

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

    পরামিতি

    start

    ক্রমটির জন্য ব্যবহার করা শুরুর মান। যদি ক্রমটিতে কোনো মান থাকে তবে প্রথমটি হল start ।

    end

    ক্রম সীমাবদ্ধ করার জন্য একটি শেষ মান। end হল ফলাফলের ক্রমটির শেষ উপাদান।

    count

    ফলস্বরূপ অনুক্রমের মানের সংখ্যা। count ইতিবাচক হতে হবে।

  • একটি 1-D টেনসর তৈরি করে যা একটি প্রারম্ভিক মান থেকে একটি ক্রম প্রতিনিধিত্ব করে, একটি শেষ মান পর্যন্ত এবং সমেত, নির্দিষ্ট করা মানগুলির সংখ্যা তৈরি করতে সমানভাবে ফাঁক করে৷

    পূর্বশর্ত

    start , to , এবং count একটি একক স্কেলার মান ধারণকারী টেনসর হতে হবে।

    ঘোষণা

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

    পরামিতি

    start

    ক্রমটির জন্য ব্যবহার করা শুরুর মান। যদি ক্রমটিতে কোনো মান থাকে তবে প্রথমটি হল start ।

    end

    ক্রম সীমাবদ্ধ করার জন্য একটি শেষ মান। end হল ফলাফলের ক্রমটির শেষ উপাদান।

    count

    ফলস্বরূপ অনুক্রমের মানের সংখ্যা। count ইতিবাচক হতে হবে।

যেখানে `Scalar`: `TensorFlowIndex` পাওয়া যায়

  • lowerBound এবং upperBound মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলোভাবে স্কেলার মানগুলিকে নমুনা করে নির্দিষ্ট আকৃতি সহ একটি টেনসর তৈরি করে।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    lowerBound

    বিতরণের নিম্ন সীমানা।

    upperBound

    বিতরণের উপরের সীমানা।

    seed

    বীজের মান।

যেখানে `Scalar`: `TensorFlowFloatingPoint` পাওয়া যায়

  • lowerBound এবং upperBound মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলোভাবে স্কেলার মানগুলিকে নমুনা করে নির্দিষ্ট আকৃতি সহ একটি টেনসর তৈরি করে।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    lowerBound

    বিতরণের নিম্ন সীমানা।

    upperBound

    বিতরণের উপরের সীমানা।

    seed

    বীজের মান।

  • একটি সাধারণ বন্টন থেকে এলোমেলোভাবে স্কেলার মান নমুনা করে নির্দিষ্ট আকৃতি সহ একটি টেনসর তৈরি করে।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    mean

    বিতরণের গড়।

    standardDeviation

    বিতরণের মানক বিচ্যুতি।

    seed

    বীজের মান।

  • নির্দিষ্ট আকৃতি সহ একটি টেনসর তৈরি করে, এলোমেলোভাবে একটি ছাঁটাই করা সাধারণ বন্টন থেকে স্কেলার মানগুলির নমুনা।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    mean

    বিতরণের গড়।

    standardDeviation

    বিতরণের মানক বিচ্যুতি।

    seed

    বীজের মান।

যেখানে `Scalar`: `TensorFlowIndex` পাওয়া যায়

  • একটি শ্রেণীবদ্ধ বিতরণ থেকে নমুনা অঙ্কন করে একটি টেনসর তৈরি করে।

    ঘোষণা

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

    পরামিতি

    randomCategorialLogits

    আকৃতি সহ 2-ডি টেনসর [batchSize, classCount] । প্রতিটি স্লাইস [i, :] সমস্ত শ্রেণীর জন্য অস্বাভাবিক লগ সম্ভাবনার প্রতিনিধিত্ব করে।

    sampleCount

    0-ডি. প্রতিটি সারির স্লাইসের জন্য স্বতন্ত্র নমুনার সংখ্যা।

    seed

    বীজের মান।

    ফেরত মূল্য

    আকৃতি সহ 2-ডি টেনসর [batchSize, sampleCount] । প্রতিটি স্লাইস [i, :] রেঞ্জ সহ আঁকা ক্লাস লেবেল রয়েছে [0, classCount) ।

যেখানে `Scalar`: `TensorFlowFloatingPoint` পাওয়া যায়

  • গ্লোরোট (জেভিয়ার) ইউনিফর্ম ইনিশিয়ালাইজেশন সম্পাদন করে নির্দিষ্ট আকৃতি সহ একটি টেনসর তৈরি করে।

    এটি ডিফল্ট র্যান্ডম নম্বর জেনারেটর দ্বারা উত্পন্ন -limit এবং limit মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলো নমুনাগুলি আঁকে, যেখানে limit হল sqrt(6 / (fanIn + fanOut)) এবং fanIn / fanOut গ্রহীতা দ্বারা গুণিত ইনপুট এবং আউটপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে মাঠ আকৃতি.

    রেফারেন্স: "গভীর ফিডফরোয়ার্ড নিউরাল নেটওয়ার্ক প্রশিক্ষণের অসুবিধা বোঝা"

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    seed

    বীজের মান।

  • Glorot (Xavier) স্বাভাবিক ইনিশিয়ালাইজেশন সম্পাদন করে নির্দিষ্ট আকৃতি সহ একটি টেনসর তৈরি করে।

    এটি ডিফল্ট র্যান্ডম নম্বর জেনারেটর দ্বারা উত্পন্ন স্ট্যান্ডার্ড বিচ্যুতি sqrt(2 / (fanIn + fanOut)) সহ 0 -কে কেন্দ্র করে একটি ছেঁটে যাওয়া স্বাভাবিক বন্টন থেকে এলোমেলো নমুনাগুলি আঁকে, যেখানে fanIn / fanOut গ্রহনযোগ্য ক্ষেত্র দ্বারা গুণিত ইনপুট এবং আউটপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে। আকার

    রেফারেন্স: "গভীর ফিডফরোয়ার্ড নিউরাল নেটওয়ার্ক প্রশিক্ষণের অসুবিধা বোঝা"

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    seed

    বীজের মান।

  • He (Kaiming) ইউনিফর্ম ইনিশিয়ালাইজেশন করে নির্দিষ্ট আকৃতির সাথে একটি টেনসর তৈরি করে।

    এটি ডিফল্ট র্যান্ডম নম্বর জেনারেটর দ্বারা উত্পন্ন -limit এবং limit মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলো নমুনাগুলি আঁকে, যেখানে limit হল sqrt(6 / fanIn) এবং fanIn গ্রহণযোগ্য ক্ষেত্রের আকার দ্বারা গুণিত ইনপুট বৈশিষ্ট্যের সংখ্যা উপস্থাপন করে৷

    রেফারেন্স: "রেকটিফায়ারের গভীরে প্রবেশ করা: ইমেজনেট শ্রেণীবিভাগে মানব-স্তরের পারফরম্যান্সকে ছাড়িয়ে যাওয়া"

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    seed

    বীজের মান।

  • He (Kaiming) স্বাভাবিক সূচনা সম্পাদন করে নির্দিষ্ট আকৃতির সাথে একটি টেনসর তৈরি করে।

    এটি ডিফল্ট র্যান্ডম নম্বর জেনারেটর দ্বারা উত্পন্ন স্ট্যান্ডার্ড বিচ্যুতি sqrt(2 / fanIn)) সহ 0 কে কেন্দ্র করে একটি ছেঁটে যাওয়া স্বাভাবিক বিতরণ থেকে এলোমেলো নমুনাগুলি আঁকে, যেখানে fanIn গ্রহণযোগ্য ক্ষেত্রের আকার দ্বারা গুণিত ইনপুট বৈশিষ্ট্যের সংখ্যাকে প্রতিনিধিত্ব করে।

    রেফারেন্স: "রেকটিফায়ারের গভীরে প্রবেশ করা: ইমেজনেট শ্রেণীবিভাগে মানব-স্তরের পারফরম্যান্সকে ছাড়িয়ে যাওয়া"

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    seed

    বীজের মান।

  • LeCun ইউনিফর্ম ইনিশিয়ালাইজেশন সম্পাদন করে নির্দিষ্ট আকৃতির সাথে একটি টেনসর তৈরি করে।

    এটি ডিফল্ট র্যান্ডম নম্বর জেনারেটর দ্বারা উত্পন্ন -limit এবং limit মধ্যে একটি অভিন্ন বন্টন থেকে এলোমেলো নমুনাগুলি আঁকে, যেখানে limit হল sqrt(3 / fanIn) এবং fanIn গ্রহণযোগ্য ক্ষেত্রের আকার দ্বারা গুণিত ইনপুট বৈশিষ্ট্যগুলির সংখ্যাকে প্রতিনিধিত্ব করে৷

    রেফারেন্স: "দক্ষ ব্যাকপ্রপ"

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    seed

    বীজের মান।

  • LeCun স্বাভাবিক ইনিশিয়ালাইজেশন করে নির্দিষ্ট আকৃতি সহ একটি টেনসর তৈরি করে।

    এটি ডিফল্ট র্যান্ডম নম্বর জেনারেটর দ্বারা উত্পন্ন স্ট্যান্ডার্ড বিচ্যুতি sqrt(1 / fanIn) সহ 0 কে কেন্দ্র করে একটি ছেঁটে যাওয়া স্বাভাবিক বিতরণ থেকে এলোমেলো নমুনাগুলি আঁকে, যেখানে fanIn গ্রহণযোগ্য ক্ষেত্রের আকার দ্বারা গুণিত ইনপুট বৈশিষ্ট্যগুলির সংখ্যাকে প্রতিনিধিত্ব করে৷

    রেফারেন্স: "দক্ষ ব্যাকপ্রপ"

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের মাত্রা।

    seed

    বীজের মান।

  • একটি অর্থোগোনাল ম্যাট্রিক্স বা টেনসর তৈরি করে।

    আরম্ভ করার জন্য টেনসরের আকৃতি যদি দ্বি-মাত্রিক হয়, তবে এটি একটি সাধারণ বন্টন থেকে আঁকা এলোমেলো সংখ্যাগুলির একটি ম্যাট্রিক্সের QR পচন থেকে প্রাপ্ত একটি অর্থোগোনাল ম্যাট্রিক্সের সাহায্যে আরম্ভ করা হয়। যদি ম্যাট্রিক্সে কলামের চেয়ে কম সারি থাকে তবে আউটপুটে অর্থোগোনাল সারি থাকবে। অন্যথায়, আউটপুটে অর্থোগোনাল কলাম থাকবে।

    ইনিশিয়ালাইজ করার জন্য টেনসরের আকৃতি যদি দ্বি-মাত্রিকের বেশি হয়, তবে আকৃতির একটি ম্যাট্রিক্স [shape[0] * ... * shape[rank - 2], shape[rank - 1]] শুরু করা হয়। ম্যাট্রিক্স পরবর্তীতে কাঙ্খিত আকারের একটি টেনসর দিতে পুনরায় আকার দেওয়া হয়।

    ঘোষণা

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

    পরামিতি

    shape

    টেনসরের আকৃতি।

    gain

    অরথোগোনাল টেনসরে প্রয়োগ করার জন্য একটি গুণক ফ্যাক্টর।

    seed

    এলোমেলো সংখ্যা জেনারেটর বীজের জন্য দুটি পূর্ণসংখ্যার একটি টিপল।

উপলব্ধ যেখানে `Scalar`: `TensorFlowNumeric`

  • একটি [ব্যাচড] টেনসরের [ব্যাচড] তির্যক অংশ প্রদান করে। আকৃতির টেনসর উদাহরণের জন্য [..., M, N] , আউটপুট হল আকৃতির একটি টেনসর [..., K] , যেখানে K সমান min(N, M) ।

    উদাহরণ স্বরূপ:

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

    ঘোষণা

    @differentiable
public func diagonalPart() -> Tensor

  • একটি [ব্যাচড] তির্যক অ্যারে তৈরি করে। আকৃতির টেনসর উদাহরণের জন্য [..., M] , আউটপুট হল আকৃতির একটি টেনসর [..., M, M] ।

    উদাহরণ স্বরূপ:

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

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

    ঘোষণা

    @differentiable
public func diagonal() -> Tensor

  • নতুন তির্যক মান সহ self ফেরত দেয়, যে self একটি ঐচ্ছিকভাবে ব্যাচ করা ম্যাট্রিক্স।

    প্রত্যাবর্তিত টেনসরের self মতো একই আকৃতি এবং মান রয়েছে, অন্তঃস্থ ম্যাট্রিক্সের নির্দিষ্ট কর্ণ ব্যতীত যা diagonal মানগুলি দ্বারা ওভাররাইট করা হয়।

    প্যারামিটার তির্যক: র্যাঙ্ক rank - 1 নতুন তির্যক মানগুলিকে উপস্থাপন করে।

    ঘোষণা

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

  • ঘোষণা

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

  • একটি কেন্দ্রীয় ব্যান্ড সীমানা দ্বারা সংজ্ঞায়িত একটি অন্তর্নিহিত টেনসরের একটি অনুলিপি প্রদান করে৷ আউটপুটটি উদাহরণের মতো একই আকৃতির একটি টেনসর [..., :, :] ।

    উদাহরণ স্বরূপ:

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

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

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

    ঘোষণা

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

    পরামিতি

    subdiagonalCount

    রাখতে হবে উপকর্ণের সংখ্যা। নেতিবাচক হলে, সম্পূর্ণ নিম্ন ত্রিভুজ রাখুন।

    superdiagonalCount

    সুপারডায়াগনালের সংখ্যা রাখতে হবে। নেতিবাচক হলে, পুরো উপরের ত্রিভুজটি রাখুন।

যেখানে `Scalar`: `TensorFlowFloatingPoint` পাওয়া যায়

  • টেনসরের প্রতিটি অভ্যন্তরীণ ম্যাট্রিক্সের QR পচন দেখায়, ভিতরের অর্থোগোনাল ম্যাট্রিক্স q সহ একটি টেনসর এবং ভিতরের উপরের ত্রিভুজাকার ম্যাট্রিক্স r সহ একটি টেনসর, যেমন টেনসরটি matmul(q, r) এর সমান।

    ঘোষণা

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

    পরামিতি

    fullMatrices

    true হলে, পূর্ণ আকারের q এবং r গণনা করুন। অন্যথায় শুধুমাত্র q এর অগ্রবর্তী min(shape[rank - 1], shape[rank - 2]) কলামগুলি গণনা করুন।

  • self এর একবচন মানের পচন দেখায়, যে self একটি ঐচ্ছিকভাবে ব্যাচ করা ম্যাট্রিক্স।

    ঐচ্ছিকভাবে ব্যাচ করা ম্যাট্রিক্স self একবচন মান পচন (SVD) হল মান s , u , এবং v , যেমন:

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

    স্বকে must be a tensor with shape […, M, N] . Let K = min(M, N)`।

    পূর্বশর্ত

    self অবশ্যই আকৃতি সহ একটি টেনসর হতে হবে [..., M, N] ।

    ঘোষণা

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

    পরামিতি

    computeUV

    true হলে, বাম এবং ডান একবচন ভেক্টর গণনা করা হয় এবং যথাক্রমে u এবং v হিসাবে ফেরত দেওয়া হয়। false হলে, nil মানগুলি u এবং v হিসাবে ফেরত দেওয়া হয়।

    fullMatrices

    true হলে, u এবং v যথাক্রমে [..., M, M] এবং [..., N, N] আকার থাকে। false হলে, u এবং v যথাক্রমে [..., M, K] এবং [..., K, N] আকার থাকে। computeUV মিথ্যা হলে উপেক্ষা করা হয়।

    ফেরত মূল্য

    • s: একবচন মান, আকৃতি সহ [..., K] । প্রতিটি ভেক্টরের মধ্যে, একবচন মানগুলিকে নিচের ক্রমে সাজানো হয়।
    • u: বাম একবচন ভেক্টর।
    • v: সঠিক একবচন ভেক্টর।

  • x এর বর্গমূল।

    বাস্তব প্রকারের জন্য, যদি x নেতিবাচক হয় ফলাফল হল .nan । জটিল ধরনের জন্য ঋণাত্মক বাস্তব অক্ষের উপর একটি শাখা কাটা আছে।

    ঘোষণা

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

  • x এর কোসাইন, রেডিয়ানে একটি কোণ হিসাবে ব্যাখ্যা করা হয়।

    ঘোষণা

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

  • x এর সাইন, রেডিয়ানে একটি কোণ হিসাবে ব্যাখ্যা করা হয়।

    ঘোষণা

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

  • x এর স্পর্শক, রেডিয়ানে একটি কোণ হিসাবে ব্যাখ্যা করা হয়।

    ঘোষণা

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

  • রেডিয়ানে x এর বিপরীত কোসাইন।

    ঘোষণা

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

  • রেডিয়ানে x এর বিপরীত সাইন।

    ঘোষণা

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

  • রেডিয়ানে x এর বিপরীত স্পর্শক।

    ঘোষণা

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

  • x এর হাইপারবোলিক কোসাইন।

    ঘোষণা

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

  • x এর হাইপারবোলিক সাইন।

    ঘোষণা

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

  • x এর অধিবৃত্তীয় স্পর্শক।

    ঘোষণা

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

  • x এর বিপরীত হাইপারবোলিক কোসাইন।

    ঘোষণা

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

  • x এর বিপরীত হাইপারবোলিক সাইন।

    ঘোষণা

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

  • x এর বিপরীত হাইপারবোলিক ট্যানজেন্ট।

    ঘোষণা

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

  • সূচকীয় ফাংশন x , বা e**x এ প্রয়োগ করা হয়।

    ঘোষণা

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

  • দুটি x ক্ষমতায় উত্থাপিত।

    ঘোষণা

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

  • দশ শক্তি x এ উত্থাপিত হয়।

    ঘোষণা

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

  • exp(x) - 1 মূল্যায়ন করা হয়েছে যাতে শূন্যের কাছাকাছি নির্ভুলতা রক্ষা করা যায়।

    ঘোষণা

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

  • x এর প্রাকৃতিক লগারিদম।

    ঘোষণা

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

  • x এর বেস-টু লগারিদম।

    ঘোষণা

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

  • x এর বেস-টেন লগারিদম।

    ঘোষণা

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

  • log(1 + x) মূল্যায়ন করা হয়েছে যাতে শূন্যের কাছাকাছি নির্ভুলতা রক্ষা করা যায়।

    ঘোষণা

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

  • exp(y log(x)) মধ্যবর্তী নির্ভুলতা না হারিয়ে গণনা করা হয়েছে।

    বাস্তব প্রকারের জন্য, x ঋণাত্মক হলে ফলাফল হবে NaN, এমনকি y একটি অবিচ্ছেদ্য মান থাকলেও। জটিল ধরণের জন্য, নেতিবাচক বাস্তব অক্ষের উপর একটি শাখা কাটা রয়েছে।

    ঘোষণা

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

  • x n পাওয়ারে উত্থিত।

    x এর n কপিগুলির পণ্য।

    ঘোষণা

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

  • x এর n থ্রি রুট।

    বাস্তব প্রকারের জন্য, যদি x নেতিবাচক হয় এবং n সমান হয় তবে ফলাফলটি ন্যান। জটিল ধরণের জন্য, নেতিবাচক বাস্তব অক্ষ বরাবর একটি শাখা কাটা আছে।

    ঘোষণা

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

  • ঘোষণা

    public typealias VectorSpaceScalar = Float

  • ঘোষণা

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

  • ঘোষণা

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

  • ঘোষণা

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
উপলব্ধ যেখানে `স্কেলার`:` সংখ্যার `

  • টেনসারের প্রতিটি স্কেলারে স্কেলার যুক্ত করে এবং যোগফল উত্পাদন করে।

    ঘোষণা

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

  • টেনসারের প্রতিটি স্কেলারে স্কেলার যুক্ত করে এবং যোগফল উত্পাদন করে।

    ঘোষণা

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

  • টেনসরের প্রতিটি স্কেলার থেকে স্কেলারটি বিয়োগ করে এবং পার্থক্য তৈরি করে।

    ঘোষণা

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

  • টেনসরের প্রতিটি স্কেলার থেকে স্কেলারটি বিয়োগ করে এবং পার্থক্য তৈরি করে

    ঘোষণা

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

  • দুটি টেনার যুক্ত করে এবং ফলাফলটি বাম-হাতের ভেরিয়েবলের মধ্যে সঞ্চয় করে।

    বিঃদ্রঃ

    += সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • টেনসারের প্রতিটি স্কেলারে স্কেলার যুক্ত করে এবং ফলাফলটি বাম-হাতের ভেরিয়েবলের মধ্যে সঞ্চয় করে।

    ঘোষণা

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

  • প্রথম থেকে দ্বিতীয় টেনসর বিয়োগ করে এবং ফলাফলটি বাম-হাতের ভেরিয়েবলের মধ্যে সঞ্চয় করে।

    বিঃদ্রঃ

    -= সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • টেনসরের প্রতিটি স্কেলার থেকে স্কেলারটি বিয়োগ করে এবং ফলাফলটি বাম-হাতের ভেরিয়েবলের মধ্যে সঞ্চয় করে।

    ঘোষণা

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

  • দুটি টেনারকে গুণ করে উত্পাদিত টেনসরকে ফিরিয়ে দেয়।

    বিঃদ্রঃ

    * সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • টেনসরের প্রতিটি স্কেলারের সাথে এটি গুণ করে টেনসরকে ফিরিয়ে দেয়।

    ঘোষণা

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

  • টেনসারের প্রতিটি স্কেলারের সাথে স্কেলারকে গুণ করে এবং পণ্য উত্পাদন করে।

    ঘোষণা

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

  • দুটি টেনারকে গুণ করে এবং ফলাফলটি বাম-হাতের ভেরিয়েবলটিতে সঞ্চয় করে।

    বিঃদ্রঃ

    *= সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • স্কেলারের সাথে টেনসরকে গুণ করে, স্কেলারটি সম্প্রচার করে এবং ফলাফলটি বাম-হাতের ভেরিয়েবলের মধ্যে সঞ্চয় করে।

    ঘোষণা

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

  • দ্বিতীয় দ্বারা প্রথম টেনসরকে বিভক্ত করার ভাগফলকে ফিরিয়ে দেয়।

    বিঃদ্রঃ

    / সম্প্রচার সমর্থন।

    ঘোষণা

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

  • স্কেলারটি সম্প্রচার করে স্কেলার দ্বারা স্কেলারকে বিভক্ত করার ভাগফলকে ফিরিয়ে দেয়।

    ঘোষণা

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

  • স্কেলার দ্বারা স্কেলারটি সম্প্রচার করে টেনসরকে বিভক্ত করার ভাগফলকে ফিরিয়ে দেয়।

    ঘোষণা

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

  • প্রথম টেনসরকে দ্বিতীয় দ্বারা বিভক্ত করে এবং বাম-হাতের ভেরিয়েবলের মধ্যে ভাগফলকে সঞ্চয় করে।

    ঘোষণা

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

  • স্কেলার দ্বারা টেনসরকে বিভক্ত করে, স্কেলারটি সম্প্রচার করে এবং বাম-হাতের ভেরিয়েবলের মধ্যে ভাগফলকে সঞ্চয় করে।

    ঘোষণা

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

  • দ্বিতীয় দ্বারা প্রথম টেনসরকে বিভক্ত করার বাকী অংশগুলি প্রদান করে।

    বিঃদ্রঃ

    % সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • স্কেলার দ্বারা স্কেলারটি সম্প্রচার করে টেনসরকে বিভক্ত করার বাকী অংশগুলি প্রদান করে।

    ঘোষণা

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

  • স্কেলার দ্বারা স্কেলারটি বিভক্ত করার বাকী অংশগুলি স্কেলার সম্প্রচার করে।

    ঘোষণা

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

  • প্রথম টেনসরকে দ্বিতীয় দ্বারা বিভক্ত করে এবং বাকী অংশগুলি বাম-হাতের ভেরিয়েবলটিতে সঞ্চয় করে।

    ঘোষণা

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

  • স্কেলার দ্বারা টেনসরকে বিভক্ত করে এবং বাকীগুলি বাম-হাতের ভেরিয়েবলের মধ্যে সঞ্চয় করে।

    ঘোষণা

    public static func %= (lhs: inout Tensor, rhs: Scalar)
যেখানে `স্কেলার` ==` বুল` উপলভ্য
যেখানে `স্কেলার`:` টেনসরফ্লাউনউমারিকু `উপলভ্য
যেখানে `স্কেলার`:` স্বাক্ষরিত

  • নির্দিষ্ট টেনসর উপাদান ভিত্তিক অবহেলা প্রদান করে।

    ঘোষণা

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
উপলব্ধ যেখানে `স্কেলার`:` সংখ্যার `
যেখানে `স্কেলার`:` টেনসরফ্লোফ্লোয়েটিংপয়েন্ট `উপলভ্য

  • x এর উপাদানগুলি সীমাবদ্ধ তা নির্দেশ করে একটি বুলিয়ান টেনসরকে ফিরিয়ে দেয়।

    ঘোষণা

    public var isFinite: Tensor<Bool> { get }

  • x এর কোন উপাদানগুলি অসীম তা নির্দেশ করে একটি বুলিয়ান টেনসর প্রদান করে।

    ঘোষণা

    public var isInfinite: Tensor<Bool> { get }

  • x এর কোন উপাদানগুলি ন্যান-মূল্যবান তা নির্দেশ করে একটি বুলিয়ান টেনসর প্রদান করে।

    ঘোষণা

    public var isNaN: Tensor<Bool> { get }
যেখানে `স্কেলার` ==` বুল` উপলভ্য

  • সমস্ত স্কেলার true সমান হলে true প্রত্যাবর্তন করে। অন্যথায়, false ফেরত দেয়।

    ঘোষণা

    public func all() -> Bool

  • যদি কোনও স্কেলারগুলি true সমান হয় তবে true প্রত্যাবর্তন করে। অন্যথায়, false ফেরত দেয়।

    ঘোষণা

    public func any() -> Bool

  • নির্দিষ্ট অক্ষগুলি বরাবর একটি যৌক্তিক এবং অপারেশন সম্পাদন করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর একটি যৌক্তিক এবং অপারেশন সম্পাদন করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর একটি যৌক্তিক এবং অপারেশন সম্পাদন করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর একটি যৌক্তিক বা অপারেশন সম্পাদন করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

যেখানে `স্কেলার`:` সংখ্যার & `তুলনামূলক` উপলভ্য

  • ঘোষণা

    @differentiable
public func min() -> Tensor

  • ঘোষণা

    @differentiable
public func max() -> Tensor

  • নির্দিষ্ট অক্ষ বরাবর সর্বাধিক মান প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বাধিক মান প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বাধিক মান প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন মানগুলি প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন মানগুলি প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন মানগুলি প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে সর্বাধিক মানের সূচকগুলি ফেরত দেয়। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে ন্যূনতম মানগুলির সূচকগুলি প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর সর্বনিম্ন ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • সমতল স্কেলারগুলির সর্বাধিক মানের সূচকটি ফেরত দেয়।

    ঘোষণা

    public func argmax() -> Tensor<Int32>

  • সমতল স্কেলারগুলির সর্বনিম্ন মানের সূচকটি প্রদান করে।

    ঘোষণা

    public func argmin() -> Tensor<Int32>
উপলব্ধ যেখানে `স্কেলার`:` সংখ্যার `

  • নির্দিষ্ট অক্ষ বরাবর যোগফল প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর যোগফল প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর যোগফল প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • ঘোষণা

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

  • নির্দিষ্ট অক্ষ বরাবর যোগফল প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর যোগফল প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর যোগফল প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর পণ্য প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর পণ্য প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর পণ্য প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • ঘোষণা

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

  • নির্দিষ্ট অক্ষ বরাবর পণ্য প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর পণ্য প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর পণ্য প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে গাণিতিক গড়টি ফেরত দেয়। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে গাণিতিক গড়টি ফেরত দেয়। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে গাণিতিক গড়টি ফেরত দেয়। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank...rank থাকতে হবে।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • ঘোষণা

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

  • নির্দিষ্ট অক্ষগুলির সাথে গাণিতিক গড়টি ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে গাণিতিক গড়টি ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে গাণিতিক গড়টি ফেরত দেয়। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা সরানো হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা সরানো হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রাগুলি মান 1 দিয়ে ধরে রাখা হয় বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • ঘোষণা

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

  • নির্দিষ্ট অক্ষ বরাবর বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রাগুলি মান 1 দিয়ে ধরে রাখা হয় বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রাগুলি মান 1 দিয়ে ধরে রাখা হয় বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রাগুলি মান 1 দিয়ে ধরে রাখা হয় বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষ বরাবর এই টেনসারের সংশ্লেষিত যোগফলটি ফিরিয়ে দেয়। ডিফল্টরূপে, এই ফাংশনটি একটি অন্তর্ভুক্তিমূলক সমষ্টি সম্পাদন করে যার অর্থ ইনপুটটির প্রথম উপাদানটি আউটপুটটির প্রথম উপাদানটির সাথে সমান:

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

    true exclusive যুক্তি সেট করে, পরিবর্তে একটি একচেটিয়া ক্রমবর্ধমান যোগফল সম্পাদিত হয়:

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

    reverse যুক্তিটিকে true সেট করে, সংশ্লেষিত যোগফলটি বিপরীত দিকে সঞ্চালিত হয়:

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

    এটি ফলাফলের টেনসরকে আলাদাভাবে বিপরীত করার চেয়ে আরও দক্ষ।

    পূর্বশর্ত

    axis অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axis

    অক্ষ যা বরাবর ক্রমবর্ধমান সমষ্টি অপারেশন সম্পাদন করতে হবে।

    exclusive

    একচেটিয়া সংশ্লেষিত যোগফল সম্পাদন করবেন কিনা তা নির্দেশ করে।

    reverse

    বিপরীত ক্রমে ক্রমবর্ধমান যোগফল সম্পাদন করবেন কিনা তা নির্দেশ করে।

    ফেরত মূল্য

    ক্রমবর্ধমান সমষ্টি অপারেশনের ফলাফল।

  • নির্দিষ্ট অক্ষ বরাবর এই টেনসারের সংশ্লেষিত যোগফলটি ফিরিয়ে দেয়। ডিফল্টরূপে, এই ফাংশনটি একটি অন্তর্ভুক্তিমূলক সমষ্টি সম্পাদন করে যার অর্থ ইনপুটটির প্রথম উপাদানটি আউটপুটটির প্রথম উপাদানটির সাথে সমান:

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

    true exclusive যুক্তি সেট করে, পরিবর্তে একটি একচেটিয়া ক্রমবর্ধমান যোগফল সম্পাদিত হয়:

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

    reverse যুক্তিটিকে true সেট করে, সংশ্লেষিত যোগফলটি বিপরীত দিকে সঞ্চালিত হয়:

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

    এটি ফলাফলের টেনসরকে আলাদাভাবে বিপরীত করার চেয়ে আরও দক্ষ।

    পূর্বশর্ত

    axis.rank অবশ্যই 0 হতে হবে।

    পূর্বশর্ত

    axis অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axis

    অক্ষ যা বরাবর ক্রমবর্ধমান সমষ্টি অপারেশন সম্পাদন করতে হবে।

    exclusive

    একচেটিয়া সংশ্লেষিত যোগফল সম্পাদন করবেন কিনা তা নির্দেশ করে।

    reverse

    বিপরীত ক্রমে ক্রমবর্ধমান যোগফল সম্পাদন করবেন কিনা তা নির্দেশ করে।

    ফেরত মূল্য

    ক্রমবর্ধমান সমষ্টি অপারেশনের ফলাফল।

  • নির্দিষ্ট অক্ষ বরাবর এই টেনসারের ক্রমবর্ধমান পণ্যটি ফেরত দেয়। ডিফল্টরূপে, এই ফাংশনটি একটি অন্তর্ভুক্তিমূলক পণ্য সম্পাদন করে যার অর্থ ইনপুটটির প্রথম উপাদানটি আউটপুটটির প্রথম উপাদানটির সাথে সমান:

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

    true exclusive যুক্তি সেট করে, পরিবর্তে একটি একচেটিয়া ক্রমযুক্ত পণ্য সঞ্চালিত হয়:

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

    reverse যুক্তিটিকে true সেট করে, সংশ্লেষিত পণ্যটি বিপরীত দিকে সঞ্চালিত হয়:

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

    এটি ফলাফলের টেনসরকে আলাদাভাবে বিপরীত করার চেয়ে আরও দক্ষ।

    পূর্বশর্ত

    axis অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axis

    অক্ষটি যার সাথে ক্রমবর্ধমান পণ্য অপারেশন সম্পাদন করতে হবে।

    exclusive

    একচেটিয়া ক্রমযুক্ত পণ্য সম্পাদন করবেন কিনা তা নির্দেশ করে।

    reverse

    বিপরীত ক্রমে ক্রমবর্ধমান পণ্য সম্পাদন করবেন কিনা তা নির্দেশ করে।

    ফেরত মূল্য

    ক্রমবর্ধমান পণ্য অপারেশনের ফলাফল।

  • নির্দিষ্ট অক্ষ বরাবর এই টেনসারের ক্রমবর্ধমান পণ্যটি ফেরত দেয়। ডিফল্টরূপে, এই ফাংশনটি একটি অন্তর্ভুক্তিমূলক পণ্য সম্পাদন করে যার অর্থ ইনপুটটির প্রথম উপাদানটি আউটপুটটির প্রথম উপাদানটির সাথে সমান:

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

    true exclusive যুক্তি সেট করে, পরিবর্তে একটি একচেটিয়া ক্রমযুক্ত পণ্য সঞ্চালিত হয়:

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

    reverse যুক্তিটিকে true সেট করে, সংশ্লেষিত পণ্যটি বিপরীত দিকে সঞ্চালিত হয়:

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

    এটি ফলাফলের টেনসরকে আলাদাভাবে বিপরীত করার চেয়ে আরও দক্ষ।

    পূর্বশর্ত

    axis 0 র‌্যাঙ্ক থাকতে হবে।

    পূর্বশর্ত

    axis অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axis

    অক্ষটি যার সাথে ক্রমবর্ধমান পণ্য অপারেশন সম্পাদন করতে হবে।

    exclusive

    একচেটিয়া ক্রমযুক্ত পণ্য সম্পাদন করবেন কিনা তা নির্দেশ করে।

    reverse

    বিপরীত ক্রমে ক্রমবর্ধমান পণ্য সম্পাদন করবেন কিনা তা নির্দেশ করে।

    ফেরত মূল্য

    ক্রমবর্ধমান পণ্য অপারেশনের ফলাফল।

যেখানে `স্কেলার`:` টেনসরফ্লোফ্লোয়েটিংপয়েন্ট `উপলভ্য

  • নির্দিষ্ট অক্ষগুলির সাথে উপাদানগুলির স্ট্যান্ডার্ড বিচ্যুতি প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে উপাদানগুলির স্ট্যান্ডার্ড বিচ্যুতি প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে উপাদানগুলির স্ট্যান্ডার্ড বিচ্যুতি প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • এই টেনসারে সমস্ত উপাদানগুলির মান বিচ্যুতি প্রদান করে। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

  • নির্দিষ্ট অক্ষগুলির সাথে উপাদানগুলির স্ট্যান্ডার্ড বিচ্যুতি প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে উপাদানগুলির স্ট্যান্ডার্ড বিচ্যুতি প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলির সাথে উপাদানগুলির স্ট্যান্ডার্ড বিচ্যুতি প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়। বেসেলের সংশোধন প্রয়োগ করে না।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • রিটার্নস log(exp(self).sum(squeezingAxes: axes)) । হ্রাস মাত্রা সরানো হয়।

    এই ফাংশনটি সরাসরি কম্পিউটিং log(exp(self).sum(squeezingAxes: axes)) । এটি ছোট ইনপুটগুলির log কম্পিউটিংয়ের মাধ্যমে বৃহত ইনপুট এবং আন্ডারফ্লোগুলির exp গণনা করার ফলে ওভারফ্লোগুলি এড়িয়ে যায়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • রিটার্নস log(exp(self).sum(squeezingAxes: axes)) । হ্রাস মাত্রা সরানো হয়।

    এই ফাংশনটি সরাসরি কম্পিউটিং log(exp(self).sum(squeezingAxes: axes)) । এটি ছোট ইনপুটগুলির log কম্পিউটিংয়ের মাধ্যমে বৃহত ইনপুট এবং আন্ডারফ্লোগুলির exp গণনা করার ফলে ওভারফ্লোগুলি এড়িয়ে যায়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • রিটার্নস log(exp(self).sum(squeezingAxes: axes)) । হ্রাস মাত্রা সরানো হয়।

    এই ফাংশনটি সরাসরি কম্পিউটিং log(exp(self).sum(squeezingAxes: axes)) । এটি ছোট ইনপুটগুলির log কম্পিউটিংয়ের মাধ্যমে বৃহত ইনপুট এবং আন্ডারফ্লোগুলির exp গণনা করার ফলে ওভারফ্লোগুলি এড়িয়ে যায়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • রিটার্নস log(exp(self).sum()) । ফলাফল একটি স্কেলার।

    এই ফাংশনটি সরাসরি কম্পিউটিং log(exp(self).sum()) এর চেয়ে বেশি সংখ্যার স্থিতিশীল। এটি ছোট ইনপুটগুলির log কম্পিউটিংয়ের মাধ্যমে বৃহত ইনপুট এবং আন্ডারফ্লোগুলির exp গণনা করার ফলে ওভারফ্লোগুলি এড়িয়ে যায়।

    ঘোষণা

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

  • রিটার্নস log(exp(self).sum(alongAxes: axes)) । হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    এই ফাংশনটি সরাসরি কম্পিউটিং log(exp(self).sum(alongAxes: axes)) । এটি ছোট ইনপুটগুলির log কম্পিউটিংয়ের মাধ্যমে বৃহত ইনপুট এবং আন্ডারফ্লোগুলির exp গণনা করার ফলে ওভারফ্লোগুলি এড়িয়ে যায়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • রিটার্নস log(exp(self).sum(alongAxes: axes)) । হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    এই ফাংশনটি সরাসরি কম্পিউটিং log(exp(self).sum(alongAxes: axes)) । এটি ছোট ইনপুটগুলির log কম্পিউটিংয়ের মাধ্যমে বৃহত ইনপুট এবং আন্ডারফ্লোগুলির exp গণনা করার ফলে ওভারফ্লোগুলি এড়িয়ে যায়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • রিটার্নস log(exp(self).sum(alongAxes: axes)) । হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    এই ফাংশনটি সরাসরি কম্পিউটিং log(exp(self).sum(alongAxes: axes)) । এটি ছোট ইনপুটগুলির log কম্পিউটিংয়ের মাধ্যমে বৃহত ইনপুট এবং আন্ডারফ্লোগুলির exp গণনা করার ফলে ওভারফ্লোগুলি এড়িয়ে যায়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর এই টেনসারের গড় এবং বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes অবশ্যই 1 র‌্যাঙ্ক থাকতে হবে।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর এই টেনসারের গড় এবং বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর এই টেনসারের গড় এবং বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা সরানো হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • এই টেনসারের উপাদানগুলির গড় এবং বৈকল্পিকতা প্রদান করে।

    ঘোষণা

    @differentiable(wrt: self)
public func moments() -> Moments<Scalar>

  • নির্দিষ্ট অক্ষগুলি বরাবর এই টেনসারের গড় এবং বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes অবশ্যই 1 র‌্যাঙ্ক থাকতে হবে।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর এই টেনসারের গড় এবং বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

  • নির্দিষ্ট অক্ষগুলি বরাবর এই টেনসারের গড় এবং বৈকল্পিকতা প্রদান করে। হ্রাস মাত্রা মান 1 দিয়ে ধরে রাখা হয়।

    পূর্বশর্ত

    axes প্রতিটি মান অবশ্যই রেঞ্জ -rank..<rank ।

    ঘোষণা

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

    পরামিতি

    axes

    মাত্রা কমাতে.

উপলব্ধ যেখানে `স্কেলার`:` সংখ্যার `

  • দুটি টেনসারের মধ্যে ম্যাট্রিক্স গুণনা সম্পাদন করে এবং ফলাফল তৈরি করে।

    ঘোষণা

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
যেখানে `স্কেলার`:` টেনসরফ্লোফ্লোয়েটিংপয়েন্ট `উপলভ্য

  • ঘোষণা

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

  • নির্দিষ্ট অক্ষের সাথে ইনপুটটি ব্যাচ-নরমালাইজিং থেকে গণনা করা একটি টেনসরকে ফেরত দেয়।

    বিশেষত, রিটার্নস (self - mu) / (var + epsilon) * gamma + beta যেখানে mu এবং var যথাক্রমে axis সাথে self -গড় এবং বৈচিত্র।

    ঘোষণা

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

    পরামিতি

    axis

    ব্যাচের মাত্রা।

    offset

    অফসেট, বিটা নামেও পরিচিত।

    scale

    স্কেল, গামা নামেও পরিচিত।

    epsilon

    সংখ্যার স্থায়িত্বের জন্য ডিনোমিনেটরে যুক্ত একটি ছোট মান।

  • শেষ অক্ষ বরাবর দুটি টেনারকে একত্রিত করে।

    ঘোষণা

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

  • দুটি মান যুক্ত করে এবং তাদের যোগফল উত্পাদন করে।

    ঘোষণা

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

  • গড় দুটি মান।

    ঘোষণা

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

  • দুটি মান গুণ করে।

    ঘোষণা

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

  • দুটি মান স্ট্যাক।

    ঘোষণা

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

  • ঘোষণা

    @derivative
init(shape: scalars)
যেখানে `স্কেলার`:` সমানযোগ্য `

  • ঘোষণা

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

  • ঘোষণা

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
যেখানে `স্কেলার`:` কোডেবল` উপলভ্য
উপলব্ধ যেখানে `স্কেলার`:` সংখ্যার `

  • স্কেলার জিরো টেনসর।

  • ঘোষণা

    public static var zero: Tensor { get }

  • দুটি টেনার যুক্ত করে এবং তাদের যোগফল উত্পাদন করে।

    বিঃদ্রঃ

    + সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • অন্য থেকে একটি টেনসর বিয়োগ করে এবং তাদের পার্থক্য তৈরি করে।

    বিঃদ্রঃ

    - সম্প্রচার সমর্থন করে।

    ঘোষণা

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

  • স্কেলার ওয়ান টেনসর।

    ঘোষণা

    public static var one: Tensor { get }

  • স্ব- self -স্ব-স্বীকৃতি প্রদান করে।

    ঘোষণা

    public var reciprocal: Tensor { get }

  • দুটি টেনসর উপাদান-ভিত্তিক গুণ করে এবং তাদের পণ্য উত্পাদন করে।

    বিঃদ্রঃ

    .* সম্প্রচার সমর্থন করে।

    ঘোষণা

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
যেখানে `স্কেলার`:` টেনসরফ্লোফ্লোয়েটিংপয়েন্ট `উপলভ্য

  • ঘোষণা

    public typealias TangentVector = Tensor

  • ঘোষণা

    public var zeroTangentVectorInitializer: () -> TangentVector { get }

  • একটি টীকা যোগ করে।

    দ্রষ্টব্য: কেবল এক্স 10 সমর্থিত। অন্যান্য ব্যাকেন্ডের জন্য, উমোডাইফাইড self ফিরে আসে।

    ঘোষণা

    @differentiable(wrt: self)
public func annotate(_ annotation: String) -> Tensor<Scalar>

    পরামিতি

    annotation

    টীকা যুক্ত করা হবে।

    ফেরত মূল্য

    টীকাযুক্ত টেনসর।

  • ঘোষণা

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