אזהרה: פרויקט זה הוצא משימוש. Swift for TensorFlow היה ניסוי בפלטפורמת הדור הבא ללמידת מכונה, המשלבת את המחקר העדכני ביותר על פני למידת מכונה, מהדרים, תכנות שניתן להבדיל, עיצוב מערכות ומעבר לכך. זה הועבר לארכיון בפברואר 2021.

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

פונקציות

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

l1Loss(חזוי:צפוי:)
מחזירה את הפסד L1 בין תחזיות לציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l1Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
פלטים חזויים מרשת עצבית.
expected
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
l2Loss(חזוי:צפוי:)
מחזירה את הפסד L2 בין תחזיות לציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l2Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
פלטים חזויים מרשת עצבית.
expected
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
צירLoss(חזוי:צפוי:)
מחזירה את אובדן הציר בין התחזיות והציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func hingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
פלטים חזויים מרשת עצבית.
expected
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
squaredHingeLoss(predicted:expected:)
מחזירה את אובדן הציר בריבוע בין תחזיות לציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
פלטים חזויים מרשת עצבית.
expected
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
categoricalHingeLoss(חזוי:צפוי:)
מחזירה את אובדן הציר הקטגורי בין תחזיות לציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
פלטים חזויים מרשת עצבית.
expected
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
logCoshLoss(צפוי:צפוי:)
מחזירה את הלוגריתם של הקוסינוס ההיפרבולי של השגיאה בין התחזיות לציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func logCoshLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
פלטים חזויים מרשת עצבית.
expected
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
poissonLoss(חזוי:צפוי:)
מחזיר את הפסד ה-Poisson בין תחזיות לציפיות.
הַצהָרָה
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func poissonLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
predicted
פלטים חזויים מרשת עצבית.
expected
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
kullbackLeiblerDivergence(חזוי:צפוי:)
מחזירה את סטיית ה-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
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
softmaxCrossEntropy(logits:probabilities:)
מחזירה את האנטרופיית צולב softmax (אנטרופיית צולב קטגורית) בין לוגיטים ותוויות.
הַצהָרָה
@differentiable(wrt: logits) public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, probabilities: Tensor<Scalar> ) -> Tensor<Scalar>
פרמטרים
logits
פלטים מקודדים חדים מרשת עצבית.
labels
מדדים (אינדקס אפס) של התפוקות הנכונות.
sigmoidCrossEntropy(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

withContext(_:_:)

קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי מלבד שלב הלמידה הנתון.

הַצהָרָה

public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R

פרמטרים

`context`	הקשר שיוגדר לפני שהסגירה תיקרא וישוחזר לאחר שהסגר יחזור.
`body`	סגירה אפסית. אם לסגירה יש ערך החזרה, ערך זה משמש גם כערך ההחזרה של הפונקציה `withContext(_:_:)` .

ערך החזרה

ערך ההחזרה, אם בכלל, של סגירת body .

withLearningPhase(_:_:)

קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי מלבד שלב הלמידה הנתון.

הַצהָרָה

public func withLearningPhase<R>(
  _ learningPhase: LearningPhase,
  _ body: () throws -> R
) rethrows -> R

פרמטרים

`learningPhase`	שלב למידה שיוגדר לפני הקריאה לסגירה וישוחזר לאחר חזרת הסגירה.
`body`	סגירה אפסית. אם לסגירה יש ערך החזרה, ערך זה משמש גם כערך ההחזרה של הפונקציה `withLearningPhase(_:_:)` .

ערך החזרה

ערך ההחזרה, אם בכלל, של סגירת body .

withRandomSeedForTensorFlow(_:_:)

קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי מלבד הזרע האקראי הנתון.

הַצהָרָה

public func withRandomSeedForTensorFlow<R>(
  _ randomSeed: TensorFlowSeed,
  _ body: () throws -> R
) rethrows -> R

פרמטרים

`randomSeed`	סיד אקראי שיוגדר לפני שהסגר ייקרא וישוחזר לאחר שהסגר יחזור.
`body`	סגירה אפסית. אם לסגירה יש ערך החזרה, ערך זה משמש גם כערך ההחזרה של הפונקציה `withRandomSeedForTensorFlow(_:_:)` .

ערך החזרה

ערך ההחזרה, אם בכלל, של סגירת body .

withRandomNumberGeneratorForTensorFlow(_:_:)

קורא לסגירה הנתונה בתוך הקשר שיש בו הכל זהה להקשר הנוכחי מלבד מחולל המספרים האקראיים הנתון.

הַצהָרָה

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

LazyTensorBarrier(on:devices:wait:)
LazyTensorBarrier מבטיח שכל הטנזורים החיים (במכשיר אם מסופקים) מתוזמנים ופועלים. אם המתנה מוגדרת כ-true, השיחה הזו נחסמת עד להשלמת החישוב.
הַצהָרָה
public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

valueWithGradient(at:in:)

הַצהָרָה

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

valueWithGradient(at:_:in:)

הַצהָרָה

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

valueWithGradient(at:_:_:in:)

הַצהָרָה

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

valueWithGradient(of:)

הַצהָרָה

public func valueWithGradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

valueWithGradient(of:)

הַצהָרָה

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

valueWithGradient(of:)

הַצהָרָה

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

gradient(at:in:)

הַצהָרָה

public func gradient<T, R>(
  at x: T,
  in f: @differentiable (T) -> Tensor<R>
) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

gradient(at:_:in:)

הַצהָרָה

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

gradient(at:_:_:in:)

הַצהָרָה

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

withRecomputationInPullbacks(_:)

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

הַצהָרָה

public func withRecomputationInPullbacks<T, U>(
  _ body: @escaping @differentiable (T) -> U
) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable

differentiableFunction (מאת:)

צור פונקציה הניתנת להבדלה מפונקציית מוצרים וקטור-יעקביים.

הַצהָרָה

public func differentiableFunction<T : Differentiable, R : Differentiable>(
  from vjp: @escaping (T)
           -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
) -> @differentiable (T) -> R

differentiableFunction (מאת:)

צור פונקציה הניתנת להבדלה מפונקציית מוצרים וקטור-יעקביים.

הַצהָרָה

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
ללא נגזרת(at:in:)
מחיל את body הסגירה הנתון על x . כאשר נעשה שימוש בהקשר שבו x מובחן ביחס אליו, פונקציה זו לא תייצר נגזרת כלשהי ב- x .
הַצהָרָה
@_semantics("autodiff.nonvarying") public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R

withDevice(_:_:perform:)

מבצע סגירה, מה שגורם לפעולות TensorFlow לפעול על סוג מסוים של מכשיר.

הַצהָרָה

public func withDevice<R>(
  _ kind: DeviceKind,
  _ index: UInt = 0,
  perform body: () throws -> R
) rethrows -> R

פרמטרים

`kind`	מעין מכשיר להפעלת פעולות TensorFlow.
`index`	המכשיר להפעיל את האופציות עליו.
`body`	סגירה שפעולות ה-TensorFlow שלו אמורות להתבצע בסוג המכשיר שצוין.

withDevice(named:perform:)
מבצע סגירה, מה שגורם לפעולות 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 שלו אמורות להתבצע בסוג המכשיר שצוין.
withDefaultDevice(ביצוע:)
מבצע סגירה, המאפשר ל-TensorFlow למקם פעולות של TensorFlow בכל מכשיר. פעולה זו אמורה לשחזר את התנהגות המיקום המוגדרת כברירת מחדל.
הַצהָרָה
public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R
פרמטרים
body
סגירה שפעולות ה-TensorFlow שלו אמורות להתבצע בסוג המכשיר שצוין.

resize(images:size:method:antialias:)

שנה את גודל התמונות לפי השיטה שצוינה.

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

התמונות חייבות להיות בדרגה 3 או 4 .

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

הגודל חייב להיות חיובי.

הַצהָרָה

@differentiable(wrt: images)
public func resize(
  images: Tensor<Float>,
  size: (newHeight: Int, newWidth: Int),
  method: ResizeMethod = .bilinear,
  antialias: Bool = false
) -> Tensor<Float>

פרמטרים

`images`	4-D `Tensor` של צורה `[batch, height, width, channels]` או 3-D `Tensor` של צורה `[height, width, channels]` .
`size`	הגודל החדש של התמונות.
`method`	שיטת שינוי הגודל. ערך ברירת המחדל הוא `.bilinear` .
`antialias`	אם זה `true` , השתמש במסנן נגד כינוי בעת הורדת דגימת תמונה.

resizeArea(images:size:alignCorners:)
שנה את גודל התמונות לגודל באמצעות אינטרפולציה אזורית.
תְנַאִי מוּקדָם
התמונות חייבות להיות בדרגה 3 או 4 .
תְנַאִי מוּקדָם
הגודל חייב להיות חיובי.
הַצהָרָה
public func resizeArea<Scalar: TensorFlowNumeric>( images: Tensor<Scalar>, size: (newHeight: Int, newWidth: Int), alignCorners: Bool = false ) -> Tensor<Float>
פרמטרים
images
4-D Tensor של צורה [batch, height, width, channels] או 3-D Tensor של צורה [height, width, channels] .
size
הגודל החדש של התמונות.

dilation2D(_:filter:strides:rates:padding:)

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

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

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`	שיעורי ההתרחבות עבור כל מימד של הקלט.

erosion2D(_:filter:strides:rates:padding:)

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

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

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
constantInitializer(ערך:)
מחזירה פונקציה שיוצרת טנזור על ידי אתחול כל הערכים שלו לערך שסופק.
הַצהָרָה
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
constantInitializer(ערך:)
מחזירה פונקציה שיוצרת טנזור על ידי אתחולו לערך שסופק. שים לב ששידור של הערך שסופק אינו נתמך.
הַצהָרָה
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
glorotUniform(זרע:)
מחזירה פונקציה שיוצרת טנזור על ידי ביצוע אתחול האחיד של Glorot (Xavier) עבור הצורה שצוינה, דגימה אקראית של ערכים סקלרים מהתפלגות אחידה בין -limit ל- limit , שנוצרת על ידי מחולל המספרים האקראיים המוגדר כברירת מחדל, כאשר limit הוא sqrt(6 / (fanIn + fanOut)) , ו- fanIn / fanOut מייצגים את מספר תכונות הקלט והפלט כפול השדה הקולט, אם קיים.
הַצהָרָה
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
glorotNormal(זרע:)
מחזירה פונקציה שיוצרת טנזור על ידי ביצוע אתחול נורמלי של Glorot (Xavier) עבור הצורה שצוינה, דגימה אקראית של ערכים סקלרים מהתפלגות נורמלית קטומה שמרכזה 0 עם סטיית תקן sqrt(2 / (fanIn + fanOut)) , כאשר fanIn / fanOut מייצגים את מספר תכונות הקלט והפלט כפול גודל השדה הקולט, אם קיים.
הַצהָרָה
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
heUniform(זרע:)
מחזירה פונקציה שיוצרת טנזור על ידי ביצוע האתחול האחיד של He (Kaiming) עבור הצורה שצוינה, דגימה אקראית של ערכים סקלרים מהתפלגות אחידה בין -limit ל- limit , שנוצרה על ידי מחולל ברירת המחדל של מספרים אקראיים, כאשר limit הוא sqrt(6 / fanIn) , ו- fanIn מייצג את מספר תכונות הקלט כפול השדה הקולט, אם קיים.
הַצהָרָה
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
heNormal(זרע:)
מחזירה פונקציה שיוצרת טנזור על ידי ביצוע האתחול הרגיל של He (Kaiming) עבור הצורה שצוינה, דגימה אקראית של ערכים סקלרים מהתפלגות נורמלית קטומה שבמרכזה 0 עם סטיית תקן sqrt(2 / fanIn) , כאשר fanIn מייצגת את מספר תכונות הקלט מוכפל בגודל השדה הקולט, אם קיים.
הַצהָרָה
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunUniform(זרע:)
מחזירה פונקציה שיוצרת טנזור על ידי ביצוע אתחול אחיד של LeCun עבור הצורה שצוינה, דגימה אקראית של ערכים סקלרים מהתפלגות אחידה בין -limit ל- limit , שנוצרה על ידי מחולל ברירת המחדל של מספרים אקראיים, כאשר limit הוא sqrt(3 / fanIn) ו fanIn מייצג את מספר תכונות הקלט כפול השדה הקולט, אם קיים.
הַצהָרָה
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
leCunNormal(זרע:)
מחזירה פונקציה שיוצרת טנזור על ידי ביצוע אתחול נורמלי של LeCun עבור הצורה שצוינה, דגימה אקראית של ערכים סקלרים מהתפלגות נורמלית קטומה שבמרכזה 0 עם סטיית תקן sqrt(1 / fanIn) , כאשר fanIn מייצג את מספר תכונות הקלט כפול ה- גודל שדה קליט, אם קיים.
הַצהָרָה
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
truncatedNormalInitializer(mean:standarddeviation:seed:)
מחזירה פונקציה שיוצרת טנזור על ידי אתחול כל ערכיו באופן אקראי מהתפלגות נורמלית קטועה. הערכים שנוצרו עוקבים אחר התפלגות נורמלית עם mean וסטיית תקן standardDeviation , אלא שערכים שגודלם יותר משתי סטיות תקן מהממוצע נשמטים ונדגמים מחדש.
הַצהָרָה
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

eye(rowCount:columnCount:batchShape:on:)

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

הַצהָרָה

public func eye<Scalar: Numeric>(
  rowCount: Int,
  columnCount: Int? = nil,
  batchShape: [Int] = [],
  on device: Device = .default
) -> Tensor<Scalar>

פרמטרים

`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 הממדים הפנימיים ביותר שלו יוצרים מטריצות מרובעות.
הקלט חייב להיות סימטרי וחיובי מוגדר. רק החלק התחתון-משולש של הקלט ישמש לפעולה זו. החלק העליון-משולש לא ייקרא.
הפלט הוא טנסור בעל צורה זהה לקלט המכיל את הפירוקים של Cholesky עבור כל תת-מטריצות הקלט [..., :, :] .
הַצהָרָה
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
פרמטרים
input
טנסור של צורה [..., M, M] .

triangularSolve(matrix:rhs:lower:adjoint:)

מחזירה את הפתרון 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` , פתרו עם הצמוד של `matrix` במקום `matrix` . ערך ברירת המחדל הוא `false` .

ערך החזרה

הפתרון x למערכת המשוואות הלינאריות המיוצגות על ידי Ax = b . x יש אותה צורה כמו b .

l1Loss(חזוי:צפוי:הפחתה:)

מחשב את הפסד L1 בין expected predicted . loss = reduction(abs(expected - predicted))

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l1Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

l2Loss(חזוי:צפוי:הפחתה:)

מחשב את אובדן L2 בין expected predicted . loss = reduction(square(expected - predicted))

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l2Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

meanAbsoluteError(צפוי:צפוי:)
מחשב את הממוצע של ההבדל המוחלט בין תוויות ותחזיות. 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
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
meanSquaredError(צפוי:צפוי:)
מחשב את הממוצע של ריבועי שגיאות בין תוויות ותחזיות. 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
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
meanSquaredLogarithmicError(צפוי:צפוי:)
מחשב את השגיאה הלוגריתמית הממוצעת בריבוע בין הפסד 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
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
meanAbsolutePercentageError(צפוי:צפוי:)
מחשב את השגיאה הממוצעת באחוז מוחלט בין 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
ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.

צירLoss(חזוי:צפוי:הפחתה:)

מחשב את אובדן הציר בין predicted expected . loss = reduction(max(0, 1 - predicted * expected)) הערכים expected צפויים להיות -1 או 1.

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

squaredHingeLoss(predicted:expected:reduction:)

מחשב את אובדן הציר בריבוע בין predicted expected . loss = reduction(square(max(0, 1 - predicted * expected))) הערכים expected צפויים להיות -1 או 1.

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

categoricalHingeLoss(חזוי:צפוי:הפחתה:)

מחשב את אובדן הציר הקטגורי בין predicted expected . loss = maximum(negative - positive + 1, 0) כאשר negative = max((1 - expected) * predicted) positive = sum(predicted * expected)

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

logCoshLoss(צפוי:צפוי:הפחתה:)

מחשב את הלוגריתם של הקוסינוס ההיפרבולי של שגיאת החיזוי. logcosh = log((exp(x) + exp(-x))/2) , כאשר x הוא השגיאה predicted - expected

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

poissonLoss(חזוי:צפוי:הפחתה:)

מחשב את אובדן ה-Poisson בין החזוי לצפוי אובדן ה-Poisson הוא הממוצע של האלמנטים של Tensor predicted - expected * log(predicted) .

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

kullbackLeiblerDivergence(חזוי:צפוי:הפחתה:)

מחשב את אובדן סטיית ה-Kullback-Leibler בין expected predicted . loss = reduction(expected * log(expected / predicted))

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

softmaxCrossEntropy(logits:labels:reduction:)

מחשב את האנטרופיית צולבת softmax הדלילה (אנטרופיית צולבת קטגורית) בין לוגיטים ותוויות. השתמש בפונקציית אובדן קרוסנטרופיה זו כאשר יש שתי מחלקות תוויות או יותר. אנו מצפים שתוויות יסופקו כמספרים שלמים. צריכים להיות # classes ערכי נקודה צפה לכל תכונה עבור logits וערך נקודה צפה בודדת לכל תכונה עבור expected .

הַצהָרָה

@differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Int32>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

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

softmaxCrossEntropy(logits:probabilities:reduction:)

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

הַצהָרָה

@differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  probabilities: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

`logits`	הסתברויות יומן לא מותאמות מרשת עצבית.
`probabilities`	ערכי הסתברות התואמים את הפלט הנכון. כל שורה חייבת להיות התפלגות הסתברות חוקית.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

sigmoidCrossEntropy(logits:labels:reduction:)

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

הַצהָרָה

@differentiable(wrt: logits)
@differentiable(wrt: (logits, labels)
public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

פרמטרים

`logits`	הפלט הבלתי מותאם של רשת עצבית.
`labels`	ערכים שלמים התואמים לפלט הנכון.
`reduction`	הפחתה ליישום על ערכי ההפסד המחושבים ברכיבים.

huberLoss(predicted:expected:delta:reduction:)

מחשב את אובדן הובר בין predicted expected .

עבור כל ערך x error = expected - predicted :

0.5 * x^2 אם |x| <= δ .
0.5 * δ^2 + δ * (|x| - δ) אחרת.
מקור: מאמר ויקיפדיה .

הַצהָרָה

@differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func huberLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  delta: Scalar,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

פרמטרים

`predicted`	פלטים חזויים מרשת עצבית.
`expected`	ערכים צפויים, כלומר יעדים, התואמים את הפלט הנכון.
`delta`	סקלאר של נקודה צפה המייצגת את הנקודה שבה פונקציית האובדן של Huber משתנה ממרובע לליניארי.
`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
log2(_:)
מחזירה את הלוגריתם בסיס שניים של הטנסור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
log10(_:)
מחזירה את הלוגריתם של בסיס עשר של רכיב הטנזור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

log1p(_:)

מחזירה את הלוגריתם של 1 + x מבחינת אלמנט.

הַצהָרָה

@differentiable
public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

log1mexp(_:)
מחזירה 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
sinh(_:)
מחזירה את הסינוס ההיפרבולי של הטנסור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
cosh(_:)
מחזירה את הקוסינוס ההיפרבולי של הטנזור שצוין מבחינה אלמנטרית.
הַצהָרָה
@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
acos(_:)
מחזירה את הקוסינוס ההפוך של הטנסור שצוין מבחינה אלמנטית.
הַצהָרָה
@differentiable public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
asin(_:)
מחזירה את הסינוס ההפוך של הטנסור שצוין מבחינה אלמנטרית.
הַצהָרָה
@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
acosh(_:)
מחזירה את הקוסינוס ההיפרבולי ההפוך של הטנזור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
asinh(_:)
מחזירה את הסינוס ההיפרבולי ההפוך של הטנסור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
atanh(_:)
מחזירה את הטנגנס ההיפרבולי ההפוך של הטנסור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
sqrt(_:)
מחזירה את השורש הריבועי של הרכיב הטנזור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
rsqrt(_:)
מחזירה את השורש הריבועי ההפוך של הטנסור שצוין מבחינה אלמנטרית.
הַצהָרָה
@differentiable public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
exp(_:)
מחזירה את האקספוננציאל של הטנסור שצוין מבחינה אלמנטית.
הַצהָרָה
@differentiable public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
exp2(_:)
מחזירה שתיים מורמות בחזקת הטנסור שצוין מבחינה אלמנטית.
הַצהָרָה
@differentiable public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
exp10(_:)
מחזירה עשר מורם בחזקת הטנזור שצוין מבחינה אלמנטית.
הַצהָרָה
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

expm1(_:)

מחזירה את המעריך של 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
logSigmoid(_:)
מחזירה את הלוג-סיגמואיד של הטנסור שצוין מבחינה אלמנטית. באופן ספציפי, log(1 / (1 + exp(-x))) . ליציבות מספרית, אנו משתמשים -softplus(-x) .
הַצהָרָה
@differentiable public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
softplus(_:)
מחזירה את ה-softplus של הטנסור שצוין מבחינה אלמנטית. באופן ספציפי, מחשב log(exp(features) + 1) .
הַצהָרָה
@differentiable public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
softsign(_:)
מחזירה את הסימן הרך של הטנסור שצוין מבחינה אלמנטית. באופן ספציפי, מחשב features/ (abs(features) + 1) .
הַצהָרָה
@differentiable public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
softmax(_:)
מחזירה את ה-softmax של הטנזור שצוין לאורך הציר האחרון. באופן ספציפי, מחשב exp(x) / exp(x).sum(alongAxes: -1) .
הַצהָרָה
@differentiable public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
softmax(_:alongAxis:)
מחזירה את ה-softmax של הטנזור שצוין לאורך הציר שצוין. באופן ספציפי, מחשב exp(x) / exp(x).sum(alongAxes: axis) .
הַצהָרָה
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
logSoftmax(_:)
מחזירה את log-softmax של הטנסור שצוין מבחינה אלמנטית.
הַצהָרָה
@differentiable public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
elu(_:)
מחזירה טנזור על ידי החלת יחידה לינארית מעריכית. באופן ספציפי, מחשב exp(x) - 1 אם < 0, x אחרת. ראה למידת רשת עמוקה מהירה ומדויקת על ידי יחידות לינאריות אקספוננציאליות (ELU)
הַצהָרָה
@differentiable public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
gelu(_:)
מחזירה את הפעלות של יחידת השגיאה הלינארית של גאוס (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(_:)
מחזירה טנסור על ידי החלת פונקציית ההפעלה של ReLU על הטנזור שצוין מבחינה אלמנטית. באופן ספציפי, מחשב את max(0, x) .
הַצהָרָה
@differentiable public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
relu6(_:)
מחזירה טנזור על ידי הפעלת פונקציית ההפעלה ReLU6, כלומר min(max(0, x), 6) .
הַצהָרָה
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
leakyRelu(_:alpha:)
מחזירה טנזור על-ידי החלת פונקציית ההפעלה הדולפת של ReLU על רכיב הטנזור שצוין. באופן ספציפי, מחשב max(x, x * alpha) .
הַצהָרָה
@differentiable(wrt: x) public func leakyRelu<T: TensorFlowFloatingPoint>( _ x: Tensor<T>, alpha: Double = 0.2 ) -> Tensor<T>
selu(_:)
מחזירה טנזור על-ידי החלת פונקציית ההפעלה של SeLU, כלומר scale * alpha * (exp(x) - 1) אם x < 0 , וקנה scale * x אחרת.
הערה
זה נועד לשמש יחד עם אתחולי שכבת קנה המידה של השונות. אנא עיין ב- Self-Normalizing Neural Networks לקבלת מידע נוסף.
הַצהָרָה
@differentiable public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
לְהַצְלִיף(_:)
מחזירה טנזור על ידי הפעלת פונקציית הפעלת swish, כלומר x * sigmoid(x) .
מקור: "חיפוש אחר פונקציות הפעלה" (Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941
הַצהָרָה
@differentiable public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
hardSigmoid(_:)
מחזירה טנזור על ידי החלת פונקציית ההפעלה הקשיחה של סיגמואיד, כלומר Relu6(x+3)/6 .
מקור: "Searching for MobileNetV3" (Howard et al. 2019) https://arxiv.org/abs/1905.02244
הַצהָרָה
@differentiable public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
hardSwish(_:)
מחזירה טנזור על ידי הפעלת פונקציית ההפעלה הקשה של סוויש, כלומר x * Relu6(x+3)/6 .
מקור: "Searching for MobileNetV3" (Howard et al. 2019) https://arxiv.org/abs/1905.02244
הַצהָרָה
@differentiable public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
מיש (_:)
מחזירה טנזור על ידי החלת פונקציית הפעלת מיש, כלומר x * tanh(softplus(x)) .
מקור: "מיש: A Self Regularized Non-Monotonic Neural Activation Function" 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 של הטנזור מבחינת האלמנט.

הַצהָרָה

@differentiable
public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

squaredifference(_:_:)

מחזירה את ההפרש בריבוע בין 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(_:_:)

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

הערה

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

הַצהָרָה

@differentiable
public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

min(_:_:)

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

הַצהָרָה

@differentiable(wrt: rhs)
public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

min(_:_:)

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

הַצהָרָה

@differentiable(wrt: lhs)
public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

cosineSimilarity(_:_:)

מחזירה את הדמיון הקוסינוס בין x ו- y .

הַצהָרָה

@differentiable
public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

cosineDistance(_:_:)

מחזירה את מרחק הקוסינוס בין x ל- y . מרחק קוסינוס מוגדר כ 1 - cosineSimilarity(x, y) .

הַצהָרָה

@differentiable
public func cosineDistance<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

matmul(_:transposed:_:transposed:)

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

הַצהָרָה

@differentiable
public func matmul<Scalar: Numeric>(
  _ lhs: Tensor<Scalar>,
  transposed transposeLhs: Bool = false,
  _ rhs: Tensor<Scalar>,
  transposed transposeRhs: Bool = false
) -> Tensor<Scalar>

conv1D(_:filter:stride:padding:dilatation:)
מחזירה פיתול 1-D עם הקלט, המסנן, הצעד והריפוד שצוינו.
תְנַאִי מוּקדָם
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
גורם ההתרחבות.

conv2D(_:filter:strides:padding:dilatations:)

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

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

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`	מקדם ההתרחבות עבור כל מימד של הקלט.

transposedConv2D(_:shape:filter:strides:padding:dilatations:)

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

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

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`	מקדם ההתרחבות עבור כל מימד של הקלט.

conv3D(_:filter:strides:padding:dilatations:)

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

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

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`	מקדם ההתרחבות עבור כל מימד של הקלט.

depthwiseConv2D(_:filter:strides:padding:)
מחזירה פיתול עומק דו-ממדי עם הקלט, המסנן, הצעדים והריפוד שצוינו.
תְנַאִי מוּקדָם
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
הריפוד לניתוח.
maxPool2D(_:filterSize: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
הריפוד לניתוח.
maxPool3D(_:filterSize:strides:padding:)
מחזירה 3-D max pooling, עם גדלי המסננים, הצעדים והריפוד שצוינו.
הַצהָרָה
@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
הריפוד לניתוח.
avgPool2D(_: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
הריפוד לניתוח.
avgPool3D(_: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
הריפוד לניתוח.

fractionalMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2:)

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

הערה: 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` , כרגע תומך רק בממד שורה וקול ועליו להיות >= 1.0.
`pseudoRandom`	`Bool` אופציונלי. ברירת המחדל ל- `false` . כאשר מוגדר כ- `true` , יוצר את רצף האיגום בצורה פסאודורנדומלית, אחרת, בצורה אקראית.
`overlapping`	`Bool` אופציונלי. ברירת המחדל ל- `false` . כאשר מוגדר כ- `true` , פירוש הדבר בעת איגום, הערכים בגבול תאי האיגום הסמוכים משמשים את שני התאים.
`deterministic`	`Bool` אופציונלי. כאשר מוגדר כ- `true` , אזור איגום קבוע ישמש בעת איטרציה על צומת fractionalMaxPool2D בגרף החישוב.
`seed`	`Int64` אופציונלי. ברירת המחדל היא `0` . אם מוגדר לא-אפס, מחולל המספרים האקראיים מוזרע על ידי הזרע הנתון.
`seed2`	`Int64` אופציונלי. ברירת המחדל היא `0` . זרע שני כדי למנוע התנגשות זרע.

depthToSpace(_:blockSize:)
מחזירה עותק של 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) * גודל_בלוק * גודל_גוש). צורת רכיב הפלט היא [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
spaceToDepth(_:blockSize:)
מחזירה עותק של 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) * גודל_בלוק * גודל_גוש). צורת רכיב הפלט היא [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 .
תְנַאִי מוּקדָם
רוחב הקלט חייב להיות מתחלק ב- b .
הַצהָרָה
@differentiable(wrt: input) public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

makeLARS(learningRate:momentum:trustCoefficient:nesterov:epsilon:weightDecay:)

בונה כלי אופטימיזציה לכל משקל עבור 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

makeSGD(LearningRate:מומנטום:weightDecay:nesterov:)

בונה מייעל לפי משקל מבוסס SGD.

הַצהָרָה

public func makeSGD(
  learningRate: Float = 0.01,
  momentum: Float = 0,
  weightDecay: Float = 0,
  nesterov: Bool = false
) -> ParameterGroupOptimizer

makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon:)
בונה מייעל לכל משקל עבור אדם עם ריקבון משקל.
התייחסות: "אדם - שיטה לאופטימיזציה סטוכסטית"
הַצהָרָה
public func makeAdam( learningRate: Float = 0.01, beta1: Float = 0.9, beta2: Float = 0.999, weightDecayRate: Float = 0.01, epsilon: Float = 1e-6 ) -> ParameterGroupOptimizer
randomSeedForTensorFlow(באמצעות:)
יוצר סיד אקראי חדש עבור TensorFlow.
הַצהָרָה
public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed

שרשור (_:_:)

משרשרת שני ערכים.

הַצהָרָה

@differentiable
public func concatenate<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

סְכוּם(_:_:)
מוסיף שני ערכים ומפיק את הסכום שלהם.
הַצהָרָה
@differentiable public func sum<T: Mergeable>( _ first: T, _ second: T ) -> T

מְמוּצָע(_:_:)

ממוצע של שני ערכים.

הַצהָרָה

@differentiable
public func average<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

לְהַכפִּיל(_:_:)

מכפיל שני ערכים.

הַצהָרָה

@differentiable
public func multiply<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

לַעֲרוֹם(_:_:)

ערימה שני ערכים.

הַצהָרָה

@differentiable
public func stack<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

PrintX10Metrics()
הַצהָרָה
public func PrintX10Metrics()
formatStatistics(_:)
יוצר סיכום מחרוזת של רשימה של נתונים סטטיסטיים של אימון ובדיקות.
הַצהָרָה
public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

formatStatistics(train:test:)

הַצהָרָה

public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
  -> String

runOnNTthreads(_:_:)

ממפה פונקציה על פני n שרשורים.

הַצהָרָה

public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]

`name`	שם התקן.
`body`	סגירה שפעולות ה-TensorFlow שלו אמורות להתבצע בסוג המכשיר שצוין.

`mean`	ממוצע ההתפלגות הנורמלית.
`standardDeviation`	סטיית תקן של ההתפלגות הנורמלית.

`input`	הקלט.
`filterSize`	מידות גרעין האיגום.
`strides`	הצעדים של מסנן ההזזה עבור כל מימד של הקלט.
`padding`	הריפוד לניתוח.