تانسور

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
extension Tensor: TensorProtocol
l10n-placeholdern10n-
extension Tensor: TensorGroup
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
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
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 در آرایه برگشتی، self[i, :, :, :] و هر تانسور در آن آرایه شکل [B, C, D] خواهد داشت. (توجه داشته باشید که بر خلاف Tensor.split(numSplits:alongAxis) یا Tensor.split(sizes:alongAxis) بعد باز شده در امتداد از بین رفته است).
    • اگر axis == 1 باشد، تانسور i امین آرایه برگشتی value[:, i, :, :] و هر تانسور در آن آرایه شکل [A, C, D] خواهد داشت.
    • و غیره.

    این برعکس Tensor.init(stacking:alongAxis:) است.

    پیش شرط

    axis باید در محدوده [-rank, rank) باشد، که در آن rank ، رتبه تانسورهای ارائه شده است.

    اعلام

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

    مولفه های

    axis

    ابعادی که در امتداد آن باید باز شود. ارزش های منفی دور هم جمع می شوند.

    ارزش بازگشتی

    آرایه حاوی تانسورهای بدون پشته.

  • یک تانسور را به چند تانسور تقسیم می کند. تانسور در axis ابعاد به count تانسورهای کوچکتر تقسیم می شود. این مستلزم آن است که count به طور مساوی shape[axis] را تقسیم کند.

    مثلا:

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

    پیش شرط

    count باید اندازه axis ابعاد را به طور مساوی تقسیم کند.

    پیش شرط

    axis باید در محدوده [-rank, rank) باشد، که در آن rank ، رتبه تانسورهای ارائه شده است.

    اعلام

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

    مولفه های

    count

    تعداد تقسیم برای ایجاد.

    axis

    ابعادی که در امتداد آن این تانسور تقسیم می شود. ارزش های منفی دور هم جمع می شوند.

    ارزش بازگشتی

    آرایه ای حاوی بخش تانسورها.

  • یک تانسور را به چند تانسور تقسیم می کند. تانسور به قطعات sizes.shape[0] تقسیم می شود. شکل قطعه i همان شکل این تانسور است به جز در امتداد axis بعد که اندازه آن sizes[i] است.

    مثلا:

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

    پیش شرط

    مقادیر در sizes باید به اندازه axis ابعاد جمع شوند.

    پیش شرط

    axis باید در محدوده [-rank, rank) باشد، که در آن rank ، رتبه تانسورهای ارائه شده است.

    اعلام

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

    مولفه های

    sizes

    تانسور 1 بعدی حاوی اندازه هر تقسیم.

    axis

    ابعادی که در امتداد آن این تانسور تقسیم می شود. ارزش های منفی دور هم جمع می شوند.

    ارزش بازگشتی

    آرایه حاوی قطعات تانسور.

  • اعلام

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

  • یک تانسور کاشی شده را برمی‌گرداند که با کاشی کاری این تانسور ساخته شده است.

    این سازنده با تکرار multiples بار این تانسور یک تانسور جدید ایجاد می کند. بعد i تانسور ساخته شده دارای عناصر self.shape[i] * multiples[i] است، و مقادیر این تانسور multiples[i] در امتداد بعد 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] است، و مقادیر این تانسور multiples[i] در امتداد بعد 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

  • یک کپی از تانسور جمع شده را به ترتیب ردیف اصلی به یک Tensor 1 بعدی برگردانید.

    اعلام

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

  • یک Tensor منبسط شده را برمی‌گرداند که بعد 1 در شاخص‌های شکل مشخص شده درج شده است.

    اعلام

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

  • یک Tensor منبسط شده را برمی‌گرداند که بعد 1 در شاخص‌های شکل مشخص شده درج شده است.

    اعلام

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

  • یک Tensor با رتبه بالا را با بعد پیشرو 1 برمی‌گرداند.

    اعلام

    @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

  • عملگر الحاق.

    توجه داشته باشید

    ++ یک اپراتور سفارشی است که در سوئیفت وجود ندارد، اما در Haskell/Scala وجود دارد. افزودن آن یک تغییر زبانی ناچیز نیست و ممکن است بحث برانگیز باشد. وجود/نامگذاری ++ در مرحله بعدی طراحی API مورد بحث قرار خواهد گرفت.

    اعلام

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

  • با جمع‌آوری برش‌هایی از ورودی در indices در امتداد بعد axis ، یک تانسور را برمی‌گرداند

    برای indices 0-D (اسکالار):

    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}]

    برای indices 1-D (بردار):

    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

    ابعادی که در امتداد آن جمع شود. ارزش های منفی دور هم جمع می شوند.

    ارزش بازگشتی

    تانسور جمع شده

  • برش هایی از این تانسور را در indices در امتداد axis برمی گرداند، در حالی که اولین ابعاد batchDimensionCount را که با ابعاد دسته ای مطابقت دارند نادیده می گیرد. جمع آوری در امتداد اولین بعد غیر دسته ای انجام می شود.

    عملکردی مشابه gathering را انجام می‌دهد، با این تفاوت که شکل تانسور حاصل اکنون shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] است.

    پیش شرط

    axis باید در محدوده -rank..<rank باشد و در عین حال بزرگتر یا مساوی batchDimensionCount باشد.

    پیش شرط

    batchDimensionCount باید کمتر از indices.rank باشد.

    اعلام

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

    مولفه های

    indices

    شامل شاخص هایی برای جمع آوری است.

    axis

    ابعادی که در امتداد آن جمع شود. ارزش های منفی دور هم جمع می شوند.

    batchDimensionCount

    تعداد ابعاد دسته اصلی که باید نادیده گرفته شوند.

    ارزش بازگشتی

    تانسور جمع شده

  • با جمع آوری مقادیر پس از اعمال ماسک بولی ارائه شده به ورودی، یک تانسور را برمی گرداند.

    مثلا:

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

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

    به طور کلی، 0 < mask.rank = K <= tensor.rank ، و شکل mask باید با اولین ابعاد K شکل tensor مطابقت داشته باشد. سپس داریم: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] [i1, ..., iK] i ورودی true mask (ترتیب ردیف اصلی) است.

    این axis می‌توان با mask برای نشان دادن محوری که باید از آن پوشانده شود استفاده کرد. در این صورت، axis + mask.rank <= tensor.rank و شکل mask 's shape must match the first dimensions of the محور اول + mask.rank شکل تانسور مطابقت داشته باشد.

    پیش شرط

    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) تانسور -بعدی پر شده توسط ورودی های این تانسور مربوط به مقادیر true در mask .

  • مکان مقادیر غیرصفر / واقعی را در این تانسور برمی‌گرداند.

    مختصات در یک تانسور دو بعدی بازگردانده می شوند که در آن بعد اول (ردیف ها) تعداد عناصر غیر صفر را نشان می دهد و بعد دوم (ستون ها) مختصات عناصر غیر صفر را نشان می دهد. به خاطر داشته باشید که شکل تانسور خروجی بسته به تعداد مقادیر واقعی در این تانسور می تواند متفاوت باشد. شاخص ها به ترتیب ردیف اصلی خروجی می شوند.

    مثلا:

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

  • کپی other را در Device داده شده ایجاد می کند.

    اعلام

    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

    ابعادی که در امتداد آن انباشته شود. ارزش های منفی دور هم جمع می شوند.

    ارزش بازگشتی

    تانسور انباشته.

  • tensors در امتداد بعد axis به هم متصل می کند.

    با توجه به اینکه 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 باشد یا یک Tensor 1 بعدی باشد به طوری که mask.scalarCount == self.shape[0] .

    اعلام

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

  • اگر دقت نوع اسکالر فیزیکی کاهش یابد، مقدار true را برمی‌گرداند.

    در حال حاضر، انواع اسکالر فیزیکی با دقت کاهش یافته فقط شامل BFloat16 است.

    اعلام

    public var isReducedPrecision: Bool { get }

  • یک اسکالر را با همان دستگاه و دقت تانسور داده شده به یک تانسور ارتقا می دهد.

    اعلام

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

  • یک کپی از self تبدیل شده به نوع اسکالر فیزیکی BFloat16 را برمی‌گرداند.

    اعلام

    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 باشد 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)

  • یک تانسور 1 بعدی از اسکالرها ایجاد می کند.

    اعلام

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

  • یک تانسور 1 بعدی از اسکالرها ایجاد می کند.

    اعلام

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

  • یک تانسور با شکل مشخص شده و اسکالرهای پیوسته به ترتیب ردیف اصلی ایجاد می کند.

    پیش شرط

    حاصل ضرب ابعاد شکل باید برابر با تعداد اسکالرها باشد.

    اعلام

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

    مولفه های

    shape

    شکل تانسور.

    scalars

    محتویات اسکالر تانسور.

  • یک تانسور با شکل مشخص شده و اسکالرهای پیوسته به ترتیب ردیف اصلی ایجاد می کند.

    پیش شرط

    حاصل ضرب ابعاد شکل باید برابر با تعداد اسکالرها باشد.

    اعلام

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

    مولفه های

    shape

    شکل تانسور.

    scalars

    محتویات اسکالر تانسور.

  • یک تانسور با شکل مشخص شده و اسکالرهای پیوسته به ترتیب ردیف اصلی ایجاد می کند.

    پیش شرط

    حاصل ضرب ابعاد شکل باید برابر با تعداد اسکالرها باشد.

  • یک تانسور با شکل مشخص شده و اسکالرهای پیوسته به ترتیب ردیف اصلی ایجاد می کند.

    پیش شرط

    حاصل ضرب ابعاد شکل باید برابر با تعداد اسکالرها باشد.

    اعلام

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

    مولفه های

    shape

    شکل تانسور.

    scalars

    محتویات اسکالر تانسور.

  • نوع عناصر یک آرایه به معنای واقعی کلمه.

    اعلام

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

  • یک تانسور اولیه با عناصر داده شده ایجاد می کند.

    اعلام

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

  • نمایش متنی تانسور.

    توجه داشته باشید

    از fullDescription برای توصیفی غیر زیبا که همه اسکالرها را نشان می دهد استفاده کنید.

    اعلام

    public var description: String { get }

  • نمایش متنی تانسور. اگر summarize درست باشد و تعداد عناصر از دو برابر edgeElementCount بیشتر شود، توضیحات خلاصه شده را برمی گرداند.

    اعلام

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

    مولفه های

    lineWidth

    حداکثر عرض خط برای چاپ برای تعیین تعداد اسکالرها برای چاپ در هر خط استفاده می شود.

    edgeElementCount

    حداکثر تعداد عناصر برای چاپ قبل و بعد از خلاصه سازی از طریق بیضی ( ... ).

    summarizing

    اگر درست است، اگر تعداد عناصر از دو برابر edgeElementCount بیشتر شد، توضیحات را خلاصه کنید.

  • یک نمایش متنی کامل و غیر زیبا از تانسور که همه اسکالرها را نشان می‌دهد.

    اعلام

    public var fullDescription: String { get }

  • اعلام

    public var playgroundDescription: Any { get }

  • اعلام

    public var customMirror: Mirror { get }

  • حاشیه نویسی که این تانسور را توصیف می کند.

    اعلام

    public var annotations: String { get }

  • نام مستعار برای حاشیه نویسی.

    اعلام

    public var summary: String { get }

  • اعلام

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

  • اعلام

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

  • اعلام

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

  • اعلام

    init(_xla: XLATensor)

  • اعلام

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

  • اعلام

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

  • اعلام

    var xlaTensor: XLATensor { get }
موجود در جایی که 'Scalar': 'Numeric'

  • اعلام

    @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
موجود در جایی که 'Scalar': 'Numeric' & 'Comparable'

  • با محاسبه 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': 'Equatable'

  • با محاسبه 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 بعدی ایجاد می کند که دنباله ای را از یک مقدار شروع به یک مقدار پایانی نشان می دهد، اما شامل آن نمی شود، با گام برداشتن به مقدار مشخص.

    اعلام

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

    مولفه های

    start

    مقدار شروعی که برای دنباله استفاده می شود. اگر دنباله حاوی مقادیری باشد، اولین مورد start است.

    end

    یک مقدار پایانی برای محدود کردن توالی. end هرگز عنصری از دنباله حاصل نیست.

    stride

    مقداری که باید با هر تکرار گام به گام بردارید. stride باید مثبت باشد

  • یک تانسور 1 بعدی ایجاد می کند که دنباله ای را از یک مقدار شروع به یک مقدار پایانی نشان می دهد، اما شامل آن نمی شود، با گام برداشتن به مقدار مشخص.

    اعلام

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

    مولفه های

    start

    مقدار شروعی که برای دنباله استفاده می شود. اگر دنباله حاوی مقادیری باشد، اولین مورد start است.

    end

    یک مقدار پایانی برای محدود کردن توالی. end هرگز عنصری از دنباله حاصل نیست.

    stride

    مقداری که باید با هر تکرار گام به گام بردارید. stride باید مثبت باشد

  • یک تانسور یک داغ در شاخص های داده شده ایجاد می کند. مکان های نشان داده شده توسط indices مقدار onValue دریافت می کنند (به طور پیش فرض 1 )، در حالی که همه مکان های دیگر مقدار offValue را دریافت می کنند (به طور پیش فرض 0 ). اگر indices ورودی رتبه n باشد، تانسور جدید دارای رتبه n+1 خواهد بود. محور جدید در axis بعد ایجاد می شود (به طور پیش فرض، محور جدید در انتها اضافه می شود).

    اگر indices اسکالر باشند، شکل تانسور جدید بردار depth طول خواهد بود.

    اگر indices بردار features طول باشد، شکل خروجی به این صورت خواهد بود: ویژگی x عمق، اگر محور == -1 عمق x ویژگی، اگر محور == 0 باشد.

    اگر indices یک ماتریس (دسته ای) با شکل [batch, features] باشد، شکل خروجی به این صورت خواهد بود: دسته x ویژگی x عمق، اگر محور == -1 دسته x عمق x ویژگی، اگر محور == 1 عمق x دسته x ویژگی ، اگر محور == 0 باشد

    اعلام

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

    مولفه های

    indices

    Tensor شاخص ها

    depth

    اسکالری که عمق یک بعد داغ را مشخص می کند.

    onValue

    یک اسکالر که مقدار را در مکانی که توسط برخی از شاخص ها در indices به آن اشاره می شود، تعیین می کند.

    offValue

    یک اسکالر که مقدار را در مکانی تعریف می کند که توسط هیچ شاخصی در indices به آن اشاره نمی شود.

    axis

    محوری که باید پر شود. پیش‌فرض -1 است، یک محور جدید.

در جایی که 'Scalar': 'TensorFlowFloatingPoint' موجود است

  • یک تانسور 1 بعدی ایجاد می کند که دنباله ای را از یک مقدار شروع، تا و شامل یک مقدار پایانی نشان می دهد، با فاصله مساوی برای تولید تعداد مقادیر مشخص شده.

    اعلام

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

    مولفه های

    start

    مقدار شروعی که برای دنباله استفاده می شود. اگر دنباله حاوی مقادیری باشد، اولین مورد start است.

    end

    یک مقدار پایانی برای محدود کردن توالی. end آخرین عنصر از دنباله به دست آمده است.

    count

    تعداد مقادیر در دنباله به دست آمده. count باید مثبت باشد

  • یک تانسور 1 بعدی ایجاد می کند که دنباله ای را از یک مقدار شروع، تا و شامل یک مقدار پایانی نشان می دهد، با فاصله مساوی برای تولید تعداد مقادیر مشخص شده.

    پیش شرط

    start ، to ، و count باید تانسورهایی باشند که دارای یک مقدار اسکالر واحد باشند.

    اعلام

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

    مولفه های

    start

    مقدار شروعی که برای دنباله استفاده می شود. اگر دنباله حاوی مقادیری باشد، اولین مورد start است.

    end

    یک مقدار پایانی برای محدود کردن توالی. end آخرین عنصر از دنباله به دست آمده است.

    count

    تعداد مقادیر در دنباله به دست آمده. count باید مثبت باشد

موجود در جایی که '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

    ارزش دانه

  • یک تانسور با شکل مشخص شده ایجاد می کند و به طور تصادفی مقادیر اسکالر را از یک توزیع Normal کوتاه شده نمونه برداری می کند.

    اعلام

    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

    تانسور دو بعدی با شکل [batchSize, classCount] . هر تکه [i, :] نشان دهنده احتمالات گزارش غیرعادی برای همه کلاس ها است.

    sampleCount

    0-D. تعداد نمونه های مستقل برای ترسیم برای هر برش ردیف.

    seed

    ارزش دانه

    ارزش بازگشتی

    تانسور دو بعدی با شکل [batchSize, sampleCount] . هر تکه [i, :] حاوی برچسب‌های کلاس ترسیم شده با محدوده [0, classCount) است.

در جایی که 'Scalar': 'TensorFlowFloatingPoint' موجود است

  • با انجام مقداردهی اولیه Glorot (Xavier) یک تانسور با شکل مشخص شده ایجاد می کند.

    نمونه‌های تصادفی را از یک توزیع یکنواخت بین -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) یک تانسور با شکل مشخص شده ایجاد می کند.

    این نمونه‌های تصادفی را از یک توزیع نرمال کوتاه شده با مرکزیت 0 با انحراف استاندارد sqrt(2 / (fanIn + fanOut)) که توسط مولد اعداد تصادفی پیش‌فرض تولید می‌شود، می‌گیرد، که در آن 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 نشان‌دهنده تعداد ویژگی‌های ورودی ضرب در اندازه فیلد گیرنده است.

    مرجع: "نقص عمیق در یکسو کننده ها: پیشی گرفتن از عملکرد سطح انسانی در طبقه بندی ImageNet"

    اعلام

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

    مولفه های

    shape

    ابعاد تانسور.

    seed

    ارزش دانه

  • با انجام اولیه اولیه He (Kaiming) یک تانسور با شکل مشخص شده ایجاد می کند.

    این نمونه‌های تصادفی را از یک توزیع نرمال کوتاه شده با مرکزیت 0 با انحراف استاندارد sqrt(2 / fanIn)) می‌گیرد که توسط مولد اعداد تصادفی پیش‌فرض تولید می‌شود، که در آن fanIn نشان‌دهنده تعداد ویژگی‌های ورودی ضرب در اندازه میدان دریافتی است.

    مرجع: "نقص عمیق در یکسو کننده ها: پیشی گرفتن از عملکرد سطح انسانی در طبقه بندی ImageNet"

    اعلام

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

    مولفه های

    shape

    ابعاد تانسور.

    seed

    ارزش دانه

  • با انجام مقداردهی اولیه LeCun یک تانسور با شکل مشخص شده ایجاد می کند.

    این نمونه‌های تصادفی را از یک توزیع یکنواخت بین -limit و limit تولید شده توسط مولد اعداد تصادفی پیش‌فرض می‌گیرد، که در آن limit sqrt(3 / fanIn) است و fanIn تعداد ویژگی‌های ورودی را در اندازه فیلد دریافتی ضرب می‌کند.

    مرجع: "BackProp کارآمد"

    اعلام

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

    مولفه های

    shape

    ابعاد تانسور.

    seed

    ارزش دانه

  • با انجام مقداردهی اولیه LeCun، یک تانسور با شکل مشخص شده ایجاد می کند.

    این نمونه‌های تصادفی را از یک توزیع نرمال کوتاه شده با مرکز 0 با انحراف استاندارد sqrt(1 / fanIn) که توسط مولد اعداد تصادفی پیش‌فرض تولید می‌شود، می‌گیرد، که در آن fanIn تعداد ویژگی‌های ورودی ضرب در اندازه میدان پذیرنده را نشان می‌دهد.

    مرجع: "BackProp کارآمد"

    اعلام

    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

    تعداد superdiagonals برای نگه داشتن. اگر منفی بود، کل مثلث بالایی را نگه دارید.

در جایی که 'Scalar': 'TensorFlowFloatingPoint' موجود است

  • تجزیه QR هر ماتریس داخلی در تانسور، یک تانسور با ماتریس‌های متعامد داخلی q و یک تانسور با ماتریس‌های مثلثی بالایی درونی r را برمی‌گرداند، به طوری که تانسور برابر با matmul(q, r) باشد.

    اعلام

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

    مولفه های

    fullMatrices

    اگر true ، q و r را با اندازه کامل محاسبه کنید. در غیر این صورت، فقط ستون‌های min(shape[rank - 1], shape[rank - 2]) q را محاسبه کنید.

  • با توجه به اینکه self یک ماتریس دسته‌ای اختیاری است، تجزیه مقدار منفرد self را برمی‌گرداند.

    تجزیه مقدار منفرد (SVD) self ماتریس دسته‌ای اختیاری مقادیر s ، u ، و v است، به این صورت که:

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

    خود must be a tensor with shape . 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 افزایش یافته است.

    حاصلضرب n کپی از x .

    اعلام

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

  • ریشه n ام x .

    برای انواع واقعی، اگر x منفی و n زوج باشد، نتیجه NaN است. برای انواع پیچیده، یک شاخه برش در امتداد محور واقعی منفی وجود دارد.

    اعلام

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

  • اعلام

    public typealias VectorSpaceScalar = Float

  • اعلام

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

  • اعلام

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

  • اعلام

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
موجود در جایی که 'Scalar': 'Numeric'

  • اسکالر را به هر اسکالر تانسور اضافه می کند و مجموع را تولید می کند.

    اعلام

    @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)
در جایی که 'Scalar' == 'Bool' موجود است

  • از نظر عنصر !self برمی‌گرداند.

    اعلام

    public func elementsLogicalNot() -> Tensor

  • self && other عناصر را برمی‌گرداند.

    توجه داشته باشید

    && از پخش پشتیبانی می کند.

    اعلام

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor

  • برمی‌گرداند self && other عناصر بر حسب عنصر، پخش other .

    اعلام

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

  • self || other از نظر عناصر self || other

    اعلام

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

  • self || other عنصر عاقلانه، پخش other .

    اعلام

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
در جایی که 'Scalar': 'TensorFlowNumeric' موجود است
در جایی که 'Scalar': 'SignedNumeric' موجود است

  • نفی عنصر تانسور مشخص شده را از نظر عاقلانه برمی گرداند.

    اعلام

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
موجود در جایی که 'Scalar': 'Numeric'

  • اعلام

    @differentiable(wrt: self)
public func squared() -> Tensor
در جایی که 'Scalar': 'TensorFlowFloatingPoint' موجود است

  • یک تانسور بولی را برمی‌گرداند که نشان می‌دهد کدام عناصر x محدود هستند.

    اعلام

    public var isFinite: Tensor<Bool> { get }

  • یک تانسور بولی را برمی‌گرداند که نشان می‌دهد کدام عناصر x نامتناهی هستند.

    اعلام

    public var isInfinite: Tensor<Bool> { get }

  • یک تانسور بولی را برمی‌گرداند که نشان می‌دهد کدام عناصر x دارای مقدار NaN هستند.

    اعلام

    public var isNaN: Tensor<Bool> { get }
در جایی که 'Scalar' == 'Bool' موجود است

  • اگر همه اسکالرها با true برابر باشند true را برمی گرداند. در غیر این صورت، false برمی گرداند.

    اعلام

    public func all() -> Bool

  • اگر هر یک از اسکالرها با true برابر باشد true برمی گرداند. در غیر این صورت، false برمی گرداند.

    اعلام

    public func any() -> Bool

  • عملیات AND منطقی را در محورهای مشخص شده انجام می دهد. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • عملیات AND منطقی را در محورهای مشخص شده انجام می دهد. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • عملیات AND منطقی را در محورهای مشخص شده انجام می دهد. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • عملیات OR منطقی را در امتداد محورهای مشخص شده انجام می دهد. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

موجود در جایی که 'Scalar': 'Numeric' & 'Comparable'

  • اعلام

    @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>
موجود در جایی که 'Scalar': 'Numeric'

  • مجموع را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • مجموع را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • مجموع را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • اعلام

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

  • مجموع را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • مجموع را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • مجموع را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • محصول را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • محصول را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • محصول را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • اعلام

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

  • محصول را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • محصول را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • محصول را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین حسابی را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین حسابی را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین حسابی را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank...rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • اعلام

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

  • میانگین حسابی را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین حسابی را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین حسابی را در امتداد محورهای مشخص شده برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • واریانس در امتداد محورهای مشخص شده را برمی گرداند. ابعاد کاهش یافته حذف می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • واریانس در امتداد محورهای مشخص شده را برمی گرداند. ابعاد کاهش یافته حذف می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • واریانس در امتداد محورهای مشخص شده را برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شود. اصلاح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • اعلام

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

  • واریانس در امتداد محورهای مشخص شده را برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شود. اصلاح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • واریانس در امتداد محورهای مشخص شده را برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شود. اصلاح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • واریانس در امتداد محورهای مشخص شده را برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شود. اصلاح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • مجموع تجمعی این تانسور را در امتداد محور مشخص شده برمی‌گرداند. به طور پیش فرض، این تابع یک مجموع تجمعی فراگیر را انجام می دهد که به این معنی است که اولین عنصر ورودی با اولین عنصر خروجی یکسان است:

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

    با تنظیم آرگومان exclusive روی true ، یک جمع تجمعی انحصاری به جای آن انجام می شود:

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

    با تنظیم آرگومان reverse بر روی true ، مجموع تجمعی در جهت مخالف انجام می شود:

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

    این کارآمدتر از معکوس کردن جداگانه تانسور حاصل است.

    پیش شرط

    axis باید در محدوده -rank..<rank .

    اعلام

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

    مولفه های

    axis

    محوری که در امتداد آن عملیات جمع تجمعی انجام می شود.

    exclusive

    نشان می دهد که آیا باید یک مجموع تجمعی منحصر به فرد انجام شود یا خیر.

    reverse

    نشان می دهد که آیا جمع تجمعی به ترتیب معکوس انجام شود یا خیر.

    ارزش بازگشتی

    نتیجه عملیات جمع تجمعی.

  • مجموع تجمعی این تانسور را در امتداد محور مشخص شده برمی‌گرداند. به طور پیش فرض، این تابع یک مجموع تجمعی فراگیر را انجام می دهد که به این معنی است که اولین عنصر ورودی با اولین عنصر خروجی یکسان است:

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

    با تنظیم آرگومان exclusive روی true ، یک جمع تجمعی انحصاری به جای آن انجام می شود:

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

    با تنظیم آرگومان reverse بر روی true ، مجموع تجمعی در جهت مخالف انجام می شود:

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

    این کارآمدتر از معکوس کردن جداگانه تانسور حاصل است.

    پیش شرط

    axis.rank باید 0 باشد.

    پیش شرط

    axis باید در محدوده -rank..<rank .

    اعلام

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

    مولفه های

    axis

    محوری که در امتداد آن عملیات جمع تجمعی انجام می شود.

    exclusive

    نشان می دهد که آیا باید یک مجموع تجمعی منحصر به فرد انجام شود یا خیر.

    reverse

    نشان می دهد که آیا جمع تجمعی به ترتیب معکوس انجام شود یا خیر.

    ارزش بازگشتی

    نتیجه عملیات جمع تجمعی.

  • حاصلضرب تجمعی این تانسور را در امتداد محور مشخص شده برمی‌گرداند. به طور پیش فرض، این تابع یک محصول انباشته فراگیر را انجام می دهد که به این معنی است که اولین عنصر ورودی با اولین عنصر خروجی یکسان است:

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

    با تنظیم آرگومان exclusive روی true ، یک محصول تجمعی انحصاری به جای آن انجام می شود:

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

    با تنظیم آرگومان reverse بر روی true ، محصول تجمعی در جهت مخالف انجام می شود:

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

    این کارآمدتر از معکوس کردن جداگانه تانسور حاصل است.

    پیش شرط

    axis باید در محدوده -rank..<rank .

    اعلام

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

    مولفه های

    axis

    محوری که در امتداد آن عملیات محصول تجمعی انجام می شود.

    exclusive

    نشان می دهد که آیا باید یک محصول تجمعی انحصاری انجام شود یا خیر.

    reverse

    نشان می دهد که آیا محصول تجمعی به ترتیب معکوس انجام شود یا خیر.

    ارزش بازگشتی

    نتیجه عملیات محصول تجمعی.

  • حاصلضرب تجمعی این تانسور را در امتداد محور مشخص شده برمی‌گرداند. به طور پیش فرض، این تابع یک محصول انباشته فراگیر را انجام می دهد که به این معنی است که اولین عنصر ورودی با اولین عنصر خروجی یکسان است:

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

    با تنظیم آرگومان exclusive روی true ، یک محصول تجمعی انحصاری به جای آن انجام می شود:

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

    با تنظیم آرگومان reverse بر روی true ، محصول تجمعی در جهت مخالف انجام می شود:

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

    این کارآمدتر از معکوس کردن جداگانه تانسور حاصل است.

    پیش شرط

    axis باید دارای رتبه 0 باشد.

    پیش شرط

    axis باید در محدوده -rank..<rank .

    اعلام

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

    مولفه های

    axis

    محوری که در امتداد آن عملیات محصول تجمعی انجام می شود.

    exclusive

    نشان می دهد که آیا باید یک محصول تجمعی انحصاری انجام شود یا خیر.

    reverse

    نشان می دهد که آیا محصول تجمعی به ترتیب معکوس انجام شود یا خیر.

    ارزش بازگشتی

    نتیجه عملیات محصول تجمعی.

در جایی که 'Scalar': 'TensorFlowFloatingPoint' موجود است

  • انحراف استاندارد عناصر را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • انحراف استاندارد عناصر را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • انحراف استاندارد عناصر را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • انحراف استاندارد همه عناصر در این تانسور را برمی‌گرداند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

  • انحراف استاندارد عناصر را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • انحراف استاندارد عناصر را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • انحراف استاندارد عناصر را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند. تصحیح بسل را اعمال نمی کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • log(exp(self).sum(squeezingAxes: axes)) را برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    این تابع نسبت به محاسبه مستقیم log(exp(self).sum(squeezingAxes: axes)) نظر عددی پایدارتر است. از سرریزهای ناشی از محاسبه exp ورودی‌های بزرگ و جریان‌های زیرین ناشی از محاسبه log ورودی‌های کوچک جلوگیری می‌کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • log(exp(self).sum(squeezingAxes: axes)) را برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    این تابع نسبت به محاسبه مستقیم log(exp(self).sum(squeezingAxes: axes)) نظر عددی پایدارتر است. از سرریزهای ناشی از محاسبه exp ورودی‌های بزرگ و جریان‌های زیرین ناشی از محاسبه log ورودی‌های کوچک جلوگیری می‌کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • log(exp(self).sum(squeezingAxes: axes)) را برمی گرداند. ابعاد کاهش یافته حذف می شوند.

    این تابع نسبت به محاسبه مستقیم log(exp(self).sum(squeezingAxes: axes)) نظر عددی پایدارتر است. از سرریزهای ناشی از محاسبه exp ورودی‌های بزرگ و جریان‌های زیرین ناشی از محاسبه log ورودی‌های کوچک جلوگیری می‌کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • log(exp(self).sum()) را برمی‌گرداند. نتیجه یک اسکالر است.

    این تابع نسبت به محاسبه مستقیم log(exp(self).sum()) نظر عددی پایدارتر است. از سرریزهای ناشی از محاسبه exp ورودی‌های بزرگ و جریان‌های زیرین ناشی از محاسبه log ورودی‌های کوچک جلوگیری می‌کند.

    اعلام

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

  • log(exp(self).sum(alongAxes: axes)) را برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    این تابع از لحاظ عددی پایدارتر از محاسبه مستقیم log(exp(self).sum(alongAxes: axes)) است. از سرریزهای ناشی از محاسبه exp ورودی‌های بزرگ و جریان‌های زیرین ناشی از محاسبه log ورودی‌های کوچک جلوگیری می‌کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • log(exp(self).sum(alongAxes: axes)) را برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    این تابع از لحاظ عددی پایدارتر از محاسبه مستقیم log(exp(self).sum(alongAxes: axes)) است. از سرریزهای ناشی از محاسبه exp ورودی‌های بزرگ و جریان‌های زیرین ناشی از محاسبه log ورودی‌های کوچک جلوگیری می‌کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • log(exp(self).sum(alongAxes: axes)) را برمی گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    این تابع از لحاظ عددی پایدارتر از محاسبه مستقیم log(exp(self).sum(alongAxes: axes)) است. از سرریزهای ناشی از محاسبه exp ورودی‌های بزرگ و جریان‌های زیرین ناشی از محاسبه log ورودی‌های کوچک جلوگیری می‌کند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین و واریانس این تانسور را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    axes باید دارای رتبه 1 باشند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین و واریانس این تانسور را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین و واریانس این تانسور را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته حذف می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین و واریانس عناصر این تانسور را برمی‌گرداند.

    اعلام

    @differentiable(wrt: self)
public func moments() -> Moments<Scalar>

  • میانگین و واریانس این تانسور را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    axes باید دارای رتبه 1 باشند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین و واریانس این تانسور را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

  • میانگین و واریانس این تانسور را در امتداد محورهای مشخص شده برمی‌گرداند. ابعاد کاهش یافته با مقدار 1 حفظ می شوند.

    پیش شرط

    هر مقدار در axes باید در محدوده -rank..<rank باشد.

    اعلام

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

    مولفه های

    axes

    ابعاد برای کاهش.

موجود در جایی که 'Scalar': 'Numeric'

  • ضرب ماتریس را بین دو تانسور انجام می دهد و نتیجه را ایجاد می کند.

    اعلام

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
در جایی که 'Scalar': 'TensorFlowFloatingPoint' موجود است

  • اعلام

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

  • یک تانسور محاسبه شده از نرمال سازی دسته ای ورودی در امتداد محور مشخص شده را برمی گرداند.

    به طور خاص، بازده (self - mu) / (var + epsilon) * gamma + beta که در آن mu و var به ترتیب میانگین و واریانس self در axis هستند.

    اعلام

    @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)
موجود در جایی که 'Scalar': 'Equatable'

  • اعلام

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

  • اعلام

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
موجود در جایی که 'Scalar': 'Codable'
موجود در جایی که 'Scalar': 'Numeric'

  • تانسور اسکالر صفر.

  • اعلام

    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
در جایی که 'Scalar': 'TensorFlowFloatingPoint' موجود است

  • اعلام

    public typealias TangentVector = Tensor

  • اعلام

    public var zeroTangentVectorInitializer: () -> TangentVector { get }

  • حاشیه نویسی اضافه می کند.

    توجه: فقط X10 پشتیبانی می شود. برای سایر باطن‌ها، self umodified برگردانده می‌شود.

    اعلام

    @differentiable(wrt: self)
public func annotate(_ annotation: String) -> Tensor<Scalar>

    مولفه های

    annotation

    حاشیه نویسی اضافه شود.

    ارزش بازگشتی

    تانسور مشروح.

  • اعلام

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