Para sa Data ng Lahat ng mga Shapes at Size, Ang Ragged Tensors ay Nag-aalok ng isang Home

Paglalarawan ng Content ang setup ang overview Ano ang maaari mong gawin sa isang ragged tensor Paggawa ng isang Tensor Ano ang maaari mong i-save sa isang ragged tensor Example ng paggamit Pagkakaiba at uniform na mga dimensyon Mga pahinang tumuturo sa Sparks Mga TensorFlow API Mga Keras Mga Example Mga data Mga Function Mga Modelo Mga operator ng overload ang setup !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 ang overview Ang iyong data ay dumating sa maraming mga form; ang iyong tensors ay dapat din. ay ang TensorFlow na katumbas ng naka-incorporated variable-length lists. Ang mga ito ay nagbibigay-daan sa madaling i-storage at pagproseso ng data sa mga non-uniform shapes, kabilang ang: Mga Tensioner Variable-length features, tulad ng ang set ng mga aktor sa isang pelikula. Batch ng variable-length sequential input, tulad ng sentences o video clips. Hierarchical input, tulad ng mga dokumento ng teksto na subdivided sa mga seksyon, paragraphs, sentences, at mga salita. Individual na mga field sa mga na-structured input, tulad ng mga buffer ng protocol. Ano ang maaari mong gawin sa isang ragged tensor Ang mga tensors na nagtatrabaho ay sumusuporta sa higit sa isang hundred TensorFlow operations, kabilang ang mga matematika operations (tulad ng: at ang Ang mga operating system (tulad ng at ang ), string manipulation ops (tulad ng Mga Operasyon sa Pag-control ng Flow (Kasi ang at ang ), at maraming iba pang mga tao: 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) Mayroong maraming mga paraan at operasyon na espesyal sa ragged tensors, kabilang ang mga paraan ng factory, mga paraan ng conversion, at mga operasyon ng value-mapping. Para sa isang listahan ng suportahan na ops, tingnan ang Mga pakete ng dokumento. tf.ragged Ang mga tensors na nagtatrabaho ay sumusuporta sa maraming TensorFlow APIs, kabilang ang na ang na ang na ang at ang Para sa karagdagang impormasyon, tingnan ang seksyon sa sa loob. Mga Keras Mga data Mga Function Mga Modelo Mga Example TensorFlow APIs Tulad ng mga normal na tensors, maaari mong gamitin ang Python-style indexing upang makakuha ng access sa anumang mga slices ng isang ragged tensor. Para sa karagdagang impormasyon, tingnan ang seksyon sa sa loob. 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. At tulad ng mga normal na tensors, maaari mong gamitin ang Python arithmetic at comparison operators upang gawin ang operations sa elementwise. Para sa karagdagang impormasyon, tingnan ang seksyon sa sa loob. Overloaded operators print(digits + 3) print(digits + tf.ragged.constant([[1, 2, 3, 4], [], [5, 6, 7], [8], []])) Kung kailangan mong gawin ang isang elemental na transformasyon sa mga halaga ng a Maaari mong gamitin ang , na may isang function plus isa o higit pa ng mga argumento, at gumagamit ang function upang i-transform ang ang mga values. 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)) Ang mga tensors ay maaaring i-convert sa nested Python S at NumPy sa pamamagitan ng: 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) Paggawa ng isang Tensor Ang pinaka simpleng paraan upang bumuo ng isang ragged tensor ay gamit ang Na kung ano ang ibig sabihin ng Pagkakaiba sa isang anumang ni-nested Python ang numero : 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) Ang napili ng mga taga-hanga: Ragged tensors can also be constructed by pairing flat Tensyon sa ang mga tensors na nagpapakita kung paano ang mga halaga na ito ay dapat divided sa mga linya, gamit ang mga factory class methods tulad ng na ang at ang . Mga Value Mga Partisipasyon tf.RaggedTensor.from_value_rowids tf.RaggedTensor.from_row_lengths tf.RaggedTensor.from_row_splits tf.RaggedTensor.from_value_rowids tf.Tensor.from_value_rowids sa pamamagitan ng Pero kapag nalaman niyang nakilala mo siya dahil binasa mo ang diary... get ready for the consequences. Paggamit ng A Paglalarawan ng mga Tensors: 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 sa pamamagitan ng Pero kapag nalaman niyang nakilala mo siya dahil binasa mo ang diary... get ready for the consequences. Paglalarawan ng mga Tensors: 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 ang napili ng mga taga-hanga: Tensor.from_row_splits Pero kapag nalaman niyang nakilala mo siya dahil binasa mo ang diary... get ready for the consequences. Paglalarawan ng mga Tensors: row_splits print(tf.RaggedTensor.from_row_splits( values=[3, 1, 4, 1, 5, 9, 2], row_splits=[0, 4, 4, 6, 7])) Tingnan ang Class documentation para sa isang kumpletong listahan ng factory methods. tf.RaggedTensor Tandaan: Sa default, ang mga pabrika na mga paraan ay magdagdag ng mga assertions na ang tensor ng row partition ay napaka-formed at consistent sa bilang ng mga halaga. Ang validate=False parameter ay maaaring gamitin upang i-save ang mga check na ito kung maaari mong garantisahin na ang mga input ay napaka-formed at consistent. Sa default, ang mga factory methods ay sumali ng mga assertions na ang row partition tensor ay napaka-formed at consistent sa bilang ng mga halaga. Ang parameter ay maaaring gamitin upang i-slip ang mga check na ito kung maaari mong garantisahin na ang mga input ay mabuti at consistent. Note: validate=False Ano ang maaari mong i-save sa isang ragged tensor Dahil sa normal s, ang mga halaga sa a Ang lahat ng mga ito ay dapat na magkaroon ng parehong uri; at ang mga halaga ay dapat na magkaroon ng parehong pag-iisip (ang sa pamamagitan ng tensor): Tensor RaggedTensor ang rank 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 Example ng paggamit Ang mga sumusunod na halimbawa ay nagpapakita kung paano Ang s ay maaaring gamitin at kombinasyon ng unigram at bigram embeddings para sa isang batch ng variable-length queries, gamit ang mga espesyal na markers para sa simula at katapusan ng bawat sentence. Para sa higit pang mga detalye sa mga ops na ginagamit sa halimbawa na ito, tingnan ang Mga pakete ng dokumento. 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) Pagkakaiba at uniform na mga dimensyon A ang Ang maliliit na negosyo sa mga sumusunod na sektor ay kinakailangan: pagproseso ng produktong agrikultural ( nagtatapos sa tuldok ( , ... , Ang mga dimensyon na ang mga slices ng lahat ay may parehong length ay tinatawag na . Mga Dimensyon rt=[[3, 1, 4, 1], [], [5, 9, 2], [6], []] rt[0, :] rt[4, :] Mga Dimensyon Mga Dimensyon Ang pinakamalaking dimensyon ng isang ragged tensor ay palaging uniform, dahil ito ay binubuo ng isang single slice (at, kaya, walang posibilidad para sa iba't ibang lengths ng slice). Ang iba't ibang mga dimensyon ay maaaring maging either ragged o uniform. Halimbawa, maaari mong i-save ang word embeddings para sa bawat salita sa isang batch ng sentences gamit ang isang ragged tensor na may shape at kung saan ang mga pars Ipinapakita na ang dimensyon ay ragged. [num_sentences, (num_words), embedding_size] (num_words) Ang mga ragged tensors ay maaaring magkaroon ng maraming ragged dimensions. Halimbawa, maaari mong i-save ang isang batch ng mga strukturadong mga dokumento ng teksto gamit ang isang tensor na may shape (Ngunit ang mga parentesse ay ginagamit upang ipakita ang mga dimensyon na ragged). [num_documents, (num_paragraphs), (num_sentences), (num_words)] Dahil sa , ang Ang mga sumusunod na mga katangian ay ang total na bilang ng mga dimensyon ng isang ragged tensor (kabilang ang parehong ragged at uniform dimensions). Ito ay isang halaga na maaaring maging isang o sa . tf.Tensor ang rank Potensyal na Tensyon tf.Tensor tf.RaggedTensor ang rank Potensyal na Tensyon Sa paglalarawan ng shape ng isang RaggedTensor, ang ragged dimensions ay conventionally indicated sa pamamagitan ng pag-incorporating ang mga ito sa mga parentesse. Halimbawa, tulad ng nakita mo sa itaas, ang shape ng isang 3D RaggedTensor na nag-alagad ng word embeddings para sa bawat salita sa isang batch ng mga sentence ay maaaring isulat bilang . [num_sentences, (num_words), embedding_size] ang Ibalik ang atributo a para sa isang ragged tensor kung saan ang ragged dimensions ay may size : RaggedTensor.shape tf.TensorShape None tf.ragged.constant([["Hi"], ["How", "are", "you"]]).shape TensorShape([2, None]) ang method Dapat gamitin ang isang maliit na maliit na maliit na maliit na maliit na. : tf.RaggedTensor.bounding_shape RaggedTensor print(tf.ragged.constant([["Hi"], ["How", "are", "you"]]).bounding_shape()) tf.Tensor([2 3], shape=(2,), dtype=int64) Mga pahinang tumuturo sa Sparks Ang isang napaka-tension ay dapat Sa mga mas mababang posisyon ay may mga species ng Eurobond fauna, at ang mga altitude ng bundok ay dumarami sa pagtaas ng altitude. ang modelo ng parehong data sa isang compact format; ngunit ang ragged tensor ay isang Ang mga ito ay nagkakaiba sa pag-aayos ng isang extended class ng data. Ang pagkakaiba na ito ay mahalaga sa pag-defining operations: hindi Efektibo ang mga code para sa tf.Tensor Ang extension ay tf.Tensor Ang pag-apply ng isang op sa isang sparse o dense tensor ay dapat palagi ang parehong resulta. Paggamit ng isang op sa isang ragged o sparse tensor ay maaaring magbigay ng iba't ibang mga resulta. Bilang isang ilustrasyon, tingnan kung paano mag-array ng mga operasyon tulad ng na ang at ang Ang mga ito ay defined para sa ragged vs. sparse tensors. Concatenating ragged tensors sumali sa bawat row upang lumikha ng isang single row na may ang combined length: 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)) Gayunpaman, ang pag-concatenating ng mga sparse tensors ay katumbas sa pag-concatenating ng mga katumbas na dense tensors, tulad ng ilustrado sa sumusunod na halimbawa (na kung saan ang Ø ay nagpapakita ng mga walang halaga): 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) Para sa isa pang halimbawa ng kung bakit ito ay mahalaga, tingnan ang definisyon ng "ang average na halaga ng bawat linya" para sa isang op tulad ng: Para sa isang ragged tensor, ang average na halaga para sa isang row ay ang sumusunod ng mga halaga ng row na divided sa width ng row. Ngunit para sa isang sparse tensor, ang average na halaga para sa isang row ay ang sumusunod ng mga halaga ng row na divided sa kabuuan ng sparse tensor (na kung saan ay mas mataas o katumbas sa width ng pinakamalaking row). tf.reduce_mean Mga TensorFlow API Mga Keras ay ang TensorFlow's high-level API para sa pagbuo at pagsasanay ng mga modelo ng deep learning. Hindi ito may ragged suporta. Ngunit ito ay sumusuporta sa masked tensors. Kaya ang pinakamahusay na paraan upang gamitin ang isang ragged tensor sa isang Keras modelo ay upang i-convert ang ragged tensor sa isang dense tensor, gamit ang at pagkatapos ay gumagamit ng Keras's builtin masking: Mga pahinang .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]] Mga Example Ang isang standard Pag-coding para sa data ng TensorFlow. Ang data na na-coded sa Sa mga mas mababang posisyon ay may mga species ng Eurobond fauna, at ang mga altitude ng bundok ay dumarami sa pagtaas ng altitude. Mga mensahe na may iba't ibang mga lengths: Mga Example ang prototype 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]} } } }''')] Maaari mong i-codify ang data na ito gamit ang , na ginamit ng isang tensor ng serialized strings at isang feature specification dictionary, at bumalik ng isang dictionary mapping feature names sa tensors. Upang basahin ang variable-length features sa ragged tensors, gamitin mo lamang ang Ipinapakita ang Specification Dictionary: 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= May mga bagay na kailangan nating maging 'teknikal' at hindi natin kailangan ng emosyon para makapag-desisyon tayo ng maayos. . tf.io.RaggedFeature Mga Dokumento ng Fire Mga data ay isang API na nagbibigay-daan sa iyo upang bumuo ng mga kompleksong input pipelines mula sa simpleng, reusable pieces. , na nagpapakita ng isang sequence ng mga elemento, kung saan ang bawat elemento ay binubuo ng isa o higit pa ng mga bahagi. ang 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)) Pagbuo ng Datasets na may ragged tensors Ang datasets ay maaaring bumuo mula sa ragged tensors gamit ang parehong mga paraan na ginagamit upang bumuo ang mga ito mula sa S o NumPy S, tulad ng : 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] Note: Ang Dataset.from_generator ay hindi sumusuporta sa ragged tensors ngayon, ngunit ang suporta ay idinagdag malapit. Hindi pa rin nag-support ang mga tensors, ngunit mag-support ay mag-upload nang malapit. Note: Dataset.from_generator Batching at unbatching Datasets na may ragged tensors Ang mga datasets na may ragged tensors ay maaaring batch (ang kung saan ay binubuo Mga Elementong Pagkakaiba (Using a Element) ang metriko. n Dataset.batch batched_dataset = dataset.batch(2) print_dictionary_dataset(batched_dataset) Element 0: colors = lengths = Element 1: colors = lengths = Inversely, ang isang batch na dataset ay maaaring i-transform sa isang flat dataset gamit ang . 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] Batching Datasets na may variable-length non-ragged tensors Kung mayroon ka ng isang Dataset na naglalaman ng non-ragged tensors, at ang mga lengths ng tensors ay nagkakaiba sa lahat ng mga elemento, pagkatapos ay maaari mong batch ang mga non-ragged tensors sa ragged tensors sa pamamagitan ng paggamit ng ang ang transformasyon: 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. I-transform ang mga datasets gamit ang ragged tensors Maaari kang lumikha o i-transform ang ragged tensors sa Datasets gamit ang : 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 = Mga Function ay isang decorator na precomputes TensorFlow graphs para sa Python function, na maaaring mababago ng karaniwang pagganap ng iyong TensorFlow code. Halimbawa, ang mga sumusunod na function ay gumagana sa parehong ragged at non-ragged tensors: Mga 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 Kung gusto mong malaman ang mga Para sa Pagkatapos ay maaari mong gawin ito gamit ang . 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]])) ( , ) Mga Konsepto ng Function I-encapsulate ang mga individual traced graphs na binubuo ng Paggamit na tensors ay maaaring gamitin transparently sa mga function ng betong. Mga Konsepto ng Function 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)) Mga Modelo A ang Ito ay isang serialized TensorFlow programa, kabilang ang parehong mga timbang at pag-calculation. Ito ay maaaring bumuo mula sa isang Keras modelo o mula sa isang custom model. Sa parehong kaso, ang ragged tensors ay maaaring gamitin transparently sa mga function at mga paraan na defined sa pamamagitan ng isang SavedModel. Mga Modelo Halimbawa: I-save ang isang Keras model 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()) Example: I-save ang isang 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 Tandaan: Ang mga signature sa SavedModel ay mga konkretong function. Tulad ng tinutukoy sa seksyon sa Concrete Functions sa itaas, ang ragged tensors ay tinutukoy lamang sa mga konkretong function na nagsisimula sa TensorFlow 2.3. Kung kailangan mong gamitin ang mga signature sa SavedModel sa isang nakaraang bersyon ng TensorFlow, pagkatapos ay inirerekomenda na i-decompose ang ragged tensor sa mga component tensors. Mga Modelo Bilang sinasabi sa seksyon sa Concrete Functions sa itaas, ang ragged tensors ay tinutukoy lamang ng mga concrete function na nagsisimula sa TensorFlow 2.3. Kung kailangan mong gamitin ang mga signature ng SavedModel sa isang nakaraang bersyon ng TensorFlow, pagkatapos ay inirerekomenda na i-decompose ang ragged tensors sa mga component tensors. Note: Mga Signature Mga Signature Mga operator ng overload ang Class overloads ang mga standard na Python aritmetic at comparison operators, gumagawa ito ng madaling pagganap ng mga pangunahing 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) Dahil ang mga overloaded operator ay gumagawa ng elemental calculations, ang mga input sa lahat ng binary operations ay dapat na magkaroon ng parehong shape o magiging broadcastable sa parehong shape. Sa simplest broadcasting kaso, isang single scalar ay pinagsama elementally sa bawat halaga sa isang ragged tensor: x = tf.ragged.constant([[1, 2], [3], [4, 5, 6]]) print(x + 3) Para sa isang pakikipag-ugnayan ng karagdagang mga kaso, tingnan ang seksyon sa . Broadcasting Ang mga tensors ay nag-overload ng parehong set ng mga operator tulad ng normal s: ang unary operator na ang at ang Ang mga binary operators na ang na ang na ang na ang na ang na ang na ang na ang na ang na ang na ang na ang na ang at ang . Tensor - ~ abs() + - * / // % ** & | ^ == >= Nai-publish sa __TensorFlow __website, ang artikulong ito ay ipinapakita dito sa ilalim ng isang bagong headline at ay may lisensya sa ilalim ng CC BY 4.0. Nai-publish sa __TensorFlow __website, ang artikulong ito ay ipinapakita dito sa ilalim ng isang bagong headline at ay may lisensya sa ilalim ng CC BY 4.0. Mga TensorFlow