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

מבנים

המבנים הבאים זמינים ברחבי העולם.

  • שרשור של שני רצפים עם אותו סוג אלמנט.

    הַצהָרָה

    public struct Concatenation<Base1: Sequence, Base2: Sequence>: Sequence
    where Base1.Element == Base2.Element
    extension Concatenation: Collection where Base1: Collection, Base2: Collection
    extension Concatenation: BidirectionalCollection
    where Base1: BidirectionalCollection, Base2: BidirectionalCollection
    extension Concatenation: RandomAccessCollection
    where Base1: RandomAccessCollection, Base2: RandomAccessCollection
  • מבט מסובב על אוסף.

    הַצהָרָה

    public struct RotatedCollection<Base> : Collection where Base : Collection
    extension RotatedCollection: BidirectionalCollection
    where Base: BidirectionalCollection
    extension RotatedCollection: RandomAccessCollection
    where Base: RandomAccessCollection
  • הַצהָרָה

    public struct AnyDifferentiable : Differentiable
  • ערך נגזר מחיקת סוג.

    הסוג AnyDerivative מעביר את פעולותיו לערך נגזר בסיסי שרירותי AnyDerivative את Differentiable ו- AdditiveArithmetic , ומסתיר את הספציפיות של הערך הבסיסי.

    הַצהָרָה

    @frozen
    public struct AnyDerivative : Differentiable & AdditiveArithmetic
  • מערך רב ממדי של אלמנטים המהווים הכללה של וקטורים ומטריצות לממדים פוטנציאליים גבוהים יותר.

    הפרמטר הגנרי Scalar מתאר את סוג הסקלרים בטנזור (כמו Int32 , Float וכו ').

    הַצהָרָה

    @frozen
    public struct Tensor<Scalar> where Scalar : TensorFlowScalar
    extension Tensor: Collatable
    extension Tensor: CopyableToDevice
    extension Tensor: AnyTensor
    extension Tensor: ExpressibleByArrayLiteral
    extension Tensor: CustomStringConvertible
    extension Tensor: CustomPlaygroundDisplayConvertible
    extension Tensor: CustomReflectable
    extension Tensor: TensorGroup
    extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
    extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
    extension Tensor: Equatable where Scalar: Equatable
    c4d9f7e7e7e
  • פונקצית נסיגה שמבצעת Tensors של שידור שני Tensors .

    הַצהָרָה

    public struct BroadcastingPullback
  • הקשר המאחסן מידע קונטקסטואלי על-פי פתיל המשמש ממשקי API למידה עמוקה כמו שכבות.

    השתמש ב- Context.local כדי לאחזר את ההקשר המקומי של החוטים הנוכחי.

    דוגמאות:

    • הגדר את שלב הלמידה הנוכחי לאימונים כך ששכבות כמו BatchNorm יחשבו ממוצע ושונות כאשר יושמו על תשומות.
      Context.local.learningPhase = .training
    
    • הגדר את שלב הלמידה הנוכחי לנקוט כך ששכבות כמו Dropout לא יישרו יחידות כאשר יושמו על תשומות.
      Context.local.learningPhase = .inference
    

    הַצהָרָה

    public struct Context
  • שכבת התפשטות 1-D (למשל התפכחות זמנית בסדרת זמן).

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

    הַצהָרָה

    @frozen
    public struct Conv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבת התפתחות דו-ממדית (למשל התמכרות מרחבית על פני תמונות).

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

    הַצהָרָה

    @frozen
    public struct Conv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבת התפתחות תלת מימדית להתמכרות מרחבית / מרחבית על תמונות.

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

    הַצהָרָה

    @frozen
    public struct Conv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה של התפשטות תלת-ממדית (למשל, התמכרות טרנסומלית זמנית על תמונות).

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

    הַצהָרָה

    @frozen
    public struct TransposedConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה של התפשטות דו-מימדית (למשל התפשטות מרחבית שהועברה על פני תמונות).

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

    הַצהָרָה

    @frozen
    public struct TransposedConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה של התפשטות תלת-ממדית שהועברה (למשל, המפנה מרחבית שהועברה על פני תמונות).

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

    הַצהָרָה

    @frozen
    public struct TransposedConv3D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבת התפשטות דו-ממדית בעומק.

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

    הַצהָרָה

    @frozen
    public struct DepthwiseConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה להוספת ריפוד אפס בממד הזמני.

    הַצהָרָה

    public struct ZeroPadding1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבה להוספת ריפוד אפס במידות המרחביות.

    הַצהָרָה

    public struct ZeroPadding2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבה להוספת ריפוד אפס במימדים המרחביים / מרחביים.

    הַצהָרָה

    public struct ZeroPadding3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת התפשטות חד-ממדית להפרדה.

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

    הַצהָרָה

    @frozen
    public struct SeparableConv1D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבת התפתחות דו-ממדית נפרדת.

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

    הַצהָרָה

    @frozen
    public struct SeparableConv2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה לשטח.

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

    הַצהָרָה

    @frozen
    public struct Flatten<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבה לעיצוב מחדש.

    הַצהָרָה

    @frozen
    public struct Reshape<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבה התוחמת פונקציה ניתנת להתאמה אישית.

    הַצהָרָה

    public struct Function<Input, Output> : ParameterlessLayer where Input : Differentiable, Output : Differentiable
  • ערך סוג דינמי TensorFlow שניתן ליצור מסוגים התואמים TensorFlowScalar .

    הַצהָרָה

    public struct TensorDataType : Equatable
  • הַצהָרָה

    @frozen
    public struct BFloat16
    extension BFloat16: TensorFlowScalar
    extension BFloat16: XLAScalarType
  • מייצג מערכת אלמנטים פוטנציאלית גדולה.

    ניתן להשתמש Dataset כדי לייצג צינור קלט כאוסף של טנסי טמנטים.

    הַצהָרָה

    @available(*, deprecated, message: "Datasets will be removed in S4TF v0.10. Please use the new Batches API instead.")
    @frozen
    public struct Dataset<Element> where Element : TensorGroup
    extension Dataset: Sequence
  • הסוג המאפשר איטרציה על פני אלמנטים של מערך נתונים.

    הַצהָרָה

    @available(*, deprecated)
    @frozen
    public struct DatasetIterator<Element> where Element : TensorGroup
    extension DatasetIterator: IteratorProtocol
  • מבנה דמוי 2 כפות המתאים ל- TensorGroup המייצג זנב של שני סוגים התואמים TensorGroup .

    הַצהָרָה

    @frozen
    public struct Zip2TensorGroup<T, U> : TensorGroup where T : TensorGroup, U : TensorGroup
  • שכבת רשת עצבית המחוברת בצפיפות.

    Dense מיישמת את activation(matmul(input, weight) + bias) הפעולה activation(matmul(input, weight) + bias) , כאשר weight הוא מטריצה ​​במשקל, bias היא וקטור הטיה activation היא פונקציית הפעלה חכמה אלמנטית.

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

    הַצהָרָה

    @frozen
    public struct Dense<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • מכשיר עליו ניתן להקצות Tensor s.

    הַצהָרָה

    public struct Device
    extension Device: Equatable
    extension Device: CustomStringConvertible
  • שכבת נשירה.

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

    הַצהָרָה

    @frozen
    public struct Dropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • GaussianNoise מוסיפה רעש שנדגם מההפצה הרגילה.

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

    הַצהָרָה

    public struct GaussianNoise<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • GaussianDropout מכפיל את הקלט עם הרעש שנדגם מהתפלגות רגילה עם ממוצע 1.0.

    מכיוון שמדובר בשכבת סדירות היא פעילה רק בזמן אימונים. במהלך ההסקה, GaussianDropout עובר בקלט ללא שינוי.

    הַצהָרָה

    public struct GaussianDropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת נשירה של אלפא.

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

    מקור: רשתות עצביות עם נורמליזציה עצמית: https://arxiv.org/abs/1706.02515

    הַצהָרָה

    @frozen
    public struct AlphaDropout<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת הטבעה.

    Embedding היא למעשה טבלת בדיקות הממפה מדדים מאוצר מילים קבוע לייצוגי וקטור בגודל קבוע (צפוף), למשל [[0], [3]] -> [[0.25, 0.1], [0.6, -0.2]] .

    הַצהָרָה

    public struct Embedding<Scalar> : Module where Scalar : TensorFlowFloatingPoint
  • מבנה ריק המייצג TangentVector ריקות לשכבות ללא פרמטרים.

  • זוג רגעים ראשונים ושניים (כלומר, ממוצע ושונות).

    הערה

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

    הַצהָרָה

    public struct Moments<Scalar> : Differentiable where Scalar : TensorFlowFloatingPoint
  • שכבת התרחבות מורפולוגית דו-ממדית

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

    הַצהָרָה

    @frozen
    public struct Dilation2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבת שחיקה מורפולוגית דו-ממדית

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

    הַצהָרָה

    @frozen
    public struct Erosion2D<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • מבחר עצלנים של אלמנטים, בסדר מסוים, מאוסף הבסיסים.

    הַצהָרָה

    public struct Sampling<Base: Collection, Selection: Collection>
    where Selection.Element == Base.Index
    extension Sampling: SamplingProtocol
    extension Sampling: Collection
    extension Sampling: BidirectionalCollection
      where Selection: BidirectionalCollection
    extension Sampling: RandomAccessCollection
      where Selection: RandomAccessCollection
  • אוסף של פרוסות הרצף הארוכות ביותר שלא חופפות זו בזו של אוסף Base , החל מהאלמנט הראשון שלו, ובעל אורך מקסימלי קבוע.

    האלמנטים של אוסף זה, למעט האחרון, כוללים count batchSize , אלא אם כן Base.count % batchSize !=0 , ובמקרה זה count האצווה האחרונה היא base.count % batchSize.

    הַצהָרָה

    public struct Slices<Base> where Base : Collection
    extension Slices: Collection
  • שכבת נורמליזציה של אצווה.

    מנרמל את ההפעלה של השכבה הקודמת בכל אצווה, כלומר מיישמת טרנספורמציה השומרת על ההפעלה הממוצעת קרוב ל 0 ואת סטיית התקן של ההפעלה קרוב ל 1 .

    הפניה: נורמליזציה של אצווה: האצת אימוני רשת עמוקה על ידי הפחתת משמרת קולית פנימית .

    הַצהָרָה

    @frozen
    public struct BatchNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה המחילה נורמליזציה של שכבה על מיני אצווה של תשומות.

    הפניה: נורמליזציה של שכבה .

    הַצהָרָה

    @frozen
    public struct LayerNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה המחילה נורמליזציה קבוצתית על מיני אצווה של תשומות.

    הפניה: נורמליזציה קבוצתית .

    הַצהָרָה

    @frozen
    public struct GroupNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • שכבה המחילה נורמליזציה למשל על מיני אצווה של כניסות.

    הפניה: נורמליזציה של המופע: החומר החסר לסטיילינג מהיר .

    הַצהָרָה

    @frozen
    public struct InstanceNorm<Scalar> : Layer where Scalar : TensorFlowFloatingPoint
  • ציין צעד אחד במשקל יחיד במיטוב.

    הַצהָרָה

    public struct OptimizerWeightStepState
  • מדינה גלובלית ניגשת באמצעות StateAccessor .

    הַצהָרָה

    public struct OptimizerState
  • [String: Float] אך ניתן לגשת לאלמנטים כאילו היו חברים.

    הַצהָרָה

    @dynamicMemberLookup
    public struct HyperparameterDictionary
  • מיטוב שעובד על קבוצת פרמטרים יחידה.

    הַצהָרָה

    public struct ParameterGroupOptimizer
  • עטיפה בטוחה לסוג סביב ערך אינדקס Int לערכים מקומיים למיטוב.

    הַצהָרָה

    public struct LocalAccessor
  • עטיפה בטוחה לסוג סביב ערך אינדקס Int לערכים גלובליים של האופטימיזציה.

    הַצהָרָה

    public struct GlobalAccessor
  • עטיפה בטוחה לסוג סביב ערך אינדקס Int לערכי מצב מיטוב.

    הַצהָרָה

    public struct StateAccessor
  • בונה ParameterGroupOptimizer . זה משמש בעיקרו של ממשקל אחד במודל. מיפוי מקבוצות פרמטרים שנבחרו על ידי ( [Bool] ל- ParameterGroupOptimizer) מגדיר את האופטימיזציה הסופית.

    הַצהָרָה

    public struct ParameterGroupOptimizerBuilder
  • שכבת איגום מקסימאלית לנתונים זמניים.

    הַצהָרָה

    @frozen
    public struct MaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום מקסימאלית לנתונים מרחביים.

    הַצהָרָה

    @frozen
    public struct MaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום מקסימאלית לנתונים מרחביים או מרחביים.

    הַצהָרָה

    @frozen
    public struct MaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום ממוצעת לנתונים זמניים.

    הַצהָרָה

    @frozen
    public struct AvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום ממוצעת לנתונים מרחביים.

    הַצהָרָה

    @frozen
    public struct AvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום ממוצעת לנתונים מרחביים או מרחביים.

    הַצהָרָה

    @frozen
    public struct AvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום ממוצעת עולמית לנתונים זמניים.

    הַצהָרָה

    @frozen
    public struct GlobalAvgPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום ממוצעת עולמית עבור נתונים מרחביים.

    הַצהָרָה

    @frozen
    public struct GlobalAvgPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום ממוצעת עולמית לנתונים מרחביים ומרחביים.

    הַצהָרָה

    @frozen
    public struct GlobalAvgPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום מקסימאלית עולמית לנתונים זמניים.

    הַצהָרָה

    @frozen
    public struct GlobalMaxPool1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום מקסימאלית עולמית לנתונים מרחביים.

    הַצהָרָה

    @frozen
    public struct GlobalMaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום מקסימאלית עולמית לנתונים מרחביים ומרחביים.

    הַצהָרָה

    @frozen
    public struct GlobalMaxPool3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבת איגום מקסימאלית לשברים עבור נתונים מרחביים. הערה: ל- FractionalMaxPool אין יישום XLA, ולכן יכולות להיות השלכות על ביצועים.

    הַצהָרָה

    @frozen
    public struct FractionalMaxPool2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • PythonObject מייצג אובייקט ב- Python ותומך PythonObject חברים דינמי. כל גישה object.foo כמו object.foo תבקש באופן דינמי את זמן ההפעלה של Python עבור חבר עם השם שצוין באובייקט זה.

    PythonObject מועבר וחוזר מכל שיחות הפונקציה של Python והפניות לחברים. הוא תומך במפעילי חשבון פיתון סטנדרטיים והשוואה.

    באופן פנימי, PythonObject מיושם PythonObject התייחסות ל- Python C API PyObject .

    הַצהָרָה

    @dynamicCallable
    @dynamicMemberLookup
    public struct PythonObject
    extension PythonObject : CustomStringConvertible
    extension PythonObject : CustomPlaygroundDisplayConvertible
    extension PythonObject : CustomReflectable
    extension PythonObject : PythonConvertible, ConvertibleFromPython
    extension PythonObject : SignedNumeric
    extension PythonObject : Strideable
    extension PythonObject : Equatable, Comparable
    extension PythonObject : Hashable
    extension PythonObject : MutableCollection
    extension PythonObject : Sequence
    extension PythonObject : ExpressibleByBooleanLiteral, ExpressibleByIntegerLiteral,
    ExpressibleByFloatLiteral, ExpressibleByStringLiteral
    extension PythonObject : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral
  • עטיפת PythonObject המאפשרת שיחות שיטת זריקה. חריגים המיוצרים על ידי פונקציות Python משתקפים כשגיאות מהירות ונזרקות.

    הערה

    בכוונה @dynamicCallable ThrowingPythonObject אין את התכונה @dynamicCallable מכיוון @dynamicCallable השיחה אינו אינטואיטיבי: x.throwing(arg1, arg2, ...) . השיטות עדיין ייקראו dynamicallyCall עד להמשך דיון / תכנון.

    הַצהָרָה

    public struct ThrowingPythonObject
  • עטיפת PythonObject המאפשרת גישה לחברים. פעולות גישה לחברים מחזירות תוצאה Optional . כאשר הגישה לחברים נכשלה, nil מוחזר.

    הַצהָרָה

    @dynamicMemberLookup
    public struct CheckingPythonObject
  • ממשק לפיתון.

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

    הערה

    זה לא מיועד ל- PythonInterface לאתחל ישירות. במקום זאת, אנא השתמש במופע הגלובלי של PythonInterface שנקרא Python .

    הַצהָרָה

    @dynamicMemberLookup
    public struct PythonInterface
  • הַצהָרָה

    public struct PythonLibrary
  • מחולל מספרים אקראיים שנמחקו.

    סוג AnyRandomNumberGenerator מעביר פעולות לייצור מספרים אקראיים למחולל המספרים האקראיים הבסיסי, ומסתיר את סוגו הבסיסי הספציפי.

    הַצהָרָה

    public struct AnyRandomNumberGenerator : RandomNumberGenerator
  • יישום של SeedableRandomNumberGenerator באמצעות ARC4.

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

    ARC4 מתואר ב- Schneier, B., "Cryptography יישומי: פרוטוקולים, אלגוריתמים וקוד מקור ב- C", המהדורה השנייה, 1996.

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

    הַצהָרָה

    @frozen
    public struct ARC4RandomNumberGenerator : SeedableRandomNumberGenerator
  • יישום של SeedableRandomNumberGenerator באמצעות Threefry. סלמון ואח '. SC 2011. מספרים אקראיים מקבילים: קלים כמו 1, 2, 3. http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

    מבנה זה מיישם Threefry2x32 PRNG בן 20 סיבובים. יש לזרוע אותו בערך 64 סיביות.

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

    הַצהָרָה

    public struct ThreefryRandomNumberGenerator : SeedableRandomNumberGenerator
  • יישום של SeedableRandomNumberGenerator באמצעות Philox. סלמון ואח '. SC 2011. מספרים אקראיים מקבילים: קלים כמו 1, 2, 3. http://www.thesalmons.org/john/random123/papers/random123sc11.pdf

    מבנה זה מיישם PhilNX4x32 PRNG בעשרה סיבובים. יש לזרוע אותו בערך 64 סיביות.

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

    הַצהָרָה

    public struct PhiloxRandomNumberGenerator : SeedableRandomNumberGenerator
  • הַצהָרָה

    @frozen
    public struct UniformIntegerDistribution<T> : RandomDistribution where T : FixedWidthInteger
  • הַצהָרָה

    @frozen
    public struct UniformFloatingPointDistribution<T: BinaryFloatingPoint>: RandomDistribution
    where T.RawSignificand: FixedWidthInteger
  • הַצהָרָה

    @frozen
    public struct NormalDistribution<T: BinaryFloatingPoint>: RandomDistribution
    where T.RawSignificand: FixedWidthInteger
  • הַצהָרָה

    @frozen
    public struct BetaDistribution : RandomDistribution
  • קלט לרשת עצבית חוזרת.

    הַצהָרָה

    public struct RNNCellInput<Input, State> : Differentiable where Input : Differentiable, State : Differentiable
    extension RNNCellInput: EuclideanDifferentiable
    where Input: EuclideanDifferentiable, State: EuclideanDifferentiable
  • פלט לרשת עצבית חוזרת.

    הַצהָרָה

    public struct RNNCellOutput<Output, State> : Differentiable where Output : Differentiable, State : Differentiable
    extension RNNCellOutput: EuclideanDifferentiable
    where Output: EuclideanDifferentiable, State: EuclideanDifferentiable
  • תא RNN בסיסי.

    הַצהָרָה

    public struct BasicRNNCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint
  • תא LSTM.

    הַצהָרָה

    public struct LSTMCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint
  • תא GRU.

    הַצהָרָה

    public struct GRUCell<Scalar> : RecurrentLayerCell where Scalar : TensorFlowFloatingPoint
  • הַצהָרָה

    public struct RecurrentLayer<Cell> : Layer where Cell : RecurrentLayerCell
    extension RecurrentLayer: Equatable where Cell: Equatable
    extension RecurrentLayer: AdditiveArithmetic where Cell: AdditiveArithmetic
  • שכבה המרכיבה ברצף שניים או יותר שכבות אחרות.

    דוגמאות:

    • בנה מודל פשוט של שתי שכבות percepttron עבור MNIST:
    let inputSize = 28 * 28
    let hiddenSize = 300
    var classifier = Sequential {
         Dense<Float>(inputSize: inputSize, outputSize: hiddenSize, activation: relu)
         Dense<Float>(inputSize: hiddenSize, outputSize: 3, activation: identity)
     }
    
    • בנה מקודד אוטומטי עבור MNIST:
    var autoencoder = Sequential {
        // The encoder.
        Dense<Float>(inputSize: 28 * 28, outputSize: 128, activation: relu)
        Dense<Float>(inputSize: 128, outputSize: 64, activation: relu)
        Dense<Float>(inputSize: 64, outputSize: 12, activation: relu)
        Dense<Float>(inputSize: 12, outputSize: 3, activation: relu)
        // The decoder.
        Dense<Float>(inputSize: 3, outputSize: 12, activation: relu)
        Dense<Float>(inputSize: 12, outputSize: 64, activation: relu)
        Dense<Float>(inputSize: 64, outputSize: 128, activation: relu)
        Dense<Float>(inputSize: 128, outputSize: imageHeight * imageWidth, activation: tanh)
    }
    

    הַצהָרָה

    public struct Sequential<Layer1: Module, Layer2: Layer>: Module
        where Layer1.Output == Layer2.Input,
              Layer1.TangentVector.VectorSpaceScalar == Layer2.TangentVector.VectorSpaceScalar
    extension Sequential: Layer where Layer1: Layer
  • הַצהָרָה

    @_functionBuilder
    public struct LayerBuilder
  • ShapedArray הוא מערך רב ממדי. יש לה צורה, בעלת סוג [Int] ומגדירה את ממדי המערך, ומשתמשת ב- TensorBuffer פנימי כאחסון.

    הַצהָרָה

    @frozen
    public struct ShapedArray<Scalar> : _ShapedArrayProtocol
    extension ShapedArray: RandomAccessCollection, MutableCollection
    extension ShapedArray: CustomStringConvertible
    extension ShapedArray: CustomPlaygroundDisplayConvertible
    extension ShapedArray: CustomReflectable
    extension ShapedArray: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar
    extension ShapedArray: Equatable where Scalar: Equatable
    extension ShapedArray: Hashable where Scalar: Hashable
    extension ShapedArray: Codable where Scalar: Codable
  • פרוסה רציפה של מופע ShapedArray או ShapedArraySlice .

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

    מערכי אלמנטים הם אלמנטים תת-ממדיים של ShapedArray : דרגתם היא אחת פחות מזו של הבסיס שלהם. פרוסות מערך אלמנט מתקבלות על ידי אינדקס של ShapedArray למשל עם ביחיד Int32 מדד.

    לדוגמה:

        var matrix = ShapedArray(shape: [2, 2], scalars: [0, 1, 2, 3])
        // `matrix` represents [[0, 1], [2, 3]].
    
        let element = matrix[0]
        // `element` is a `ShapedArraySlice` with shape [2]. It is an element
        // array, specifically the first element in `matrix`: [0, 1].
    
        matrix[1] = ShapedArraySlice(shape: [2], scalars: [4, 8])
        // The second element in `matrix` has been mutated.
        // `matrix` now represents [[0, 1, 4, 8]].
    

    סובאראיי הם טווח רציף של האלמנטים ב- ShapedArray . דרגת מערך זהה לזו של בסיסה, אך הממד המוביל שלה הוא ספירת טווח הפרוסות. פרוסות סובארשי מתקבלות על ידי אינדקס של ShapedArray עם Range<Int32> המייצג טווח של אלמנטים (בממד המוביל). שיטות כמו prefix(:) suffix(:) שמייצר אינדקס פנימי עם טווח מייצרות גם תת-מערך.

    לדוגמה:

        let zeros = ShapedArray(repeating: 0, shape: [3, 2])
        var matrix = ShapedArray(shape: [3, 2], scalars: Array(0..<6))
        // `zeros` represents [[0, 0], [0, 0], [0, 0]].
        // `matrix` represents [[0, 1], [2, 3], [4, 5]].
    
        let subarray = matrix.prefix(2)
        // `subarray` is a `ShapedArraySlice` with shape [2, 2]. It is a slice
        // of the first 2 elements in `matrix` and represents [[0, 1], [2, 3]].
    
        matrix[0..<2] = zeros.prefix(2)
        // The first 2 elements in `matrix` have been mutated.
        // `matrix` now represents [[0, 0], [0, 0], [4, 5]].
    

    הַצהָרָה

    @frozen
    public struct ShapedArraySlice<Scalar> : _ShapedArrayProtocol
    extension ShapedArraySlice: RandomAccessCollection, MutableCollection
    extension ShapedArraySlice: CustomStringConvertible
    extension ShapedArraySlice: CustomPlaygroundDisplayConvertible
    extension ShapedArraySlice: CustomReflectable
    extension ShapedArraySlice: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar
    extension ShapedArraySlice: Equatable where Scalar: Equatable
    extension ShapedArraySlice: Hashable where Scalar: Hashable
    extension ShapedArraySlice: Codable where Scalar: Codable
  • StringTensor הוא מערך רב ממדי שהרכיבים שלו הם String s.

    הַצהָרָה

    @frozen
    public struct StringTensor
    extension StringTensor: TensorGroup
  • TensorHandle הוא הסוג שמשמש אופ. זה כולל סוג Scalar , בו פנימי המהדר יכולים להשתמש בכדי לקבוע את סוגי הנתונים של הפרמטרים כאשר הם מחולצים לתוכנית טנזור.

    הַצהָרָה

    public struct TensorHandle<Scalar> where Scalar : _TensorFlowDataTypeCompatible
    extension TensorHandle: TensorGroup
  • הַצהָרָה

    public struct ResourceHandle
    extension ResourceHandle: TensorGroup
  • הַצהָרָה

    public struct VariantHandle
    extension VariantHandle: TensorGroup
  • מבנה המייצג את צורתו של טנסור.

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

    הַצהָרָה

    @frozen
    public struct TensorShape : ExpressibleByArrayLiteral
    extension TensorShape: Collection, MutableCollection
    extension TensorShape: RandomAccessCollection
    extension TensorShape: RangeReplaceableCollection
    extension TensorShape: Equatable
    extension TensorShape: Codable
    extension TensorShape: CustomStringConvertible
  • TensorVisitorPlan מתקרב ל- [WritableKeyPath<Base, Tensor<Float>] אך הוא יעיל יותר. זה שימושי לכתיבת מיטבי אופטימיזציה גנריים שרוצים למפות את הדרגתיות, המשקולות הקיימות, ואינדקס בו ניתן להשתמש כדי למצוא משקולות המאוחסנות בעזרה. זה מעט יעיל יותר (~ 2x) אבל זה יכול להיות טוב יותר מכיוון שהוא נסחר בתקורות מעט גבוהות יותר (הסרת מצביע נוספת) על כך שלא נדרש לבצע עבודות O (עומק_ת_tree) הנדרשות עם רשימה רגילה כדי לאתר את כל מפתח הדרך האישי.

    הַצהָרָה

    public struct TensorVisitorPlan<Base>
  • שכבה מדגמת עליונה לתשומות חד-מימדיות.

    הַצהָרָה

    @frozen
    public struct UpSampling1D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבה מדגמת עליונה לתשומות דו-ממדיות.

    הַצהָרָה

    @frozen
    public struct UpSampling2D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • שכבה מדגמת עליונה לתשומות תלת מימדיות.

    הַצהָרָה

    @frozen
    public struct UpSampling3D<Scalar> : ParameterlessLayer where Scalar : TensorFlowFloatingPoint
  • אוסף מוני חיזוי נכונים וסיכומי הפסד.

    הַצהָרָה

    public struct HostStatistics