GitHub
דף זה תורגם על ידי Cloud Translation API.
Switch to English

מוֹתֵחַ

@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
extension Tensor: TensorGroup
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Equatable where Scalar: Equatable
3d0f1abaff9e09

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

הפרמטר הגנרי 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, :, :, :] הפרוסה self[i, :, :, :] וכל טנסור באותו מערך יהיה בעל צורה [B, C, D] . (שים לב שהממד Tensor.split(numSplits:alongAxis) איתו נעלם, שלא כמו Tensor.split(numSplits:alongAxis) , או Tensor.split(sizes:alongAxis) ).
    • אם axis == 1 אז הטנסור ה- i במערך המוחזר הוא value[:, 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] חלקים 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

    טנסור חד-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] , והערכים של טנסור זה משוכפלים 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
  • חזור עותק של מותח התמוטט לתוך 1-D Tensor , על מנת בשורה-מרכזי.

    הַצהָרָה

    @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 -מימדיים (וקטוריים):

    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 הראשונה 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 , 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 לציר + + mask.rank dimensions of the צורת הטנזור.

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

    mask לא יכולה להיות mask.rank != 0 : 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 .

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

    הקואורדינטות מוחזרות במתח 2-D בו הממד הראשון (שורות) מייצג את מספר האלמנטים שאינם אפסיים, והממד השני (העמודות) מייצג את הקואורדינטות של האלמנטים הלא אפסיים. קחו בחשבון שצורתו של טנזור הפלט יכולה להשתנות תלוי בכמה ערכים אמיתיים ישנם בטנזור זה. המדדים מוצגים לפי סדר ראשי.

    לדוגמה:

    // '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-D כך mask.scalarCount == self.shape[0] .

    הַצהָרָה

    @differentiable(wrt: (self, other)
    ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
  • חוזר אמיתי אם סוג הסקלר הפיזי הוא דיוק מופחת.

    נכון לעכשיו, סוגי BFloat16 הגופניים הפיזיים המופחתים כוללים רק BFloat16 .

    הַצהָרָה

    public var isReducedPrecision: Bool { get }
  • מקדם סקלר לטנזור עם אותו מכשיר ודיוק כמו הטנזור הנתון.

    הַצהָרָה

    @differentiable
    public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
  • מחזירה עותק של המרה self לסוג BFloat16 הפיזי BFloat16 .

    הַצהָרָה

    648543778 א
  • מחזירה עותק של המרה self לסוג Scalar הפיזי 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: RandomAccessCollection>(
      _ vector: C, on device: Device = .default
    ) where C.Element == Scalar
  • יוצר טנסור עם הצורה שצוינה וסקאלארים רציפים בסדר-ראשי.

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

    התוצר של מידות הצורה חייב להיות שווה למספר הסקלרים.

    הַצהָרָה

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

    פרמטרים

    shape

    צורת הטנזור.

    scalars

    התוכן הסקלרי של הטנזור.

  • יוצר טנסור עם הצורה שצוינה וסקאלארים רציפים בסדר-ראשי.

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

    התוצר של מידות הצורה חייב להיות שווה למספר הסקלרים.

    הַצהָרָה

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

    פרמטרים

    shape

    צורת הטנזור.

    scalars

    התוכן הסקלרי של הטנזור.

  • יוצר טנסור עם הצורה שצוינה והסקאלארים הרציפים בסדר גודל ראשי.

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

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

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

    התוצר של מידות הצורה חייב להיות שווה למספר הסקלרים.

    הַצהָרָה

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

    פרמטרים

    shape

    צורת הטנזור.

    scalars

    התוכן הסקלרי של הטנזור.

  • סוג האלמנטים של מערך מילולי.

    הַצהָרָה

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
  • יוצר טנזור אשר מאתחל עם האלמנטים הנתונים.

    הַצהָרָה

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
  • ייצוג טקסטואלי של הטנזור.

    הערה

    השתמש ב- fullDescription שאינו מודפס יפהפה המציג את כל הסקלרים.

    הַצהָרָה

    public var description: String { get }
  • ייצוג טקסטואלי של הטנזור. מחזירה תיאור מסוכם אם summarize הוא נכון וספירת האלמנטים חורגת פי שניים מ- edgeElementCount .

    הַצהָרָה

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

    פרמטרים

    lineWidth

    רוחב הקו המרבי להדפסה. משמש לקביעת מספר הסקלרים להדפסה בכל שורה.

    edgeElementCount

    המספר המרבי של האלמנטים להדפיס לפני ואחרי סיכום באמצעות אליפסות ( ... ).

    summarizing

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

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

    הַצהָרָה

    public var fullDescription: String { get }
  • הַצהָרָה

    public var playgroundDescription: Any { get }
  • הַצהָרָה

    public var customMirror: Mirror { get }
  • הַצהָרָה

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
  • הַצהָרָה

    public init<C: RandomAccessCollection>(
      _handles: C
    ) where C.Element: _AnyTensorHandle
  • הַצהָרָה

    public init(_ array: ShapedArray<Scalar>, on device: Device = .default)
  • הַצהָרָה

    init(_xla: XLATensor)
  • הַצהָרָה

    var xlaTensor: XLATensor { get }

ניתן להשיג במקום 'סקלרי': `מספרי '

  • הַצהָרָה

    @differentiable(wrt: self)
    public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor
  • הַצהָרָה

    @differentiable(wrt: self)
    public func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • הַצהָרָה

    @differentiable(wrt: self)
    public func unbroadcasted(to shape: TensorShape) -> Tensor
  • מצב שמכתיב כיצד מרופד טנזור.

    הַצהָרָה

    public enum PaddingMode
  • מחזירה טנזור מרופד עם קבוע בהתאם לגדלי הריפוד שצוינו.

    הַצהָרָה

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
      -> Tensor
  • מחזירה טנזור מרופד בהתאם לגדלי הריפוד והמצב שצוינו.

    הַצהָרָה

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor

ניתן להשיג במקום 'סקלרי': `מספרי 'ו'השוואה'

  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs < rhs חכמה.

    הַצהָרָה

    public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs <= rhs חכמה.

    הַצהָרָה

    public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs > rhs חכמה.

    הַצהָרָה

    public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs >= rhs .

    הַצהָרָה

    public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs < rhs חכמה.

    הערה

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

    הַצהָרָה

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs <= rhs .

    הערה

    .<= תומך בשידור.

    הַצהָרָה

    public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs > rhs חכמה.

    הערה

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

    הַצהָרָה

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs >= rhs .

    הערה

    .>= תומך בשידור.

    הַצהָרָה

    public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs < rhs חכמה.

    הערה

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

    הַצהָרָה

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs <= rhs .

    הערה

    .<= תומך בשידור.

    הַצהָרָה

    public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs > rhs חכמה.

    הערה

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

    הַצהָרָה

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs >= rhs .

    הערה

    .>= תומך בשידור.

    הַצהָרָה

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

ניתן להשיג במקום 'סקלרי': 'שווה ערך'

  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs == rhs חכמה.

    הערה

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

    הַצהָרָה

    public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs != rhs .

    הערה

    .!= תומך בשידור.

    הַצהָרָה

    public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs == rhs חכמה.

    הערה

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

    הַצהָרָה

    public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs != rhs .

    הערה

    .!= תומך בשידור.

    הַצהָרָה

    public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs == rhs חכמה.

    הערה

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

    הַצהָרָה

    public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • מחזירה טנסור של סקלרים בוליאניים על ידי חישוב lhs != rhs חכמה.

    הערה

    .!= תומך בשידור.

    הַצהָרָה

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

ניתן להשיג במקום 'סקלרי': `TensorFlowFloatingPoint` &` Equatable`

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

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

    self other חייבים להיות באותה צורה.

    הַצהָרָה

    public func elementsAlmostEqual(
      _ other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Tensor<Bool>

ניתן להשיג במקום 'סקלר': 'TensorFlowFloatingPoint'

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

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

    self other חייבים להיות באותה צורה.

    הַצהָרָה

    public func isAlmostEqual(
      to other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Bool

ניתן להשיג במקום 'סקלרי': 'TensorFlowNumeric'

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

    הַצהָרָה

    public mutating mutating func crossReplicaSum(_ scale: Double)

ניתן להשיג במקום 'סקלר': 'TensorFlowFloatingPoint'

ניתן להשיג במקום 'סקלרי': `מספרי '

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

    הַצהָרָה

    public init(_ other: Tensor<Bool>)
  • בצע המרה Tensor אלמנט Tensor אחר.

    הַצהָרָה

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

ניתן להשיג במקום 'סקלר': 'TensorFlowFloatingPoint'

ניתן להשיג במקום 'סקלרי': `מספרי '

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

    הַצהָרָה

    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 , ציר פנימי ביותר ביותר.

ניתן להשיג במקום 'סקלר': '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 חייבים להיות טנסורים המכילים ערך סקלרי יחיד.

    הַצהָרָה

    699364899 ד

    פרמטרים

    start

    ערך ההתחלה שישמש לרצף. אם הרצף מכיל ערכים כלשהם, הראשון הוא start .

    end

    ערך סיום להגבלת הרצף. end הוא האלמנט האחרון ברצף שהתקבל.

    count

    מספר הערכים ברצף שהתקבל. count חייבת להיות חיובית.

ניתן להשיג במקום 'סקלר': 'TensorFlowIndex'

  • יוצר טנסור עם הצורה שצוינה, lowerBound באופן אקראי ערכים סקלריים מהתפלגות אחידה בין 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

    The seed value.

Available where `Scalar`: `TensorFlowFloatingPoint`

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

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    lowerBound

    The lower bound of the distribution.

    upperBound

    The upper bound of the distribution.

    seed

    The seed value.

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

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    mean

    The mean of the distribution.

    standardDeviation

    The standard deviation of the distribution.

    seed

    The seed value.

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

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    mean

    The mean of the distribution.

    standardDeviation

    The standard deviation of the distribution.

    seed

    The seed value.

Available where `Scalar`: `TensorFlowIndex`

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

    Declaration

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

    Parameters

    randomCategorialLogits

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

    sampleCount

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

    seed

    The seed value.

    Return Value

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

Available where `Scalar`: `TensorFlowFloatingPoint`

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

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

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

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

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

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

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

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

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

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

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

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

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

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

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

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

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

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

    Reference: “Efficient BackProp”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

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

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

    Reference: “Efficient BackProp”

    Declaration

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

    Parameters

    shape

    The dimensions of the tensor.

    seed

    The seed value.

  • Creates an orthogonal matrix or tensor.

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

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

    Declaration

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

    Parameters

    shape

    The shape of the tensor.

    gain

    A multiplicative factor to apply to the orthogonal tensor.

    seed

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

Available where `Scalar`: `TensorFlowNumeric`

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

    For example:

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

    Declaration

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

    For example:

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

    Declaration

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

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

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

    Declaration

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

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

    For example:

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

    Declaration

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

    Parameters

    subdiagonalCount

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

    superdiagonalCount

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

Available where `Scalar`: `TensorFlowFloatingPoint`

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

    Declaration

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

    Parameters

    fullMatrices

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

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

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

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

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

    Precondition

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

    Declaration

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

    Parameters

    computeUV

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

    fullMatrices

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

    Return Value

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

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

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

    Declaration

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

    The product of n copies of x .

    Declaration

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

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

    Declaration

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

    public typealias VectorSpaceScalar = Float
  • Declaration

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

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

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

Available where `Scalar`: `Numeric`

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Note

    += supports broadcasting.

    Declaration

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

    Declaration

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

    Note

    -= supports broadcasting.

    Declaration

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

    Declaration

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

    Note

    * supports broadcasting.

    Declaration

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

    Declaration

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

    Declaration

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

    Note

    *= supports broadcasting.

    Declaration

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

    Declaration

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

    Note

    / supports broadcasting.

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Note

    % supports broadcasting.

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

Available where `Scalar` == `Bool`

  • Returns !self element-wise.

    Declaration

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

    Note

    && supports broadcasting.

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

Available where `Scalar`: `TensorFlowNumeric`

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

    Declaration

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

    Declaration

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

    Declaration

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

    Declaration

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

Available where `Scalar`: `SignedNumeric`

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

    Declaration

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

Available where `Scalar`: `Numeric`

  • Declaration

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

Available where `Scalar`: `TensorFlowFloatingPoint`

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

    Declaration

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

    Declaration

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

    Declaration

    public var isNaN: Tensor<Bool> { get }

Available where `Scalar` == `Bool`

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

    Declaration

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

    Declaration

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

  • Declaration

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

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Declaration

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

    Declaration

    public func argmin() -> Tensor<Int32>

Available where `Scalar`: `Numeric`

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

  • Declaration

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

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

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis.rank must be 0 .

    Precondition

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

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Return Value

    Result of the cumulative sum operation.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

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

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

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

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

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

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

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

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

    This is more efficient than separately reversing the resulting tensor.

    Precondition

    axis must have rank 0 .

    Precondition

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

    Declaration

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

    Parameters

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Return Value

    Result of the cumulative product operation.

Available where `Scalar`: `TensorFlowFloatingPoint`

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

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

    Declaration

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

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

    axes must have rank 1 .

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Declaration

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

    Precondition

    axes must have rank 1 .

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

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

    Precondition

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

    Declaration

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

    Parameters

    axes

    The dimensions to reduce.

Available where `Scalar`: `Numeric`

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

    Declaration

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Declaration

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

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

    Declaration

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

    Parameters

    axis

    The batch dimension.

    offset

    The offset, also known as beta.

    scale

    The scale, also known as gamma.

    epsilon

    A small value added to the denominator for numerical stability.

  • Declaration

    @derivative
    init(shape: scalars)

Available where `Scalar`: `Equatable`

  • Declaration

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

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

Available where `Scalar`: `Codable`

  • Declaration

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

    public init(from decoder: Decoder) throws

Available where `Scalar`: `Numeric`

  • The scalar zero tensor.

  • Declaration

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

    Note

    + supports broadcasting.

    Declaration

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

    Note

    - supports broadcasting.

    Declaration

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

    The scalar one tensor.

    Declaration

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

    Declaration

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

    Note

    .* supports broadcasting.

    Declaration

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

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Declaration

    public typealias TangentVector = Tensor