מוֹתֵחַ

ה- TensorHandle הבסיסי.

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

מפצל טנסור למספר טנסורים. הטנזור מחולק לחתיכות 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]

מחזירה טנזור עם אריחים, שנבנה על ידי ריצוף טנזור זה.

בנאי זה יוצר טנזור חדש על ידי שכפול טנזור זה multiples פעמים. לממד ה i של הטנזור הבנוי יש אלמנטים self.shape[i] * multiples[i] , והערכים של הטנזור הזה משוכפלים multiples[i] פעמים לאורך הממד ה i . לדוגמה, ריצוף [abcd] על ידי [2] מייצר [abcdabcd] .

מחזירה טנזור עם אריחים, שנבנה על ידי ריצוף טנזור זה.

בנאי זה יוצר טנזור חדש על ידי שכפול טנזור זה multiples פעמים. לממד ה i של הטנזור הבנוי יש אלמנטים self.shape[i] * multiples[i] , והערכים של הטנזור הזה משוכפלים multiples[i] פעמים לאורך הממד ה i . לדוגמה, ריצוף [abcd] על ידי [2] מייצר [abcdabcd] .

עצב מחדש את הצורה של Tensor שצוין.

עצב מחדש את הצורה שצוינה.

עצב מחדש את Tensor שצוין המייצג צורה.

החזר עותק של הטנסור הממוטט לתוך Tensor 1-D, בסדר שורה עיקרית.

מחזירה Tensor מורחב צורה, עם ממד 1 שהוכנס במדדי הצורה שצוינו.

מחזירה Tensor מורחב צורה, עם ממד 1 שהוכנס במדדי הצורה שצוינו.

מחזירה Tensor מורם עם ממד מוביל של 1.

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

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

מחזירה טנזור שעבר טרנספורמציה, עם מימדים מוחלפים בסדר שצוין.

מחזירה טנזור שעבר טרנספורמציה, עם מימדים מוחלפים בסדר שצוין.

מחזירה טנזור שעבר טרנספורמציה, עם מימדים מוחלפים בסדר שצוין.

מחזירה טנזור שעבר טרנספורמציה, עם מימדים מוחלפים בסדר שצוין.

מחזירה טנזור שעבר טרנספורמציה, עם מימדים מוחלפים בסדר שצוין.

מחזירה טנזור שעבר טרנספורמציה, עם מימדים מוחלפים בסדר שצוין.

מחזירה טנזור שעבר טרנספורמציה, עם מימדים מוחלפים בסדר הפוך.

מחזירה טנזור עם ממדים שצוינו הפוכים.

מחזירה טנזור עם ממדים שצוינו הפוכים.

מחזירה טנזור עם ממדים שצוינו הפוכים.

מחזירה טנזור משורשר לאורך הציר שצוין.

מפעיל שרשור.

החזרת טנזור על ידי איסוף פרוסות של הקלט 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)...] .

מחזירה פרוסות של טנזור זה indices לאורך ממד axis , תוך התעלמות מממדי batchDimensionCount הראשונים התואמים לממדים של אצווה. האיסוף מתבצע לאורך המימד הראשון שאינו אצווה.

מבצע פונקציונליות דומה gathering , מלבד שצורת הטנזור המתקבלת היא כעת shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

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

לדוגמה:

// 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 's shape must match the first dimensions of the צורת הטנזור.

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

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

לדוגמה:

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

שדר לאותה צורה כמו ה- Tensor שצוין.

מחלץ פרוסה מהטנזור המוגדר על ידי הגבול התחתון והעליון עבור כל מימד.

בודק שכל רכיב של axes מציין ציר self , ועוצר את התוכנית עם אבחון אחרת.

בודק שכל רכיב של axes מציין ציר self , ועוצר את התוכנית עם אבחון אחרת.

בודק ש- k מציין ציר self , ועוצר את התוכנית עם אבחון אחרת.

יוצר עותק של other Device הנתון.

יוצר טנזור עם הצורה שצוינה וערך סקלרי יחיד שחוזר על עצמו.

יוצר טנזור עם הצורה שצוינה וערך סקלרי יחיד שחוזר על עצמו.

יוצר טנזור על ידי שידור הסקלר הנתון לדרגה נתונה כאשר כל הממדים הם 1.

יוצר טנזור ממערך של טנסורים (שעשויים בעצמם להיות סקלרים).

עורמת 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:) .

משרשרת 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]

מחליף אלמנטים של טנזור זה other בנתיבים שבהם mask true .

מחזירה אמת אם הסוג הסקלרי הפיזי מופחת דיוק.

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

מקדם סקלאר לטנזור עם אותו התקן ודיוק כמו הטנזור הנתון.

מחזיר עותק של self שהומר לסוג סקלרי פיזי BFloat16 .

מחזיר עותק של self שהומר לסוג סקלרי פיזי Scalar .

מספר הממדים של Tensor .

צורת Tensor .

מספר הסקלרים Tensor .

דרגת הטנזור, המיוצגת Tensor<Int32> .

מידות הטנזור, המיוצגות Tensor<Int32> .

מספר הסקלרים בטנזור, המיוצג Tensor<Int32> .

מחזירה true אם rank שווה ל-0 ו- false אחרת.

מחזירה את האלמנט הסקלרי הבודד אם rank שווה ל-0 nil אחרת.

עצב מחדש לסקלרי.

יוצר טנזור 0-D מערך סקלרי.

יוצר טנזור 1D מסקלרים.

יוצר טנזור 1D מסקלרים.

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

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

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

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

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

יוצר טנזור שאותחל עם האלמנטים הנתונים.

ייצוג טקסטואלי של הטנזור.

ייצוג טקסטואלי של הטנזור. מחזירה תיאור מסכם אם summarize נכון ומספר האלמנטים עולה על פי שניים מה- edgeElementCount .

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

ההערות המתארות את הטנזור הזה.

כינוי להערות.

מצב שמכתיב כיצד מרופד טנזור.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

יוצר טנזור 1-D המייצג רצף מערך התחלה ועד, אך לא כולל, ערך סיום, תוך צעד בכמות שצוינה.

יוצר טנזור 1-D המייצג רצף מערך התחלה ועד, אך לא כולל, ערך סיום, תוך צעד בכמות שצוינה.

יוצר טנזור חם אחד במדדים נתונים. המיקומים המיוצגים על ידי 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

יוצר טנזור 1-D המייצג רצף מערך התחלתי, עד וכולל ערך סיום, מרווח באופן שווה כדי ליצור את מספר הערכים שצוין.

יוצר טנזור 1-D המייצג רצף מערך התחלתי, עד וכולל ערך סיום, מרווח באופן שווה כדי ליצור את מספר הערכים שצוין.

יוצר טנזור עם הצורה שצוינה, תוך דגימה אקראית של ערכים סקלרים מהתפלגות אחידה בין lowerBound ל- upperBound .

יוצר טנזור עם הצורה שצוינה, תוך דגימה אקראית של ערכים סקלרים מהתפלגות אחידה בין lowerBound ל- upperBound .

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

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

יוצר טנזור על ידי ציור דוגמאות מהתפלגות קטגורית.

יוצר טנזור עם הצורה שצוינה על ידי ביצוע אתחול אחיד של Glorot (Xavier).

הוא שואב דגימות אקראיות מחלוקה אחידה בין -limit ל- limit שנוצרו על ידי מחולל המספרים האקראיים המוגדר כברירת מחדל, כאשר limit הוא sqrt(6 / (fanIn + fanOut)) ו- fanIn / fanOut מייצגים את מספר תכונות הקלט והפלט כפול ה-receptive גודל השדה.

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

יוצר טנזור עם הצורה שצוינה על ידי ביצוע אתחול רגיל של Glorot (Xavier).

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

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

יוצר טנזור עם הצורה שצוינה על ידי ביצוע אתחול אחיד He (Kaiming).

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

התייחסות: "התעמקות במיישרים: מעבר לביצועים ברמת האדם בסיווג ImageNet"

יוצר טנזור עם הצורה שצוינה על ידי ביצוע אתחול רגיל של He (Kaiming).

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

התייחסות: "התעמקות במיישרים: מעבר לביצועים ברמת האדם בסיווג ImageNet"

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

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

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

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

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

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

יוצר מטריצה ​​אורתוגונלית או טנזור.

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

אם צורת הטנזור לאתחול היא יותר מדו-ממדית, מטריצה ​​של צורה [shape[0] * ... * shape[rank - 2], shape[rank - 1]] מאתחלת. לאחר מכן, המטריצה ​​מעוצבת מחדש כדי לתת טנזור של הצורה הרצויה.

מחזירה את החלק האלכסוני [באצווה] של טנזור [באצווה]. עבור מופע הטנזור של הצורה [..., 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]

בונה מערך אלכסוני [באצווה]. עבור מופע הטנזור של הצורה [..., 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]]

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

לטנזור המוחזר יש את אותם צורה וערכים כמו self , למעט האלכסונים שצוינו של המטריצות הפנימיות ביותר, אשר מוחלף על ידי הערכים diagonal .

פרמטר אלכסון: טנזור עם דרגה rank - 1 המייצג את ערכי האלכסון החדשים.

מחזירה עותק של טנזור פנימי המוגדר על ידי גבולות פס מרכזי. הפלט הוא טנזור באותה צורה כמו המופע [..., :, :] .

לדוגמה:

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

מחזירה את פירוק QR של כל מטריצה ​​פנימית בטנזור, טנזור עם מטריצות אורתוגונליות פנימיות q וטנזור עם מטריצות משולשות עליונות פנימיות r , כך שהטנזור שווה ל- matmul(q, r) .

מחזירה את פירוק הערך הסינגולרי של 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)`.

השורש הריבועי של x .

עבור טיפוסים אמיתיים, אם x הוא שלילי התוצאה היא .nan . עבור טיפוסים מורכבים יש חתך ענף על הציר האמיתי השלילי.

הקוסינוס של x , מתפרש כזווית ברדיאנים.

הסינוס של x , מתפרש כזווית ברדיאנים.

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

הקוסינוס ההפוך של x ברדיאנים.

הסינוס ההפוך של x ברדיאנים.

הטנגנס ההפוך של x ברדיאנים.

הקוסינוס ההיפרבולי של x .

הסינוס ההיפרבולי של x .

הטנגנס ההיפרבולי של x .