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

ניב & # 39; tfl & # 39; הַגדָרָה

הניב TensorFlow Lite.

ניב זה ממפה לפעולות TensorFlow Lite.

בלתי פוסקים:

  • כל הערכים הם מסוג טנסור (בפרט, סקלרים מיוצגים באמצעות טנסורים ממדי אפס);

הגדרת המבצע

tfl.abs (TFL :: AbsOp)

מפעיל ערך מוחלט

תיאור:

בהינתן טנזור x , פעולה זו מחזירה טנסור המכיל את הערך המוחלט של כל רכיב ב- x . לדוגמה, אם x הוא אלמנט קלט ו- y הוא אלמנט פלט, פעולה זו מחשבת \ (y = | x | \).

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.add_n (TFL :: AddNOp)

להוסיף מפעיל

תיאור:

מוסיף את כל הטנסורים הקלטים בצורה אלמנטית.

מפעיל:

  1. inputs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. sum : טנסור מכל ערכי סוג

tfl.add (TFL :: AddOp)

מפעיל תוספות

תיאור:

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

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
fused_activation_function StringAttr תכונה enum הפעלה ממולאת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.arg_max (TFL :: ArgMaxOp)

מפעיל ArgMax

תיאור:

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

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. dim : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
output_type Attribute תכונה נגזרת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.arg_min (TFL :: ArgMinOp)

מפעיל ArgMin

תיאור:

מחזירה את האינדקס עם הערך הקטן ביותר על פני הממדים של טנסור. "A = [1, 10, 26.9, 2.8, 166.32, 62.3] b = tf.math.argmin (input = a) c = tf.keras.backend.eval (ב)

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. dim : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
output_type Attribute תכונה נגזרת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.average_pool_2d (TFL :: AveragePool2DOp)

מפעיל ממוצע pool_2d

תיאור:

מבצע פעולת איגום ממוצעת בכניסה.

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
filter_height IntegerAttr תכונה שלם שלם שלם של 32 סיביות
filter_width IntegerAttr תכונה שלם שלם שלם של 32 סיביות
padding StringAttr ריפוד תכונת enum
stride_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות
stride_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות
fused_activation_function StringAttr תכונה enum הפעלה ממולאת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.basic_lstm (TFL :: BasicLSTMOp)

מפעיל ה- lstm הבסיסי

תיאור:

מפעיל תא LSTM בסיסי.

מפעיל:

  1. data_input : טנסור מכל ערכי סוג
  2. prev_activ_input : טנסור מכל ערכי סוג
  3. weights_input : טנסור מכל ערכי סוג
  4. biases_input : טנסור מכל ערכי סוג
  5. prev_state_input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
fused_activation_function StringAttr תכונה enum הפעלה ממולאת
cell_clip FloatAttr תכונת Float של 32 סיביות
proj_clip FloatAttr תכונת Float של 32 סיביות
kernel_type StringAttr lstm סוג גרעין enum מקרה תכונה בסיסית

תוצאות:

  1. activ_output : טנסור דו מימדי מכל ערכי סוג
  2. state_output : טנסור דו מימדי מכל ערכי סוג
  3. concat_temp : טנסור 2D מכל ערכי סוג
  4. activ_temp : טנסור דו מימדי מכל ערכי סוג

tfl.batch_to_space_nd (TFL :: BatchToSpaceNdOp)

מפעיל BatchToSpaceNd

תיאור:

פעולה זו מעצבת מחדש את ממד "אצווה" לממדי שטח.

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. block_shape : טנסור מכל ערכי סוג
  3. indices : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.cast (TFL :: CastOp)

מפעיל יצוק

תיאור:

מעביר קלט מסוג קלט לסוג פלט.

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.ceil (TFL :: CeilOp)

מפעיל תקרה

תיאור:

מחזירה את ערך התקרה בצורה אלמנטית של הקלט.

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.concatenation (TFL :: ConcatenationOp)

מפעיל שרשור

תיאור:

מורכב טנסורים לאורך ממד אחד

מפעיל:

  1. values : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
axis IntegerAttr תכונה שלם שלם שלם של 32 סיביות
fused_activation_function StringAttr תכונה enum הפעלה ממולאת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.pseudo_const (TFL :: ConstOp)

פסאודו מתמיד.

תיאור:

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

ל- OP מותר לכל אחד מאותו סוג של תכונות כמו ש- tf.Const עושה (למשל, תכונות TF אטומות מותרות).

מפעיל:

תכונות:

תְכוּנָה סוג MLIR תיאור
value ElementsAttr תכונה וקטורית / טנסור קבועה

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.conv_2d (TFL :: Conv2DOp)

מפעיל המרה

תיאור:

מבצע פעולת עיבוי על תשומות.

כניסות: inputs[0] : חובה: inputs[1] טנזור להפעלת inputs[1] : חובה: inputs[2] טנזור משקל המסנן inputs[2] : אופציונלי: טנזור ההטיה

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. filter : טנסור מכל ערכי סוג
  3. bias : טנסור מכל ערכי סוג או כל סוג שהוא

תכונות:

תְכוּנָה סוג MLIR תיאור
dilation_h_factor IntegerAttr תכונה שלם שלם שלם של 32 סיביות
dilation_w_factor IntegerAttr תכונה שלם שלם שלם של 32 סיביות
fused_activation_function StringAttr תכונה enum הפעלה ממולאת
padding StringAttr ריפוד תכונת enum
stride_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות
stride_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.convolution_2d_transpose_bias (TFL :: Convolution2DTransposeBiasOp)

החלף התפכחות עם מפעיל הטיה

תיאור:

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

 Inputs:
  `inputs[0]`: required: the input activation tensor
  `inputs[1]`: required: the filter weight tensor
  `inputs[2]`: optional: the bias tensor
 

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. filter : טנסור מכל ערכי סוג
  3. bias : טנסור מכל ערכי סוג או כל סוג שהוא

תכונות:

תְכוּנָה סוג MLIR תיאור
padding StringAttr ריפוד תכונת enum
stride_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות
stride_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.cos (TFL :: CosOp)

מפעיל קוסנה

תיאור:

מחשבת את הקוסין מבחינה אלמנטית מהקלט

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.densify (TFL :: DensifyOp)

צפיפות מפעיל

תיאור:

ממיר טנסור דליל לפורמט צפוף.

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.depth_to_space (TFL :: DepthToSpaceOp)

מפעיל DepthToSpace

תיאור:

מסדר מחדש נתונים מעומק לבלוקים של נתונים מרחביים. זו המהפך ההפוך של SpaceToDepth. ליתר דיוק, אופ זה מוציא עותק של טנזור הקלט בו ערכים מממד depth מועברים בלוקים מרחביים למידות height width . גודל ה- attr block_size מציין את גודל חסימת הקלט ואת אופן העברת הנתונים.

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
block_size IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.depthwise_conv_2d (TFL :: DepthwiseConv2DOp)

מפעיל עיקול המופרד בעומק

תיאור:

מבצע פעולת עיבוי על תשומות.

כניסות: inputs[0] : חובה: inputs[1] טנזור להפעלת inputs[1] : חובה: inputs[2] טנזור משקל המסנן inputs[2] : אופציונלי: טנזור ההטיה

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. filter : טנסור מכל ערכי סוג
  3. bias : טנסור מכל ערכי סוג או כל סוג שהוא

תכונות:

תְכוּנָה סוג MLIR תיאור
dilation_h_factor IntegerAttr תכונה שלם שלם שלם של 32 סיביות
dilation_w_factor IntegerAttr תכונה שלם שלם שלם של 32 סיביות
fused_activation_function StringAttr תכונה enum הפעלה ממולאת
padding StringAttr ריפוד תכונת enum
stride_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות
stride_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות
depth_multiplier IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.dequantize (TFL :: DequantizeOp)

לפקח את המפעיל

תיאור:

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

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.div (TFL :: DivOp)

מפעיל החטיבה

תיאור:

פעולת חלוקה אלמנטית-חכמה.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
fused_activation_function StringAttr תכונה enum הפעלה ממולאת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.elu (TFL :: EluOp)

מפעיל יחידה לינארית מעריכית

תיאור:

מחשבת את הקווי האקספוננציאלי f (x) -> exp (x) - 1 עבור x <0, x עבור x> = 0. מבחינה אלמנטית.

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.embedding_lookup (TFL :: EmbeddingLookupOp)

הטמעת מפעיל בדיקה

תיאור:

מחפש מזהים ברשימה של טמני הטבעה.

מפעיל:

  1. lookup : טנסור מכל ערכי סוג
  2. value : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.equal (TFL :: EqualOp)

מפעיל שווה

תיאור:

מחזירה את אלמנט האמת של x == y בצורה חכמה

מפעיל:

  1. x : טנסור מכל ערכי סוג
  2. y : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.exp (TFL :: ExpOp)

מפעיל התפשטות טבעית

תיאור:

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

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.expand_dims (TFL :: ExpandDimsOp)

מכניס ממד של 1 לצורה של טנור.

תיאור:

בהינתן input טנזור, פעולה זו מכניסה ממד של 1 axis אינדקס הממד של צורת input . axis אינדקס הממד מתחיל באפס; אם אתה מציין מספר שלילי axis הוא נספר לאחור מהסוף.

פעולה זו שימושית אם ברצונך להוסיף ממד אצווה לאלמנט יחיד. לדוגמה, אם יש לך תמונה יחידה של צורה [height, width, channels] , אתה יכול להפוך אותה לאצווה של תמונה אחת עם expand_dims(image, 0) , אשר תהפוך את הצורה [1, height, width, channels] .

דוגמאות נוספות:

 # 't' is a tensor of shape [2]
shape(expand_dims(t, 0)) ==> [1, 2]
shape(expand_dims(t, 1)) ==> [2, 1]
shape(expand_dims(t, -1)) ==> [2, 1]

# 't2' is a tensor of shape [2, 3, 5]
shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
 

פעולה זו דורשת:

-1-input.dims() <= dim <= input.dims()

פעולה זו קשורה squeeze() , המסלקת ממדים בגודל 1.

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. dim : tensor מכל סוג שלם

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.external_const (TFL :: ExternalConstOp)

חיצוני const op.

תיאור:

חיצוני const op מכיל buffer_index שמצביע על קבוע באולם השטח.

מפעיל:

תכונות:

תְכוּנָה סוג MLIR תיאור
buffer_index IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.fake_quant (TFL :: FakeQuantOp)

מפעיל FakeQuant

תיאור:

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

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
min FloatAttr תכונת Float של 32 סיביות
max FloatAttr תכונת Float של 32 סיביות
num_bits IntegerAttr תכונה שלם שלם שלם של 32 סיביות
narrow_range BoolAttr תכונה bool

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.fill (TFL :: FillOp)

מלא את הטנסור בערך נתון.

תיאור:

מלא את הטנסור בערך נתון.

מפעיל:

  1. dims : טנסור מכל ערכי סוג
  2. value : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. res : טנסור מכל ערכי סוג

tfl.floor_div (TFL :: FloorDivOp)

מפעיל חלוקה לקומה

תיאור:

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

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.floor_mod (TFL :: FloorModOp)

תזכורת חלוקה

תיאור:

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

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.floor (TFL :: FloorOp)

מפעיל רצפה

תיאור:

מחזירה את ערך הרצפה ברמת האלמנט של הקלט.

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.fully_connected (TFL :: FullyConnectedOp)

מחובר לחלוטין

תיאור:

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. filter : טנסור מכל ערכי סוג
  3. bias : טנסור מכל ערכי סוג או כל סוג שהוא

תכונות:

תְכוּנָה סוג MLIR תיאור
fused_activation_function StringAttr תכונה enum הפעלה ממולאת
weights_format StringAttr תכונות פורמט משקולות אופציות מחוברות לחלוטין
keep_num_dims BoolAttr תכונה bool

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.gather_nd (TFL :: GatherNdOp)

מפעיל Gather_nd

תיאור:

אוספים פרוסות params לטנסור עם צורה מוגדרת על ידי indices .

מפעיל:

  1. params : טנסור מכל ערכי סוג
  2. indices : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.gather (TFL :: GatherOp)

אסוף מפעיל

תיאור:

אסוף פרוסות מציר axis params לפי indices .

מפעיל:

  1. params : טנסור מכל ערכי סוג
  2. indices : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
axis IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.gesser_equal (TFL :: GreaterEqualOp)

מפעיל גדול יותר

תיאור:

פעולה אלמנטית-חכמה יותר.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.g Greater (TFL :: GreaterOp)

מפעיל גדול יותר

תיאור:

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

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.hard_swish (TFL :: HardSwishOp)

פונקציית הפעלה קשה.

תיאור:

מחשבת את פונקציית ההפעלה הקשה-swish f (x) -> (x * relu6 (x + 3)) / 6 מבחינה אלמנטית.

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. out : טנסור מכל ערכי סוג

tfl.l2_normalization (TFL :: L2NormalizationOp)

L2 מנרמל מפעיל

תיאור:

L2Normalization Op

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
fused_activation_function StringAttr תכונה enum הפעלה ממולאת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.lstm (TFL :: LSTMOp)

מפעיל lstm המלא

תיאור:

יחידת זיכרון ארוכת טווח (LSTM) שכבת רשת חוזרת. יישום ברירת המחדל שאינו עיכול מבוסס על: http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf S. Hochreiter ו- J. Schmidhuber. "זיכרון ארוך טווח". חישוב עצביים, 9 (8): 1735-1780, 1997. יישום העין מבוסס על: https://research.google.com/pubs/archive/43905.pdf חסים סאק, אנדרו סניר ופרנסואז בופייז. "ארכיטקטורות רשת עצביות חוזרות לזיכרון לטווח הקצר למודלים אקוסטיים בקנה מידה גדול. INTERSPEECH, 2014. צימוד שער הזנה ושכחה (CIFG) מבוסס על: http://arxiv.org/pdf/1503.04069.pdf Greff et al. . "LSTM: אודיסיאה בחלל החיפוש" נורמליזציה של השכבה מבוססת על: https://arxiv.org/pdf/1607.06450.pdf Ba et al. "Normalization Layer"

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. input_to_input_weights : טנסור מכל ערכי סוג או סוג כלשהו
  3. input_to_forget_weights : טנסור מכל ערכי סוג
  4. input_to_cell_weights : טנסור מכל ערכי סוג
  5. input_to_output_weights : טנסור מכל ערכי סוג
  6. recurrent_to_input_weights חוזרות_כדי_כניסה: טנסור מכל ערכי סוג או סוג כלשהו
  7. recurrent_to_forget_weights : טנסור מכל ערכי סוג
  8. recurrent_to_cell_weights : טנסור מכל ערכי סוג
  9. recurrent_to_output_weights חוזרות_לפלט_משקל: טנסור מכל ערכי סוג
  10. cell_to_input_weights : טנסור מכל ערכי סוג או סוג כלשהו
  11. cell_to_forget_weights : טנסור מכל ערכי סוג או סוג כלשהו
  12. cell_to_output_weights : טנסור מכל ערכי סוג או סוג כלשהו
  13. input_gate_bias : טנסור מכל ערכי סוג או סוג כלשהו
  14. forget_gate_bias : טנסור מכל ערכי סוג
  15. cell_bias : טנסור מכל ערכי סוג
  16. output_gate_bias : טנסור מכל ערכי סוג
  17. projection_weights : טנסור מכל ערכי סוג או סוג כלשהו
  18. projection_bias : טנסור מכל ערכי סוג או סוג כלשהו
  19. input_activation_state : טנזור מצבי
  20. input_cell_state : טנזור מצבי
  21. input_layer_norm_coefficients : טנסור מכל ערכי סוג או כל סוג שהוא
  22. forget_layer_norm_coefficients : טנסור מכל ערכי סוג או כל סוג
  23. cell_layer_norm_coefficients : טנסור מכל ערכי סוג או כל סוג שהוא
  24. output_layer_norm_coefficients : טנסור מכל ערכי סוג או כל סוג שהוא

תכונות:

תְכוּנָה סוג MLIR תיאור
fused_activation_function StringAttr תכונה enum הפעלה ממולאת
cell_clip FloatAttr תכונת Float של 32 סיביות
proj_clip FloatAttr תכונת Float של 32 סיביות
kernel_type StringAttr lstm סוג הגרעין enum מקרה מלא

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.leaky_relu (TFL :: LeakyReluOp)

מפעיל Leaky Relu

תיאור:

מפעיל ReLU דליפה מבחינת אלמנט x -> x> = 0? x: (אלפא * x)

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
alpha FloatAttr תכונת Float של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.less_equal (TFL :: LessEqualOp)

מפעיל פחות_שווה

תיאור:

פעולה פחות חכמה-אלמנטית.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.less (TFL :: LessOp)

פחות מפעיל

תיאור:

פעולה פחות חכמה.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.local_response_normalization (TFL :: LocalResponseNormalizationOp)

נורמליזציה של תגובה מקומית.

תיאור:

מתייחס לכונן input 4-D כאל מערך תלת מימדי של וקטורים חד-מימדיים (לאורך הממד האחרון), וכל וקטור מנורמל באופן עצמאי. בתוך וקטור נתון, כל מרכיב מחולק בסכום המשוקלל depth_radius של התשומות בתוך depth_radius . בפירוט,

 sqr_sum[a, b, c, d] =
    sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
output = input / (bias + alpha * sqr_sum) ** beta
 

לפרטים, ראה Krizhevsky et al., סיווג ImageNet עם רשתות עצביות מפותלות עמוקות (NIPS 2012) .

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
radius IntegerAttr תכונה שלם שלם שלם של 32 סיביות
bias FloatAttr תכונת Float של 32 סיביות
alpha FloatAttr תכונת Float של 32 סיביות
beta FloatAttr תכונת Float של 32 סיביות

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.log (TFL :: LogOp)

מפעיל לוגריתם טבעי

תיאור:

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

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.log_softmax (TFL :: LogSoftmaxOp)

התחבר למפעיל softmax

תיאור:

מחשבים הפעלות softmax של יומן חכם באמצעות הנוסחה הבאה

קלט - יומן (reduc_sum (exp (input), dim))

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.logical_and (TFL :: LogicalAndOp)

הגיוני ומפעיל

תיאור:

הגיוני ותפעול חכם אלמנט.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.logical_not (TFL :: LogicalNotOp)

מפעיל הגיוני ולא

תיאור:

פעולה הגיונית מבחינת אלמנט לא.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.logical_or (TFL :: LogicalOrOp)

מפעיל לוגי או

תיאור:

פעולה הגיונית או חכמת אלמנט או פעולה.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.logistic (TFL :: LogisticOp)

מפעיל לוגיסטי

תיאור:

מחשבת סיגמואיד מתוך קלט

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.matrix_diag (TFL :: MatrixDiagOp)

 Returns a tensor with the provided diagonal and everything else padded with zeros.
 

תיאור:

בהינתן אלכסון, מחזיר טנסור עם האלכסון וכל השאר מרופד באפסים. נניח באלכסון יש ממדי k [I, J, K, ..., N] , אז הפלט הוא טנזור של דרגה k+1 עם הממדים [I, J, K, ..., N, N] איפה: output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n].

מפעיל:

  1. diagonal : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.matrix_set_diag (TFL :: MatrixSetDiagOp)

 Returns a batched matrix tensor with new batched diagonal values.
 

תיאור:

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

מפעיל:

  1. input : טנסור מסוג מספר שלם של 32 סיביות או שלם של 32 סיביות או מספר שלם של 64 סיביות או שלם של 8 סיביות או סוג QI8 או סוג QI16 או סוג QUI8 או סוג uint8 מסוג TFLite או סוג Qint8 של TFLite
  2. diagonal : טנסור של מספר שלם של 32 סיביות או שלם של 32 סיביות או שלם של 64 סיביות או שלם של 8 סיביות או סוג QI8 או סוג QI16 או סוג QUI8 או TFLite uint8 או ערכים מסוג TFLite quint8

תכונות:

תוצאות:

  1. output : טנסור של מספר שלם של 32 סיביות או שלם של 32 סיביות או שלם של 64 סיביות או מספר שלם של 8 סיביות או סוג QI8 או סוג QI16 או סוג QUI8 או TFLite uint8 או TFLite ערכות מסוג Quint8

tfl.max_pool_2d (TFL :: MaxPool2DOp)

מקס בריכה דו מימדית

תיאור:

מבצע מקסימום בריכה 2D בכניסה.

כניסות: inputs[0] : חובה: טנסור הקלט

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
padding StringAttr ריפוד תכונת enum
stride_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות
stride_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות
filter_width IntegerAttr תכונה שלם שלם שלם של 32 סיביות
filter_height IntegerAttr תכונה שלם שלם שלם של 32 סיביות
fused_activation_function StringAttr תכונה enum הפעלה ממולאת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.max_pooling_with_argmax_2d (TFL :: MaxPoolingWithArgMax2DOp)

מקסימום בריכה דו מימדית עם ארגמקס אופ

תיאור:

מבצע איגום מקסימלי על הקלט ופלט הן ערכי מקסימום ומדדים. כל אינדקס הוא אינדקס משוטח במערך משנה בגודל "filter_w" x "filter_h" שים לב זה אופציה מותאמת אישית שאינה נתמכת בזמן הריצה הרגיל.

כניסות: inputs[0] : חובה: טנזור הפעלת הקלט

מפעיל:

  1. input : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
padding StringAttr ריפוד תכונת enum
stride_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות
stride_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות
filter_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות
filter_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. value : טנסור מכל ערכי סוג
  2. indices : טנסור מכל ערכי סוג

tfl.max_unpooling_2d (TFL :: MaxUnpooling2DOp)

מקס Unpool 2D

תיאור:

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

כניסות: inputs[0] : חובה: קלט הפעלת טנזור ההפעלה inputs[1] : חובה: מדדי הקלט

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. indices : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
padding StringAttr ריפוד תכונת enum
stride_w IntegerAttr תכונה שלם שלם שלם של 32 סיביות
stride_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות
filter_w IntegerAttr תכונה של 32 סיביות שלמות שלמה
filter_h IntegerAttr תכונה שלם שלם שלם של 32 סיביות

תוצאות:

  1. outputs : טנסור מכל ערכי סוג

tfl.maximum (TFL :: MaximumOp)

מפעיל מקסימאלי

תיאור:

פעולה מקסימאלית חכמה באלמנט.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. max : טנסור מכל ערכי סוג

tfl.mean (TFL :: MeanOp)

מפעיל ממוצע

תיאור:

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

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. axis : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
keep_dims BoolAttr תכונה bool

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.minimum (TFL :: MinimumOp)

מיני מפעיל

תיאור:

פעולה מינימלית חכמה.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. min : טנסור מכל ערכי סוג

tfl.mirror_pad (TFL :: MirrorPadOp)

מפעיל MirrorPad. מרפד טנסור עם ערכי שיקוף.

תיאור:

פעולה זו מרפדת קלט עם ערכי שיקוף בהתאם לריפודים שאתה מציין. רפידות היא טנסור שלם בעל צורה [n, 2], כאשר n הוא דרגת הקלט. עבור כל ממד D של הקלט, רפידות [D, 0] מציינות כמה ערכים להוסיף לפני תוכן הקלט בממד זה, וריפודים [D, 1] מציינים כמה ערכים להוסיף לאחר תוכן הקלט בממד זה.

שני ההנפות [D, 0] וההכריות [D, 1] צריכות להיות אינן גדולות יותר מ- input.dim_size (D) (או input.dim_size (D) - 1) אם copy_border נכון (אם כוזב, בהתאמה).

הגודל המרופד של כל ממד D של הפלט הוא:

רפידות (D, 0) + input.dim_size (D) + רפידות (D, 1)

מפעיל:

  1. input : טנסור מכל ערכי סוג
  2. pad : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
mode StringAttr תכונת משטח מראה

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.mul (TFL :: MulOp)

מפעיל כפל

תיאור:

פעולת כפל חכמה-אלמנטית.

מפעיל:

  1. lhs : טנסור מכל ערכי סוג
  2. rhs : טנסור מכל ערכי סוג

תכונות:

תְכוּנָה סוג MLIR תיאור
fused_activation_function StringAttr תכונה enum הפעלה ממולאת

תוצאות:

  1. output : טנסור מכל ערכי סוג

tfl.neg (TFL :: NegOp)

מפעיל שלילה

תיאור:

מחשבת שלילת קלט בצורה אלמנטית

מפעיל:

  1. x : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. y : טנסור מכל ערכי סוג

tfl.non_max_suppression_v4 (TFL :: NonMaxSuppressionV4Op)

באדיבות בוחרת תת קבוצה של תיבות גבול בסדר יורד יורד,

תיאור:

גיזום תיבות שיש בהן חפיפה גבוהה בין צומת לאיחוד (IOU) עם תיבות שנבחרו בעבר. תיבות score_threshold עם ציון פחות score_threshold ציון score_threshold מוסרות. תיבות גבול מסופקות כ [y1, x1, y2, x2], שם (y1, x1) ו- (y2, x2) הם הקואורדינטות של כל זוג פינות תיבה אלכסוניות וניתן לספק את הקואורדינטות כמורמללות (כלומר, שוכבות בתוך המרווח [0, 1]) או מוחלט. שים לב שאלגוריתם זה אגנוסטי למקום הימצאו במערכת הקואורדינטות ובאופן כללי יותר אינו משתנה לטרנספורמציות אורטוגונליות ותרגומי מערכת הקואורדינטות; וכך התרגום או ההשתקפויות של מערכת הקואורדינטות מביאים לאותן תיבות שנבחרות על ידי האלגוריתם. הפלט של פעולה זו הוא מערך של מספרים שלמים באינדקס לאוסף הקלט של תיבות הגבול המייצגות את התיבות שנבחרו. לאחר מכן ניתן להשיג את tf.gather operation המתאימות למדדים שנבחרו באמצעות tf.gather operation . לדוגמה: select_indices = tf.image.non_max_suppression_v2 (תיבות, ציונים, max_output_size, iou_threshold, score_threshold) valgt_boxes = tf.gather (תיבות, שנבחרו_indices)

מפעיל:

  1. boxes : טנסור מכל ערכי סוג
  2. scores : טנסור מכל ערכי סוג
  3. max_output_size : טנסור מכל ערכי סוג
  4. iou_threshold : טנסור מכל ערכי סוג
  5. score_threshold : טנסור מכל ערכי סוג

תכונות:

תוצאות:

  1. selected_indices : מותח של כל ערכי סוג
  2. valid_outputs : טנסור מכל ערכי סוג

tfl.non_max_suppression_v5 (TFL :: NonMaxSuppressionV5Op)

באדיבות בוחרת תת קבוצה של תיבות גבול בסדר יורד יורד,

תיאור:

גיזום תיבות שיש בהן חפיפה גבוהה בין צומת לאיחוד (IOU) עם תיבות שנבחרו בעבר. תיבות score_threshold עם ציון פחות score_threshold ציון score_threshold מוסרות. תיבות גבול מסופקות כ [y1, x1, y2, x2], שם (y1, x1) ו- (y2, x2) הם הקואורדינטות של כל זוג פינות תיבה אלכסוניות וניתן לספק את הקואורדינטות כמורמללות (כלומר, שוכבות בתוך המרווח [0, 1]) או מוחלט. שים לב שאלגוריתם זה אגנוסטי למקום הימצאו במערכת הקואורדינטות ובאופן כללי יותר אינו משתנה לטרנספורמציות אורטוגונליות ותרגומי מערכת הקואורדינטות; וכך התרגום או ההשתקפויות של מערכת הקואורדינטות מביאים לאותן תיבות שנבחרות על ידי האלגוריתם. הפלט של פעולה זו הוא מערך של מספרים שלמים באינדקס לאוסף הקלט של תיבות הגבול המייצגות את התיבות שנבחרו. לאחר מכן ניתן להשיג את tf.gather operation המתאימות למדדים שנבחרו באמצעות tf.gather operation . For example: selected_indices = tf.image.non_max_suppression_v2( boxes, scores, max_output_size, iou_threshold, score_threshold) selected_boxes = tf.gather(boxes, selected_indices) This op also supports a Soft-NMS (with Gaussian weighting) mode (cf Bodla et al, https://arxiv.org/abs/1704.04503) where boxes reduce the score of other overlapping boxes instead of directly causing them to be pruned. To enable this Soft-NMS mode, set the soft_nms_sigma parameter to be larger than 0.

Operands:

  1. boxes : tensor of any type values
  2. scores : tensor of any type values
  3. max_output_size : tensor of any type values
  4. iou_threshold : tensor of any type values
  5. score_threshold : tensor of any type values
  6. soft_nms_sigma : tensor of any type values

Attributes:

Results:

  1. selected_indices : tensor of any type values
  2. selected_scores : tensor of any type values
  3. valid_outputs : tensor of any type values

tfl.not_equal (TFL::NotEqualOp)

Not_equal operator

Description:

Element-wise not_equal operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.NumericVerify (TFL::NumericVerifyOp)

Verifies the numericals of the two operands

Description:

The NumericVerify op is a debugging op to verify the numericals of the two activations. It is a custom op in TFLite.

Operands:

  1. input : tensor of any type values
  2. ref : tensor of any type values

Attributes:

Attribute MLIR Type Description
tolerance FloatAttr 32-bit float attribute attribute

Results:

tfl.one_hot (TFL::OneHotOp)

OneHot operator

Description:

Returns a one-hot tensor.The locations represented by indices in indices take value on_value , while all other locations take value off_value .

If the input indices is rank N , the output will have rank N+1 , The new axis is created at dimension axis (default: the new axis is appended at the end).

Operands:

  1. indices : tensor of any type values
  2. depth : tensor of any type values
  3. on_value : tensor of any type values
  4. off_value : tensor of any type values

Attributes:

Attribute MLIR Type Description
axis IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.prelu (TFL::PReluOp)

Parameterized Relu operator

Description:

Parameterized Relu operator x -> x >= 0 ? x : (alpha * x) where alpha is a trainable tensor. alpha should have one less rank than the input as it doesn't have the batch dimension, and the other dimensions either should be the same size as input or size 1, where it is broadcasted in the second case.

Operands:

  1. input : tensor of any type values
  2. alpha : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.pack (TFL::PackOp)

Packs a list of tensors along a dimension into one tensor

Description:

Packs a list of values_count rank- R tensors into one rank- (R+1) tensor.

Packs the values_count tensors in values into a tensor with rank one higher than each tensor in values , by packing them along the axis dimension.

Given a list of tensors of shape (A, B, C) ;

if axis == 0 then the output tensor will have the shape (N, A, B, C) . if axis == 1 then the output tensor will have the shape (A, N, B, C) . Etc.

For example:

 # 'x' is [1, 4]
# 'y' is [2, 5]
# 'z' is [3, 6]
pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
 

This is the opposite of unpack .

Operands:

  1. values : tensor of any type values

Attributes:

Attribute MLIR Type Description
values_count IntegerAttr 32-bit integer attribute attribute
axis IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.pad (TFL::PadOp)

Padding operator

Description:

This operation pads a input with zeros according to the paddings you specify. paddings is an integer tensor with shape [Dn, 2] , where n is the rank of input . For each dimension D of input , paddings[D, 0] indicates how many zeros to add before the contents of input in that dimension, and paddings[D, 1] indicates how many zeros to add after the contents of input in that dimension.

The padded size of each dimension D of the output is:

paddings(D, 0) + input.dim_size(D) + paddings(D, 1)

For example:

 # 't' is [[1, 1], [2, 2]]
# 'paddings' is [[1, 1], [2, 2]]
# rank of 't' is 2
pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
                      [0, 0, 1, 1, 0, 0]
                      [0, 0, 2, 2, 0, 0]
                      [0, 0, 0, 0, 0, 0]]
 

Operands:

  1. input : tensor of any type values
  2. padding : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.padv2 (TFL::PadV2Op)

Padding operator v2

Description:

This operation pads a input according to the paddings and constant_values you specify. paddings is an integer tensor with shape [Dn, 2] , where n is the rank of input . For each dimension D of input , paddings[D, 0] indicates how many zeros to add before the contents of input in that dimension, and paddings[D, 1] indicates how many zeros to add after the contents of input in that dimension. constant_values is a scalar tensor of the same type as input that indicates the value to use for padding input .

The padded size of each dimension D of the output is:

paddings(D, 0) + input.dim_size(D) + paddings(D, 1)

For example:

 # 't' is [[1, 1], [2, 2]]
# 'paddings' is [[1, 1], [2, 2]]
# rank of 't' is 2
pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
                      [0, 0, 1, 1, 0, 0]
                      [0, 0, 2, 2, 0, 0]
                      [0, 0, 0, 0, 0, 0]]
 

Operands:

  1. input : tensor of any type values
  2. padding : tensor of any type values
  3. constant_values : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.pow (TFL::PowOp)

Power operator

Description:

Element-wise power operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.pseudo_qconst (TFL::QConstOp)

Quantized constant pseudo op

Description:

Represents a quantized constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead. The quantization parameters are stored as a type attribute in this constant.

Operands:

Attributes:

Attribute MLIR Type Description
qtype TypeAttr Tensor type attribute attribute
value ElementsAttr constant vector/tensor attribute attribute

Results:

  1. output : tensor of any type values

tfl.quantize (TFL::QuantizeOp)

Quantize operator

Description:

Converts floating point tensors to quantized integer tensors according to the quantization parameters defined in the type attribute.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
qtype TypeAttr Tensor type attribute attribute

Results:

  1. output : tensor of any type values

tfl.range (TFL::RangeOp)

Range operator

Description:

Returns a 1D tensor defined by a sequence from start to limit with a given delta .

Operands:

  1. start : tensor of any type values
  2. limit : tensor of any type values
  3. delta : tensor of any type values

Attributes:

Results:

  1. result : tensor of any type values

tfl.rank (TFL::RankOp)

Rank operator.

Description:

Returns the rank of a tensor.

Operands:

  1. input : tensor of any type values

Attributes:

Results:

  1. output : tensor of any integer type

tfl.reduce_any (TFL::ReduceAnyOp)

Computes the "logical or" of elements across dimensions of a tensor.

Description:

Reduces input along the dimensions given in axis . Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis . If keep_dims is true, the reduced dimensions are retained with length 1.

Operands:

  1. input : tensor of any type values
  2. reduction_indices : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.reduce_max (TFL::ReduceMaxOp)

Max-reduction operator

Description:

Computes the max reduction along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.reduce_min (TFL::ReduceMinOp)

Min-reduction operator

Description:

Computes the min reduction along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.reduce_prod (TFL::ReduceProdOp)

Prod-reduction operator

Description:

Computes the product along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.relu_n1_to_1 (TFL::Relu1Op)

Relu1 operator

Description:

Element-wise Relu1 operator x -> max(-1, min(1, x))

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.relu6 (TFL::Relu6Op)

Relu6 operator

Description:

Element-wise Relu6 operator x -> max(0, min(6, x))

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.relu (TFL::ReluOp)

Relu operator

Description:

Element-wise Relu operator x -> max(0, x)

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.reshape (TFL::ReshapeOp)

Reshape operator

Description:

Produces a tensor with the same values but different static shape defined by the output type.

Operands:

  1. input : tensor of any type values
  2. shape : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.resize_bilinear (TFL::ResizeBilinearOp)

ResizeBilinear Op

Description:

Resize images to size using bilinear interpolation.

Operands:

  1. input : tensor of any type values
  2. size : tensor of any type values

Attributes:

Attribute MLIR Type Description
align_corners BoolAttr bool attribute attribute
half_pixel_centers BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.resize_nearest_neighbor (TFL::ResizeNearestNeighborOp)

ResizeNearestNeighbor Op

Description:

Resize images to size using nearest neighbor interpolation.

Operands:

  1. input : tensor of any type values
  2. size : tensor of any type values

Attributes:

Attribute MLIR Type Description
align_corners BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.reverse_sequence (TFL::ReverseSequenceOp)

Reverses variable length slices.

Description:

This op first slices input along the dimension batch_dim , and for each slice i , reverses the first seq_lengths[i] elements along the dimension seq_dim .

The elements of seq_lengths must obey seq_lengths[i] <= input.dims[seq_dim] , and seq_lengths must be a vector of length input.dims[batch_dim] .

The output slice i along dimension batch_dim is then given by input slice i , with the first seq_lengths[i] slices along dimension seq_dim reversed.

Operands:

  1. input : tensor of any type values
  2. seq_lengths : tensor of any type values

Attributes:

Attribute MLIR Type Description
seq_dim IntegerAttr 32-bit integer attribute attribute
batch_dim IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.reverse_v2 (TFL::ReverseV2Op)

ReverseV2 Operator

Description:

Reverses specific dimensions of a tensor.

Given a tensor, and a int32/int64 tensor axis representing the set of dimensions of tensor to reverse. This operation reverses each dimension i for which there exists j st axis[j] == i.

Args: tensor: A Tensor. Must be one of the following types: uint8, int16, int32, int64, float32, bool Up to 8-D.

axis: A Tensor. Must be one of the following types: int32, int64. with only 1 element which is the axis index. TODO: Add support for multiple elements.

Operands:

  1. input : tensor of any type values
  2. axis : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.round (TFL::RoundOp)

Round operator

Description:

Rounds the values of a tensor to the nearest integer, element-wise.

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.rsqrt (TFL::RsqrtOp)

Reciprocal of square root operator

Description:

Computes element-wise reverse square root of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.svdf (TFL::SVDFOp)

Single value decomposition filter operator

Description:

The SVDF op is a decomposition of a densely connected op into low rank filters. For details: https://research.google.com/pubs/pub43813.html https://arxiv.org/abs/1812.02802

Operands:

  1. input : tensor of any type values
  2. feature_weights : tensor of any type values
  3. time_weights : tensor of any type values
  4. input_gate_bias : tensor of any type values or none type
  5. activation_state : stateful tensor

Attributes:

Attribute MLIR Type Description
rank IntegerAttr 32-bit integer attribute attribute
fused_activation_function StringAttr fused activation enum attribute

Results:

  1. output : tensor of any type values

tfl.segment_sum (TFL::SegmentSumOp)

SegmentSum operator

Description:

Computes the sum along segments of a tensor.

Operands:

  1. data : tensor of any type values
  2. segment_ids : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.select (TFL::SelectOp)

Select operator

Description:

Select values of 'x' if the corresponding value of 'condition' is true or the value of 'y' if false. There are valid condition input sizes:

  1. Either the same shape (in which case the select is elementwise), or
  2. condition must be Rank 1 and match over the first dimension.

Operands:

  1. condition : tensor of any type values
  2. x : tensor of any type values
  3. y : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.select_v2 (TFL::SelectV2Op)

SelectV2 operator

Description:

Select values of 'x' if the corresponding value of 'condition' is true or the value of 'y' if false. There are valid condition input sizes:

  1. Either the same shape (in which case the select is elementwise), or
  2. Broadcastable shapes between 'condition', 'x' and 'y'.

Operands:

  1. condition : tensor of any type values
  2. x : tensor of any type values
  3. y : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.shape (TFL::ShapeOp)

Shape operator

Description:

Returns the shape of a tensor.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
out_type Attribute derived attribute attribute

Results:

  1. output : tensor of any type values

tfl.sin (TFL::SinOp)

Sine operator

Description:

Computes element-wise Sine of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.slice (TFL::SliceOp)

Return a slice from 'input'.

Description:

The output tensor is a tensor with dimensions described by 'size' whose values are extracted from 'input' starting at the offsets in 'begin'.

begin is zero-based; size is one-based. If size[i] is -1, all remaining elements in dimension i are included in the slice. In other words, this is equivalent to setting: size[i] = input.dim_size(i) - begin[i]

Requirements : 0 <= begin[i] <= begin[i] + size[i] <= Di for i in [0, n)

Operands:

  1. input : tensor of any type values
  2. begin : tensor of any type values
  3. size : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.softmax (TFL::SoftmaxOp)

Softmax operator

Description:

Computes element-wise softmax activations with the following formula

exp(input) / tf.reduce_sum(exp(input * beta), dim)

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
beta FloatAttr 32-bit float attribute attribute

Results:

  1. output : tensor of any type values

tfl.space_to_batch_nd (TFL::SpaceToBatchNdOp)

SpaceToBatchNd operator

Description:

This operation reshapes space dimensions into the "batch" dimension 0

Operands:

  1. input : tensor of any type values
  2. block_shape : tensor of any type values
  3. paddings : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.space_to_depth (TFL::SpaceToDepthOp)

SpaceToDepth operator

Description:

Rearranges blocks of spatial data, into depth. More specifically, this op outputs a copy of the input tensor where values from the height and width dimensions are moved to the depth dimension. block_size indicates the input block size.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
block_size IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.pseudo_sparse_const (TFL::SparseConstOp)

Sparse constant pseudo op.

Description:

Represents a sparse constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead.

Operands:

Attributes:

Attribute MLIR Type Description
value ElementsAttr constant vector/tensor attribute attribute
s_param TFL::SparsityParameterAttr Sparsity parameter. attribute

Results:

  1. output : tensor of any type values

tfl.pseudo_sparse_qconst (TFL::SparseQConstOp)

Sparse quantized constant pseudo op

Description:

Represents a sparse quantized constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead. The quantization parameters are stored as a type attribute in this constant.

Operands:

Attributes:

Attribute MLIR Type Description
qtype TypeAttr Tensor type attribute attribute
value ElementsAttr constant vector/tensor attribute attribute
s_param TFL::SparsityParameterAttr Sparsity parameter. attribute

Results:

  1. output : tensor of any type values

tfl.sparse_to_dense (TFL::SparseToDenseOp)

Converts a sparse representation into a dense tensor.

Description:

Builds an array dense with shape output_shape such that

 # If sparse_indices is scalar
dense[i] = (i == sparse_indices ? sparse_values : default_value)

# If sparse_indices is a vector, then for each i
dense[sparse_indices[i]] = sparse_values[i]

# If sparse_indices is an n by d matrix, then for each i in [0, n)
dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
 

All other values in dense are set to default_value . If sparse_values is a scalar, all sparse indices are set to this single value.

Indices should be sorted in lexicographic order, and indices must not contain any repeats. If validate_indices is true, these properties are checked during execution.

Operands:

  1. sparse_indices : tensor of any type values
  2. output_shape : tensor of any type values
  3. sparse_values : tensor of any type values
  4. default_value : tensor of any type values

Attributes:

Results:

  1. dense : tensor of any type values

tfl.split (TFL::SplitOp)

Splits a tensor into num_split tensors along one dimension.

Description:

Splits the value tensor along split_dim into a number of sub-tensors with same shape as the original one, except for split_dim . Same as tf.Split.

Operands:

  1. split_dim : tensor of any type values
  2. value : tensor of any type values

Attributes:

Attribute MLIR Type Description
num_splits IntegerAttr positive 32-bit integer attribute attribute

Results:

  1. outputs : tensor of any type values

tfl.split_v (TFL::SplitVOp)

Splits a tensor into num_split tensors along one dimension.

Description:

Splits the value tensor along split_dim into a number of sub-tensors with same shape as the original one, except for split_dim . The grouping of the resultant sub-tensors is decided by size-splits . Same as tf.SplitV.

Operands:

  1. value : tensor of any type values
  2. size_splits : 1D tensor of 32-bit integer values
  3. split_dim : 0D tensor of 32-bit integer values

Attributes:

Attribute MLIR Type Description
num_splits IntegerAttr positive 32-bit integer attribute attribute

Results:

  1. outputs : tensor of any type values

tfl.sqrt (TFL::SqrtOp)

Square root operator

Description:

Computes element-wise Square root of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.square (TFL::SquareOp)

Square operator

Description:

Computes element-wise Square of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.squared_difference (TFL::SquaredDifferenceOp)

Squared difference operator

Description:

Element-wise squared difference operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.squeeze (TFL::SqueezeOp)

Removes dimensions of size 1 from the shape of a tensor.

Description:

Given a tensor input , this operation returns a tensor of the same type with all dimensions of size 1 removed. If you don't want to remove all size 1 dimensions, you can remove specific size 1 dimensions by specifying axis .

For example:

 # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t)) ==> [2, 3]
 

Or, to remove specific size 1 dimensions:

 # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
 

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
squeeze_dims ArrayAttr 64-bit integer array attribute attribute

Results:

  1. output : tensor of any type values

tfl.strided_slice (TFL::StridedSliceOp)

StridedSlice Op

Description:

Return a strided slice from input .

Operands:

  1. input : tensor of any type values
  2. begin : tensor of any type values
  3. end : tensor of any type values
  4. strides : tensor of any type values

Attributes:

Attribute MLIR Type Description
begin_mask IntegerAttr 32-bit integer attribute attribute
end_mask IntegerAttr 32-bit integer attribute attribute
ellipsis_mask IntegerAttr 32-bit integer attribute attribute
new_axis_mask IntegerAttr 32-bit integer attribute attribute
shrink_axis_mask IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.sub (TFL::SubOp)

Subtraction operator

Description:

Element-wise subtraction operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Attribute MLIR Type Description
fused_activation_function StringAttr fused activation enum attribute

Results:

  1. output : tensor of any type values

tfl.sum (TFL::SumOp)

Sum operator

Description:

Computes the sum reduction along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.tanh (TFL::TanhOp)

Hyperbolic tangent operator

Description:

Computes element-wise Hyperbolic tangent of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.tile (TFL::TileOp)

Tile operator.

Description:

Constructs a tensor by tiling a given tensor.

This operation creates a new tensor by replicating input multiples times. The output tensor's i'th dimension has input.dims(i) * multiples[i] elements, and the values of input are replicated multiples[i] times along the 'i'th dimension. For example, tiling [abcd] by [2] produces [abcdabcd].

Operands:

  1. input : tensor of any type values
  2. multiples : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.topk_v2 (TFL::TopKV2Op)

TopK operator

Description:

Returns the top k largest element along each last dimensional slice of input and the indices of values within the last dimension of the input tensor.

Operands:

  1. input : tensor of any type values
  2. k : tensor of any type values

Attributes:

Results:

  1. values : tensor of any type values
  2. indices : tensor of any type values

tfl.transpose_conv (TFL::TransposeConvOp)

Transpose convolution operator

Description:

Performs transpose convolution operation on input.

Operands:

  1. output_shape : 1D tensor of any type values
  2. weights : tensor of any type values
  3. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
padding StringAttr padding enum attribute
stride_h IntegerAttr 32-bit integer attribute attribute
stride_w IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.transpose (TFL::TransposeOp)

Transpose operator

Description:

Returns the Transpose of x

Operands:

  1. x : tensor of any type values
  2. perm : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.unidirectional_sequence_lstm (TFL::UnidirectionalSequenceLSTMOp)

Unidirectional sequence lstm operator

Description:

A recurrent neural network specified by an LSTM cell. This Op supports unrolling the input along the time or batch dimensions, and implements the following operation for each element in the sequence s = 1...sequence_length: outputs[s] = state = activation(LSTMOp(inputs[s]))

where LSTMOp is LSTM TF Lite Op and the “activation” is the function passed as the “fused_activation_function” argument (if not “NONE”).

Operands:

  1. input : tensor of any type values
  2. input_to_input_weights : tensor of any type values or none type
  3. input_to_forget_weights : tensor of any type values
  4. input_to_cell_weights : tensor of any type values
  5. input_to_output_weights : tensor of any type values
  6. recurrent_to_input_weights : tensor of any type values or none type
  7. recurrent_to_forget_weights : tensor of any type values
  8. recurrent_to_cell_weights : tensor of any type values
  9. recurrent_to_output_weights : tensor of any type values
  10. cell_to_input_weights : tensor of any type values or none type
  11. cell_to_forget_weights : tensor of any type values or none type
  12. cell_to_output_weights : tensor of any type values or none type
  13. input_gate_bias : tensor of any type values or none type
  14. forget_gate_bias : tensor of any type values
  15. cell_bias : tensor of any type values
  16. output_gate_bias : tensor of any type values
  17. projection_weights : tensor of any type values or none type
  18. projection_bias : tensor of any type values or none type
  19. input_activation_state : stateful tensor
  20. input_cell_state : stateful tensor
  21. input_layer_norm_coefficients : tensor of any type values or none type
  22. forget_layer_norm_coefficients : tensor of any type values or none type
  23. cell_layer_norm_coefficients : tensor of any type values or none type
  24. output_layer_norm_coefficients : tensor of any type values or none type

Attributes:

Attribute MLIR Type Description
fused_activation_function StringAttr fused activation enum attribute
cell_clip FloatAttr 32-bit float attribute attribute
proj_clip FloatAttr 32-bit float attribute attribute
time_major BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.unidirectional_sequence_rnn (TFL::UnidirectionalSequenceRNNOp)

Unidirectional sequence rnn operator

Description:

A recurrent neural network specified by an RNN cell. This Op takes in input in a format {batch_size, seq_len, input_size} or {seq_len, batch_size, input_size} if it's time-majored.

It implements the following operation for each element in the sequence s = 1...sequence_length: outputs[s] = state = activation(RNNOp(inputs[s]))

where RNNOp is RNNOp TF Lite Op and the “activation” is the function passed as the “fused_activation_function” argument (if not “NONE”).

Operands:

  1. input : tensor of any type values
  2. input_to_input_weights : tensor of any type values
  3. recurrent_to_input_weights : tensor of any type values
  4. input_gate_bias : tensor of any type values
  5. hidden_state : stateful tensor

Attributes:

Attribute MLIR Type Description
time_major BoolAttr bool attribute attribute
fused_activation_function StringAttr fused activation enum attribute

Results:

  1. output : tensor of any type values

tfl.unique (TFL::UniqueOp)

Unique Op.

Description:

This operation returns a tensor y containing all of the unique elements of x sorted in the same order that they occur in x . This operation also returns a tensor idx the same size as x that contains the index of each value of x in the unique output y . In other words:

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
idx_out_type Attribute derived attribute attribute

Results:

  1. output : tensor of any type values
  2. idx : tensor of any type values

tfl.unpack (TFL::UnpackOp)

Unpacks a tensor along a dimension into multiple tensors

Description:

Unpacks a given dimension of a rank- R tensor into num rank- (R-1) tensors.

Unpacks num tensors from value by chipping it along the axis dimension. For example, given a tensor of shape (A, B, C, D) ;

If axis == 0 then the i'th tensor in output is the slice value[i, :, :, :] and each tensor in output will have shape (B, C, D) . (Note that the dimension unpacked along is gone, unlike split ).

If axis == 1 then the i'th tensor in output is the slice value[:, i, :, :] and each tensor in output will have shape (A, C, D) . Etc.

This is the opposite of pack .

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
num IntegerAttr 32-bit integer attribute attribute
axis IntegerAttr 32-bit integer attribute attribute

Results:

  1. outputs : tensor of any type values

tfl.where (TFL::WhereOp)

Returns locations of nonzero / true values in a tensor.

Description:

This operation returns the coordinates of true elements in condition . The coordinates are returned in a 2-D tensor where the first dimension (rows) represents the number of true elements, and the second dimension (columns) represents the coordinates of the true elements. Keep in mind, the shape of the output tensor can vary depending on how many true values there are in condition . Indices are output in row-major order.

Operands:

  1. input : tensor of any type values

Attributes:

Results:

  1. index : tensor of any type values

tfl.while (TFL::WhileOp)

While loop

Description:

output = input; while (cond(output)) { output = body(output) }

While loop where all values are passes through arguments with implicit capture.

input: A list of input tensors whose types are T. output: A list of output tensors whose types are T. cond: A region takes 'input' and returns a boolean scalar tensor. body: A region that takes a list of tensors and returns another list of tensors. Both lists have the same types.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
is_stateless BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.yield (TFL::YieldOp)

Yield operation

Description:

The "yield" operation represents a return operation within the conditional and body of structured control flow (eg, while). The operation takes variable number of operands and produces no results. The operand number and types must match the signature of the region that contains the operation.

Operands:

  1. operands : any type

Attributes:

Results:

tfl.zeros_like (TFL::ZerosLikeOp)

ZerosLike operator

Description:

Returns a tensor of zeros with the same shape and type as the input tensor.

Operands:

  1. input : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values