Tensor 

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
extension Tensor: TensorProtocol
extension Tensor: TensorGroup
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: Codable where Scalar: Codable
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

מערך רב ממדי של אלמנטים שהוא הכללה של וקטורים ומטריצות למימדים בעלי פוטנציאל גבוה יותר.

הפרמטר הגנרי Scalar מתאר את סוג הסקלרים בטנזור (כגון Int32 , Float וכו').

  • ה- TensorHandle הבסיסי.

    פֶּתֶק

    handle הוא ציבורי כדי לאפשר פעולות מוגדרות על ידי משתמש, אך בדרך כלל אין להשתמש בו.

    הַצהָרָה 

    public let handle: TensorHandle<Scalar>

  • הַצהָרָה 

    public init(handle: TensorHandle<Scalar>)

  • מפרק את הממד הנתון של טנסור דרגה- R לטנסור דרגה מרובים (R-1) . מפרק N טנסורים מהטנזור הזה על-ידי חיתוך שלו לאורך ממד axis , כאשר N מסיק מצורתו של טנזור זה. לדוגמה, בהינתן טנזור עם צורה [A, B, C, D] :

    • אם axis == 0 אז הטנסור i במערך המוחזר הוא ה-Slice 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-D המכיל את הגודל של כל פיצול.

    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-D, בסדר שורה עיקרית.

    הַצהָרָה 

    @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

  • מפעיל שרשור.

    פֶּתֶק

    ++ הוא אופרטור מותאם אישית שלא קיים ב-Swift, אבל כן ב-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)...] .

    פֶּתֶק

    במעבד, אם נמצא אינדקס מחוץ לטווח, נגרמת שגיאה. ב-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] היא הכניסה true i של mask (סדר עיקרי בשורה).

    ניתן להשתמש axis עם mask כדי לציין את הציר ממנו יש להסוות. במקרה זה, axis + mask.rank <= tensor.rank וצורת mask חייבות להתאים dimensions of the ציר + mask.rank 's shape must match the first של צורת הטנזור.

    תְנַאִי מוּקדָם

    mask לא יכולה להיות סקלרית: mask.rank != 0 .

    הַצהָרָה 

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

    פרמטרים

    mask

    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 .

    בהינתן שלכולם יש צורה [A, B, C] , ו- tensors 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 או שווה ל 1 , אז mask חייבת להיות בעלת אותה צורה כמו self או להיות Tensor 1-D כך ש- 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)

  • מחזיר עותק של 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 }

  • מחזירה true אם rank שווה ל-0 ו- 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': 'נומרי'

  • הַצהָרָה 

    @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': 'נומרי' ו'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`

  • מחזירה true אם כל מרכיבי self שווים בערך לאלו של other .

    תְנַאִי מוּקדָם

    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': 'נומרי'

  • בצע המרה מסוג אלמנט מטנזור Bool .

    הַצהָרָה 

    public init(_ other: Tensor<Bool>)

  • בצע המרה אלמנט Tensor אחר.

    הַצהָרָה 

    @differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
זמין כאשר `Scalar`: `TensorFlowFloatingPoint`
זמין כאשר 'Scalar': 'נומרי'

  • יוצר טנזור עם כל הסקלרים מוגדרים לאפס.

    הַצהָרָה 

    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 חייבים להיות Tensors המכילים ערך סקלרי יחיד.

    הַצהָרָה 

    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

    טנסור דו-ממדי עם צורה [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 מייצגים את מספר תכונות הקלט והפלט כפול ה-receptive גודל השדה.

    התייחסות: "הבנת הקושי באימון רשתות עצביות הזנות עמוקות"

    הַצהָרָה 

    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 מייצג את מספר תכונות הקלט כפול גודל השדה הקולט.

    התייחסות: "Prop BackProp יעיל"

    הַצהָרָה 

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

    פרמטרים

    shape

    מידות הטנזור.

    seed

    ערך הזרע.

  • יוצר טנזור עם הצורה שצוינה על ידי ביצוע אתחול רגיל של LeCun.

    הוא שואב דגימות אקראיות מהתפלגות נורמלית קטומה שבמרכזה 0 עם סטיית תקן sqrt(1 / fanIn) שנוצרת על ידי מחולל המספרים האקראיים המוגדר כברירת מחדל, כאשר fanIn מייצג את מספר תכונות הקלט כפול גודל השדה הקולט.

    התייחסות: "Prop 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

    מספר אלכסוני העל שיש לשמור. אם שלילי, שמור את כל המשולש העליון.

זמין כאשר `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 [..., 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 .

    המכפלה של 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': 'נומרי'

  • מוסיף את הסקלר לכל סקלר של הטנזור ומפיק את הסכום.

    הַצהָרָה 

    @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 חכמת אלמנט self || other , משודרת other .

    הַצהָרָה 

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
זמין איפה 'סקלר': `tensorflownumeric

  • מחזיר max(min(self, max), min) .

    הַצהָרָה 

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

  • מחזיר max(min(self, max), min) .

    הַצהָרָה 

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

  • מחזיר max(min(self, max), min) .

    הַצהָרָה 

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

  • מחזיר max(min(self, max), min) .

    הַצהָרָה 

    @differentiable(wrt: self)
public func clipped(min: Scalar, max: Scalar) -> Tensor
זמין במקום בו 'סקלר': `signdnumeric '

  • מחזיר את שלילתו של טנזור צוין-אלמנט-חכמה.

    הַצהָרָה 

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
זמין איפה 'סקלר': 'מספרי'

  • הַצהָרָה 

    @differentiable(wrt: self)
public func squared() -> Tensor
זמין איפה 'סקלר': `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

  • מבצע הגיוני ופעולה לאורך הצירים שצוינו. הממדים המופחתים מוסרים.

    תְנַאִי מוּקדָם

    כל ערך 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])

    על ידי קביעת הטיעון 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

    מציין אם לבצע את המוצר המצטבר בסדר הפוך.

    ערך החזרה

    תוצאה של פעולת המוצר המצטברת.

זמין איפה 'סקלר': `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

    הממדים לצמצום.

זמין איפה 'סקלר': 'מספרי'

  • מבצע כפל מטריקס בין שני טנסורים ומפיק את התוצאה.

    הַצהָרָה 

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
זמין איפה 'סקלר': `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)
זמין במקום בו 'סקלר': 'שווה'

  • הַצהָרָה 

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

  • הַצהָרָה 

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
זמין איפה 'סקלר': 'קידוד'

  • הַצהָרָה 

    public func encode(to encoder: Encoder) throws

  • הַצהָרָה 

    public init(from decoder: Decoder) throws
זמין איפה 'סקלר': 'מספרי'

  • טנזור האפס הסקלרי.

  • הַצהָרָה 

    public static var zero: Tensor { get }

  • מוסיף שני טנסורים ומייצר את הסכום שלהם.

    פֶּתֶק

    + תומך בשידור.

    הַצהָרָה 

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

  • מחסור טנזור אחד מאחר ומייצר את ההבדל שלהם.

    פֶּתֶק

    - תומך בשידור.

    הַצהָרָה 

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

  • הטנזור הסקלרי.

    הַצהָרָה 

    public static var one: Tensor { get }

  • מחזיר את ההדדיות החכמה של self .

    הַצהָרָה 

    public var reciprocal: Tensor { get }

  • מכפיל שני טנסורים מבחינה אלמנטית ומייצר את המוצר שלהם.

    פֶּתֶק

    .* תומך בשידור.

    הַצהָרָה 

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
זמין איפה 'סקלר': `tensorflowfloatingpoint`

  • הַצהָרָה 

    public typealias TangentVector = Tensor

  • הַצהָרָה 

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

  • מוסיף הערה.

    הערה: רק X10 נתמך. עבור Backends אחרים, 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>
)