Pentru date de toate formele și mărimile, tensiunile răsucite oferă o casă

Conținut Overview setare Prezentare generală Ce poți face cu un tensiune Construirea unui tensiune ragged Ce puteți stoca într-un tensiune ragged Exemplu de caz de utilizare Dimensiuni simple și uniforme Războiul vs Sparta Aplicații TensorFlow Keramică F. Exemplu Dată tf. funcţie Modele de salvare Operatori supraîncărcați setare !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 Prezentare generală Datele dvs. vin în multe forme; tensiunile dvs. ar trebui, de asemenea. sunt echivalentul TensorFlow al listelor de lungime variabilă încorporate. Acestea facilitează stocarea și prelucrarea datelor cu forme neuniforme, inclusiv: Tensiuni ridicate Caracteristici de lungime variabilă, cum ar fi setul de actori dintr-un film. Baterii de intrări secvențiale cu lungime variabilă, cum ar fi propoziții sau clipuri video. Intrări ierarhice, cum ar fi documente text care sunt împărțite în secțiuni, paragrafe, propoziții și cuvinte. Câmpuri individuale în intrări structurate, cum ar fi buffere de protocol. Ce se poate face cu un tensiune Tensorurile de tip rug sunt susținute de mai mult de o sută de operații TensorFlow, inclusiv operații matematice (cum ar fi şi operaţiuni de array (cum ar fi şi , operațiuni de manipulare a șirurilor (cum ar fi operatiuni de control al fluxului (cum ar fi şi ) și multe altele: 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) Există, de asemenea, o serie de metode și operațiuni care sunt specifice tensorilor ragged, inclusiv metode de fabrică, metode de conversie și operațiuni de cartografiere a valorii. Pachetul de documente. tf.ragged Tensioarele rigide sunt acceptate de multe API-uri TensorFlow, inclusiv , , , şi Pentru mai multe informații, verificați secțiunea mai jos . Keramică Dată tf. funcţie Modele de salvare F. Exemplu TensorFlow APIs Ca și în cazul tensorilor obișnuiți, puteți utiliza indexarea în stil Python pentru a accesa felii specifice ale unui tensor răsucit. mai jos . 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. Și, la fel ca tensorii normali, puteți utiliza operatorii aritmetice și de comparație Python pentru a efectua operațiuni elementare. mai jos . Overloaded operators print(digits + 3) print(digits + tf.ragged.constant([[1, 2, 3, 4], [], [5, 6, 7], [8], []])) Dacă trebuie să efectuaţi o transformare elementară la valorile a Puteți utiliza , care ia o funcție plus unul sau mai mulți argumente și aplică funcția pentru a transforma şi a valorilor. 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)) Tensorii răsfățați pot fi convertiți în Python înnăscut S și NumPy s din: 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) Construirea unui tensiune ragged Cea mai simplă modalitate de a construi un tensor este de a folosi care construieşte corespunzător unui anumit născut Python sau numărul : 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) Tensioanele rigide pot fi, de asemenea, construite prin împerecherea planului Tensiuni cu tensori care indică modul în care aceste valori ar trebui împărțite în rânduri, folosind metode de clasă din fabrică, cum ar fi , şi . Valorile Răspândirea tf.RaggedTensor.from_value_rowids tf.RaggedTensor.from_row_lengths tf.RaggedTensor.from_row_splits tf.RaggedTensor.from_value_rowids tf.Răspundeți.from_value_rowids Dacă știți la ce rând aparține fiecare valoare, atunci puteți construi o Utilizarea a Tensiune de partiție: 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.Tensor.from_row_lengths Dacă știți cât de lungă este fiecare linie, atunci puteți utiliza o Tensiune de partiție: 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 tf.Tensor.from_row_splits înregistrări Dacă cunoașteți indexul unde începe și se termină fiecare rând, atunci puteți utiliza un Tensiune de partiție: row_splits print(tf.RaggedTensor.from_row_splits( values=[3, 1, 4, 1, 5, 9, 2], row_splits=[0, 4, 4, 6, 7])) Vezi pe documentație de clasă pentru o listă completă de metode de fabrică. tf.RaggedTensor Notă: În mod implicit, aceste metode de fabrică adaugă afirmații conform cărora tensorul de partiție de rând este bine format și consistent cu numărul de valori. Parametrul validate=False poate fi utilizat pentru a omite aceste verificări dacă puteți garanta că intrările sunt bine formate și coerente. În mod implicit, aceste metode de fabrică adaugă afirmații conform cărora tensorul de partiție de rând este bine format și consistent cu numărul de valori. Parametrul poate fi folosit pentru a omite aceste verificări dacă puteți garanta că intrările sunt bine formate și coerente. Note: validate=False Ce puteți stoca într-un tensiune ragged La fel ca în mod normal s, valorile din a toate trebuie să aibă acelaşi tip; şi valorile trebuie să fie la aceeaşi adâncime a cuibului (cel În ceea ce privește tensiunea): Tensor RaggedTensor rangului 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 Exemplu de caz de utilizare Următorul exemplu demonstrează cum s poate fi folosit pentru a construi și a combina încorporările unigram și bigram pentru un lot de interogări cu lungime variabilă, folosind markeri speciali pentru începutul și sfârșitul fiecărei propoziții. Pachetul de documente. 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) Dimensiuni simple și uniforme a este o dimensiune ale cărei felii pot avea lungimi diferite. De exemplu, dimensiunea interioară (columna) a este ruptă, deoarece coloana de tăieturi ( , ... , Dimensiunile ale caror felii au toate aceeasi lungime se numesc . Dimensiunea rafinată rt=[[3, 1, 4, 1], [], [5, 9, 2], [6], []] rt[0, :] rt[4, :] Dimensiuni uniforme Dimensiunea rafinată Dimensiunea cea mai exterioară a unui tensor este întotdeauna uniformă, deoarece este alcătuită dintr-o singură fâșie (și, prin urmare, nu există nicio posibilitate de lungimi diferite ale fâșiei). Dimensiunile rămase pot fi fie rigide, fie uniforme. De exemplu, puteți stoca inserțiile cuvântului pentru fiecare cuvânt într-un lot de propoziții folosind un tensor rigid cu formă În cazul în care parantezele din jurul indică faptul că dimensiunea este răsucită. [num_sentences, (num_words), embedding_size] (num_words) Tenzorii răsucite pot avea mai multe dimensiuni răsucite. De exemplu, puteți stoca un lot de documente text structurate folosind un tensor cu formă (în cazul în care, din nou, paranteze sunt folosite pentru a indica dimensiuni răsucite). [num_documents, (num_paragraphs), (num_sentences), (num_words)] Ca şi cu De aceea, la numărul total de dimensiuni (inclusiv atât dimensiunile rigide, cât și cele uniforme). este o valoare care poate fi fie a sau a . tf.Tensor rangului Tensiune potențială tf.Tensor tf.RaggedTensor rangului Tensiune potențială Când descrieți forma unui RaggedTensor, dimensiunile răsucite sunt indicate în mod convențional prin includerea lor în paranteze. De exemplu, după cum ați văzut mai sus, forma unui RaggedTensor 3D care stochează încorporările de cuvinte pentru fiecare cuvânt într-un lot de propoziții poate fi scrisă ca . [num_sentences, (num_words), embedding_size] pe atributul returnează a pentru un tensiune ragged în cazul în care dimensiunile ragged au dimensiuni : RaggedTensor.shape tf.TensorShape None tf.ragged.constant([["Hi"], ["How", "are", "you"]]).shape TensorShape([2, None]) Metodă poate fi folosit pentru a găsi o formă de limită strânsă pentru o anumită : tf.RaggedTensor.bounding_shape RaggedTensor print(tf.ragged.constant([["Hi"], ["How", "are", "you"]]).bounding_shape()) tf.Tensor([2 3], shape=(2,), dtype=int64) Războiul vs Sparta Un tensiune ar trebui să este considerat un tip de tensiune scarsă. în special, tensiunile scars sunt care modelează aceleaşi date într-un format compact; dar tensorul ragged este un care modelează o clasă extinsă de date. Această diferență este crucială atunci când se definesc operațiunile: nu Codificare eficientă pentru tf.Tensor Extinderea la tf.Tensor Aplicarea unei opțiuni la un tensor slab sau dens ar trebui să dea întotdeauna același rezultat. Aplicarea unei opțiuni la un tensor răsucit sau slab poate da rezultate diferite. Ca exemplu ilustrativ, luați în considerare modul în care array operațiuni, cum ar fi , şi sunt definite pentru tensioane ragged vs. sparse. Tensioanele ragged concomitente se alătură fiecărui rând pentru a forma o singură linie cu lungimea combinată: 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)) Cu toate acestea, conjuncturarea tensiunilor rare este echivalentă cu conjuncturarea tensiunilor dense corespunzătoare, după cum este ilustrat de următorul exemplu (unde Ø indică valorile lipsă): 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) Pentru un alt exemplu de ce această distincție este importantă, luați în considerare definiția "valoarea medie a fiecărei rânduri" pentru o op cum ar fi: Pentru un tensor rupt, valoarea medie pentru o linie este suma valorilor liniei împărțite la lățimea liniei.Dar pentru un tensor rar, valoarea medie pentru o linie este suma valorilor liniei împărțite la lățimea totală a tensorului rupt (care este mai mare sau egal cu lățimea liniei celei mai lungi). tf.reduce_mean Aplicații TensorFlow Keramică este API-ul de nivel înalt al TensorFlow pentru construirea și instruirea modelelor de învățare profundă. Nu are suport ragged. Dar suportă tensori mascați. Așadar, cea mai ușoară modalitate de a utiliza un tensor ragged într-un model Keras este de a converti tensorul ragged într-un tensor dens, folosind și apoi folosind mascarea builtin a lui Keras: tf. căruță .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]] F. Exemplu Este un standard codificare pentru datele TensorFlow. date codificate cu s include adesea caracteristici de lungime variabilă. De exemplu, următorul cod defineşte un lot de patru Mesajele cu lungimi diferite de caracteristici: F. Exemplu prototipuri 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]} } } }''')] Puteți parsa aceste date codificate folosind , care ia un tensor de șiruri serializate și un dicționar de specificații de caracteristici, și returnează un dicționar de cartografiere nume de caracteristici pentru tensori. În dicționarul de specificații: 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= De asemenea, poate fi folosit pentru a citi caracteristici cu dimensiuni multiple. Pentru detalii, consultaţi . tf.io.RaggedFeature Documentarea focului Dată este un API care vă permite să construiți conducte de intrare complexe din bucăți simple, reutilizabile. , care reprezintă o secvență de elemente, în care fiecare element constă dintr-una sau mai multe componente. Tf. date 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)) Construirea seturilor de date cu tensiuni ragged Seturile de date pot fi construite din tensori ragged folosind aceleași metode care sunt folosite pentru a le construi din S sau NumPy s, cum ar fi : 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] Notă: Dataset.from_generator nu acceptă încă tensori ragged, dar suportul va fi adăugat în curând. Deocamdată nu există suport pentru tensiuni, dar va fi adăugat în curând. Note: Dataset.from_generator Batching și unbatching seturi de date cu tensori ragged seturi de date cu tensori răsucite pot fi batchate (care combină elemente consecutive într-un singur element) folosind Metodă . n Dataset.batch batched_dataset = dataset.batch(2) print_dictionary_dataset(batched_dataset) Element 0: colors = lengths = Element 1: colors = lengths = Dimpotrivă, un set de date batch poate fi transformat într-un set de date plat folosind . 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] Batcharea seturilor de date cu tensori cu lungime variabilă non-ragged Dacă aveți un set de date care conține tensori non-ragged, iar lungimile tensorilor variază între elemente, atunci puteți împărți acele tensori non-ragged în tensori ragged aplicând de transformare: 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. Transformarea seturilor de date cu tensiuni ragged De asemenea, puteți să creați sau să transformați tensori ragged în seturi de date utilizând : 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 = tf. funcţie este un decorator care precalculează graficele TensorFlow pentru funcțiile Python, care pot îmbunătăți în mod substanțial performanța codului TensorFlow. De exemplu, următoarea funcție funcționează atât cu tensiuni ragged, cât și cu tensiuni non-ragged: tf. funcţie @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 Dacă doriţi să specificaţi în mod explicit Pentru cei După aceea, puteți utiliza . 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]])) ( , ) Funcții concrete încorporează diagrame individuale trase care sunt construite de Tensioanele înclinate pot fi utilizate în mod transparent cu funcții concrete. Funcții concrete 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)) Modele de salvare a este un program serializat TensorFlow, incluzând atât greutățile, cât și calculul. Poate fi construit dintr-un model Keras sau dintr-un model personalizat. În ambele cazuri, tensorii ragged pot fi utilizați în mod transparent cu funcțiile și metodele definite de un SavedModel. Modelul de salvare Exemplu: Salvarea unui model 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()) Exemplu: Salvați un model custom 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 Notă: Semnăturile SavedModel sunt funcții concrete.Așa cum am discutat în secțiunea Funcții concrete de mai sus, tensorii răsucite sunt tratați corect numai de funcții concrete începând cu TensorFlow 2.3. Modelul de salvare După cum am discutat în secțiunea Funcții de beton de mai sus, tensorii de beton sunt tratați corect numai de funcții de beton începând cu TensorFlow 2.3. Note: signatures Semnăturile Operatori supraîncărcați pe clasa supraîncărcă operatorii aritmetice și de comparație standard Python, făcând ușor să efectuați matematica elementară de bază: RaggedTensor x = tf.ragged.constant([[1, 2], [3], [4, 5, 6]]) y = tf.ragged.constant([[1, 1], [2], [3, 3, 3]]) print(x + y) Deoarece operatorii supraîncărcați efectuează calcule elementare, intrările pentru toate operațiunile binare trebuie să aibă aceeași formă sau să fie broadcastable la aceeași formă. x = tf.ragged.constant([[1, 2], [3], [4, 5, 6]]) print(x + 3) Pentru o discuție despre cazuri mai avansate, verificați secțiunea . Broadcasting Tensorii supraîncărcați supraîncărcă același set de operatori ca în mod normal s: operatorii unari , şi • Operatorii binari , , , , , , , , , , , , , şi . Tensor - ~ abs() + - * / // % ** & | ^ == >= Publicat inițial pe site-ul __TensorFlow, acest articol apare aici sub un titlu nou și este licențiat sub CC BY 4.0. Publicat inițial pe site-ul __TensorFlow, acest articol apare aici sub un titlu nou și este licențiat sub CC BY 4.0. TensorFlow