הפונקציות הבאות זמינות ברחבי העולם.
מחזירה את ההפסד L1 בין תחזיות וציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l1Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את ההפסד L2 בין תחזיות וציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l2Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את אובדן הצירים בין התחזיות והציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func hingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את אובדן הצירים בריבוע בין התחזיות והציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את אובדן הצירים הקטגורי בין תחזיות וציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את הלוגריתם של הקוסינוס ההיפרבולי של השגיאה בין תחזיות וציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func logCoshLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את ההפסד של פויסון בין תחזיות וציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func poissonLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את ההבדל בין Kullback-Leibler (KL) בין בין ציפיות לתחזיות. בהינתן שתי הפצות
p
ו-q
, הבדלי KL מחשבp * log(p / q)
.הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחזירה את האנטרופיה הצולבת של softmax (אנטרופיה צולבת קטגורית) בין לוגים ותוויות.
הַצהָרָה
@differentiable(wrt: logits) public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, probabilities: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
logits
יציאות מקודדות חד-חם מרשת עצבית.
labels
מדדים (אפס-אינדקס) של התפוקות הנכונות.
מחזירה את האנטרופיה הצולבת הסיגמואידית (אנטרופיה צולבת בינארית) בין לוגים ותוויות.
הַצהָרָה
@differentiable(wrt: logits) @differentiable(wrt: (logits, labels) public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, labels: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
logits
הפלט הלא מדורג של רשת עצבית.
labels
ערכים שלמים התואמים את הפלט הנכון.
מחזירה טנסור בעל צורה ואותן סולם כמו הטנזר שצוין.
הַצהָרָה
@differentiable public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar
קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי למעט שלב הלמידה הנתון.
הַצהָרָה
public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R
פרמטרים
context
הקשר שיוקם לפני שהסגירה תתקשר ותשוחזר לאחר החזרה של הסגירה.
body
סגירת ביטול. אם הסגר יש ערך בתמורה, ערך המשמש גם כערך החזרה של
withContext(_:_:)
פונקציה.ערך החזרה
הערך המוחזר, אם בכלל, של
body
הסגר.קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי למעט שלב הלמידה הנתון.
הַצהָרָה
public func withLearningPhase<R>( _ learningPhase: LearningPhase, _ body: () throws -> R ) rethrows -> R
פרמטרים
learningPhase
שלב למידה שייקבע לפני שהסגירה תתקבל ותשוחזר לאחר חזרת הסגירה.
body
סגירת ביטול. אם הסגר יש ערך בתמורה, ערך המשמש גם כערך החזרה של
withLearningPhase(_:_:)
פונקציה.ערך החזרה
הערך המוחזר, אם בכלל, של
body
הסגר.קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי למעט הזרע האקראי הנתון.
הַצהָרָה
public func withRandomSeedForTensorFlow<R>( _ randomSeed: TensorFlowSeed, _ body: () throws -> R ) rethrows -> R
פרמטרים
randomSeed
זרע אקראי שיוגדר לפני הסגירה יקרא ויוחזר לאחר החזרה של הסגירה.
body
סגירת ביטול. אם הסגר יש ערך בתמורה, ערך המשמש גם כערך החזרה של
withRandomSeedForTensorFlow(_:_:)
פונקציה.ערך החזרה
הערך המוחזר, אם בכלל, של
body
הסגר.קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי למעט מחולל המספרים האקראיים הנתון.
הַצהָרָה
public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>( _ randomNumberGenerator: inout G, _ body: () throws -> R ) rethrows -> R
פרמטרים
randomNumberGenerator
מחולל מספרים אקראיים שיוגדר לפני הסגירה יקרא וישוחזר לאחר החזרה של הסגירה.
body
סגירת ביטול. אם הסגר יש ערך בתמורה, ערך המשמש גם כערך החזרה של
withRandomNumberGeneratorForTensorFlow(_:_:)
פונקציה.ערך החזרה
הערך המוחזר, אם בכלל, של
body
הסגר.הַצהָרָה
public func zip<T: TensorGroup, U: TensorGroup>( _ dataset1: Dataset<T>, _ dataset2: Dataset<U> ) -> Dataset<Zip2TensorGroup<T, U>>
הַצהָרָה
public func valueWithGradient<T, R>( at x: T, in f: @differentiable (T) -> Tensor<R> ) -> (value: Tensor<R>, gradient: T.TangentVector) where T: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func valueWithGradient<T, U, R>( at x: T, _ y: U, in f: @differentiable (T, U) -> Tensor<R> ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector)) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func valueWithGradient<T, U, V, R>( at x: T, _ y: U, _ z: V, in f: @differentiable (T, U, V) -> Tensor<R> ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector)) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func valueWithGradient<T, R>( of f: @escaping @differentiable (T) -> Tensor<R> ) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector) where T: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func valueWithGradient<T, U, R>( of f: @escaping @differentiable (T, U) -> Tensor<R> ) -> (T, U) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector)) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func valueWithGradient<T, U, V, R>( of f: @escaping @differentiable (T, U, V) -> Tensor<R> ) -> (T, U, V) -> ( value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector) ) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func gradient<T, R>( at x: T, in f: @differentiable (T) -> Tensor<R> ) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func gradient<T, U, R>( at x: T, _ y: U, in f: @differentiable (T, U) -> Tensor<R> ) -> (T.TangentVector, U.TangentVector) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func gradient<T, U, V, R>( at x: T, _ y: U, _ z: V, in f: @differentiable (T, U, V) -> Tensor<R> ) -> (T.TangentVector, U.TangentVector, V.TangentVector) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func gradient<T, R>( of f: @escaping @differentiable (T) -> Tensor<R> ) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func gradient<T, U, R>( of f: @escaping @differentiable (T, U) -> Tensor<R> ) -> (T, U) -> (T.TangentVector, U.TangentVector) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
הַצהָרָה
public func gradient<T, U, V, R>( of f: @escaping @differentiable (T, U, V) -> Tensor<R> ) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
הפוך את הפונקציה לחישוב מחדש בנסיגה שלה, המכונה "מחסום" בהבחנה אוטומטית מסורתית.
הַצהָרָה
public func withRecomputationInPullbacks<T, U>( _ body: @escaping @differentiable (T) -> U ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable
צור פונקציה מובחנת מפונקציית מוצרים וקטוריים-ג'ייקוביים.
הַצהָרָה
public func differentiableFunction<T : Differentiable, R : Differentiable>( from vjp: @escaping (T) -> (value: R, pullback: (R.TangentVector) -> T.TangentVector) ) -> @differentiable (T) -> R
צור פונקציה מובחנת מפונקציית מוצרים וקטוריים-ג'ייקוביים.
הַצהָרָה
public func differentiableFunction<T, U, R>( from vjp: @escaping (T, U) -> (value: R, pullback: (R.TangentVector) -> (T.TangentVector, U.TangentVector)) ) -> @differentiable (T, U) -> R
חזרות
x
כמו פונקציית זהות. כאשר נעשה שימוש בהקשר שבוx
מתבצע בדיל ביחס, פונקציה זו לא תניב שום נגזרת בx
.הַצהָרָה
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
חל על סגירת נתון
body
כדיx
. כאשר נעשה שימוש בהקשר שבוx
מתבצע בדיל ביחס, פונקציה זו לא תניב שום נגזרת בx
.הַצהָרָה
@_semantics("autodiff.nonvarying") public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R
מבצע סגירה, וגורם לפעולות TensorFlow לפעול במכשיר מסוג מסוים.
הַצהָרָה
public func withDevice<R>( _ kind: DeviceKind, _ index: UInt = 0, perform body: () throws -> R ) rethrows -> R
פרמטרים
kind
מעין מכשיר להריץ עליו פעולות TensorFlow.
index
המכשיר להריץ את האופציות.
body
סגירה שאת פעולות TensorFlow יש לבצע בסוג המכשיר שצוין.
מבצע סגירה, וגורם לפעולות TensorFlow לפעול במכשיר בעל שם ספציפי.
כמה דוגמאות לשמות מכשירים:
- "/Device: CPU: 0": המעבד של המכשיר שלך.
- "/GPU: 0": סימון ביד קצרה עבור ה- GPU הראשון של המחשב שלך הנראה ל- TensorFlow
- "/Job: localhost/replica: 0/task: 0/device: GPU: 1": שם מוסמך לחלוטין של ה- GPU השני של המחשב שלך הנראה ל- TensorFlow.
הַצהָרָה
public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R
פרמטרים
name
שם התקן.
body
סגירה שאת פעולות TensorFlow יש לבצע בסוג המכשיר שצוין.
מבצע סגירה ומאפשר ל- TensorFlow למקם פעולות TensorFlow בכל מכשיר. פעולה זו אמורה לשחזר את התנהגות המיקום המוגדרת כברירת מחדל.
הַצהָרָה
public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R
פרמטרים
body
סגירה שאת פעולות TensorFlow יש לבצע בסוג המכשיר שצוין.
שנה את גודל התמונות לגודל באמצעות השיטה שצוינה.
תְנַאִי מוּקדָם
התמונות חייבות להיות בדרגה3
או4
.תְנַאִי מוּקדָם
הגודל חייב להיות חיובי.הַצהָרָה
@differentiable(wrt: images) public func resize( images: Tensor<Float>, size: (newHeight: Int, newWidth: Int), method: ResizeMethod = .bilinear, antialias: Bool = false ) -> Tensor<Float>
שנה את גודל התמונות לגודל באמצעות אינטרפולציה אזורית.
תְנַאִי מוּקדָם
התמונות חייבות להיות בדרגה3
או4
.תְנַאִי מוּקדָם
הגודל חייב להיות חיובי.הַצהָרָה
public func resizeArea<Scalar: TensorFlowNumeric>( images: Tensor<Scalar>, size: (newHeight: Int, newWidth: Int), alignCorners: Bool = false ) -> Tensor<Float>
מחזירה הרחבה דו-ממדית עם הקלט, המסנן, הצעדים והריפוד שצוין.
תְנַאִי מוּקדָם
input
חייב להיות בדרגה4
.תְנַאִי מוּקדָם
filter
חייב להיות בדרגה3
.הַצהָרָה
@differentiable(wrt: (input, filter) public func dilation2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), rates: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filter
מסנן ההרחבה.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע
rates
שיעורי ההתרחבות לכל ממד הקלט.
מחזירה שחיקה דו-ממדית עם הקלט, המסנן, הצעדים והריפוד שצוין.
תְנַאִי מוּקדָם
input
חייב להיות בדרגה4
.תְנַאִי מוּקדָם
filter
חייב להיות בדרגה 3.הַצהָרָה
@differentiable(wrt: (input, filter) public func erosion2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), rates: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filter
מסנן השחיקה.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע
rates
שיעורי ההתרחבות לכל ממד הקלט.
מחזירה פונקציה היוצרת טנסור על ידי אתחול כל ערכיו לאפסים.
הַצהָרָה
public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
מחזירה פונקציה היוצרת טנסור על ידי אתחול כל ערכיו לערך המסופק.
הַצהָרָה
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
מחזירה פונקציה היוצרת טנסור על ידי אתחולו לערך המסופק. שים לב שידור של הערך שסופק אינו נתמך.
הַצהָרָה
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
חזרות פונקציה שיוצרת מותח ידי ביצוע Glorot (Xavier) אתחול אחיד בצורה שצוינה, דגימת ערכים סקלר אקראי מתוך התפלגות אחידה בין
-limit
וlimit
, שנוצרה על ידי מחולל מספרים אקראיים ברירת מחדל, שבו גבול הואsqrt(6 / (fanIn + fanOut))
, וfanIn
/fanOut
מייצגים את מספר הקלט והפלט תכונות מוכפל בשטח פתוח, אם קיים.הַצהָרָה
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
החזרות פונקציה שיוצרת מותח ידי ביצוע Glorot (Xavier) אתחול רגיל עבור הצורה שצוין, דגימה ערכים סקלר אקראי מתוך התפלגות נורמלית מקוצץ התרכזו
0
עם סטיית תקןsqrt(2 / (fanIn + fanOut))
, שבוfanIn
/fanOut
מייצגים את מספר תכונות הקלט והפלט מוכפל בגודל השדה הקולט, אם קיים.הַצהָרָה
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
חזרות פונקציה שיוצרת מותח ידי ביצוע הוא (Kaiming) אתחול אחיד בצורה שצוינה, דגימת ערכים סקלר אקראי מתוך התפלגות אחידה בין
-limit
וlimit
, שנוצרה על ידי מחולל המספרים המחדלים אקראיים, שבו גבול הואsqrt(6 / fanIn)
, וfanIn
מייצג את מספר תכונות קלט מוכפל בשטח פתוח, אם קיים.הַצהָרָה
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
החזרות פונקציה שיוצרת מותח ידי ביצוע הוא (Kaiming) אתחול רגיל עבור הצורה שצוין, דגימה ערכים סקלר אקראי מתוך התפלגות נורמלית מקוצץ התרכזו
0
עם סטיית תקןsqrt(2 / fanIn)
, שבוfanIn
מייצג את מספר תכונות קלט מוכפל בגודל השדה הקולט, אם קיים.הַצהָרָה
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
חזרות פונקציה שיוצרת מותחים על ידי ביצוע אתחול אחיד LeCun עבור הצורה שצוינה, דגימת ערכים סקלר אקראי מתוך התפלגות אחידה בין
-limit
וlimit
, שנוצרה על ידי מחולל מספרים אקראיים ברירת מחדל, שבו גבול הואsqrt(3 / fanIn)
, וfanIn
מייצג את מספר תכונות קלט מוכפל בשטח פתוח, אם קיים.הַצהָרָה
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
חזרות פונקציה שיוצרת מותחים על ידי ביצוע אתחול רגיל LeCun עבור הצורה שצוינה, דגימת ערכים סקלר אקראי מתוך התפלגות נורמאלי מקוצצת התרכזו
0
עם סטיית תקןsqrt(1 / fanIn)
, שבוfanIn
מייצג את מספר קלט תכונות מוכפל גודל שדה קליטה, אם קיים.הַצהָרָה
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
מחזירה פונקציה היוצרת טנסור על ידי אתחול כל ערכיה באופן אקראי מתוך התפלגות נורמלית קטומה. הערכים שנוצר בעקבות התפלגות נורמלית עם ממוצע
mean
ואת סטיית תקןstandardDeviation
, למעט ערכים בסדר גודל שלו הוא יותר משתי סטיות תקן מן הממוצע מושמטים ו resampled.הַצהָרָה
public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>( mean: Tensor<Scalar> = Tensor<Scalar>(0), standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1), seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
פרמטרים
mean
ממוצע ההתפלגות הנורמלית.
standardDeviation
סטיית תקן של ההתפלגות הנורמלית.
ערך החזרה
פונקציית אתחול פרמטר רגיל קטוע.
הַצהָרָה
public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
מחזירה מטריצת זהות או חבורה של מטריצות.
הַצהָרָה
פרמטרים
rowCount
מספר השורות בכל מטריצת אצווה.
columnCount
מספר העמודות בכל מטריצת אצווה.
batchShape
מידות האצווה המובילות של הטנסור המוחזר.
מחשב את העקבות של מטריצה מקובצת אופציונלית. העקוב הוא הסכום לאורך האלכסון הראשי של כל מטריצה פנימית ביותר.
הקלט הוא מותח עם צורה
[..., M, N]
. הפלט הוא מותח עם צורה[...]
.תְנַאִי מוּקדָם
matrix
חייב להיות מותח עם צורה[..., M, N]
.הַצהָרָה
@differentiable(wrt: matrix) public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
פרמטרים
matrix
טנזור של צורה
[..., M, N]
.מחזירה את הפירוק Cholesky של מטריצה מרובעת אחת או יותר.
הקלט הוא מותח של צורה
[..., M, M]
אשר הפנימי ביותר 2 הממדים ליצור מטריצות רבועות.הקלט חייב להיות סימטרי וחיובי. לפעולה זו ישמש רק החלק המשולש התחתון של הקלט. החלק המשולש העליון לא יקרא.
הפלט הוא מותח של אותה צורה כקלט המכיל את decompositions Cholesky לכל submatrices קלט
[..., :, :]
.הַצהָרָה
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
פרמטרים
input
טנזור של צורה
[..., M, M]
.חזרות הפתרון
x
למערכת של משוואות ליניאריות מיוצגות על ידיAx = b
.תְנַאִי מוּקדָם
matrix
חייב להיות מותח עם צורה[..., M, M]
.תְנַאִי מוּקדָם
rhs
חייב להיות מותח עם צורה[..., M, K]
.הַצהָרָה
@differentiable public func triangularSolve<T: TensorFlowFloatingPoint>( matrix: Tensor<T>, rhs: Tensor<T>, lower: Bool = true, adjoint: Bool = false ) -> Tensor<T>
פרמטרים
matrix
הקלט משולש מקדם מטריקס, המייצגת ב
A
Ax = b
.rhs
ערכים בצד ימין, מייצג
b
בAx = b
.lower
אם
matrix
היא משולש נמוך (true
) או משולש עליון (false
). ערך ברירת המחדל הואtrue
.adjoint
אם
true
, לפתור עם adjoint שלmatrix
במקוםmatrix
. ערך ברירת המחדל הואfalse
.ערך החזרה
הפתרון
x
למערכת של משוואות ליניאריות מיוצג על ידיAx = b
.x
יש את אותה צורה כמוb
.מחשב את ההפסד L1 בין
expected
ואתpredicted
.loss = reduction(abs(expected - predicted))
הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את ההפסד L2 בין
expected
ואתpredicted
.loss = reduction(square(expected - predicted))
הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את ממוצע ההבדל המוחלט בין תוויות לתחזיות.
loss = mean(abs(expected - predicted))
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחשב את ממוצע ריבועי השגיאות בין תוויות לתחזיות.
loss = mean(square(expected - predicted))
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחשב את שגיאת לוגריתמים בריבוע הממוצעת בין
predicted
וexpected
loss = square(log(expected) - log(predicted))
הערה
ערכים מותחים שליליים יוצמדו ב
0
כדי למנוע התנהגות לוגריתמים מוגדרת, כמוlog(_:)
איננו מוגדר עבור ריאל השלילית.הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחשב את השגיאה אחוז הממוצע המוחלט בין
predicted
ואתexpected
.loss = 100 * mean(abs((expected - predicted) / abs(expected)))
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
מחשב את ההפסד הציר בין
predicted
ואתexpected
.loss = reduction(max(0, 1 - predicted * expected))
expected
ערכים צפויים להיות -1 או 1.הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את ההפסד ציר בריבוע בין
predicted
ואתexpected
.loss = reduction(square(max(0, 1 - predicted * expected)))
expected
ערכים צפויים להיות -1 או 1.הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את הפסד ציר הקטגוריה בין
predicted
ואתexpected
.loss = maximum(negative - positive + 1, 0)
שבוnegative = max((1 - expected) * predicted)
וpositive = sum(predicted * expected)
הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את הלוגריתם של הקוסינוס ההיפרבולי של שגיאת החיזוי.
logcosh = log((exp(x) + exp(-x))/2)
, כאשר X הוא שגיאהpredicted - expected
הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את ההפסד פואסון בין חזה וצפוי הפסד פואסון הוא הממוצע של האלמנטים של
Tensor
predicted - expected * log(predicted)
.הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
אובדן הבדלי מחשב Kullback-ליבלר בין
expected
ואתpredicted
.loss = reduction(expected * log(expected / predicted))
הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את האנטרופיה הצולבת של softmax הדלילה (אנטרופיה צולבת קטגורית) בין לוגים ותוויות. השתמש בפונקציית אובדן crossentropy זו כאשר יש שתי מחלקות תווית או יותר. אנו מצפים שתוויות יסופקו כמספרים שלמים. לא צריך להיות
# classes
צף ערכי הצבע לכל תכונה עבורlogits
וערך נקודה אחת צף לכל תכונהexpected
.הַצהָרָה
פרמטרים
logits
יציאות מקודדות חד-חם מרשת עצבית.
labels
מדדים (אפס-אינדקס) של התפוקות הנכונות.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את האנטרופיה הצולבת של softmax דלילה (אנטרופיה צולבת קטגוריאלית) בין לוגים ותוויות. השתמש בפונקציית אובדן crossentropy זו כאשר יש שתי מחלקות תווית או יותר. אנו מצפים תוויות להינתן שסופקו
one_hot
ייצוג. לא צריך להיות# classes
צפות ערכי צבע לכול תכונה.הַצהָרָה
פרמטרים
logits
הסתברויות יומן לא מדורגות מרשת עצבית.
probabilities
ערכי הסתברות התואמים את הפלט הנכון. כל שורה חייבת להיות חלוקת הסתברות תקפה.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את האנטרופיה הצולבת הסיגמואדית (אנטרופיה צולבת בינארית) בין לוגים ותוויות. השתמש באובדן חוצה אנטרופיה זה כאשר יש רק שתי מחלקות תוויות (בהנחה שהם 0 ו -1). עבור כל דוגמה, צריך להיות ערך נקודה צפה אחת לכל תחזית.
הַצהָרָה
פרמטרים
logits
הפלט הלא מדורג של רשת עצבית.
labels
ערכים שלמים התואמים את הפלט הנכון.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
מחשב את ההפסד הובר בין
predicted
ואתexpected
.עבור כל ערך
x
בerror = expected - predicted
:-
0.5 * x^2
אם|x| <= δ
. 0.5 * δ^2 + δ * (|x| - δ)
אחרת.מקור: מאמר בויקיפדיה .
הַצהָרָה
פרמטרים
predicted
תפוקות צפויות מרשת עצבית.
expected
ערכים צפויים, כלומר מטרות, התואמים את הפלט הנכון.
delta
סולם נקודה צפה המייצג את הנקודה שבה פונקציית ההפסד של הובר משתנה מרובעת לינארית.
reduction
הפחתה ליישום על ערכי ההפסד המחושבים באלמנטים.
-
מחזירה את הערך המוחלט של רכיב הטנסור שצוין מבחינת אלמנט.
הַצהָרָה
@differentiable public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
מחזירה את הלוגריתם הטבעי של אלמנט הטנסור שצוין מבחינת יסוד.
הַצהָרָה
@differentiable public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הלוגריתם הבסיס-שני של רכיב הטנסור שצוין מבחינה אלמנטית.
הַצהָרָה
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הלוגריתם הבסיסי של רכיב הטנסור שצוין מבחינת רכיב הטנזור.
הַצהָרָה
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
החזרת הלוגריתם של
1 + x
אלמנט-חכם.הַצהָרָה
@differentiable public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
חזרות
log(1 - exp(x))
באמצעות גישה יציבה מבחינה מספרית.הערה
הגישה מוצגת משוואה 7 של: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .הַצהָרָה
@differentiable public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הסינוס של רכיב הטנסור שצוין מבחינת אלמנט.
הַצהָרָה
@differentiable public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הקוסינוס של רכיב הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את המשיק של רכיב הטנסור שצוין מבחינה אלמנטית.
הַצהָרָה
@differentiable public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הסינוס ההיפרבולי של אלמנט הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הקוסינוס ההיפרבולי של אלמנט הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את המשיק ההיפרבולי של אלמנט הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הקוסינוס ההפוך של אלמנט הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הסינוס ההפוך של אלמנט הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את המשיק ההפוך של אלמנט הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הקוסינוס ההיפרבולי ההפוך של האלמנט המצוין.
הַצהָרָה
@differentiable public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הסינוס ההיפרבולי ההפוך של האלמנט המצוין מבחינת רכיב הטנסור.
הַצהָרָה
@differentiable public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את המשיק ההיפרבולי ההפוך של רכיב הטנסור שצוין מבחינת רכיב הטנסור.
הַצהָרָה
@differentiable public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את השורש הריבועי של רכיב הטנסור שצוין.
הַצהָרָה
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את השורש הריבועי ההפוך של רכיב הטנסור שצוין מבחינת רכיב הטנסור.
הַצהָרָה
@differentiable public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את האקספוננציאל של רכיב הטנסור שצוין מבחינת רכיב הטנסור.
הַצהָרָה
@differentiable public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה שניים שהועלו לכוחו של אלמנט הטנסור שצוין מבחינת אלמנט.
הַצהָרָה
@differentiable public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה עשרה שהועלו לכוחו של אלמנט הטנסור שצוין מבחינה יסודית.
הַצהָרָה
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
חזרת המעריכים של
x - 1
אלמנט-חכם.הַצהָרָה
@differentiable public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הערכים של הטנזר שצוין מעוגלים למספר השלם הקרוב ביותר, מבחינת האלמנטים.
הַצהָרָה
@differentiable public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את התקרה של רכיב הטנסור שצוין מבחינת אלמנט.
הַצהָרָה
@differentiable public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את הרצפה של רכיב הטנסור שצוין מבחינת אלמנט.
הַצהָרָה
@differentiable public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה אינדיקציה לסימן של רכיב הטנסור שצוין מבחינת רכיב טנסור. באופן ספציפי, מחשב
y = sign(x) = -1
אםx < 0
; 0 אםx == 0
; 1 אםx > 0
.הַצהָרָה
@differentiable public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
מחזירה את הסיגמואיד של רכיב הטנסור שצוין מבחינת רכיב הטנסור. באופן ספציפי, מחשב
1 / (1 + exp(-x))
.הַצהָרָה
@differentiable public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את log-sigmoid של רכיב הטנסור שצוין מבחינת רכיב טנסור. באופן ספציפי,
log(1 / (1 + exp(-x)))
. לקבלת יציבות נומרית, אנו משתמשים-softplus(-x)
.הַצהָרָה
@differentiable public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את התוכנה הרכה של רכיב הטנסור שצוין מבחינת רכיב הטנסור. באופן ספציפי, מחשב
log(exp(features) + 1)
.הַצהָרָה
@differentiable public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את סימן הרך של רכיב הטנסור שצוין מבחינת רכיב הטנסור. באופן ספציפי, מחשב
features/ (abs(features) + 1)
.הַצהָרָה
@differentiable public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את softmax של הטנזר שצוין לאורך הציר האחרון. באופן ספציפי, מחשב
exp(x) / exp(x).sum(alongAxes: -1)
.הַצהָרָה
@differentiable public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את softmax של הטנזר שצוין לאורך הציר שצוין. באופן ספציפי, מחשב
exp(x) / exp(x).sum(alongAxes: axis)
.הַצהָרָה
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את log-softmax של רכיב הטנסור שצוין מבחינת רכיב טנסור.
הַצהָרָה
@differentiable public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה טנסור על ידי החלת יחידה לינארית מעריכית. באופן ספציפי, מחשב
exp(x) - 1
אם <0,x
אחרת. ראה מהירה ומדויקת עמוק למידה ברשת על ידי מעריכי לינארי יחידות (אלוס)הַצהָרָה
@differentiable public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את ההפעלות של יחידת לינארית השגיאה הגאוסית (GELU) של רכיב הטנסור שצוין מבחינת רכיב טנסור.
באופן ספציפי,
gelu
קירובxP(X <= x)
, שבוP(X <= x)
היא ההתפלגות המצטברת גאוס רגיל, על ידי חישוב: X * [0.5 * (1 + TANH [√ (2 / π) * (x + 0.044715 * x^3)])].הַצהָרָה
@differentiable public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה טנסור על ידי החלת פונקציית ההפעלה ReLU על רכיב הטנסור שצוין מבחינת רכיב טנסור. באופן ספציפי, מחשב
max(0, x)
.הַצהָרָה
@differentiable public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה מותח על ידי יישום פונקצית הפעלת ReLU6, כלומר
min(max(0, x), 6)
.הַצהָרָה
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזיר טנסור על ידי החלת פונקציית ההפעלה ReLU הדולפת על רכיב הטנסור שצוין. באופן ספציפי, מחשב
max(x, x * alpha)
.הַצהָרָה
@differentiable(wrt: x) public func leakyRelu<T: TensorFlowFloatingPoint>( _ x: Tensor<T>, alpha: Double = 0.2 ) -> Tensor<T>
מחזירה מותחת על ידי יישום פונקצית הפעלת SeLU, כלומר
scale * alpha * (exp(x) - 1)
אםx < 0
, וscale * x
אחרת.הערה
זה נועד לשמש יחד עם אתחול שכבת קנה המידה השונות. עיין עצמית נורמליזציה רשתות עצביות לקבלת מידע נוסף.הַצהָרָה
@differentiable public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה מותח על ידי יישום פונקצית הפעלת סוויש, כלומר
x * sigmoid(x)
.מקור: (. ראמאצ'אנדראן ואח 2017) "מחפש פונקציות הפעלה" https://arxiv.org/abs/1710.05941
הַצהָרָה
@differentiable public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה מותח על ידי יישום פונקצית ההפעלה סיגמואיד הקשה, כלומר
Relu6(x+3)/6
.מקור: "מחפשים MobileNetV3" (. הווארד ואח '2019) https://arxiv.org/abs/1905.02244
הַצהָרָה
@differentiable public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה מותח על ידי יישום פונקצית ההפעלה סוויש הקשה, כלומר
x * Relu6(x+3)/6
.מקור: "מחפשים MobileNetV3" (. הווארד ואח '2019) https://arxiv.org/abs/1905.02244
הַצהָרָה
@differentiable public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה מותח על ידי יישום פונקצית הפעלת mish, כלומר
x * tanh(softplus(x))
.מקור: "מיש: עצמי סדיר ללא מונוטונית עצבית הפעלה פונקציה" https://arxiv.org/abs/1908.08681
הַצהָרָה
@differentiable public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את העוצמה של הטנסור הראשון לטנסור השני.
הַצהָרָה
@differentiable public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את עוצמת הסולם לטנסור, משדרת את הסקלר.
הַצהָרָה
@differentiable(wrt: rhs) public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את כוחו של הטנסור לסקלר, משדרת את הסקלר.
הַצהָרָה
@differentiable(wrt: lhs) public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזירה את כוחו של הטנסור לסקלר, משדרת את הסקלר.
הַצהָרָה
@differentiable public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
חזרת מבחינת אלמנט
n
th שורש המותח.הַצהָרָה
@differentiable public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
מחזיר את ההפרש בריבוע בין
x
ו-y
.הַצהָרָה
@differentiable public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
ערך החזרה
(x - y) ^ 2
.מחזירה את המרבי מבחינת האלמנטים של שני טנסורים.
הערה
max
תומך שידור.הַצהָרָה
@differentiable public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
מחזירה את המקסימום מבחינת האלמנטים של הסקלר והטנסור, ומשדרת את הסולם.
הַצהָרָה
@differentiable(wrt: rhs) public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
מחזירה את המקסימום מבחינת האלמנטים של הסקלר והטנסור, ומשדרת את הסולם.
הַצהָרָה
@differentiable(wrt: lhs) public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
מחזירה את המינימום מבחינת האלמנטים של שני טנסורים.
הערה
min
תומך שידור.הַצהָרָה
@differentiable public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
מחזירה את המינימום מבחינת האלמנטים של הסקלר והטנסור, ומשדרת את הסולם.
הַצהָרָה
@differentiable(wrt: rhs) public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
מחזירה את המינימום מבחינת האלמנטים של הסקלר והטנסור, ומשדרת את הסולם.
הַצהָרָה
@differentiable(wrt: lhs) public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
חזרות הדמיון קוסינוס בין
x
ו-y
.הַצהָרָה
@differentiable public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
חזרות המרחק קוסינוס בין
x
ו-y
. מרחק קוסינוס מוגדר1 - cosineSimilarity(x, y)
.הַצהָרָה
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
מחזירה עיקול בתלת ממד עם הקלט, הסינון, הצעד והריפוד שצוין.
תְנַאִי מוּקדָם
input
חייב להיות בדרגה3
.תְנַאִי מוּקדָם
filter
חייב להיות בדרגה 3.הַצהָרָה
@differentiable(wrt: (input, filter) public func conv1D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, stride: Int = 1, padding: Padding = .valid, dilation: Int = 1 ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filter
מסנן הכיפוף.
stride
הצעד של מסנן הזזה.
padding
הריפוד למבצע.
dilation
גורם ההרחבה.
מחזירה עיקול דו-ממדי עם הקלט, המסנן, הצעדים והריפוד שצוין.
תְנַאִי מוּקדָם
input
חייב להיות בדרגה4
.תְנַאִי מוּקדָם
filter
חייב להיות בדרגה 4.הַצהָרָה
@differentiable(wrt: (input, filter) public func conv2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid, dilations: (Int, Int, Int, Int) = (1, 1, 1, 1) ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filter
מסנן הכיפוף.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע
dilations
גורם ההתרחבות לכל ממד של הקלט.
מחזירה עיקול משולב דו-ממדי עם הקלט, המסנן, הצעדים והריפוד שצוין.
תְנַאִי מוּקדָם
input
חייב להיות בדרגה4
.תְנַאִי מוּקדָם
filter
חייב להיות בדרגה 4.הַצהָרָה
@differentiable(wrt: (input, filter) public func transposedConv2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, shape: [Int64], filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid, dilations: (Int, Int, Int, Int) = (1, 1, 1, 1) ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
shape
צורת הפלט של פעולת הפירוק.
filter
מסנן הכיפוף.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע
dilations
גורם ההתרחבות לכל ממד של הקלט.
מחזירה עיקול תלת-ממדי עם הקלט שצוין, מסנן, צעדים, ריפוד והרחבות.
תְנַאִי מוּקדָם
input
חייב להיות בדרגה5
.תְנַאִי מוּקדָם
filter
חייב להיות בדרגה 5.הַצהָרָה
@differentiable(wrt: (input, filter) public func conv3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1), padding: Padding = .valid, dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1) ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filter
מסנן הכיפוף.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע.
dilations
גורם ההתרחבות לכל ממד הקלט.
מחזירה עיקול דו-ממדי עם הקלט, המסנן, הצעדים והריפוד שצוין.
תְנַאִי מוּקדָם
input
חייב להיות בדרגה 4.תְנַאִי מוּקדָם
filter
חייב להיות בדרגה 4.הַצהָרָה
@differentiable(wrt: (input, filter) public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filter
מסנן ההתכווצות לעומק.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע.
מחזירה צירוף מקסימלי דו-ממדי, עם גדלי המסננים, הצעדים והריפוד שצוין.
הַצהָרָה
@differentiable(wrt: input) public func maxPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filterSize
ממדי הגרעין המאגר.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע.
מחזירה איחוד מקסימלי תלת-ממדי, עם גדלי המסננים, הצעדים והריפוד שצוין.
הַצהָרָה
@differentiable(wrt: input) public func maxPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filterSize
ממדי הגרעין המאגר.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע.
מחזירה איחוד ממוצע דו-ממדי, עם גדלי המסננים, הצעדים והריפוד שצוין.
הַצהָרָה
@differentiable(wrt: input) public func avgPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filterSize
ממדי הגרעין המאגר.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע.
מחזירה איחוד ממוצע תלת-ממדי, עם גדלי המסננים, הצעדים והריפוד שצוין.
הַצהָרָה
@differentiable(wrt: input) public func avgPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
פרמטרים
input
הקלט.
filterSize
ממדי הגרעין המאגר.
strides
הצעדים של מסנן הזזה לכל ממד הקלט.
padding
הריפוד למבצע.
מחזירה איחוד מקסימלי שברירי דו-ממדי, עם יחסי האיחוד שצוין.
הערה:
fractionalMaxPool
אין יישום XLA, וכך עשוי להיות שלכות ביצועים.הַצהָרָה
@differentiable(wrt: input) public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, poolingRatio: (Double, Double, Double, Double), pseudoRandom: Bool = false, overlapping: Bool = false, deterministic: Bool = false, seed: Int64 = 0, seed2: Int64 = 0 ) -> Tensor<Scalar>
פרמטרים
input
טנסור. 4-D עם צורה
[batch, height, width, channels]
.poolingRatio
רשימת
Doubles
. איגום יחס לכל מימד שלinput
, תומך כעת רק מימד שורה col וצריך להיות> = 1.0.pseudoRandom
אופציונלי
Bool
. ברירות מחדל כדיfalse
. כאשר מוגדרtrue
, יוצר רצף האיגום בצורה פסוודו, אחרת, באופן אקראי.overlapping
אופציונלי
Bool
. ברירות מחדל כדיfalse
. כאשר מוגדרtrue
, זה אומר כאשר איגום, הערכים בגבול תאי איגום הסמוך נמצאים בשימוש על ידי שני תאים.deterministic
אופציונלי
Bool
. כאשר מוגדרtrue
, אזור איגום קבוע ישמש כאשר ולביקורות מעל צומת fractionalMaxPool2D בגרף החישוב.seed
אופציונלי
Int64
. ברירות מחדל כדי0
. אם הוא מוגדר להיות לא אפס, מחולל המספרים האקראיים נזרע על ידי הזרע הנתון.seed2
אופציונלי
Int64
. ברירות מחדל כדי0
. זרע שני למניעת התנגשות זרעים.החזרת עותק של
input
שבו ערכים מממד העומק מועברים בבלוקים מרחבית לגובה וממדי רוחב.לדוגמה, נתון קלט בכושר
[1, 2, 2, 1]
, data_format = "NHWC" ו block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
פלט רצון פעולה זו טנזור של צורה
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
הנה, הקלט יש קבוצה של 1 וכול אלמנט יצווה יש צורה
[2, 2, 1]
, את הפלט המתאים יהיה אלמנט בודד (כלומר רוחב והגובה הם 1) ויהיה בעל עומק של 4 ערוצים (1 * block_size * block_size). צורת אלמנט הפלט היא[1, 1, 4]
.לקבלת מותח קלט עם עומק גדול, כאן בכושר
[1, 2, 2, 3]
, למשלx = [[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]]
פעולה זו, עבור block_size של 2, תחזיר את המותח של הצורה הבאה
[1, 1, 1, 12]
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
באופן דומה, עבור הקלט הבא של צורה
[1 4 4 1]
, וכן גודל בלוק של 2:x = [[[[1], [2], [5], [6]], [[3], [4], [7], [8]], [[9], [10], [13], [14]], [[11], [12], [15], [16]]]]
המפעיל יחזיר את המותח של הצורה הבאה
[1 2 2 4]
:x = [[[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]]]
תְנַאִי מוּקדָם
input.rank == 4 && b >= 2
.תְנַאִי מוּקדָם
מספר התכונות חייבים להתחלק רבוע שלb
.הַצהָרָה
@differentiable(wrt: input) public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
החזרת עותק של
input
שבו ערכים מן הגובה ממדי רוחב מועברים ממד העומק.לדוגמה, נתון קלט בכושר
[1, 2, 2, 1]
, data_format = "NHWC" ו block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
פלט רצון פעולה זו טנזור של צורה
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
הנה, הקלט יש קבוצה של 1 וכול אלמנט יצווה יש צורה
[2, 2, 1]
, את הפלט המתאים יהיה אלמנט בודד (כלומר רוחב וגובה הם 1) ויהיה בעל עומק של 4 ערוצים (1 * block_size * block_size). צורת אלמנט הפלט היא[1, 1, 4]
.לקבלת מותח קלט עם עומק גדול, כאן בכושר
[1, 2, 2, 3]
, למשלx = [[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]]
פעולה זו, עבור block_size של 2, תחזיר את המותח של הצורה הבאה
[1, 1, 1, 12]
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
Similarly, for the following input of shape
[1 4 4 1]
, and a block size of 2:x = [[[[1], [2], [5], [6]], [[3], [4], [7], [8]], [[9], [10], [13], [14]], [[11], [12], [15], [16]]]]
the operator will return the following tensor of shape
[1 2 2 4]
:x = [[[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]]]
תְנַאִי מוּקדָם
input.rank == 4 && b >= 2
.תְנַאִי מוּקדָם
The height of the input must be divisible byb
.תְנַאִי מוּקדָם
The width of the input must be divisible byb
.הַצהָרָה
@differentiable(wrt: input) public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).
הַצהָרָה
public func makeLARS( learningRate: Float = 0.01, momentum: Float = 0.9, trustCoefficient: Float = 0.001, nesterov: Bool = false, epsilon: Float = 0.0, weightDecay: Float = 0.0 ) -> ParameterGroupOptimizer
Builds a SGD based per-weight optimizer.
הַצהָרָה
public func makeSGD( learningRate: Float = 0.01, momentum: Float = 0, weightDecay: Float = 0, nesterov: Bool = false ) -> ParameterGroupOptimizer
Builds a per-weight optimizer for Adam with weight decay.
הַצהָרָה
public func makeAdam( learningRate: Float = 0.01, beta1: Float = 0.9, beta2: Float = 0.999, weightDecayRate: Float = 0.01, epsilon: Float = 1e-6 ) -> ParameterGroupOptimizer
Generates a new random seed for TensorFlow.
הַצהָרָה
public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
Concatenates two values.
הַצהָרָה
@differentiable public func concatenate<T: Mergeable>( _ first: T, _ second: T ) -> T
Adds two values and produces their sum.
הַצהָרָה
@differentiable public func sum<T: Mergeable>( _ first: T, _ second: T ) -> T
Averages two values.
הַצהָרָה
@differentiable public func average<T: Mergeable>( _ first: T, _ second: T ) -> T
Multiplies two values.
הַצהָרָה
@differentiable public func multiply<T: Mergeable>( _ first: T, _ second: T ) -> T
Stack two values.
הַצהָרָה
@differentiable public func stack<T: Mergeable>( _ first: T, _ second: T ) -> T
הַצהָרָה
public func PrintX10Metrics()
Creates a string summary of a list of training and testing stats.
הַצהָרָה
public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
הַצהָרָה
public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics) -> String
Maps a function over n threads.
הַצהָרָה
public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]