Izveidojiet gudrākus modeļus ar TensorFlow visvairāk nenovērtēto funkciju – paplašinājumu veidiem

Satura pārskats Tensor API dispečers Izmantojiet vienu API Dispatch visiem unary elementwise API Dispatch bināro visu elementāro API Batchable paplašinājuma veidi BatchableExtensionType piemērs: Tīkla TensorFlow API, kas atbalsta ExtensionTypes @tf. funkcijas Plūsmas kontroles operācijas Autogrāfu kontroles plūsma Keramika Glābšanas modelis Datori Tensor API dispečers Paplašinājuma veidi var būt "tensor līdzīgi", tādā nozīmē, ka tie specializē vai paplašina saskarni, ko definē Piemēri tensoru līdzīgu paplašinājumu veidiem ietver , un Tātad TensorFlow var tikt izmantots, lai atspoguļotu TensorFlow operāciju noklusējuma uzvedību, ja to piemēro tensoru līdzīgiem paplašinājuma veidiem. tf.Tensor RaggedTensor SparseTensor MaskedTensor Dekoratīvie diski Dekoratīvie diski @tf.eksperimentālā.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) Izmantojiet vienu API Tās dekorators pārkāpj norādītās TensorFlow operācijas noklusējuma uzvedību, kad tā tiek izsaukta ar norādīto parakstu. Process būtu Vērtības : 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)) Tas novērš noklusējuma ieviešanu Katru reizi, kad tas tiek aicināts ar sarakstu Vērtības (kopš Argumenti tiek pieminēti ar ) no : 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]) Lai ļautu lai apstrādātu maisījumu sarakstus un vērtības, varat uzlabot tipveida piezīmi par parametru un atbilstoši atjaunināt funkcijas ķermeni: 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]) Lai iegūtu sarakstu ar API, ko var pārvērst, skatiet API dokumentāciju . tf.experimental.dispatch_for_api Dispatch visiem unary elementwise API Tās dekorators ignorē noklusējuma uzvedību unary elementwise ops (piemēram, ) ikreiz, kad pirmā argumenta vērtība (parasti nosaukta ) atbilst anotācijas tipam Dekoratīvajai funkcijai vajadzētu būt diviem argumentiem: tf.experimental.dispatch_for_unary_elementwise_apis Visi tf.math.cos x x_type Visi api_func: Funkcija, kas ņem vienu parametru un veic elementveida darbību (piemēram, tf.abs). x: Pirmais arguments elementveida operācijai. Nākamais piemērs atjaunina visas unary elementwise operācijas, lai apstrādātu Tipisks : 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) Šī funkcija tagad tiks izmantota katru reizi, kad tiek izsaukta vienota elementveida operācija uz . MaskedTensor x = MaskedTensor([1, -2, -3], [True, False, True]) print(tf.abs(x)) print(tf.ones_like(x, dtype=tf.float32)) Dispatch bināro visu elementāro API Līdzīgi arī var izmantot, lai atjauninātu visas bināro elementu operācijas, lai Tipisks : 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) Lai iegūtu sarakstu ar elementāriem API, kas ir pārklāti, dodieties uz API dokumentāciju un . tf.experimental.dispatch_for_unary_elementwise_apis tf.experimental.dispatch_for_binary_elementwise_apis Bataljons s Paplašinātājs Paplašinātājs un ir ja vienu instanci var izmantot, lai pārstāvētu vērtību partiju. Parasti tas tiek panākts, pievienojot partijas izmērus visām Sekojošie TensorFlow API prasa, lai jebkura paplašinājuma tipa ieejas būtu partijas: ExtensionType Bataljonu Tensor tf.data.Dataset (pakete, nepakete, no_tensor_slices) tf.keras (piemērot, novērtēt, prognozēt) tf.mapa_fn pēc nepilnības, izveido partijas vērtības, apvienojot jebkuru nested ar s, S un s. Ja tas nav piemērots jūsu klasei, tad jums būs jāizmanto lai novērstu šo noklusējuma uzvedību. Piemēram, nebūtu lietderīgi izveidot vērtības, vienkārši uzkrājot atsevišķus sparse tensors' , un laukus – vairumā gadījumu jūs nevarat uzkrāt šos tensorus, jo tiem ir nesaderīgas formas; un pat ja jūs varētu, rezultāts nebūtu derīgs . BatchableExtensionType Tensor CompositeTensor ExtensionType tf.experimental.ExtensionTypeBatchEncoder tf.SparseTensor values indices dense_shape SparseTensor Piezīme: BatchableExtensionTypes automātiski nenosaka dispečeri tf.stack, tf.concat, tf.slice utt. Ja jūsu klasei ir jāatbalsta šie API, izmantojiet iepriekš aprakstītos dispečera dekoratorus. Piezīme: BatchableExtensionTypes automātiski nenosaka dispečeri tf.stack, tf.concat, tf.slice utt. Ja jūsu klasei ir jāatbalsta šie API, izmantojiet iepriekš aprakstītos dispečera dekoratorus. Piemērs : BatchableExtensionType Network Kā piemēru var minēt vienkāršu klases, ko izmanto slodzes balansēšanai, kas izseko, cik daudz darba ir jāveic katrā mezglā, un cik daudz joslas platuma ir pieejams, lai pārvietotu darbu starp mezgliem: 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]]) Lai padarītu šo tipu batchable, mainiet bāzes tipu uz , un pielāgojiet katra lauka formu, lai iekļautu papildu partijas izmērus. lai izsekotu partijas formu. šī Teritorija nav nepieciešama vai Bet tas Pieprasījums pēc . BatchableExtensionType shape shape tf.data.Dataset tf.map_fn ir 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}") Tad jūs varat izmantot lai iterētu, izmantojot virkni tīklu: 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}") Jūs varat arī izmantot Lai piemērotu funkciju katram partijas elementam: 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, kas atbalsta s Paplašinātājs Paplašinātājs @tf. funkcijas ir dekorators, kas iepriekš aprēķina TensorFlow grafikus Python funkcijām, kas var būtiski uzlabot TensorFlow koda veiktspēju. Dekoratīvās funkcijas 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) Ja vēlaties skaidri norādīt par , tad jūs varat to izdarīt, izmantojot paplašinājuma veidu . 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) Konkrētas funkcijas Konkrētas funkcijas iekapsulē atsevišķas izsekotās diagrammas, ko veido Paplašinājuma veidus var izmantot pārredzami ar konkrētām funkcijām. tf.function cf = combine_pastry_features.get_concrete_function(pastry_spec) cf(cookie) Plūsmas kontroles operācijas Paplašinājuma veidus atbalsta TensorFlow kontroles plūsmas operācijas: TF. kondīcija TF. gadījums tf.while_lāpstiņas TF. identitāte # 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]) Autogrāfu kontroles plūsma Paplašinājuma veidus atbalsta arī kontroles plūsmas paziņojumi (izmantojot autogrāfu). turpmākajā piemērā Deklarācija un paziņojumi tiek automātiski pārveidoti uz un operācijas, kas atbalsta paplašinājuma veidus. 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))) Keramika ir TensorFlow augsta līmeņa API, lai izveidotu un apmācītu dziļas mācīšanās modeļus. Paplašinājuma veidus var nodot kā ievadi Keras modelim, nodot starp Keras slāņiem un atgriezt Keras modeļiem. Kārlis Kārlis Tiem jābūt batšējamiem (iet uz "Batchable ExtensionTypes" iepriekš). Viņiem ir jābūt laukam vai īpašumam, ko sauc par formu. forma[0] tiek pieņemta kā partijas izmērs. Nākamajās divās apakšiedaļās ir sniegti piemēri, kas parāda, kā paplašinājuma veidus var izmantot ar Keras. Kārļa piemērs: Network Tīkls Pirmais piemērs ir domāt par klases, kas definētas "Batchable" s" sadaļa iepriekš, ko var izmantot slodzes balansēšanas darbam starp mezgliem. tās definīcija tiek atkārtota šeit: 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]]]) Jūs varat definēt jaunu Keras slāni, kas apstrādā S ir 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) Tad jūs varat izmantot šos slāņus, lai izveidotu vienkāršu modeli. Lai izveidotu modeli, jūs varat izmantot Layer ar iestatīt uz paplašinājuma veida Ja Keras modeli izmantos partiju apstrādei, tad Ir jāiekļauj batšu izmērs. 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(), ]) Visbeidzot, jūs varat piemērot modeli vienam tīklam un vairākiem tīkliem. model(single_network) model(batch_of_networks) Ieķeksēts kā: masking Šajā piemērā, Tiek paplašināts atbalsts Tātad ir definēta kā īpašums, kas tiek aprēķināts no Keras prasa, lai šo īpašību pievienotu gan paplašinājuma tipam, gan tā Tātad Tā definē a izmaiņas, kas būs nepieciešamas, lai Serializācija ir zemāk. 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)) Tālāk dispečera dekoratori tiek izmantoti, lai pārvērstu vairāku TensorFlow API noklusējuma uzvedību. Tādējādi, atbrīvojot tos, mēs varam izmantot šos līdzekļus. Šā piemēra mērķiem, maskētiem tensoriem ir definēts, lai apstrādātu maskētās vērtības kā nulles (t.i., lai tos neiekļautu produktā). 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) Tad jūs varat izveidot Keras modeli, kas pieņem ieejas, izmantojot standarta Keras slāņus: 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)) Glābšanas modelis A ir serializēta TensorFlow programma, kas ietver gan svaru, gan aprēķinu. To var veidot no Keras modeļa vai no pielāgotā modeļa. Abos gadījumos paplašinājuma veidus var izmantot pārredzami ar SavedModel definētajām funkcijām un metodēm. Glābšanas modelis SavedModel var saglabāt modeļus, slāņus un funkcijas, kas apstrādā paplašinājuma veidus, ja vien paplašinājuma veidiem ir Šis nosaukums tiek izmantots, lai reģistrētu paplašinājuma tipu, lai to varētu atrast, kad modelis tiek ielādēts. __name__ Piemērs: ietaupīt Keras modeli Keras modeļus, kas izmanto paplašinājuma veidus, var saglabāt, izmantojot . 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) Piemērs: saglabāt pielāgotu modeli SavedModel var izmantot arī, lai saglabātu pielāgotu Subklases ar funkcijām, kas apstrādā paplašinājuma veidus. 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])) Lādējot SavedModel, kad Nav pieejams Paplašinātājs Paplašinātājs Ja jūs ielādējat a Tas izmanto vienu Bet tas nav pieejams (tas ir, tas nav importēts), tad jūs saņemsiet brīdinājumu un TensorFlow atgriezīsies, izmantojot "anonīmu paplašinājuma veida" objektu. SavedModel ExtensionType ExtensionType Izmanto S ar TensorFlow Serving ExtensionType Paplašinātājs Pašlaik , (un citi SavedModel "parakstu" vārdnīca patērētāji) prasa, lai visi ieejas un izejas būtu neapstrādāti tensori.Ja vēlaties izmantot TensorFlow Serving ar modeli, kas izmanto paplašinājuma veidus, tad varat pievienot iesaiņošanas metodes, kas veido vai nojauc paplašinājuma tipa vērtības no tensoriem. TensorFlow apkalpošana 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 ir API, kas ļauj jums veidot sarežģītas ievades cauruļvadus no vienkāršiem, atkārtoti lietojamiem gabaliem. , kas ir elementu secība, kurā katrs elements sastāv no vienas vai vairākām sastāvdaļām. tf.data tf.data.Dataset ēkas S ar paplašinājuma veidiem Datori Datori Datu kopas var veidot no paplašinājuma tipa vērtībām, izmantojot , vai : 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 un unbatching S ar paplašinājuma veidiem Dataset Datori Datu kopas ar paplašinājuma veidiem var būt batchand un unbatched, izmantojot un . 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) Sākotnēji publicēts TensorFlow tīmekļa vietnē, šis raksts šeit parādās ar jaunu virsrakstu un ir licencēts saskaņā ar CC BY 4.0. Sākotnēji publicēts TensorFlow tīmekļa vietnē, šis raksts šeit parādās ar jaunu virsrakstu un ir licencēts saskaņā ar CC BY 4.0. TensorFlow TensorFlow