פונקציות

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

  • מחזירה את ההבדל בין Kullback-Leibler (KL) בין בין ציפיות לתחזיות. בהינתן שתי הפצות p ו- q , הבדלי KL מחשב p * log(p / q) .

    הַצהָרָה

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

    פרמטרים

    predicted

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

    expected

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

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

    הַצהָרָה

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

    פרמטרים

    logits

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

    labels

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

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

    הַצהָרָה

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

    פרמטרים

    logits

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

    labels

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

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

    הַצהָרָה

    @differentiable
public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

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

    הַצהָרָה

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

    פרמטרים

    context

    הקשר שיוקם לפני שהסגירה תתקשר ותשוחזר לאחר החזרה של הסגירה.

    body

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

    ערך החזרה

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

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

    הַצהָרָה

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

    פרמטרים

    learningPhase

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

    body

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

    ערך החזרה

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

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

    הַצהָרָה

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

    פרמטרים

    randomSeed

    זרע אקראי שיוגדר לפני הסגירה יקרא ויוחזר לאחר החזרה של הסגירה.

    body

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

    ערך החזרה

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

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

    הַצהָרָה

    public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>(
  _ randomNumberGenerator: inout G,
  _ body: () throws -> R
) rethrows -> R

    פרמטרים

    randomNumberGenerator

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

    body

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

    ערך החזרה

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

  • הַצהָרָה

    public func zip<T: TensorGroup, U: TensorGroup>(
  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
) -> Dataset<Zip2TensorGroup<T, U>>

  • 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

    IFF true , להשתמש במסנן anti-aliasing כאשר downsampling תמונה.

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

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

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

    public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>(
  mean: Tensor<Scalar> = Tensor<Scalar>(0),
  standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1),
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

    פרמטרים

    mean

    ממוצע ההתפלגות הנורמלית.

    standardDeviation

    סטיית תקן של ההתפלגות הנורמלית.

    ערך החזרה

    פונקציית אתחול פרמטר רגיל קטוע.

  • הַצהָרָה

    public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool

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

    הַצהָרָה

    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 הממדים ליצור מטריצות רבועות.

    הקלט חייב להיות סימטרי וחיובי. לפעולה זו ישמש רק החלק המשולש התחתון של הקלט. החלק המשולש העליון לא יקרא.

    הפלט הוא מותח של אותה צורה כקלט המכיל את decompositions Cholesky לכל submatrices קלט [..., :, :] .

    הַצהָרָה

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

    פרמטרים

    input

    טנזור של צורה [..., M, M] .

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

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

    matrix חייב להיות מותח עם צורה [..., M, M] .

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

    rhs חייב להיות מותח עם צורה [..., M, K] .

    הַצהָרָה

    @differentiable
public func triangularSolve<T: TensorFlowFloatingPoint>(
  matrix: Tensor<T>,
  rhs: Tensor<T>,
  lower: Bool = true,
  adjoint: Bool = false
) -> Tensor<T>

    פרמטרים

    matrix

    הקלט משולש מקדם מטריקס, המייצגת ב A Ax = b .

    rhs

    ערכים בצד ימין, מייצג b ב Ax = b .

    lower

    אם matrix היא משולש נמוך ( true ) או משולש עליון ( false ). ערך ברירת המחדל הוא true .

    adjoint

    אם true , לפתור עם adjoint של matrix במקום matrix . ערך ברירת המחדל הוא false .

    ערך החזרה

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

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

    הַצהָרָה

    @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

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

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

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

    reduction

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

  • מחזירה את הערך המוחלט של רכיב הטנסור שצוין מבחינת אלמנט.

    הַצהָרָה

    @differentiable
public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

  • חזרות log(1 - exp(x)) באמצעות גישה יציבה מבחינה מספרית.

    הערה

    הגישה מוצגת משוואה 7 של: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

  • מחזירה את הסינוס ההפוך של אלמנט הטנסור שצוין מבחינה יסודית.

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

  • מחזירה את הסינוס ההיפרבולי ההפוך של האלמנט המצוין מבחינת רכיב הטנסור.

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

  • מחזירה את השורש הריבועי ההפוך של רכיב הטנסור שצוין מבחינת רכיב הטנסור.

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

  • חזרת המעריכים של x - 1 אלמנט-חכם.

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

  • מחזירה אינדיקציה לסימן של רכיב הטנסור שצוין מבחינת רכיב טנסור. באופן ספציפי, מחשב y = sign(x) = -1 אם x < 0 ; 0 אם x == 0 ; 1 אם x > 0 .

    הַצהָרָה

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

  • מחזירה את הסיגמואיד של רכיב הטנסור שצוין מבחינת רכיב הטנסור. באופן ספציפי, מחשב 1 / (1 + exp(-x)) .

    הַצהָרָה

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

  • מחזירה את log-sigmoid של רכיב הטנסור שצוין מבחינת רכיב טנסור. באופן ספציפי, log(1 / (1 + exp(-x))) . לקבלת יציבות נומרית, אנו משתמשים -softplus(-x) .

    הַצהָרָה

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

  • מחזירה את התוכנה הרכה של רכיב הטנסור שצוין מבחינת רכיב הטנסור. באופן ספציפי, מחשב log(exp(features) + 1) .

    הַצהָרָה

    @differentiable
public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • מחזירה את סימן הרך של רכיב הטנסור שצוין מבחינת רכיב הטנסור. באופן ספציפי, מחשב features/ (abs(features) + 1) .

    הַצהָרָה

    @differentiable
public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • מחזירה את softmax של הטנזר שצוין לאורך הציר האחרון. באופן ספציפי, מחשב exp(x) / exp(x).sum(alongAxes: -1) .

    הַצהָרָה

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

  • מחזירה את softmax של הטנזר שצוין לאורך הציר שצוין. באופן ספציפי, מחשב exp(x) / exp(x).sum(alongAxes: axis) .

    הַצהָרָה

    @differentiable
public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

  • מחזירה את log-softmax של רכיב הטנסור שצוין מבחינת רכיב טנסור.

    הַצהָרָה

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

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

    הַצהָרָה

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

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

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

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

    הַצהָרָה

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

  • מחזירה טנסור על ידי החלת פונקציית ההפעלה ReLU על רכיב הטנסור שצוין מבחינת רכיב טנסור. באופן ספציפי, מחשב max(0, x) .

    הַצהָרָה

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

  • מחזירה מותח על ידי יישום פונקצית הפעלת ReLU6, כלומר min(max(0, x), 6) .

    הַצהָרָה

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

  • מחזיר טנסור על ידי החלת פונקציית ההפעלה ReLU הדולפת על רכיב הטנסור שצוין. באופן ספציפי, מחשב max(x, x * alpha) .

    הַצהָרָה

    @differentiable(wrt: x)
public func leakyRelu<T: TensorFlowFloatingPoint>(
  _ x: Tensor<T>,
  alpha: Double = 0.2
) -> Tensor<T>

  • מחזירה מותחת על ידי יישום פונקצית הפעלת SeLU, כלומר scale * alpha * (exp(x) - 1) אם x < 0 , ו scale * x אחרת.

    הערה

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

    הַצהָרָה

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

  • מחזירה מותח על ידי יישום פונקצית הפעלת סוויש, כלומר x * sigmoid(x) .

    מקור: (. ראמאצ'אנדראן ואח 2017) "מחפש פונקציות הפעלה" https://arxiv.org/abs/1710.05941

    הַצהָרָה

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

  • מחזירה מותח על ידי יישום פונקצית ההפעלה סיגמואיד הקשה, כלומר Relu6(x+3)/6 .

    מקור: "מחפשים MobileNetV3" (. הווארד ואח '2019) https://arxiv.org/abs/1905.02244

    הַצהָרָה

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

  • מחזירה מותח על ידי יישום פונקצית ההפעלה סוויש הקשה, כלומר x * Relu6(x+3)/6 .

    מקור: "מחפשים MobileNetV3" (. הווארד ואח '2019) https://arxiv.org/abs/1905.02244

    הַצהָרָה

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

  • מחזירה מותח על ידי יישום פונקצית הפעלת mish, כלומר x * tanh(softplus(x)) .

    מקור: "מיש: עצמי סדיר ללא מונוטונית עצבית הפעלה פונקציה" https://arxiv.org/abs/1908.08681

    הַצהָרָה

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

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

    הַצהָרָה

    @differentiable
public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

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

    הַצהָרָה

    @differentiable(wrt: rhs)
public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

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

    הַצהָרָה

    @differentiable(wrt: lhs)
public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint

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

    הַצהָרָה

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

  • חזרת מבחינת אלמנט n th שורש המותח.

    הַצהָרָה

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

  • מחזיר את ההפרש בריבוע בין x ו- y .

    הַצהָרָה

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

    ערך החזרה

    (x - y) ^ 2 .

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

    הערה

    max תומך שידור.

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הערה

    min תומך שידור.

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

    הַצהָרָה

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

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

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

    input חייב להיות בדרגה 3 .

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

    filter חייב להיות בדרגה 3.

    הַצהָרָה

    @differentiable(wrt: (input, filter)
public func conv1D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  stride: Int = 1,
  padding: Padding = .valid,
  dilation: Int = 1
) -> Tensor<Scalar>

    פרמטרים

    input

    הקלט.

    filter

    מסנן הכיפוף.

    stride

    הצעד של מסנן הזזה.

    padding

    הריפוד למבצע.

    dilation

    גורם ההרחבה.

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

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

    input חייב להיות בדרגה 4 .

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

    filter חייב להיות בדרגה 4.

    הַצהָרָה

    @differentiable(wrt: (input, filter)
public func conv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

    פרמטרים

    input

    הקלט.

    filter

    מסנן הכיפוף.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע

    dilations

    גורם ההתרחבות לכל ממד של הקלט.

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

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

    input חייב להיות בדרגה 4 .

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

    filter חייב להיות בדרגה 4.

    הַצהָרָה

    @differentiable(wrt: (input, filter)
public func transposedConv2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  shape: [Int64],
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
) -> Tensor<Scalar>

    פרמטרים

    input

    הקלט.

    shape

    צורת הפלט של פעולת הפירוק.

    filter

    מסנן הכיפוף.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע

    dilations

    גורם ההתרחבות לכל ממד של הקלט.

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

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

    input חייב להיות בדרגה 5 .

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

    filter חייב להיות בדרגה 5.

    הַצהָרָה

    @differentiable(wrt: (input, filter)
public func conv3D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  filter: Tensor<Scalar>,
  strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1),
  padding: Padding = .valid,
  dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1)
) -> Tensor<Scalar>

    פרמטרים

    input

    הקלט.

    filter

    מסנן הכיפוף.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע.

    dilations

    גורם ההתרחבות לכל ממד הקלט.

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

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

    input חייב להיות בדרגה 4.

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

    filter חייב להיות בדרגה 4.

    הַצהָרָה

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

    פרמטרים

    input

    הקלט.

    filter

    מסנן ההתכווצות לעומק.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע.

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

    הַצהָרָה

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

    פרמטרים

    input

    הקלט.

    filterSize

    ממדי הגרעין המאגר.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע.

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

    הַצהָרָה

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

    פרמטרים

    input

    הקלט.

    filterSize

    ממדי הגרעין המאגר.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע.

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

    הַצהָרָה

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

    פרמטרים

    input

    הקלט.

    filterSize

    ממדי הגרעין המאגר.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע.

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

    הַצהָרָה

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

    פרמטרים

    input

    הקלט.

    filterSize

    ממדי הגרעין המאגר.

    strides

    הצעדים של מסנן הזזה לכל ממד הקלט.

    padding

    הריפוד למבצע.

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

    הערה: fractionalMaxPool אין יישום XLA, וכך עשוי להיות שלכות ביצועים.

    הַצהָרָה

    @differentiable(wrt: input)
public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>(
  _ input: Tensor<Scalar>,
  poolingRatio: (Double, Double, Double, Double),
  pseudoRandom: Bool = false,
  overlapping: Bool = false,
  deterministic: Bool = false,
  seed: Int64 = 0,
  seed2: Int64 = 0
) -> Tensor<Scalar>

    פרמטרים

    input

    טנסור. 4-D עם צורה [batch, height, width, channels] .

    poolingRatio

    רשימת Doubles . איגום יחס לכל מימד של input , תומך כעת רק מימד שורה col וצריך להיות> = 1.0.

    pseudoRandom

    אופציונלי Bool . ברירות מחדל כדי false . כאשר מוגדר true , יוצר רצף האיגום בצורה פסוודו, אחרת, באופן אקראי.

    overlapping

    אופציונלי Bool . ברירות מחדל כדי false . כאשר מוגדר true , זה אומר כאשר איגום, הערכים בגבול תאי איגום הסמוך נמצאים בשימוש על ידי שני תאים.

    deterministic

    אופציונלי Bool . כאשר מוגדר true , אזור איגום קבוע ישמש כאשר ולביקורות מעל צומת fractionalMaxPool2D בגרף החישוב.

    seed

    אופציונלי Int64 . ברירות מחדל כדי 0 . אם הוא מוגדר להיות לא אפס, מחולל המספרים האקראיים נזרע על ידי הזרע הנתון.

    seed2

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

  • החזרת עותק של input שבו ערכים מממד העומק מועברים בבלוקים מרחבית לגובה וממדי רוחב.

    לדוגמה, נתון קלט בכושר [1, 2, 2, 1] , data_format = "NHWC" ו block_size = 2:

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

    פלט רצון פעולה זו טנזור של צורה [1, 1, 1, 4] :

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

    הנה, הקלט יש קבוצה של 1 וכול אלמנט יצווה יש צורה [2, 2, 1] , את הפלט המתאים יהיה אלמנט בודד (כלומר רוחב והגובה הם 1) ויהיה בעל עומק של 4 ערוצים (1 * block_size * block_size). צורת אלמנט הפלט היא [1, 1, 4] .

    לקבלת מותח קלט עם עומק גדול, כאן בכושר [1, 2, 2, 3] , למשל

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

    פעולה זו, עבור block_size של 2, תחזיר את המותח של הצורה הבאה [1, 1, 1, 12]

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

    באופן דומה, עבור הקלט הבא של צורה [1 4 4 1] , וכן גודל בלוק של 2:

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

    המפעיל יחזיר את המותח של הצורה הבאה [1 2 2 4] :

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

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

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

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

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

    הַצהָרָה

    @differentiable(wrt: input)
public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • החזרת עותק של input שבו ערכים מן הגובה ממדי רוחב מועברים ממד העומק.

    לדוגמה, נתון קלט בכושר [1, 2, 2, 1] , data_format = "NHWC" ו block_size = 2:

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

    פלט רצון פעולה זו טנזור של צורה [1, 1, 1, 4] :

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

    הנה, הקלט יש קבוצה של 1 וכול אלמנט יצווה יש צורה [2, 2, 1] , את הפלט המתאים יהיה אלמנט בודד (כלומר רוחב וגובה הם 1) ויהיה בעל עומק של 4 ערוצים (1 * block_size * block_size). צורת אלמנט הפלט היא [1, 1, 4] .

    לקבלת מותח קלט עם עומק גדול, כאן בכושר [1, 2, 2, 3] , למשל

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

    פעולה זו, עבור block_size של 2, תחזיר את המותח של הצורה הבאה [1, 1, 1, 12]

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

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

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

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

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

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

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

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

    The height of the input must be divisible by b .

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

    The width of the input must be divisible by b .

    הַצהָרָה

    @differentiable(wrt: input)
public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    הַצהָרָה

    public func makeLARS(
  learningRate: Float = 0.01,
  momentum: Float = 0.9,
  trustCoefficient: Float = 0.001,
  nesterov: Bool = false,
  epsilon: Float = 0.0,
  weightDecay: Float = 0.0
) -> ParameterGroupOptimizer

  • Builds a SGD based per-weight optimizer.

    הַצהָרָה

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

  • Builds a per-weight optimizer for Adam with weight decay.

    Reference: “Adam - A Method for Stochastic Optimization”

    הַצהָרָה

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

  • Generates a new random seed for TensorFlow.

    הַצהָרָה

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

  • Concatenates two values.

    הַצהָרָה

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

  • Adds two values and produces their sum.

    הַצהָרָה

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

  • Averages two values.

    הַצהָרָה

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

  • Multiplies two values.

    הַצהָרָה

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

  • Stack two values.

    הַצהָרָה

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

  • הַצהָרָה

    public func PrintX10Metrics()

  • Creates a string summary of a list of training and testing stats.

    הַצהָרָה

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

  • הַצהָרָה

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

  • Maps a function over n threads.

    הַצהָרָה

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