Membina model yang lebih pintar dengan ciri yang paling kurang dinilai TensorFlow — jenis ekstensi

Gambaran keseluruhan kandungan Tensor API Dispatch Dispatch untuk satu API Dispatch untuk semua unary elementwise APIs Dispatch untuk binari semua elementwise API Perbezaan Batchable BatchableExtensionType contoh: Rangkaian TensorFlow API yang menyokong ExtensionTypes @tf. fungsi Operasi kawalan aliran Autograph kawalan aliran Keras Penyelamat Dataset Tensor API Dispatch Jenis ekstensi boleh "seperti tensor", dalam arti bahawa mereka mengkhususkan atau memperluaskan antara muka yang ditakrifkan oleh Contoh-contoh jenis ekstensi seperti tensor termasuk daripada dan daripada boleh digunakan untuk membalikkan tingkah laku lalai operasi TensorFlow apabila digunakan kepada jenis ekstensi seperti tensor. TensorFlow kini mendefinisikan tiga dekorator penghantaran: tf.Tensor RaggedTensor SparseTensor MaskedTensor Dispatch Dekorasi Dispatch Dekorasi @tf.experimental.dispatch_for_api(tf_api) @tf.experimental.dispatch_for_unary_elementwise_apis(x_type) @tf.experimental.dispatch_for_binary_elementwise_apis(x_type, y_type) Dispatch untuk satu API yang dekorator mengabaikan tingkah laku lalai operasi TensorFlow tertentu apabila ia dipanggil dengan tanda tangan yang ditetapkan. perlu proses Nilai : tf.experimental.dispatch_for_api tf.stack MaskedTensor @tf.experimental.dispatch_for_api(tf.stack) def masked_stack(values: List[MaskedTensor], axis = 0): return MaskedTensor(tf.stack([v.values for v in values], axis), tf.stack([v.mask for v in values], axis)) Ini mengabaikan pelaksanaan default untuk Setiap kali ia dipanggil dengan senarai Nilai (Sejak daripada Argumen ini dianugerahkan dengan ) : tf.stack MaskedTensor values typing.List[MaskedTensor] x = MaskedTensor([1, 2, 3], [True, True, False]) y = MaskedTensor([4, 5, 6], [False, True, True]) tf.stack([x, y]) untuk membenarkan untuk menangani senarai campuran dan nilai, anda boleh menyempurnakan jenis nota untuk parameter dan mengemas kini badan fungsi dengan betul: tf.stack MaskedTensor Tensor values tf.experimental.unregister_dispatch_for(masked_stack) def convert_to_masked_tensor(x): if isinstance(x, MaskedTensor): return x else: return MaskedTensor(x, tf.ones_like(x, tf.bool)) @tf.experimental.dispatch_for_api(tf.stack) def masked_stack_v2(values: List[Union[MaskedTensor, tf.Tensor]], axis = 0): values = [convert_to_masked_tensor(v) for v in values] return MaskedTensor(tf.stack([v.values for v in values], axis), tf.stack([v.mask for v in values], axis)) x = MaskedTensor([1, 2, 3], [True, True, False]) y = tf.constant([4, 5, 6]) tf.stack([x, y, x]) Untuk senarai APIs yang boleh dibungkus, lihat dokumen API untuk . tf.experimental.dispatch_for_api Dispatch untuk semua unary elementwise APIs yang Pihak berkuasa mengabaikan tingkah laku default unary elementwise ops (seperti ) apabila nilai untuk argumen pertama (biasanya dinamakan ) cocok dengan jenis anotasi Fungsi yang dihiasi perlu mengambil dua argumen: tf.experimental.dispatch_for_unary_elementwise_apis Semua tf.math.cos x x_type Semua api_func: Fungsi yang mengambil parameter tunggal dan melaksanakan operasi elementwise (contohnya, tf.abs). x: Argumen pertama untuk operasi elemental. Contoh berikut mengemas kini semua operasi unary elementwise untuk menangani Jenis : MaskedTensor @tf.experimental.dispatch_for_unary_elementwise_apis(MaskedTensor) def masked_tensor_unary_elementwise_api_handler(api_func, x): return MaskedTensor(api_func(x.values), x.mask) Fungsi ini kini akan digunakan setiap kali operasi unary elementwise dipanggil pada . MaskedTensor x = MaskedTensor([1, -2, -3], [True, False, True]) print(tf.abs(x)) print(tf.ones_like(x, dtype=tf.float32)) Dispatch untuk binari semua elementwise API Begitu juga, boleh digunakan untuk mengemas kini semua operasi binari elementwise untuk menangani Jenis : tf.experimental.dispatch_for_binary_elementwise_apis MaskedTensor @tf.experimental.dispatch_for_binary_elementwise_apis(MaskedTensor, MaskedTensor) def masked_tensor_binary_elementwise_api_handler(api_func, x, y): return MaskedTensor(api_func(x.values, y.values), x.mask & y.mask) x = MaskedTensor([1, -2, -3], [True, False, True]) y = MaskedTensor([[4], [5]], [[True], [False]]) tf.math.add(x, y) Untuk senarai APIs elemental yang di atas, pergi ke dokumen API untuk dan . tf.experimental.dispatch_for_unary_elementwise_apis tf.experimental.dispatch_for_binary_elementwise_apis Batch boleh s Perpanjangan Perpanjangan kepada ialah jika satu instance boleh digunakan untuk mewakili satu batch nilai. Biasanya, ini dicapai dengan menambah saiz batch kepada semua nested s. API TensorFlow berikut memerlukan bahawa sebarang input jenis ekstensi boleh dibahagikan: ExtensionType Batch boleh Tensor tf.data.Dataset (batch, unbatch, dari_tensor_slices) tf.keras (sesuai, menilai, meramalkan) Peta / Peta / Fn Oleh yang demikian, mencipta nilai batch dengan batching apa-apa nested daripada s, S dan s. Jika ini tidak sesuai untuk kelas anda, maka anda perlu menggunakan untuk mengalih keluar daripada tingkah laku lalai ini. Sebagai contoh, tidak sesuai untuk mencipta batch nilai-nilai dengan hanya menumpukan tensors sparse individu' daripada dan medan - dalam kebanyakan kes, anda tidak boleh menumpukan tensors ini, kerana mereka mempunyai bentuk yang tidak serasi; dan walaupun jika anda boleh, hasilnya tidak akan sah . BatchableExtensionType Tensor CompositeTensor ExtensionType tf.experimental.ExtensionTypeBatchEncoder tf.SparseTensor values indices dense_shape SparseTensor Nota: BatchableExtensionTypes tidak secara automatik menentukan penyampai untuk tf.stack, tf.concat, tf.slice, dan lain-lain Jika kelas anda perlu disokong oleh API-API ini, maka gunakan penyampai penyampai yang diterangkan di atas. S untuk secara automatik mendefinisikan dispatcher untuk daripada daripada Jika kelas anda perlu disokong oleh API ini, maka gunakan dekorator penghantaran yang diterangkan di atas. Note: BatchableExtensionType Tidak tf.stack tf.concat tf.slice Contoh : BatchableExtensionType Network Sebagai contoh, pertimbangkan satu kelas yang digunakan untuk keseimbangan beban, yang menjejaki berapa banyak kerja yang tersisa untuk dilakukan pada setiap nod, dan berapa banyak lebar pita yang tersedia untuk memindahkan kerja antara nod: Network class Network(tf.experimental.ExtensionType): # This version is not batchable. work: tf.Tensor # work[n] = work left to do at node n bandwidth: tf.Tensor # bandwidth[n1, n2] = bandwidth from n1->n2 net1 = Network([5., 3, 8], [[0., 2, 0], [2, 0, 3], [0, 3, 0]]) net2 = Network([3., 4, 2], [[0., 2, 2], [2, 0, 2], [2, 2, 0]]) Untuk membuat jenis ini batchable, ubah jenis asas kepada , dan menyesuaikan bentuk setiap medan untuk memasukkan saiz batch opsional. contoh berikut juga menambah untuk menjejaki bentuk batch. ini Kawasan ini tidak diperlukan oleh atau Tetapi ia Diperlukan oleh . BatchableExtensionType shape shape tf.data.Dataset tf.map_fn ialah tf.keras class Network(tf.experimental.BatchableExtensionType): shape: tf.TensorShape # batch shape. A single network has shape=[]. work: tf.Tensor # work[*shape, n] = work left to do at node n bandwidth: tf.Tensor # bandwidth[*shape, n1, n2] = bandwidth from n1->n2 def __init__(self, work, bandwidth): self.work = tf.convert_to_tensor(work) self.bandwidth = tf.convert_to_tensor(bandwidth) work_batch_shape = self.work.shape[:-1] bandwidth_batch_shape = self.bandwidth.shape[:-2] self.shape = work_batch_shape.merge_with(bandwidth_batch_shape) def __repr__(self): return network_repr(self) def network_repr(network): work = network.work bandwidth = network.bandwidth if hasattr(work, 'numpy'): work = ' '.join(str(work.numpy()).split()) if hasattr(bandwidth, 'numpy'): bandwidth = ' '.join(str(bandwidth.numpy()).split()) return (f" ") net1 = Network([5., 3, 8], [[0., 2, 0], [2, 0, 3], [0, 3, 0]]) net2 = Network([3., 4, 2], [[0., 2, 2], [2, 0, 2], [2, 2, 0]]) batch_of_networks = Network( work=tf.stack([net1.work, net2.work]), bandwidth=tf.stack([net1.bandwidth, net2.bandwidth])) print(f"net1={net1}") print(f"net2={net2}") print(f"batch={batch_of_networks}") Kemudian anda boleh menggunakan untuk iterasi melalui batch rangkaian: tf.data.Dataset dataset = tf.data.Dataset.from_tensor_slices(batch_of_networks) for i, network in enumerate(dataset): print(f"Batch element {i}: {network}") Anda juga boleh menggunakan untuk memohon fungsi kepada setiap elemen batch: map_fn def balance_work_greedy(network): delta = (tf.expand_dims(network.work, -1) - tf.expand_dims(network.work, -2)) delta /= 4 delta = tf.maximum(tf.minimum(delta, network.bandwidth), -network.bandwidth) new_work = network.work + tf.reduce_sum(delta, -1) return Network(new_work, network.bandwidth) tf.map_fn(balance_work_greedy, batch_of_networks) TensorFlow API yang menyokong s ExtensionType Perpanjangan @tf. fungsi adalah dekorator yang mengira graf TensorFlow untuk fungsi Python, yang boleh meningkatkan prestasi kod TensorFlow anda secara ketara. fungsi yang dihiasi. tf.function @tf.function class Pastry(tf.experimental.ExtensionType): sweetness: tf.Tensor # 2d embedding that encodes sweetness chewiness: tf.Tensor # 2d embedding that encodes chewiness @tf.function def combine_pastry_features(x: Pastry): return (x.sweetness + x.chewiness) / 2 cookie = Pastry(sweetness=[1.2, 0.4], chewiness=[0.8, 0.2]) combine_pastry_features(cookie) Jika anda ingin menjelaskan secara jelas untuk , maka anda boleh melakukannya menggunakan jenis ekstensi . input_signature tf.function TypeSpec pastry_spec = Pastry.Spec(tf.TensorSpec([2]), tf.TensorSpec(2)) @tf.function(input_signature=[pastry_spec]) def increase_sweetness(x: Pastry, delta=1.0): return Pastry(x.sweetness + delta, x.chewiness) increase_sweetness(cookie) Fungsi konkrit Fungsi-fungsi konkrit melampirkan grafik-graf mengikut individu yang dibina oleh Jenis ekstensi boleh digunakan secara transparan dengan fungsi konkrit. tf.function cf = combine_pastry_features.get_concrete_function(pastry_spec) cf(cookie) Operasi kawalan aliran Jenis ekstensi disokong oleh operasi aliran kawalan TensorFlow: Sijil : Cond TF. kes tf.while_keluar Tag: identiti # Example: using tf.cond to select between two MaskedTensors. Note that the # two MaskedTensors don't need to have the same shape. a = MaskedTensor([1., 2, 3], [True, False, True]) b = MaskedTensor([22., 33, 108, 55], [True, True, True, False]) condition = tf.constant(True) print(tf.cond(condition, lambda: a, lambda: b)) # Example: using tf.while_loop with MaskedTensor. cond = lambda i, _: i < 10 def body(i, mt): return i + 1, mt.with_values(mt.values + 3 / 7) print(tf.while_loop(cond, body, [0, b])[1]) Autograph kawalan aliran Jenis ekstensi juga disokong oleh pernyataan aliran kawalan dalam (Menggunakan autograf) Dalam contoh berikut, Pernyataan dan Pernyataan-pernyataan ini secara automatik ditukar kepada dan operasi, yang menyokong jenis ekstensi. tf.function if for tf.cond tf.while_loop @tf.function def fn(x, b): if b: x = MaskedTensor(x, tf.less(x, 0)) else: x = MaskedTensor(x, tf.greater(x, 0)) for i in tf.range(5 if b else 7): x = x.with_values(x.values + 1 / 2) return x print(fn(tf.constant([1., -2, 3]), tf.constant(True))) print(fn(tf.constant([1., -2, 3]), tf.constant(False))) Keras adalah API peringkat tinggi TensorFlow untuk membina dan melatih model pembelajaran mendalam. jenis ekstensi boleh dihantar sebagai input kepada model Keras, dihantar antara lapisan Keras, dan dikembalikan oleh model Keras. Tf. keras Mereka mesti batchable ( pergi ke "Batchable ExtensionTypes" di atas). Mereka mesti mempunyai medan atau sifat yang dipanggil bentuk. bentuk[0] dianggap sebagai dimensi batch. Dua subseksyen berikut memberikan contoh yang menunjukkan bagaimana jenis ekstensi boleh digunakan dengan Keras. Keras contoh : Network Rangkaian Sebagai contoh pertama, pertimbangkan kelas yang ditakrifkan dalam "Batchable s" bahagian di atas, yang boleh digunakan untuk kerja keseimbangan beban antara nod. definisinya diulang di sini: Network ExtensionType class Network(tf.experimental.BatchableExtensionType): shape: tf.TensorShape # batch shape. A single network has shape=[]. work: tf.Tensor # work[*shape, n] = work left to do at node n bandwidth: tf.Tensor # bandwidth[*shape, n1, n2] = bandwidth from n1->n2 def __init__(self, work, bandwidth): self.work = tf.convert_to_tensor(work) self.bandwidth = tf.convert_to_tensor(bandwidth) work_batch_shape = self.work.shape[:-1] bandwidth_batch_shape = self.bandwidth.shape[:-2] self.shape = work_batch_shape.merge_with(bandwidth_batch_shape) def __repr__(self): return network_repr(self) single_network = Network( # A single network with 4 nodes. work=[8.0, 5, 12, 2], bandwidth=[[0.0, 1, 2, 2], [1, 0, 0, 2], [2, 0, 0, 1], [2, 2, 1, 0]]) batch_of_networks = Network( # Batch of 2 networks, each w/ 2 nodes. work=[[8.0, 5], [3, 2]], bandwidth=[[[0.0, 1], [1, 0]], [[0, 2], [2, 0]]]) Anda boleh mendefinisikan lapisan Keras baru yang memproses daripada s. Network class BalanceNetworkLayer(tf.keras.layers.Layer): """Layer that balances work between nodes in a network. Shifts work from more busy nodes to less busy nodes, constrained by bandwidth. """ def call(self, inputs): # This function is defined above in the "Batchable `ExtensionType`s" section. return balance_work_greedy(inputs) Anda kemudian boleh menggunakan lapisan ini untuk mencipta model yang mudah. Dalam satu model, anda boleh menggunakan layer dengan Tentukan kepada jenis ekstensi Jika model Keras akan digunakan untuk memproses batch, maka mesti mengandungi saiz batch. ExtensionType tf.keras.layer.Input type_spec TypeSpec type_spec input_spec = Network.Spec(shape=None, work=tf.TensorSpec(None, tf.float32), bandwidth=tf.TensorSpec(None, tf.float32)) model = tf.keras.Sequential([ tf.keras.layers.Input(type_spec=input_spec), BalanceNetworkLayer(), ]) Akhirnya, anda boleh memohon model kepada satu rangkaian dan kepada serangkaian rangkaian. model(single_network) model(batch_of_networks) Contoh Keras: MaskedTensor Dalam contoh ini, diperluaskan untuk menyokong daripada merupakan harta yang dihitung daripada Keras memerlukan anda menambah sifat ini kepada kedua-dua jenis ekstensi dan daripada Ia juga menentukan a variabel yang diperlukan untuk Perbincangan di bawah ( MaskedTensor Keras shape values TypeSpec MaskedTensor __name__ SavedModel class MaskedTensor(tf.experimental.BatchableExtensionType): # __name__ is required for serialization in SavedModel; see below for details. __name__ = 'extension_type_colab.MaskedTensor' values: tf.Tensor mask: tf.Tensor shape = property(lambda self: self.values.shape) dtype = property(lambda self: self.values.dtype) def with_default(self, default): return tf.where(self.mask, self.values, default) def __repr__(self): return masked_tensor_str(self.values, self.mask) class Spec: def __init__(self, shape, dtype=tf.float32): self.values = tf.TensorSpec(shape, dtype) self.mask = tf.TensorSpec(shape, tf.bool) shape = property(lambda self: self.values.shape) dtype = property(lambda self: self.values.dtype) def with_shape(self): return MaskedTensor.Spec(tf.TensorSpec(shape, self.values.dtype), tf.TensorSpec(shape, self.mask.dtype)) Seterusnya, decorators dispatch digunakan untuk membalikkan tingkah laku lalai beberapa TensorFlow API. Oleh kerana API ini digunakan oleh lapisan Keras standard (seperti kepada mereka, akan membolehkan kita menggunakannya dengan Untuk tujuan contoh ini, untuk tensors disembunyikan ditakrifkan untuk merawat nilai disembunyikan sebagai nol (iaitu, untuk tidak memasukkan mereka dalam produk). Dense MaskedTensor matmul @tf.experimental.dispatch_for_unary_elementwise_apis(MaskedTensor) def unary_elementwise_op_handler(op, x): return MaskedTensor(op(x.values), x.mask) @tf.experimental.dispatch_for_binary_elementwise_apis( Union[MaskedTensor, tf.Tensor], Union[MaskedTensor, tf.Tensor]) def binary_elementwise_op_handler(op, x, y): x = convert_to_masked_tensor(x) y = convert_to_masked_tensor(y) return MaskedTensor(op(x.values, y.values), x.mask & y.mask) @tf.experimental.dispatch_for_api(tf.matmul) def masked_matmul(a: MaskedTensor, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, output_type=None): if isinstance(a, MaskedTensor): a = a.with_default(0) if isinstance(b, MaskedTensor): b = b.with_default(0) return tf.matmul(a, b, transpose_a, transpose_b, adjoint_a, adjoint_b, a_is_sparse, b_is_sparse, output_type) Anda kemudian boleh membina model Keras yang menerima Input, menggunakan lapisan Keras standard: MaskedTensor input_spec = MaskedTensor.Spec([None, 2], tf.float32) masked_tensor_model = tf.keras.Sequential([ tf.keras.layers.Input(type_spec=input_spec), tf.keras.layers.Dense(16, activation="relu"), tf.keras.layers.Dense(1)]) masked_tensor_model.compile(loss='binary_crossentropy', optimizer='rmsprop') a = MaskedTensor([[1., 2], [3, 4], [5, 6]], [[True, False], [False, True], [True, True]]) masked_tensor_model.fit(a, tf.constant([[1], [0], [1]]), epochs=3) print(masked_tensor_model(a)) Penyelamat A ialah adalah program TensorFlow seri, termasuk kedua-dua berat dan pengiraan. Ia boleh dibina daripada model Keras atau daripada model tersuai. Dalam kedua-dua kes, jenis ekstensi boleh digunakan secara transparan dengan fungsi dan kaedah yang ditakrifkan oleh SavedModel. Penyelamat SavedModel boleh menyimpan model, lapisan, dan fungsi yang memproses jenis ekstensi, selagi jenis ekstensi mempunyai Nama ini digunakan untuk mendaftarkan jenis ekstensi, supaya ia boleh ditempatkan apabila model dimuat naik. __name__ Contoh: Menyelamatkan model Keras Model Keras yang menggunakan jenis ekstensi boleh disimpan menggunakan . SavedModel masked_tensor_model_path = tempfile.mkdtemp() tf.saved_model.save(masked_tensor_model, masked_tensor_model_path) imported_model = tf.saved_model.load(masked_tensor_model_path) imported_model(a) Contoh: Menyelamatkan model custom SavedModel juga boleh digunakan untuk menyimpan custom subkelas dengan fungsi yang memproses jenis ekstensi. tf.Module class CustomModule(tf.Module): def __init__(self, variable_value): super().__init__() self.v = tf.Variable(variable_value) @tf.function def grow(self, x: MaskedTensor): """Increase values in `x` by multiplying them by `self.v`.""" return MaskedTensor(x.values * self.v, x.mask) module = CustomModule(100.0) module.grow.get_concrete_function(MaskedTensor.Spec(shape=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(MaskedTensor([1., 2, 3], [False, True, False])) Menyelamatkan pelupusan apabila Tidak tersedia Perpanjangan Perpanjangan Jika anda memuatkan a Ia menggunakan satu Tetapi bahawa tidak tersedia (iaitu, ia tidak diimport), maka anda akan menerima amaran dan TensorFlow akan jatuh semula untuk menggunakan objek "jenis ekstensi anonim". objek ini akan mempunyai medan yang sama dengan jenis asal, tetapi akan kekurangan sebarang penyesuaian lanjut yang anda telah menambah untuk jenis itu, seperti kaedah atau sifat tersuai. SavedModel ExtensionType ExtensionType Menggunakan Menggunakan TensorFlow Serving Perpanjangan Perpanjangan Pada masa ini, (dan pengguna lain dalam kamus "tanda tangan" SavedModel) memerlukan bahawa semua input dan output adalah tensors mentah.Jika anda ingin menggunakan TensorFlow Serving dengan model yang menggunakan jenis ekstensi, maka anda boleh menambah kaedah wrapper yang menyusun atau memecahkan nilai jenis ekstensi daripada tensors. Perkhidmatan TensorFlow class CustomModuleWrapper(tf.Module): def __init__(self, variable_value): super().__init__() self.v = tf.Variable(variable_value) @tf.function def var_weighted_mean(self, x: MaskedTensor): """Mean value of unmasked values in x, weighted by self.v.""" x = MaskedTensor(x.values * self.v, x.mask) return (tf.reduce_sum(x.with_default(0)) / tf.reduce_sum(tf.cast(x.mask, x.dtype))) @tf.function() def var_weighted_mean_wrapper(self, x_values, x_mask): """Raw tensor wrapper for var_weighted_mean.""" return self.var_weighted_mean(MaskedTensor(x_values, x_mask)) module = CustomModuleWrapper([3., 2., 8., 5.]) module.var_weighted_mean_wrapper.get_concrete_function( tf.TensorSpec(None, tf.float32), tf.TensorSpec(None, tf.bool)) custom_module_path = tempfile.mkdtemp() tf.saved_model.save(module, custom_module_path) imported_model = tf.saved_model.load(custom_module_path) x = MaskedTensor([1., 2., 3., 4.], [False, True, False, True]) imported_model.var_weighted_mean_wrapper(x.values, x.mask) s Dataset adalah API yang membolehkan anda membina paip input yang kompleks daripada bahagian-bahagian yang mudah dan boleh digunakan semula. , yang mewakili urutan elemen, di mana setiap elemen terdiri daripada satu atau lebih komponen. tf.data tf.data.Dataset Pembinaan s dengan jenis ekstensi Dataset Dataset Set data boleh dibina daripada nilai jenis ekstensi menggunakan daripada atau : Dataset.from_tensors Dataset.from_tensor_slices Dataset.from_generator ds = tf.data.Dataset.from_tensors(Pastry(5, 5)) iter(ds).next() mt = MaskedTensor(tf.reshape(range(20), [5, 4]), tf.ones([5, 4])) ds = tf.data.Dataset.from_tensor_slices(mt) for value in ds: print(value) def value_gen(): for i in range(2, 7): yield MaskedTensor(range(10), [j%i != 0 for j in range(10)]) ds = tf.data.Dataset.from_generator( value_gen, output_signature=MaskedTensor.Spec(shape=[10], dtype=tf.int32)) for value in ds: print(value) Batching dan Unbatching s dengan jenis ekstensi Dataset Dataset Set data dengan jenis ekstensi boleh batchand dan unbatched menggunakan dan . Dataset.batch Dataset.unbatch batched_ds = ds.batch(2) for value in batched_ds: print(value) unbatched_ds = batched_ds.unbatch() for value in unbatched_ds: print(value) Awalnya diterbitkan di laman web TensorFlow, artikel ini muncul di sini di bawah tajuk baru dan dilesenkan di bawah CC BY 4.0. Awalnya diterbitkan di laman web TensorFlow, artikel ini muncul di sini di bawah tajuk baru dan dilesenkan di bawah CC BY 4.0. TensorFlow TensorFlow