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

פונקציות

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

  • מחזירה את אובדן הציר הקטגורי בין התחזיות והציפיות.

    הַצהָרָה

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

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    logits

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

    labels

    מדדים (צמודים באפס) של התפוקות הנכונות.

  • מחזירה את האנטרופיה הצלבית sigmoid (אנטרופיה צולבת בינארית) בין logits ותוויות.

    הַצהָרָה

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

    הַצהָרָה

    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": מעבד ה- CPU של המחשב שלך.
    • "/ 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 , שנוצר על ידי מחולל המספרים האקראיים המוגדר כברירת מחדל, כאשר הגבול הוא sqrt(6 / (fanIn + fanOut)) ו- fanIn / fanOut מייצגים את מספר תכונות הקלט והפלט כפול השדה הקולט, אם קיים.

    הַצהָרָה

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • מחזירה פונקציה שיוצרת טנסור על ידי ביצוע אתחול נורמלי של גלורוט (Xavier) עבור הצורה שצוינה, דגימה אקראית של ערכים סקלריים מהפצה נורמלית קטועה במרכז 0 עם סטיית תקן sqrt(2 / (fanIn + fanOut)) , שם fanIn / fanOut מייצגים את מספר תכונות הקלט והפלט כפול גודל השדה הקולט, אם קיים.

    הַצהָרָה

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

    הַצהָרָה

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • מחזירה פונקציה שיוצרת טנסור על ידי ביצוע האתחול הרגיל של He (Kaiming) עבור הצורה שצוינה, דגימה אקראית של ערכים סקלריים מהפצה נורמלית קטועה sqrt(2 / fanIn) 0 עם סטיית סטנדרט סטנדרטית sqrt(2 / fanIn) , שם fanIn מייצג את מספר תכונות הקלט כפול גודל השדה הקולט, אם קיים.

    הַצהָרָה

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • מחזירה פונקציה שיוצרת טנסור על ידי ביצוע אתחול אחיד של LeCun עבור הצורה שצוינה, דגימה אקראית של ערכים סקלריים מהתפלגות אחידה בין -limit limit , שנוצרת על ידי מחולל המספרים האקראיים המוגדר כברירת מחדל, כאשר הגבול הוא sqrt(3 / fanIn) , ו- fanIn מייצג את מספר תכונות הקלט כפול השדה הקולט, אם קיים.

    הַצהָרָה

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • מחזירה פונקציה שיוצרת טנסור על ידי ביצוע אתחול נורמלי של LeCun עבור הצורה שצוינה, דגימה אקראית של ערכים סקלריים מהפצה נורמלית קטועה שבמרכזה 0 עם סטיית סטנדרט סטנדרטית sqrt(1 / fanIn) , כאשר fanIn מייצג את מספר תכונות הקלט כפול ה גודל שדה פתוח, אם קיים.

    הַצהָרָה

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • מחזירה פונקציה שיוצרת טנסור על ידי איתחול כל ערכיה באופן אקראי מהפצה רגילה קטועה. הערכים שנוצרו עוקבים אחר התפלגות רגילה עם ממוצע mean וסטיית תקן סטיית standardDeviation , למעט שערכים שעוצמתם עולה על יותר משתי סטיות תקן מהממוצע נושרים ומודגמים מחדש.

    הַצהָרָה

    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

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

  • מחשב את שגיאת לוגריתמים בריבוע הממוצעת בין predicted ו expected loss = square(log(expected) - log(predicted))

    הערה

    ערכי טנזור שליליים יוחמצו ב 0 כדי להימנע מהתנהגות לוגריתמית בלתי מוגדרת, שכן log(_:) אינו מוגדר לריאליטי שלילי.

    הַצהָרָה

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

  • מחשבת את שגיאת האחוזים המוחלטת הממוצעת בין predicted expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    הַצהָרָה

    @differentiable(wrt: predicted)
    @differentiable(wrt: (predicted, expected)
    public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>(
      predicted: Tensor<Scalar>,
      expected: Tensor<Scalar>
    ) -> Tensor<Scalar>

    פרמטרים

    predicted

    תפוקות חזויות מרשת עצבית.

    expected

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

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

    הַצהָרָה

    @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

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

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

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

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

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

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

    סקלר של נקודה צפה המייצג את הנקודה בה פונקציית אובדן ההובר משתנה מריבוע ליניארי.

    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 אלמנטי.

    הַצהָרָה

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

    הַצהָרָה

    @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
  • מחזירה את היומן-sigmoid של אלמנט הטנזור שצוין. באופן ספציפי, 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
  • מחזירה את ההפעלה של יחידת השגיאה Gaussian Unit Line (GELU) של האלמנט הטנזור שצוין.

    באופן ספציפי, gelu xP(X <= x) , כאשר P(X <= x) הוא ההתפלגות המצטברת של גאוסית הסטנדרטית, על ידי מחשוב: x * [0.5 * (1 + tanh [√ (2 / π) * (x + 0.044715 * x ^ 3)])].

    ראה יחידות שגיאות גאוסיות .

    הַצהָרָה

    @differentiable
    public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • מחזירה טנסור על ידי החלת פונקציית ההפעלה ReLU על אלמנט הטנזור שצוין. באופן ספציפי, מחשבים max(0, x) .

    הַצהָרָה

    @differentiable
    public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • מחזירה טנסור על ידי החלת פונקציית ההפעלה ReLU6, כלומר min(max(0, x), 6) .

    הַצהָרָה

    @differentiable
    public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • מחזירה טנסור על ידי החלת פונקציית ההפעלה ReLU הדולפת על אלמנט הטנזור שצוין. באופן ספציפי, מחשבים max(x, x * alpha) .

    הַצהָרָה

    @differentiable(wrt: x)
    public func leakyRelu<T: TensorFlowFloatingPoint>(
      _ x: Tensor<T>,
      alpha: Double = 0.2
    ) -> Tensor<T>
  • מחזירה טנסור על ידי יישום פונקציית ההפעלה SeLU, כלומר scale * alpha * (exp(x) - 1) אם x < 0 , scale * x אחרת.

    הערה

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

    הַצהָרָה

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • מחזירה טנסור על ידי החלת פונקציית ההפעלה 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
  • מחזירה טנסור על ידי החלת פונקציית ההפעלה הקשה של sigmoid, כלומר Relu6(x+3)/6 .

    Source: “Searching for MobileNetV3” (Howard et al. 2019) https://arxiv.org/abs/1905.02244

    Declaration

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Returns a tensor by applying the hard swish activation function, namely x * Relu6(x+3)/6 .

    Source: “Searching for MobileNetV3” (Howard et al. 2019) https://arxiv.org/abs/1905.02244

    Declaration

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Returns the power of the first tensor to the second tensor.

    Declaration

    @differentiable
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Returns the power of the scalar to the tensor, broadcasting the scalar.

    Declaration

    @differentiable(wrt: rhs)
    public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Returns the power of the tensor to the scalar, broadcasting the scalar.

    Declaration

    @differentiable(wrt: lhs)
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Returns the power of the tensor to the scalar, broadcasting the scalar.

    Declaration

    @differentiable
    public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Returns the element-wise n th root of the tensor.

    Declaration

    @differentiable
    public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Returns the squared difference between x and y .

    Declaration

    @differentiable
    public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    Return Value

    (x - y) ^ 2 .

  • Returns the element-wise maximum of two tensors.

    Note

    max supports broadcasting.

    Declaration

    @differentiable
    public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Returns the element-wise maximum of the scalar and the tensor, broadcasting the scalar.

    Declaration

    @differentiable(wrt: rhs)
    public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Returns the element-wise maximum of the scalar and the tensor, broadcasting the scalar.

    Declaration

    @differentiable(wrt: lhs)
    public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Returns the element-wise minimum of two tensors.

    Note

    min supports broadcasting.

    Declaration

    @differentiable
    public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Returns the element-wise minimum of the scalar and the tensor, broadcasting the scalar.

    Declaration

    @differentiable(wrt: rhs)
    public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Returns the element-wise minimum of the scalar and the tensor, broadcasting the scalar.

    Declaration

    @differentiable(wrt: lhs)
    public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Returns the cosine similarity between x and y .

    Declaration

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Returns the cosine distance between x and y . Cosine distance is defined as 1 - cosineSimilarity(x, y) .

    Declaration

    @differentiable
    public func cosineDistance<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Performs matrix multiplication with another tensor and produces the result.

    Declaration

    @differentiable
    public func matmul<Scalar: Numeric>(
      _ lhs: Tensor<Scalar>,
      transposed transposeLhs: Bool = false,
      _ rhs: Tensor<Scalar>,
      transposed transposeRhs: Bool = false
    ) -> Tensor<Scalar>
  • Returns a 1-D convolution with the specified input, filter, stride, and padding.

    Precondition

    input must have rank 3 .

    Precondition

    filter must have rank 3.

    Declaration

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

    Parameters

    input

    The input.

    filter

    The convolution filter.

    stride

    The stride of the sliding filter.

    padding

    The padding for the operation.

    dilation

    The dilation factor.

  • Returns a 2-D convolution with the specified input, filter, strides, and padding.

    Precondition

    input must have rank 4 .

    Precondition

    filter must have rank 4.

    Declaration

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

    Parameters

    input

    The input.

    filter

    The convolution filter.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation

    dilations

    The dilation factor for each dimension of the input.

  • Returns a 2-D transposed convolution with the specified input, filter, strides, and padding.

    Precondition

    input must have rank 4 .

    Precondition

    filter must have rank 4.

    Declaration

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

    Parameters

    input

    The input.

    shape

    The output shape of the deconvolution operation.

    filter

    The convolution filter.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation

    dilations

    The dilation factor for each dimension of the input.

  • Returns a 3-D convolution with the specified input, filter, strides, padding and dilations.

    Precondition

    input must have rank 5 .

    Precondition

    filter must have rank 5.

    Declaration

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

    Parameters

    input

    The input.

    filter

    The convolution filter.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

    dilations

    The dilation factor for each dimension of the input.

  • Returns a 2-D depthwise convolution with the specified input, filter, strides, and padding.

    Precondition

    input must have rank 4.

    Precondition

    filter must have rank 4.

    Declaration

    @differentiable(wrt: (input, filter)
    public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>(
      _ input: Tensor<Scalar>,
      filter: Tensor<Scalar>,
      strides: (Int, Int, Int, Int),
      padding: Padding
    ) -> Tensor<Scalar>

    Parameters

    input

    The input.

    filter

    The depthwise convolution filter.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 2-D max pooling, with the specified filter sizes, strides, and padding.

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 3-D max pooling, with the specified filter sizes, strides, and padding.

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 2-D average pooling, with the specified filter sizes, strides, and padding.

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 3-D average pooling, with the specified filter sizes, strides, and padding.

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

  • Returns a 2-D fractional max pooling, with the specified pooling ratios.

    Note: fractionalMaxPool does not have an XLA implementation, and thus may have performance implications.

    Declaration

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

    Parameters

    input

    A Tensor. 4-D with shape [batch, height, width, channels] .

    poolingRatio

    A list of Doubles . Pooling ratio for each dimension of input , currently only supports row and col dimension and should be >= 1.0.

    pseudoRandom

    An optional Bool . Defaults to false . When set to true , generates the pooling sequence in a pseudorandom fashion, otherwise, in a random fashion.

    overlapping

    An optional Bool . Defaults to false . When set to true , it means when pooling, the values at the boundary of adjacent pooling cells are used by both cells.

    deterministic

    An Optional Bool . When set to true , a fixed pooling region will be used when iterating over a fractionalMaxPool2D node in the computation graph.

    seed

    An optional Int64 . Defaults to 0 . If set to be non-zero, the random number generator is seeded by the given seed.

    seed2

    An optional Int64 . Defaults to 0 . A second seed to avoid seed collision.

  • Returns a copy of input where values from the depth dimension are moved in spatial blocks to the height and width dimensions.

    For example, given an input of shape [1, 2, 2, 1] , data_format = “NHWC” and block_size = 2:

    x = [[[[1], [2]],
          [[3], [4]]]]
    

    This operation will output a tensor of shape [1, 1, 1, 4] :

    [[[[1, 2, 3, 4]]]]
    

    Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

    For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

    x = [[[[1, 2, 3], [4, 5, 6]],
          [[7, 8, 9], [10, 11, 12]]]]
    

    This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

    [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
    

    Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

    x = [[[[1],   [2],  [5],  [6]],
          [[3],   [4],  [7],  [8]],
          [[9],  [10], [13],  [14]],
          [[11], [12], [15],  [16]]]]
    

    the operator will return the following tensor of shape [1 2 2 4] :

    x = [[[[1, 2, 3, 4],
           [5, 6, 7, 8]],
          [[9, 10, 11, 12],
           [13, 14, 15, 16]]]]
    

    Precondition

    input.rank == 4 && b >= 2 .

    Precondition

    The number of the features must be divisible by square of b .

    Declaration

    @differentiable(wrt: input)
    public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Returns a copy of input where values from the height and width dimensions are moved to the depth dimension.

    For example, given an input of shape [1, 2, 2, 1] , data_format = “NHWC” and block_size = 2:

    x = [[[[1], [2]],
          [[3], [4]]]]
    

    This operation will output a tensor of shape [1, 1, 1, 4] :

    [[[[1, 2, 3, 4]]]]
    

    Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

    For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

    x = [[[[1, 2, 3], [4, 5, 6]],
          [[7, 8, 9], [10, 11, 12]]]]
    

    This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

    [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
    

    Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

    x = [[[[1],   [2],  [5],  [6]],
          [[3],   [4],  [7],  [8]],
          [[9],  [10], [13],  [14]],
          [[11], [12], [15],  [16]]]]
    

    the operator will return the following tensor of shape [1 2 2 4] :

    x = [[[[1, 2, 3, 4],
           [5, 6, 7, 8]],
          [[9, 10, 11, 12],
           [13, 14, 15, 16]]]]
    

    Precondition

    input.rank == 4 && b >= 2 .

    Precondition

    The height of the input must be divisible by b .

    Precondition

    The width of the input must be divisible by b .

    Declaration

    @differentiable(wrt: input)
    public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    Declaration

    public func makeLARS(
      learningRate: Float = 0.01,
      momentum: Float = 0.9,
      trustCoefficient: Float = 0.001,
      nesterov: Bool = false,
      epsilon: Float = 0.0,
      weightDecay: Float = 0.0
    ) -> ParameterGroupOptimizer
  • Builds a SGD based per-weight optimizer.

    Declaration

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • Generates a new random seed for TensorFlow.

    Declaration

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Declaration

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    Declaration

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

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    Declaration

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