סוגי הרחבה של TensorFlow מוסברים בדוגמאות

תוכן תצפית התקנת סוגי הרחבה APIs תומכים דרישות סוגי שדה מוטציה פונקציונליות נוספת של ExtensionType יצרן הדפסה מייצגת שותפים לשוויון שיטת Validation Immutability אימוץ תגיותTypeSpec סוגים של ExtensionTypes הפעלת ההצגה המודפסת default הגדרת שיטות הגדרת שיטות כיתה ושיטות סטטיות הגדרת נכסים הגדרת ה-Default Constructor הפעלת מפעיל שוויון ברירת המחדל (eq) שימוש בהנחיות קדימה הגדרת סובייקטים הגדרת שדות פרטיים התאמה אישית של TypeSpec של ExtensionType התקנת !pip install -q tf_nightly import tensorflow as tf import numpy as np from typing import Tuple, List, Mapping, Union, Optional import tempfile סוגי הרחבה סוגים מוגדרים על-ידי המשתמש יכולים להפוך את הפרויקטים לקריא יותר, מודולרי יותר ולשימור. עם זאת, לרוב APIs של TensorFlow יש תמיכה מוגבלת מאוד לסוגי Python מוגדרים על-ידי המשתמש. , , ) ו- APIs ברמה נמוכה יותר (כגון ו • TensorFlow ניתן להשתמש בו כדי ליצור סוגים ממוקדים אובייקטים המוגדרים על-ידי המשתמש שעובדים בצורה חלקה עם APIs של TensorFlow. כבסיס, ושימוש כדי לציין את הסוג עבור כל שדה. קרס תגית: FUNCTION tf.SavedModel tf.while_loop tf.concat extension types tf.experimental.ExtensionType סוגי הערות class TensorGraph(tf.experimental.ExtensionType): """A collection of labeled nodes connected by weighted edges.""" edge_weights: tf.Tensor # shape=[num_nodes, num_nodes] node_labels: Mapping[str, tf.Tensor] # shape=[num_nodes]; dtype=any class MaskedTensor(tf.experimental.ExtensionType): """A tensor paired with a boolean mask, indicating which values are valid.""" values: tf.Tensor mask: tf.Tensor # shape=values.shape; false for missing/invalid values. class CSRSparseMatrix(tf.experimental.ExtensionType): """Compressed sparse row matrix (https://en.wikipedia.org/wiki/Sparse_matrix).""" values: tf.Tensor # shape=[num_nonzero]; dtype=any col_index: tf.Tensor # shape=[num_nonzero]; dtype=int64 row_index: tf.Tensor # shape=[num_rows+1]; dtype=int64 The שיעור הבסיס פועל באופן דומה ו באופן אוטומטי, הוא מוסיף יצרן ושיטות מיוחדות (כגון: ו ) בהתבסס על ציטוטים מסוג השדה. tf.experimental.ExtensionType typing.NamedTuple @dataclasses.dataclass __repr__ __eq__ בדרך כלל, סוגים של הרחבות נוטים להיכנס לאחת משתי קטגוריות: מבנים נתונים, שמסווגים יחד אוסף של ערכים קשורים, ויכולים לספק פעולות שימושיות המבוססות על ערכים אלה. מבנים נתונים עשויים להיות כלליים למדי (כגון דוגמה TensorGraph לעיל); או שהם עשויים להיות מותאמים אישית מאוד למודל מסוים. סוגים בקטגוריה זו יש דירוג, צורה, ובדרך כלל dtype; וזה הגיוני להשתמש בהם עם פעולות Tensor (כגון tf.stack, tf.add, או tf.matmul). מבנים נתונים סוגים דומים APIs תומכים סוגים של הרחבות נתמכים על ידי APIs TensorFlow הבאים: Keras: סוגים של הרחבות ניתן להשתמש ככניסות ופיתוחים עבור Keras מודלים ושכבות. tf.data.Dataset: סוגים של הרחבות ניתן לכלול ב Datasets, ומוחזרים על ידי iterators dataset. TensorFlow Hub: ניתן להשתמש בסוגים של הרחבות ככניסות והיציאות עבור מודולים tf.hub. SavedModel: ניתן להשתמש בסוגים של הרחבות ככניסות והיציאות לפונקציות של SavedModel. tf.function: ניתן להשתמש בסוגים של הרחבות כארגומנטים ולהחזיר ערכים עבור פונקציות מעוטרות עם @tf.function decorator. בעוד זרמים: סוגים של הרחבה ניתן להשתמש בתור משתנים זרם ב- tf.while_loop, וניתן להשתמש בהם כארגומנטים וערכים להחזיר עבור גופו של זרם זרם. סוגים של הרחבות ניתן לבחור בתנאי באמצעות tf.cond ו tf.case. tf.py_function: ניתן להשתמש בסוגים של הרחבות כארגומנטים ולהחזיר ערכים עבור ארגומנט funk ל- tf.py_function. Tensor ops: ניתן להרחיב את סוגי ההרחבה כדי לתמוך ברוב TensorFlow ops אשר מקבלים Tensor inputs (כגון tf.matmul, tf.gather, and tf.reduce_sum). אסטרטגיית הפצה: ניתן להשתמש בסוגים של הרחבות כערכים per-replica. לקבלת פרטים נוספים, ראה את הסעיף על "TensorFlow APIs that support ExtensionTypes" למטה. דרישות סוגי שדה כל השדות – משתנים דוגמאות – חייבים להיות מסומנים, וצריך לספק ציון סוג עבור כל שדה. Type Example Python integers i: int Python floats f: float Python strings s: str Python booleans b: bool Python None n: None Tensor shapes shape: tf.TensorShape s Tensor dtype dtype: tf.DType Tensors t: tf.Tensor Extension types mt: MyMaskedTensor Ragged tensors rt: tf.RaggedTensor Sparse tensors st: tf.SparseTensor Indexed slices s: tf.IndexedSlices Optional tensors o: tf.experimental.Optional Type unions int_or_float: typing.Union[int, float] Tuples params: typing.Tuple[int, float, tf.Tensor, int] Var-length tuples lengths: typing.Tuple[int, ...] Mappings tags: typing.Mapping[str, tf.Tensor] Optional values weight: typing.Optional[tf.Tensor] Python אינטגרציה i: int Python פלואטס f: float Python Stringsעריכה s: str Python Boolean b: bool פיטון None n: None צורות טנטור shape: tf.TensorShape s טנטור dtype dtype: tf.DType טנזרים t: tf.Tensor סוגי הרחבה mt: MyMaskedTensor טמפרטורות Tensors rt: tf.RaggedTensor חיסכון בטרנזיטים st: tf.SparseTensor סימני אינדקס s: tf.IndexedSlices טנסיות אופציונליות o: tf.experimental.Optional סוגי איגודים int_or_float: typing.Union[int, float] תאומים params: typing.Tuple[int, float, tf.Tensor, int] טופס ארוך lengths: typing.Tuple[int, ...] מפות tags: typing.Mapping[str, tf.Tensor] ערכים אופציונליים weight: typing.Optional[tf.Tensor] מוטציה סוגים של הרחבות נדרשים להיות בלתי משתנים. זה מבטיח שהם יכולים להיות מעקבים כראוי על ידי מנגנוני מעקב גרף של TensorFlow. אם אתה מוצא את עצמך רוצה למוטט ערך סוג הרחבה, לשקול במקום להגדיר שיטות המשתנות ערכים. שיטות לשינוי A אתה יכול להגדיר a שיטה שמחזירה חדש : set_mask MaskedTensor replace_mask MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def replace_mask(self, new_mask): self.values.shape.assert_is_compatible_with(new_mask.shape) return MaskedTensor(self.values, new_mask) פונקציונליות נוספת סוג ההרחבה סוג ההרחבה The Class Base מספקת את הפונקציונליות הבאה: ExtensionType יצרן חדש (__init__) שיטת ייצוג מדפסת (__repr__) שחקנים של שוויון וחוסר שוויון (__eq__). שיטה של אימות (__validate__) אימוץ בלתי תלוי. תגיותTypeSpec תמיכה ב-Tensor API Dispatch לחצו על "Customize סעיף s" למטה לקבלת מידע נוסף על התאמה אישית של פונקציונליות זו. ExtensionType יצרן המפיק הוסיף על ידי לוקח כל שדה כארגומנט שנקרא (בהסדר שבו הם נרשמו בהגדרה של הכיתה). שדות משתמשים משתמשים · השדות הופכים ל s; ו השדות הופכים לדיקטטים בלתי משתנים. ExtensionType Tensor tf.convert_to_tensor Tuple tuple Mapping class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor # Constructor takes one parameter for each field. mt = MaskedTensor(values=[[1, 2, 3], [4, 5, 6]], mask=[[True, True, False], [True, False, True]]) # Fields are type-checked and converted to the declared types. # For example, `mt.values` is converted to a Tensor. print(mt.values) היצרן מעלה את אם לא ניתן להמיר ערך שדה לסוג המפורסם שלו: TypeError try: MaskedTensor([1, 2, 3], None) except TypeError as e: print(f"Got expected TypeError: {e}") ניתן לציין את הערך המוגדר כברירת מחדל עבור שדה על-ידי הגדרת הערך שלו ברמת הכיתה: class Pencil(tf.experimental.ExtensionType): color: str = "black" has_erasor: bool = True length: tf.Tensor = 1.0 Pencil() Pencil(length=0.5, color="blue") הדפסה מייצגת דוגמה נוספת היא שיטת ההדפסה ( ) הכולל את שם הכיתה ואת הערך עבור כל שדה: ExtensionType __repr__ print(MaskedTensor(values=[1, 2, 3], mask=[True, True, False])) שותפים לשוויון תגיות קשורות תגיות קשורות תגיות קשורות תגיות ( ו שדות Tensor נחשבים שווים אם יש להם את אותה צורה והם שווים עבור כל האלמנטים. ExtensionType __eq__ __ne__ a = MaskedTensor([1, 2], [True, False]) b = MaskedTensor([[3, 4], [5, 6]], [[False, True], [True, True]]) print(f"a == a: {a==a}") print(f"a == b: {a==b}") print(f"a == a.values: {a==a.values}") הערה: אם שדה כלשהו מכיל טנזר, אז __eq__ עשוי להחזיר טנזר בולי סקלאר (במקום ערך בולי Python). אם שדה כלשהו מכיל a אז יכול להחזיר בולארי סקלאר (במקום ערך בולרי של Python). Note: Tensor __eq__ Tensor Validation method תוספת A היא פועלת לאחר שהמבנה נקרא, ואחרי שדות נבדקו כתיב והופנו לסוגים המפורטים שלהם, כך שהיא יכולה להניח שכל השדות יש לסוגים המפורטים שלהם. ExtensionType __validate__ הדוגמאות הבאות עדכון כדי להעריך את s ו S של שדותיה: MaskedTensor shape dtype class MaskedTensor(tf.experimental.ExtensionType): """A tensor paired with a boolean mask, indicating which values are valid.""" values: tf.Tensor mask: tf.Tensor def __validate__(self): self.values.shape.assert_is_compatible_with(self.mask.shape) assert self.mask.dtype.is_bool, 'mask.dtype must be bool' try: MaskedTensor([1, 2, 3], [0, 1, 0]) # Wrong `dtype` for mask. except AssertionError as e: print(f"Got expected AssertionError: {e}") try: MaskedTensor([1, 2, 3], [True, False]) # shapes don't match. except ValueError as e: print(f"Got expected ValueError: {e}") Immutability אימוץ תעלו את ו שיטות למניעת מוטציה, כדי להבטיח כי ערכי סוג ההרחבה אינם משתנים. ExtensionType __setattr__ __delattr__ mt = MaskedTensor([1, 2, 3], [True, False, True]) try: mt.mask = [True, True, True] except AttributeError as e: print(f"Got expected AttributeError: {e}") try: mt.mask[0] = False except TypeError as e: print(f"Got expected TypeError: {e}") try: del mt.mask except AttributeError as e: print(f"Got expected AttributeError: {e}") תגיותTypeSpec כל אחד לכיתה יש תואם קבוצה, אשר נוצר אוטומטית ומאוחסן כ . ExtensionType TypeSpec .Spec כיתה זו תופסת את כל המידע מתוך ערך על פי הערכים של כל טמפרטורות נטושות. עבור ערך נוצר על-ידי החלפת כל Tensor, ExtensionType, או CompositeTensor המוטבע עם . חוץ TypeSpec TypeSpec class Player(tf.experimental.ExtensionType): name: tf.Tensor attributes: Mapping[str, tf.Tensor] anne = Player("Anne", {"height": 8.3, "speed": 28.1}) anne_spec = tf.type_spec_from_value(anne) print(anne_spec.name) # Records `dtype` and `shape`, but not the string value. print(anne_spec.attributes) # Records keys and TensorSpecs for values. ערכים יכולים להיות בנויים באופן מפורש, או שהם יכולים להיות בנויים מתוך ערך שימוש : TypeSpec ExtensionType tf.type_spec_from_value spec1 = Player.Spec(name=tf.TensorSpec([], tf.float32), attributes={}) spec2 = tf.type_spec_from_value(anne) s משתמשים ב- TensorFlow כדי לחלק ערכים לתוך ו A : TypeSpec static component dynamic component הרכיב הסטטי (אשר קבוע בזמן Graph-Construction) מקודד עם tf.TypeSpec. הרכיב הדינמי (אשר עשוי להשתנות בכל פעם שהגרף פועל) מקודד כרשימה של tf.Tensors. לדוגמה הוא מעקב אחר הפונקציה המצורפת שלו בכל פעם שיש לעיקרון תופעה שלא נראתה קודם לכן. : tf.function TypeSpec @tf.function def anonymize_player(player): print(" >") return Player(" ", player.attributes) # Function gets traced (first time the function has been called): anonymize_player(Player("Anne", {"height": 8.3, "speed": 28.1})) # Function does NOT get traced (same TypeSpec: just tensor values changed) anonymize_player(Player("Bart", {"height": 8.1, "speed": 25.3})) # Function gets traced (new TypeSpec: keys for attributes changed): anonymize_player(Player("Chuck", {"height": 11.0, "jump": 5.3})) למידע נוסף, ראה את . tf.function מדריך התאמה s סוג ההרחבה סוג ההרחבה בנוסף להצהרה פשוטה של שדות וסוגיהם, סוגי ההרחבה עשויים: להוריד את ההגדרה המוצגת כברירת מחדל (__repr__). הגדרת שיטות הגדרת שיטות כיתה ושיטות סטטיות. הגדרת נכסים להוריד את היצרן default (__init__) הפעל את מפעיל שוויון ברירת המחדל (__eq__). להגדיר מפעילים (כגון __add__ ו ). הצהיר ערכים כברירת מחדל עבור שדות. הגדרת סובייקטים הפעלת ההצגה המודפסת default באפשרותך להוריד את מפעיל ההמרה המוגדר כברירת מחדל עבור סוגים של הרחבות. כדי ליצור ייצוג מחרוזת קריא יותר כאשר ערכים מודפסים במצב Eager. MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): """A tensor paired with a boolean mask, indicating which values are valid.""" values: tf.Tensor mask: tf.Tensor # shape=values.shape; false for invalid values. def __repr__(self): return masked_tensor_str(self.values, self.mask) def masked_tensor_str(values, mask): if isinstance(values, tf.Tensor): if hasattr(values, 'numpy') and hasattr(mask, 'numpy'): return f' ' else: return f'MaskedTensor(values={values}, mask={mask})' if len(values.shape) == 1: items = [repr(v) if m else '_' for (v, m) in zip(values, mask)] else: items = [masked_tensor_str(v, m) for (v, m) in zip(values, mask)] return '[%s]' % ', '.join(items) mt = MaskedTensor(values=[[1, 2, 3], [4, 5, 6]], mask=[[True, True, False], [True, False, True]]) print(mt) הגדרת שיטות סוגים של הרחבות יכולות להגדיר שיטות, בדיוק כמו כל שיעור Python רגיל. סוג זה יכול להגדיר a שיטה שמחזירה עותק של עם ערכים מסומנים המוחלפים על ידי נתון שיטות עשויות להיות מותאמות באופן אופציונלי עם → מעצב MaskedTensor with_default self default @tf.function class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def with_default(self, default): return tf.where(self.mask, self.values, default) MaskedTensor([1, 2, 3], [True, False, True]).with_default(0) הגדרת s ו s classmethod staticmethod סוגים של הרחבות עשויים להגדיר שיטות המשתמשות ו תגיות: לדוגמה, The סוג יכול להגדיר שיטה מפעלת המסתירה כל אלמנט עם ערך נתון: @classmethod @staticmethod MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def __repr__(self): return masked_tensor_str(self.values, self.mask) @staticmethod def from_tensor_and_value_to_mask(values, value_to_mask): return MaskedTensor(values, values != value_to_mask) x = tf.constant([[1, 0, 2], [3, 0, 0]]) MaskedTensor.from_tensor_and_value_to_mask(x, 0) הגדרת נכסים סוגים של הרחבות עשויים להגדיר תכונות באמצעות כמו כל שיעור פייטון רגיל, כך גם סוג זה יכול להגדיר a רכוש זה קיצור עבור אודות הערכים : @property MaskedTensor dtype dtype class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor @property def dtype(self): return self.values.dtype MaskedTensor([1, 2, 3], [True, False, True]).dtype הגדרת ה-Default Constructor יצרנים מותאמים אישית חייבים להגדיר ערך עבור כל שדה מצהיר; ולאחר שחזור יצרנית מותאמת אישית, כל השדות ייבדקו וערכים יוחלפו כמתואר לעיל. class Toy(tf.experimental.ExtensionType): name: str price: tf.Tensor def __init__(self, name, price, discount=0): self.name = name self.price = price * (1 - discount) print(Toy("ball", 5.0, discount=0.2)) # On sale -- 20% off! לחלופין, באפשרותך לשקול להשאיר את היצרן המוגדר כברירת מחדל, אך להוסיף אחת או יותר שיטות מפעל. class Toy(tf.experimental.ExtensionType): name: str price: tf.Tensor @staticmethod def new_toy_with_discount(name, price, discount): return Toy(name, price * (1 - discount)) print(Toy.new_toy_with_discount("ball", 5.0, discount=0.2)) פגיעה בביטוח לאומי ( ) __eq__ אתה יכול להוריד את ההפסד דוגמאות למשתמשים – הדוגמאות הבאות מתעדכנות להתעלם מאפיינים מוסתרים בהשוואה לשוויון. __eq__ MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def __repr__(self): return masked_tensor_str(self.values, self.mask) def __eq__(self, other): result = tf.math.equal(self.values, other.values) result = result | ~(self.mask & other.mask) return tf.reduce_all(result) x = MaskedTensor([1, 2, 3, 4], [True, True, False, True]) y = MaskedTensor([5, 2, 0, 4], [False, True, False, True]) print(x == y) הערה: אתה בדרך כלל לא צריך להוריד , שכן יישום ברירת המחדל שלו פשוט קורא __eq__ ומכחיש את התוצאה. הערה: אתה בדרך כלל לא צריך להוריד , שכן יישום ברירת המחדל שלו פשוט קורא __eq__ ומכחיש את התוצאה. שימוש בהנחיות קדימה אם סוג השדה עדיין לא מוגדר, באפשרותך להשתמש בשורה המכילה את שם הסוג במקום זאת. הוא משמש כדי לציין את שדה כי הוא סוג זה עדיין לא מוגדר (מוחלט). "Node" children Node class Node(tf.experimental.ExtensionType): value: tf.Tensor children: Tuple["Node", ...] = () Node(3, [Node(5), Node(2)]) הגדרת סובייקטים סוגים של הרחבות יכולים להיות מחולקים באמצעות הסינתקס הסטנדרטי של Python. סוללות של סוגים של הרחבות עשויות להוסיף שדות חדשים, שיטות ותכונות; והן עשויות להוריד את היצרן, את היצירה המודפסת ואת מפעיל השוויון. שיעורים שמשתמשים בשלושה שדות כדי לקודד קבוצה של קצוות בין כפתורים.אחר כך הוא מגדיר תת-כיתה שמוסיפה שדה כדי להקליט "ערך תכונה" עבור כל צומת.העמוד התחתון מגדיר גם שיטה להפיץ את ערכי התכונה לאורך הקצוות. TensorGraph Tensor Tensor class TensorGraph(tf.experimental.ExtensionType): num_nodes: tf.Tensor edge_src: tf.Tensor # edge_src[e] = index of src node for edge e. edge_dst: tf.Tensor # edge_dst[e] = index of dst node for edge e. class TensorGraphWithNodeFeature(TensorGraph): node_features: tf.Tensor # node_features[n] = feature value for node n. def propagate_features(self, weight=1.0) -> 'TensorGraphWithNodeFeature': updates = tf.gather(self.node_features, self.edge_src) * weight new_node_features = tf.tensor_scatter_nd_add( self.node_features, tf.expand_dims(self.edge_dst, 1), updates) return TensorGraphWithNodeFeature( self.num_nodes, self.edge_src, self.edge_dst, new_node_features) g = TensorGraphWithNodeFeature( # Edges: 0->1, 4->3, 2->2, 2->1 num_nodes=5, edge_src=[0, 4, 2, 2], edge_dst=[1, 3, 2, 1], node_features=[10.0, 0.0, 2.0, 5.0, -1.0, 0.0]) print("Original features:", g.node_features) print("After propagating:", g.propagate_features().node_features) הגדרת שדות פרטיים שדות מסוג הרחבה עשויים להיות מסומנים כפרטיים על-ידי ציון אותם עם הערך התחתון (בהתאם למנהגים סטנדרטיים של Python).זה לא משפיע על האופן שבו TensorFlow מתייחס לשדות בדרך כלשהי; אבל פשוט משמש כסימן לכל משתמשים מסוג הרחבה כי שדות אלה הם פרטיים. להתאים את של ExtensionType TypeSpec כל אחד לכיתה יש תואם קבוצה, אשר נוצר אוטומטית ומאוחסן כ לקבלת מידע נוסף, עיין בסעיף "Nested TypeSpec" למעלה. ExtensionType TypeSpec .Spec כדי להתרגל , פשוט להגדיר את המעמד המצורף שלך בשם , ו היא תשתמש בזה כבסיס לבנייה אוטומטית. אתה יכול להתאים את שיעור על ידי: TypeSpec Spec ExtensionType TypeSpec Spec להוריד את הפונקציה המוצגת כברירת מחדל להוריד את היצרן המוגדר. הגדרת שיטות, שיטות כיתות, שיטות סטטיות ותכונות. הדוגמה הבאה מגדירה את שיטות שיהפכו אותו לקל יותר לשימוש: MaskedTensor.Spec class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor shape = property(lambda self: self.values.shape) dtype = property(lambda self: self.values.dtype) def __repr__(self): return masked_tensor_str(self.values, self.mask) def with_values(self, new_values): return MaskedTensor(new_values, self.mask) class Spec: def __init__(self, shape, dtype=tf.float32): self.values = tf.TensorSpec(shape, dtype) self.mask = tf.TensorSpec(shape, tf.bool) def __repr__(self): return f"MaskedTensor.Spec(shape={self.shape}, dtype={self.dtype})" shape = property(lambda self: self.values.shape) dtype = property(lambda self: self.values.dtype) הערה: בכיתה Spec מותאמת אישית לא ניתן להשתמש במשתנים כלשהם של ההזדמנות שלא הוכרזו ב- ExtensionType המקורי. הערה: בכיתה Spec מותאמת אישית לא ניתן להשתמש במשתנים כלשהם של ההזדמנות שלא הוכרזו ב- ExtensionType המקורי. פורסם במקור באתר TensorFlow, מאמר זה מופיע כאן תחת כותרת חדשה והוא מורשה תחת CC BY 4.0. פורסם במקור באתר TensorFlow, מאמר זה מופיע כאן תחת כותרת חדשה והוא מורשה תחת CC BY 4.0. TensorFlow TensorFlow