עבור נתונים של כל צורות וגדלים, Tensors Ragged להציע בית

תוכן תצפית התקנת תצפית מה שאתה יכול לעשות עם טנטור מעוצב יצירת טנטור מעוצב מה אתה יכול לאחסן בטנטור מעופף דוגמה למקרה גדלים ודימויים אחידים ספאם vs Sparse תגית: TensorFlow קרס תגית: Example נתונים תגית: FUNCTION דוגמאות מפעילים מוגזמים התקנת !pip install --pre -U tensorflow import math import tensorflow as tf 2024-08-27 01:20:40.536630: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered 2024-08-27 01:20:40.557820: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered 2024-08-27 01:20:40.563984: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered תצפית הנתונים שלך מגיעים בצורות רבות; הטנטורים שלך צריכים גם כן. הם שווה ערך TensorFlow של רשימות אורך משתנה מעורב, מה שהופך את זה קל לאחסון ועיבוד נתונים עם צורות לא אחידות, כולל: טמפרטורות Tensors תכונות אורך משתנה, כגון קבוצת השחקנים בסרט. חבילות של כניסות רצופות באורך משתנה, כגון משפטים או קליפים וידאו. כניסות הייררכיות, כגון מסמכים טקסטים המחולקים לחלקים, פרקים, משפטים ומילים. שדות בודדים בהנחיות מובנות, כגון מברשות פרוטוקול. מה אפשר לעשות עם טנטור TensorFlow נתמך על ידי יותר ממאה פעולות TensorFlow, כולל פעולות מתמטיות (כגון: ו פעילויות אטרקטיביות (כגון ו , אופי מניפולציה חוטים (כגון תפעול תפעול תפעול (כגון ו ) ועוד רבים אחרים: tf.add tf.reduce_mean tf.concat tf.tile tf.strings.substr tf.while_loop tf.map_fn digits = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []]) words = tf.ragged.constant([["So", "long"], ["thanks", "for", "all", "the", "fish"]]) print(tf.add(digits, 3)) print(tf.reduce_mean(digits, axis=1)) print(tf.concat([digits, [[5, 3]]], axis=0)) print(tf.tile(digits, [1, 2])) print(tf.strings.substr(words, 0, 2)) print(tf.map_fn(tf.math.square, digits)) WARNING: All log messages before absl::InitializeLog() is called are written to STDERR I0000 00:00:1724721643.161122 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.164924 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.168750 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.172328 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.183636 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.187178 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.190668 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.194028 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.197422 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.201089 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.204485 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721643.207934 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.469725 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.471772 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.473847 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.475930 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.477949 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.479867 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.481845 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.483831 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.486309 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.488220 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.490205 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.492181 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.532055 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.534019 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.536012 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.538150 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.540140 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.542032 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.543963 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.545991 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.547989 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.551435 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.553772 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 I0000 00:00:1724721644.556197 10064 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355 tf.Tensor([2.25 nan 5.33333333 6. nan], shape=(5,), dtype=float64) ישנם גם מספר שיטות ופעולות ספציפיות לטרנסורים מרוגזים, כולל שיטות מפעל, שיטות טרנספורמציה ופעולות מערכות ערך. חבילת מסמכים tf.ragged TensorFlow תומך במגוון רחב של APIs, כולל , , , , ו לקבלת מידע נוסף, בדוק את החלק למטה קרס נתונים תגית: FUNCTION דוגמאות תגית: Example TensorFlow APIs בדומה לטרנסורים רגילים, באפשרותך להשתמש באינדקס בסגנון Python כדי לגשת לחתיכות ספציפיות של טרנסור מרוגז. למטה Indexing print(digits[0]) # First row tf.Tensor([3 1 4 1], shape=(4,), dtype=int32) print(digits[:, :2]) # First two values in each row. print(digits[:, -2:]) # Last two values in each row. בדיוק כמו טנסורים רגילים, אתה יכול להשתמש בפייטונים של Python ומפעילים של השוואה כדי לבצע פעולות אלמנטליות. למטה Overloaded operators print(digits + 3) print(digits + tf.ragged.constant([[1, 2, 3, 4], [], [5, 6, 7], [8], []])) אם אתה צריך לבצע טרנספורמציה אלמנטלית לערכים של אתה יכול להשתמש , אשר לוקח פונקציה בתוספת אחת או יותר ארגומנטים, ומיישם את הפונקציה כדי להפוך את את הערכים RaggedTensor tf.ragged.map_flat_values RaggedTensor times_two_plus_one = lambda x: x * 2 + 1 print(tf.ragged.map_flat_values(times_two_plus_one, digits)) Tensors Ragged ניתן להמיר ל-Nested Python S ו-NumPy א s : list array digits.to_list() [[3, 1, 4, 1], [], [5, 9, 2], [6], []] digits.numpy() array([array([3, 1, 4, 1], dtype=int32), array([], dtype=int32), array([5, 9, 2], dtype=int32), array([6], dtype=int32), array([], dtype=int32)], dtype=object) יצירת טנטור מעוצב הדרך הפשוטה ביותר לבנות טנטור מעוצב היא באמצעות אשר בונה את מתאים ל-Python מסוים או מספרים : tf.ragged.constant RaggedTensor list array sentences = tf.ragged.constant([ ["Let's", "build", "some", "ragged", "tensors", "!"], ["We", "can", "use", "tf.ragged.constant", "."]]) print(sentences) paragraphs = tf.ragged.constant([ [['I', 'have', 'a', 'cat'], ['His', 'name', 'is', 'Mat']], [['Do', 'you', 'want', 'to', 'come', 'visit'], ["I'm", 'free', 'tomorrow']], ]) print(paragraphs) Tensors עשוי גם להיות בנוי על ידי זוגות שטוח מתח עם טנטורים המעידים על איך הערכים האלה צריכים להיות מחולקים לשורות, באמצעות שיטות כיתות מפעל כגון: , , ו . ערכים חלוקת רגל tf.RaggedTensor.from_value_rowids tf.RaggedTensor.from_row_lengths tf.RaggedTensor.from_row_splits tf.RaggedTensor.from_value_rowids תגית: Tensor.from_value_rowids אם אתה יודע לאיזה שורה כל ערך שייך, אז אתה יכול לבנות שימוש A מחלקת רצועות טנטור: RaggedTensor value_rowids print(tf.RaggedTensor.from_value_rowids( values=[3, 1, 4, 1, 5, 9, 2], value_rowids=[0, 0, 0, 0, 2, 2, 3])) tf.RaggedTensor.from_row_lengths tf.RaggedTensor.from_row_lengths אם אתה יודע כמה ארוך כל שורה, אז אתה יכול להשתמש מחלקת רצועות טנטור: row_lengths print(tf.RaggedTensor.from_row_lengths( values=[3, 1, 4, 1, 5, 9, 2], row_lengths=[4, 0, 2, 1])) tf.RaggedTensor.from_row_splits תגית: Tensor.from_row_splits אם אתה יודע את האינדקס שבו כל שורה מתחילה ומסתיימת, אז אתה יכול להשתמש מחלקת רצועות טנטור: row_splits print(tf.RaggedTensor.from_row_splits( values=[3, 1, 4, 1, 5, 9, 2], row_splits=[0, 4, 4, 6, 7])) לראות את תיעוד כיתה עבור רשימה מלאה של שיטות מפעל. tf.RaggedTensor הערה: כברירת מחדל, שיטות מפעל אלה מוסיפות הצהרות כי טנסור מחלוקת השורה הוא מוצק ומתאים למספר הערכים.הפרמטר validate=False ניתן להשתמש כדי לפספס את הבדיקות האלה אם אתה יכול להבטיח כי ההכנסות הן מוצק ותואם. כברירת מחדל, שיטות מפעל אלה מוסיפות הצהרות כי טנסור חלוקת השורה הוא מאורגן היטב ותואם את מספר הערכים. ניתן להשתמש בפרמטר כדי לעקוף את הבדיקות האלה אם אתה יכול להבטיח כי ההכנסות הן תבניות היטב ותואמות. Note: validate=False מה אתה יכול לאחסן בטנטור מעופף כמו עם רגיל s, הערכים ב A כל הערכים חייבים להיות באותו סוג, והערכים חייבים להיות באותו עומק (הערך על ידי Tensor : Tensor RaggedTensor רן print(tf.ragged.constant([["Hi"], ["How", "are", "you"]])) # ok: type=string, rank=2 print(tf.ragged.constant([[[1, 2], [3]], [[4, 5]]])) # ok: type=int32, rank=3 try: tf.ragged.constant([["one", "two"], [3, 4]]) # bad: multiple types except ValueError as exception: print(exception) Can't convert Python sequence with mixed types to Tensor. try: tf.ragged.constant(["A", ["B", "C"]]) # bad: multiple nesting depths except ValueError as exception: print(exception) all scalar values must have the same nesting depth דוגמה למקרה הדוגמה הבאה מוכיחה כיצד ניתן להשתמש ב- s כדי לבנות ולשלב את השבבים של unigram ו- bigram עבור קבוצה של שאילתות אורך משתנה, באמצעות מסמכים מיוחדים עבור תחילת וסוף כל משפט. חבילת מסמכים RaggedTensor tf.ragged queries = tf.ragged.constant([['Who', 'is', 'Dan', 'Smith'], ['Pause'], ['Will', 'it', 'rain', 'later', 'today']]) # Create an embedding table. num_buckets = 1024 embedding_size = 4 embedding_table = tf.Variable( tf.random.truncated_normal([num_buckets, embedding_size], stddev=1.0 / math.sqrt(embedding_size))) # Look up the embedding for each word. word_buckets = tf.strings.to_hash_bucket_fast(queries, num_buckets) word_embeddings = tf.nn.embedding_lookup(embedding_table, word_buckets) # ① # Add markers to the beginning and end of each sentence. marker = tf.fill([queries.nrows(), 1], '#') padded = tf.concat([marker, queries, marker], axis=1) # ② # Build word bigrams and look up embeddings. bigrams = tf.strings.join([padded[:, :-1], padded[:, 1:]], separator='+') # ③ bigram_buckets = tf.strings.to_hash_bucket_fast(bigrams, num_buckets) bigram_embeddings = tf.nn.embedding_lookup(embedding_table, bigram_buckets) # ④ # Find the average embedding for each sentence all_embeddings = tf.concat([word_embeddings, bigram_embeddings], axis=1) # ⑤ avg_embedding = tf.reduce_mean(all_embeddings, axis=1) # ⑥ print(avg_embedding) tf.Tensor( [[-0.07189021 0.23444025 -0.04020268 -0.27113184] [ 0.10560822 0.00976487 -0.17885399 0.5371701 ] [-0.23479678 -0.15996003 0.07078557 0.24388357]], shape=(3, 4), dtype=float32) גדלים ודימויים אחידים א זהו מימד שבו חתיכותיו עשויות להיות באורך שונה.לדוגמה, המימד הפנימי (עמודה) של מכיוון שמדובר במגוון רחב של גוונים ( , ... , יש להם אורך שונה: מימדים שכולם באותו אורך נקראים . גודל גודל rt=[[3, 1, 4, 1], [], [5, 9, 2], [6], []] rt[0, :] rt[4, :] גודל יחיד גודל גודל הממד החיצוני ביותר של טנסור מרוגז הוא תמיד זהה, מכיוון שהוא מורכב מקטע יחיד (ולכן אין אפשרות להפריד בין אורך המקטע). הממד הנותר עשוי להיות מרוגז או זהה. היכן שסובבים את הקצוות מעידים על כך שהממוצע מופרך. [num_sentences, (num_words), embedding_size] (num_words) טנסורים מעוגנים עשויים להיות בעלי ממדים מעוגנים מרובים. לדוגמה, באפשרותך לאחסן קבוצה של מסמכי טקסט מובנים באמצעות טנסור עם צורה (שם שוב משותפים משמשים כדי להצביע על ממדים מרוגזים). [num_documents, (num_paragraphs), (num_sentences), (num_words)] כמו עם → The מספר הממדים הכולל (כולל גם את הממדים המומלצים וגם את הממדים המאוחדים). זהו ערך שעלול להיות או או A . tf.Tensor רן טנטור פוטנציאלי tf.Tensor tf.RaggedTensor רן טנטור פוטנציאלי כשמתארים את הצורה של RaggedTensor, ממדים של RaggedTensor מופיעים באופן קונבנציונלי על-ידי סגירתם בקביעות. לדוגמה, כפי שראיתם לעיל, הצורה של 3D RaggedTensor שמאחסנת מילות מוטבעות עבור כל מילה בסדרה של משפטים יכולה להיות כתובה כ: . [num_sentences, (num_words), embedding_size] The תכונה מחזירה A עבור tensor ragged שבו גדלים ragged יש גודל : RaggedTensor.shape tf.TensorShape None tf.ragged.constant([["Hi"], ["How", "are", "you"]]).shape TensorShape([2, None]) השיטה ניתן להשתמש בו כדי למצוא צורה קפדנית לגבול נתון : tf.RaggedTensor.bounding_shape RaggedTensor print(tf.ragged.constant([["Hi"], ["How", "are", "you"]]).bounding_shape()) tf.Tensor([2 3], shape=(2,), dtype=int64) ספאם vs Sparse טמפרטורה רטובה צריכה להיות יש להתייחס לזה כאל סוג של טנטור נדיר, במיוחד טנטורים נדירים. זה מודל את אותם נתונים בפורמט קומפקטי; אבל טנסור ragged הוא ההבדל הזה הוא קריטי בעת הגדרת פעולות: לא קידוד יעיל עבור tf.Tensor הרחבה 2 tf.Tensor יישום אופציה לטרנסור צפוף או צפוף צריך תמיד לתת את אותו התוצאה. יישום אופציה לטרנסור מרובה או נדיר עשוי לתת תוצאות שונות. לדוגמה, יש לקחת בחשבון כיצד מתבצעות פעולות כגון , , ו הם מוגדרים עבור tensors ragged vs. sparse. concatenating tensors ragged מצטרפים לכל שורה כדי ליצור שורה אחת עם אורך משולב: concat stack tile ragged_x = tf.ragged.constant([["John"], ["a", "big", "dog"], ["my", "cat"]]) ragged_y = tf.ragged.constant([["fell", "asleep"], ["barked"], ["is", "fuzzy"]]) print(tf.concat([ragged_x, ragged_y], axis=1)) עם זאת, התכווצות של טנטורים צפופים שווה לזה של התכווצות של טנטורים צפופים המתאימים, כפי שמוצג בדוגמה הבאה (למשל, Ø מצביע על ערכים חסרים): sparse_x = ragged_x.to_sparse() sparse_y = ragged_y.to_sparse() sparse_result = tf.sparse.concat(sp_inputs=[sparse_x, sparse_y], axis=1) print(tf.sparse.to_dense(sparse_result, '')) tf.Tensor( [[b'John' b'' b'' b'fell' b'asleep'] [b'a' b'big' b'dog' b'barked' b''] [b'my' b'cat' b'' b'is' b'fuzzy']], shape=(3, 5), dtype=string) לדוגמה נוספת למה ההבדל הזה חשוב, לשקול את ההגדרה של "הערך הממוצע של כל שורה" עבור op כגון עבור טנסור מוגבל, הערך הממוצע עבור שורה הוא סכום הערכים של השורה מחולק על ידי רוחב השורה, אבל עבור טנסור נדיר, הערך הממוצע עבור שורה הוא סכום הערכים של השורה מחולק על ידי רוחב הכולל של הטנסור נדיר (הוא גדול יותר או שווה את רוחב השורה הארוכה ביותר). tf.reduce_mean תגית: TensorFlow קרס הוא API ברמה גבוהה של TensorFlow לבניית וחינוך מודלים למידה עמוקה. אין לו תמיכה ragged. אבל הוא תומך tensors מוסתרים. אז הדרך הקלה ביותר להשתמש tensor ragged במודל Keras היא להמיר tensor ragged ל tensor צפוף, באמצעות לאחר מכן השתמש במסכה של Keras builtin: תגית: Keras .to_tensor() # Task: predict whether each sentence is a question or not. sentences = tf.constant( ['What makes you think she is a witch?', 'She turned me into a newt.', 'A newt?', 'Well, I got better.']) is_question = tf.constant([True, False, True, False]) # Preprocess the input strings. hash_buckets = 1000 words = tf.strings.split(sentences, ' ') hashed_words = tf.strings.to_hash_bucket_fast(words, hash_buckets) hashed_words.to_list() [[940, 203, 668, 387, 790, 320, 939, 185], [315, 515, 791, 181, 939, 787], [564, 205], [820, 180, 993, 739]] hashed_words.to_tensor() tf.keras.Input? # Build the Keras model. keras_model = tf.keras.Sequential([ tf.keras.layers.Embedding(hash_buckets, 16, mask_zero=True), tf.keras.layers.LSTM(32, return_sequences=True, use_bias=False), tf.keras.layers.GlobalAveragePooling1D(), tf.keras.layers.Dense(32), tf.keras.layers.Activation(tf.nn.relu), tf.keras.layers.Dense(1) ]) keras_model.compile(loss='binary_crossentropy', optimizer='rmsprop') keras_model.fit(hashed_words.to_tensor(), is_question, epochs=5) Epoch 1/5 WARNING: All log messages before absl::InitializeLog() is called are written to STDERR I0000 00:00:1724721648.311913 10235 service.cc:146] XLA service 0x7f82d4008680 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices: I0000 00:00:1724721648.311945 10235 service.cc:154] StreamExecutor device (0): Tesla T4, Compute Capability 7.5 I0000 00:00:1724721648.311949 10235 service.cc:154] StreamExecutor device (1): Tesla T4, Compute Capability 7.5 I0000 00:00:1724721648.311952 10235 service.cc:154] StreamExecutor device (2): Tesla T4, Compute Capability 7.5 I0000 00:00:1724721648.311955 10235 service.cc:154] StreamExecutor device (3): Tesla T4, Compute Capability 7.5 1/1 ━━━━━━━━━━━━━━━━━━━━ 4s 4s/step - loss: 8.0590 Epoch 2/5 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 47ms/step - loss: 8.0590 Epoch 3/5 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step - loss: 8.0590 Epoch 4/5 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step - loss: 8.0590 Epoch 5/5 I0000 00:00:1724721650.626376 10235 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process. 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 43ms/step - loss: 8.0590 print(keras_model.predict(hashed_words.to_tensor())) 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 407ms/step [[-0.00517703] [-0.00227403] [-0.00706224] [-0.00354813]] תגית: Example זה סטנדרט נתוני TensorFlow נתונים מקודדים עם s לעתים קרובות כולל תכונות אורך משתנה. לדוגמה, הקוד הבא מגדיר קבוצה של ארבעה הודעות עם אורך תכונה שונה: תגית: Example פרוטוקול tf.Example tf.Example import google.protobuf.text_format as pbtext def build_tf_example(s): return pbtext.Merge(s, tf.train.Example()).SerializeToString() example_batch = [ build_tf_example(r''' features { feature {key: "colors" value {bytes_list {value: ["red", "blue"]} } } feature {key: "lengths" value {int64_list {value: [7]} } } }'''), build_tf_example(r''' features { feature {key: "colors" value {bytes_list {value: ["orange"]} } } feature {key: "lengths" value {int64_list {value: []} } } }'''), build_tf_example(r''' features { feature {key: "colors" value {bytes_list {value: ["black", "yellow"]} } } feature {key: "lengths" value {int64_list {value: [1, 3]} } } }'''), build_tf_example(r''' features { feature {key: "colors" value {bytes_list {value: ["green"]} } } feature {key: "lengths" value {int64_list {value: [3, 5, 2]} } } }''')] אתה יכול לסרוק נתונים מוצפנים אלה באמצעות , אשר לוקח טנסור של שורות סריאליזציה ומילון ספציפיזציה של תכונות, ומחזיר מפה מילון שמות תכונות עבור טנסורים. במילון הספציפיות של המילים: tf.io.parse_example tf.io.RaggedFeature feature_specification = { 'colors': tf.io.RaggedFeature(tf.string), 'lengths': tf.io.RaggedFeature(tf.int64), } feature_tensors = tf.io.parse_example(example_batch, feature_specification) for name, value in feature_tensors.items(): print("{}={}".format(name, value)) colors= lengths= ניתן להשתמש בו גם כדי לקרוא תכונות עם ממדים מרובים.למידע נוסף, ראה . tf.io.RaggedFeature תיעוד אש נתונים הוא API המאפשר לך לבנות צינורות כניסה מורכבות מתוך חתיכות פשוטות וניתנות לשימוש חוזר. , המייצג רצף של אלמנטים, שבו כל אלמנט מורכב מאחד או יותר מרכיבים. תגית: DATA tf.data.Dataset # Helper function used to print datasets in the examples below. def print_dictionary_dataset(dataset): for i, element in enumerate(dataset): print("Element {}:".format(i)) for (feature_name, feature_value) in element.items(): print('{:>14} = {}'.format(feature_name, feature_value)) בניית קבוצות נתונים עם טנטורים מעוצבים ניתן לבנות קבוצות נתונים מטרנסורים מרוגזים באמצעות אותם שיטות המשמשות לבנות אותן מטרנסורים. S או NumPy S, כגון : tf.Tensor array Dataset.from_tensor_slices dataset = tf.data.Dataset.from_tensor_slices(feature_tensors) print_dictionary_dataset(dataset) Element 0: colors = [b'red' b'blue'] lengths = [7] Element 1: colors = [b'orange'] lengths = [] Element 2: colors = [b'black' b'yellow'] lengths = [1 3] Element 3: colors = [b'green'] lengths = [3 5 2] הערה: Dataset.from_generator אינו תומך טרנסורים מעוגנים עדיין, אך תמיכה תתווסף בקרוב. הערה: Dataset.from_generator אינו תומך טרנסורים מעוגנים עדיין, אך תמיכה תתווסף בקרוב. חבילות נתונים עם tensors ragged ניתן לשלב קבוצות של נתונים עם טנטורים מרוגזים (שכוללים חומר אחד (משתמש בקטגוריה אחת) שיטות n Dataset.batch batched_dataset = dataset.batch(2) print_dictionary_dataset(batched_dataset) Element 0: colors = lengths = Element 1: colors = lengths = לעומת זאת, ניתן להפוך קבוצה של נתונים לתוך קבוצת נתונים שטוחה באמצעות . Dataset.unbatch unbatched_dataset = batched_dataset.unbatch() print_dictionary_dataset(unbatched_dataset) Element 0: colors = [b'red' b'blue'] lengths = [7] Element 1: colors = [b'orange'] lengths = [] Element 2: colors = [b'black' b'yellow'] lengths = [1 3] Element 3: colors = [b'green'] lengths = [3 5 2] קבוצות נתונים עם טנסורים ללא גזענות של אורך משתנה אם יש לך קבוצת נתונים המכילה טנסיות שאינן מוגזמות, ואורך הטנסיות משתנה בין אלמנטים, אז אתה יכול להפריד את הטנסיות שאינן מוגזמות האלה לטנסיות מוגזמות על-ידי יישום • טרנספורמציה: dense_to_ragged_batch non_ragged_dataset = tf.data.Dataset.from_tensor_slices([1, 5, 3, 2, 8]) non_ragged_dataset = non_ragged_dataset.map(tf.range) batched_non_ragged_dataset = non_ragged_dataset.apply( tf.data.experimental.dense_to_ragged_batch(2)) for element in batched_non_ragged_dataset: print(element) WARNING:tensorflow:From /tmpfs/tmp/ipykernel_10064/1427668168.py:4: dense_to_ragged_batch (from tensorflow.python.data.experimental.ops.batching) is deprecated and will be removed in a future version. Instructions for updating: Use `tf.data.Dataset.ragged_batch` instead. טרנספורמציה של קבוצות נתונים עם Tensors RAGGED באפשרותך גם ליצור או לשנות טנסורים מעוגנים במערכות נתונים באמצעות : Dataset.map def transform_lengths(features): return { 'mean_length': tf.math.reduce_mean(features['lengths']), 'length_ranges': tf.ragged.range(features['lengths'])} transformed_dataset = dataset.map(transform_lengths) print_dictionary_dataset(transformed_dataset) Element 0: mean_length = 7 length_ranges = Element 1: mean_length = 0 length_ranges = Element 2: mean_length = 2 length_ranges = Element 3: mean_length = 3 length_ranges = תגית: FUNCTION הוא מעצב שמחשב מראש גרפים TensorFlow עבור פונקציות Python, אשר יכול לשפר באופן משמעותי את הביצועים של קוד TensorFlow שלך. לדוגמה, הפונקציה הבאה פועלת עם טנסורים מרוגזים ולא מרוגזים: תגית: FUNCTION @tf.function @tf.function def make_palindrome(x, axis): return tf.concat([x, tf.reverse(x, [axis])], axis) make_palindrome(tf.constant([[1, 2], [3, 4], [5, 6]]), axis=1) make_palindrome(tf.ragged.constant([[1, 2], [3], [4, 5, 6]]), axis=1) 2024-08-27 01:20:51.662289: W tensorflow/core/grappler/optimizers/loop_optimizer.cc:933] Skipping loop optimization for Merge node with control input: RaggedConcat/assert_equal_1/Assert/AssertGuard/branch_executed/_9 אם ברצונך לציין באופן ברור את עבור The אז אתה יכול לעשות את זה באמצעות . input_signature tf.function tf.RaggedTensorSpec @tf.function( input_signature=[tf.RaggedTensorSpec(shape=[None, None], dtype=tf.int32)]) def max_and_min(rt): return (tf.math.reduce_max(rt, axis=-1), tf.math.reduce_min(rt, axis=-1)) max_and_min(tf.ragged.constant([[1, 2], [3], [4, 5, 6]])) ( , ) פונקציות ספציפיות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות טנזרים מעוצבים יכולים לשמש בצורה נקיה עם פונקציות בטון. פונקציות ספציפיות tf.function @tf.function def increment(x): return x + 1 rt = tf.ragged.constant([[1, 2], [3], [4, 5, 6]]) cf = increment.get_concrete_function(rt) print(cf(rt)) דוגמאות א הוא תוכנית TensorFlow סדרתית, הכוללת משקולות וחישובים. זה יכול להיות בנוי ממודל Keras או ממודל מותאם אישית. בשני המקרים, tensors ragged ניתן להשתמש בצורה גלויה עם הפונקציות והשיטות המוגדרות על ידי SavedModel. שימור מודל דוגמה: שמירה על מודל Keras import tempfile keras_module_path = tempfile.mkdtemp() keras_model.save(keras_module_path+"/my_model.keras") imported_model = tf.keras.models.load_model(keras_module_path+"/my_model.keras") imported_model(hashed_words.to_tensor()) דוגמה: Save a custom model class CustomModule(tf.Module): def __init__(self, variable_value): super(CustomModule, self).__init__() self.v = tf.Variable(variable_value) @tf.function def grow(self, x): return x * self.v module = CustomModule(100.0) # Before saving a custom model, you must ensure that concrete functions are # built for each input signature that you will need. module.grow.get_concrete_function(tf.RaggedTensorSpec(shape=[None, None], dtype=tf.float32)) custom_module_path = tempfile.mkdtemp() tf.saved_model.save(module, custom_module_path) imported_model = tf.saved_model.load(custom_module_path) imported_model.grow(tf.ragged.constant([[1.0, 4.0, 3.0], [2.0]])) INFO:tensorflow:Assets written to: /tmpfs/tmp/tmpkmr703wo/assets INFO:tensorflow:Assets written to: /tmpfs/tmp/tmpkmr703wo/assets הערה: חתימות SavedModel הן פונקציות מבוזרות.כפי שהוזכר בפרק על פונקציות מבוזרות לעיל, טנסורים מבוזרים מטופלים כראוי רק על ידי פונקציות מבוזרות החל מ- TensorFlow 2.3. הערה: חתימות SavedModel הן פונקציות מבוזרות.כפי שהוזכר בפרק על פונקציות מבוזרות לעיל, טנסורים מבוזרים מטופלים כראוי רק על ידי פונקציות מבוזרות החל מ- TensorFlow 2.3. חתימות מפעילים מוגזמים The class overloads the standard Python arithmetic and comparison operators, making it easy to perform basic elementwise math: RaggedTensor x = tf.ragged.constant([[1, 2], [3], [4, 5, 6]]) y = tf.ragged.constant([[1, 1], [2], [3, 3, 3]]) print(x + y) מאחר שהמעבדים המאוכלסים מבצעים חישובים אלמנטיים, הכניסות לכל הפעולות הבינאריות חייבות להיות באותו צורה או להיות נפרדות באותו צורה. x = tf.ragged.constant([[1, 2], [3], [4, 5, 6]]) print(x + 3) לקבלת דיון על מקרים מתקדמים יותר, בדוק את הסעיף . Broadcasting טנזרים מעורבים מעיפים את אותה קבוצה של מפעילים כרגיל s: המפעילים Unary , , ו • מפעילים בינאריים , , , , , , , , , , , , , , ו . Tensor - ~ abs() + - * / // % ** & | ^ == >= פורסם במקור באתר __TensorFlow __, מאמר זה מופיע כאן תחת כותרת חדשה והוא מורשה תחת CC BY 4.0. פורסם במקור באתר __TensorFlow __, מאמר זה מופיע כאן תחת כותרת חדשה והוא מורשה תחת CC BY 4.0. TensorFlow