פונקציות

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

  • מחזירה את הפסד 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

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

  • מחזיר את הפסד ה-Poisson בין תחזיות לציפיות.

    הַצהָרָה 

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

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

    הַצהָרָה 

    public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

  • הַצהָרָה 

    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>

    פרמטרים

    images

    4-D Tensor של צורה [batch, height, width, channels] או 3-D Tensor של צורה [height, width, channels] .

    size

    הגודל החדש של התמונות.

    method

    שיטת שינוי הגודל. ערך ברירת המחדל הוא .bilinear .

    antialias

    אם זה true , השתמש במסנן נגד כינוי בעת הורדת דגימת תמונה.

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

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

    התמונות חייבות להיות בדרגה 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

    הגודל החדש של התמונות.

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

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

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

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

    הַצהָרָה 

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

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

    הַצהָרָה 

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

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

    הַצהָרָה 

    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

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

    הַצהָרָה 

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

  • מחזירה את הפתרון 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 .

  • מחשב את הפסד 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

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

  • מחשב את אובדן 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

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

  • מחשב את הממוצע של ההבדל המוחלט בין תוויות ותחזיות. 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

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

  • מחשב את השגיאה הלוגריתמית הממוצעת בריבוע בין הפסד expected predicted 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.

    הַצהָרָה 

    @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

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

  • מחשב את אובדן הציר בריבוע בין 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

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

  • מחשב את אובדן הציר הקטגורי בין 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

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

  • מחשב את הלוגריתם של הקוסינוס ההיפרבולי של שגיאת החיזוי. 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

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

  • מחשב את אובדן ה-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

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

  • מחשב את אובדן סטיית ה-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

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

  • מחשב את האנטרופיית צולבת 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

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

  • מחשב את האנטרופיית צולבת 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

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

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

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

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

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

    הַצהָרָה 

    @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

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

    הַצהָרָה 

    @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(1 / (1 + exp(-x))) . ליציבות מספרית, אנו משתמשים -softplus(-x) .

    הַצהָרָה 

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

  • מחזירה את ה-softplus של הטנסור שצוין מבחינה אלמנטית. באופן ספציפי, מחשב 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 אחרת. ראה למידת רשת עמוקה מהירה ומדויקת על ידי יחידות לינאריות אקספוננציאליות (ELU)

    הַצהָרָה 

    @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 אחרת.

    פֶּתֶק

    זה נועד לשמש יחד עם אתחולי שכבת קנה המידה של השונות. אנא עיין ב- 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

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

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

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

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

    הַצהָרָה 

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

  • מחזירה פיתול 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

    גורם ההתרחבות.

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

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

    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

    הריפוד לניתוח.

  • מחזירה 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

    הריפוד לניתוח.

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

    הַצהָרָה 

    @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 , כרגע תומך רק בממד שורה וקול ועליו להיות >= 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) * גודל_חוסם * גודל_גוש). צורת רכיב הפלט היא [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) * גודל_בלוק * גודל_גוש). צורת רכיב הפלט היא [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

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

  • בונה אופטימיזציה מבוססת SGD לכל משקל.

    הַצהָרָה 

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

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

    הפניה: "אדם - שיטה לאופטימיזציה סטוכסטית"

    הַצהָרָה 

    public func makeAdam(
  learningRate: Float = 0.01,
  beta1: Float = 0.9,
  beta2: Float = 0.999,
  weightDecayRate: Float = 0.01,
  epsilon: Float = 1e-6
) -> ParameterGroupOptimizer

  • מייצר זרע אקראי חדש עבור 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

  • הַצהָרָה 

    public func PrintX10Metrics()

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

    הַצהָרָה 

    public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

  • הַצהָרָה 

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

  • ממפה פונקציה על חוטי N.

    הַצהָרָה 

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