TensorFlow paplašinājuma veidi, kas izskaidroti ar piemēriem

Satura pārskats iestatīšana Paplašināšanās veidi Atbalsta APIs Prasības Lauku veidi Mutabilitāte Funkcionalitāte, ko pievieno ExtensionType Būvnieks Nospiestā reprezentācija Vienlīdzības operatori Validācijas metode Piespiedu nemainīgums Nosaukums TypeSpec Pielāgojiet paplašinājumu veidus Nospiediet noklusējuma drukājamo attēlu Metodisko definīciju Klases metožu un statisko metožu definēšana Īpašuma definīcija Izvēlieties noklusējuma konstruktoru Noslēguma vienlīdzības operatoru (eq) pārvērtēšana Izmantojiet nākamās atsauces Subklases definīcija Privāto lauku definēšana ExtensionType TypeSpec pielāgošana iestatīšana !pip install -q tf_nightly import tensorflow as tf import numpy as np from typing import Tuple, List, Mapping, Union, Optional import tempfile Paplašināšanās veidi Lietotāja definētie tipi var padarīt projektus lasāmākus, modulārākus un uzturējamus.Tomēr lielākajai daļai TensorFlow API ir ļoti ierobežots atbalsts lietotāja definētiem Python tipiem. , , un zemāka līmeņa API (piemēram, un • TensorFlow var tikt izmantots, lai izveidotu lietotāja definētus objektorientētus tipus, kas darbojas nevainojami ar TensorFlow API. Lai izveidotu paplašinājuma tipu, vienkārši definējiet Python klasi ar kā pamatu, un izmantot Lai noteiktu tipu katram laukam. Keramika tf.function tf.SavedModel tf.while_loop tf.concat extension types tf.experimental.ExtensionType Anotācijas veidi class TensorGraph(tf.experimental.ExtensionType): """A collection of labeled nodes connected by weighted edges.""" edge_weights: tf.Tensor # shape=[num_nodes, num_nodes] node_labels: Mapping[str, tf.Tensor] # shape=[num_nodes]; dtype=any class MaskedTensor(tf.experimental.ExtensionType): """A tensor paired with a boolean mask, indicating which values are valid.""" values: tf.Tensor mask: tf.Tensor # shape=values.shape; false for missing/invalid values. class CSRSparseMatrix(tf.experimental.ExtensionType): """Compressed sparse row matrix (https://en.wikipedia.org/wiki/Sparse_matrix).""" values: tf.Tensor # shape=[num_nonzero]; dtype=any col_index: tf.Tensor # shape=[num_nonzero]; dtype=int64 row_index: tf.Tensor # shape=[num_rows+1]; dtype=int64 Tās Pamatklase darbojas līdzīgi un no standarta Python bibliotēkas. jo īpaši tas automātiski pievieno konstruktoru un īpašas metodes (piemēram, un ) pamatojoties uz lauka tipa piezīmēm. tf.experimental.ExtensionType typing.NamedTuple @dataclasses.dataclass __repr__ __eq__ Parasti paplašinājuma veidi mēdz ietilpt vienā no divām kategorijām: Datu struktūras, kas apvieno saistītu vērtību kopumu un var nodrošināt noderīgas operācijas, pamatojoties uz šīm vērtībām.Datu struktūras var būt diezgan vispārīgas (piemēram, TensorGraph piemērs iepriekš); vai arī tās var būt ļoti pielāgotas konkrētam modelim. Šīs kategorijas tipiem ir ranga, forma un parasti dtips; un ir jēga tos izmantot ar Tensor operācijām (piemēram, tf.stack, tf.add, vai tf.matmul). Datu struktūras Tenzoru veidi Atbalsta APIs Paplašinājuma veidus atbalsta šādi TensorFlow API: Keras: Paplašinājumu veidi var tikt izmantoti kā ieejas un izejas Keras modeļiem un slāņiem. tf.data.Dataset: Paplašinājuma veidus var iekļaut datu kopās un atgriezt datu kopu iteratori. TensorFlow Hub: Paplašinājuma veidus var izmantot kā ieejas un izejas tf.hub moduļiem. SavedModel: Paplašinājuma veidus var izmantot kā ieejas un izejas SavedModel funkcijām. tf.funkcija: Paplašinājuma veidus var izmantot kā argumentus un atgriezt vērtības funkcijām, kas iesaiņotas ar @tf.funkcijas dekoratoru. Lai gan sloksnes: Paplašinājuma veidus var izmantot kā sloksnes mainīgos tf.while_loop, un tos var izmantot kā argumentus un atgriezt vērtības while-loop ķermenim. Nosacījumi: Paplašinājuma veidus var nosacīti izvēlēties, izmantojot tf.cond un tf.case. tf.py_function: Paplašinājuma veidus var izmantot kā argumentus un atgriezt funkcijas argumenta vērtības tf.py_function. Tensor operācijas: Paplašinājuma veidus var paplašināt, lai atbalstītu lielāko daļu TensorFlow operāciju, kas atbalsta Tensor ieejas (piemēram, tf.matmul, tf.gather un tf.reduce_sum). Izplatīšanas stratēģija: Paplašinājuma veidus var izmantot kā per-replikas vērtības. Sīkāku informāciju skatiet sadaļā "TensorFlow API, kas atbalsta paplašinājumu veidus" zemāk. Prasības Lauku veidi Visiem laukiem — instances mainīgajiem — ir jābūt deklarētiem, un katram laukam ir jānodrošina tipa piezīme. Type Example Python integers i: int Python floats f: float Python strings s: str Python booleans b: bool Python None n: None Tensor shapes shape: tf.TensorShape s Tensor dtype dtype: tf.DType Tensors t: tf.Tensor Extension types mt: MyMaskedTensor Ragged tensors rt: tf.RaggedTensor Sparse tensors st: tf.SparseTensor Indexed slices s: tf.IndexedSlices Optional tensors o: tf.experimental.Optional Type unions int_or_float: typing.Union[int, float] Tuples params: typing.Tuple[int, float, tf.Tensor, int] Var-length tuples lengths: typing.Tuple[int, ...] Mappings tags: typing.Mapping[str, tf.Tensor] Optional values weight: typing.Optional[tf.Tensor] Python integrētāji i: int Python plūdi f: float Python strīdi s: str Python booleāns b: bool Python None n: None Tenzoru formas shape: tf.TensorShape s Tenzors dtype dtype: tf.DType Tenzori t: tf.Tensor Paplašināšanās veidi mt: MyMaskedTensor Spēcīgie tenori rt: tf.RaggedTensor Ietaupīt spiedienu st: tf.SparseTensor Indeksa slīpums s: tf.IndexedSlices Opcionālie tensori o: tf.experimental.Optional Arodbiedrību veidi int_or_float: typing.Union[int, float] dubultā params: typing.Tuple[int, float, tf.Tensor, int] Var-ilguma tuples lengths: typing.Tuple[int, ...] Mappings tags: typing.Mapping[str, tf.Tensor] Opcionālās vērtības weight: typing.Optional[tf.Tensor] Mutabilitāte Paplašinājuma veidiem ir jābūt nemainīgiem. Tas nodrošina, ka tos var pareizi izsekot ar TensorFlow grafikas izsekošanas mehānismiem. Ja konstatējat, ka vēlaties mutēt paplašinājuma tipa vērtību, apsveriet tā vietā definēt metodes, kas pārveido vērtības. Metode, lai mainītu a Jūs varat definēt a Metode, kas atgriež jaunu : set_mask MaskedTensor replace_mask MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def replace_mask(self, new_mask): self.values.shape.assert_is_compatible_with(new_mask.shape) return MaskedTensor(self.values, new_mask) Funkcionalitāte pievienota ExtensionType Paplašinātājs Tās bāzes klase nodrošina šādu funkcionalitāti: ExtensionType Izstrādātājs ir (__init__) Izdrukājama reprezentācijas metode (__repr__) Vienlīdzības un nevienlīdzības operatori (__eq__). Validācijas metožu izmantošana (validācijas metode) Piespiedu nemainīgums . Tīkls ar tipogrāfiju. Tensor API dispatch atbalsts. Iet uz “Personalizācija” s" sadaļā zemāk, lai iegūtu vairāk informācijas par šīs funkcionalitātes pielāgošanu. ExtensionType Būvnieks Ražotājs pievieno ņem katru lauku kā nosauktu argumentu (saskaņā ar kārtību, kādā tie tika uzskaitīti klases definīcijā). Šis konstruktors ievadīs katru parametru un pārvērsīs tos, ja nepieciešams. Lauki tiek pārveidoti, izmantojot · Lauki tiek pārvērsti s; un Lauki tiek pārvērsti nemainīgos diktos. ExtensionType Tensor tf.convert_to_tensor Tuple tuple Mapping class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor # Constructor takes one parameter for each field. mt = MaskedTensor(values=[[1, 2, 3], [4, 5, 6]], mask=[[True, True, False], [True, False, True]]) # Fields are type-checked and converted to the declared types. # For example, `mt.values` is converted to a Tensor. print(mt.values) Izgatavotājs paaugstina ja lauka vērtību nevar konvertēt uz deklarēto tipu: TypeError try: MaskedTensor([1, 2, 3], None) except TypeError as e: print(f"Got expected TypeError: {e}") Lauka noklusējuma vērtību var norādīt, iestatot tā vērtību klases līmenī: class Pencil(tf.experimental.ExtensionType): color: str = "black" has_erasor: bool = True length: tf.Tensor = 1.0 Pencil() Pencil(length=0.5, color="blue") Nospiestā reprezentācija Iespējams, ka tas nozīmē, ka ir jāizvēlas pareizais variants, lai izvairītos no pārslodzes ( ) kas ietver klases nosaukumu un katra lauka vērtību: ExtensionType __repr__ print(MaskedTensor(values=[1, 2, 3], mask=[True, True, False])) Vienlīdzības operatori Nākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais rakstsNākamais raksts un ) kas uzskata, ka divas vērtības ir vienādas, ja tām ir tāds pats tips un visi to lauki ir vienādi.Tensor lauki tiek uzskatīti par vienādiem, ja tiem ir tāda pati forma un ir elementāri vienādi visiem elementiem. ExtensionType __eq__ __ne__ a = MaskedTensor([1, 2], [True, False]) b = MaskedTensor([[3, 4], [5, 6]], [[False, True], [True, True]]) print(f"a == a: {a==a}") print(f"a == b: {a==b}") print(f"a == a.values: {a==a.values}") Piezīme: ja jebkurš lauks satur Tensor, tad __eq__ var atgriezt skalarboļu Tensor (nevis Python boola vērtību). Ja jebkurš lauks satur a Pēc tam var atgriezt skalarboļu (Vairāk nekā Python Boolean vērtība). Note: Tensor __eq__ Tensor Validācijas metode Pievienojiet a Tas tiek palaists pēc tam, kad konstruktors ir izsaukts, un pēc tam, kad lauki ir pārbaudīti un konvertēti uz deklarētajiem veidiem, lai tas varētu pieņemt, ka visiem laukiem ir deklarētie veidi. ExtensionType __validate__ Turpmāk minētie atjauninājumi Lai validētu S un S no saviem laukiem: MaskedTensor shape dtype class MaskedTensor(tf.experimental.ExtensionType): """A tensor paired with a boolean mask, indicating which values are valid.""" values: tf.Tensor mask: tf.Tensor def __validate__(self): self.values.shape.assert_is_compatible_with(self.mask.shape) assert self.mask.dtype.is_bool, 'mask.dtype must be bool' try: MaskedTensor([1, 2, 3], [0, 1, 0]) # Wrong `dtype` for mask. except AssertionError as e: print(f"Got expected AssertionError: {e}") try: MaskedTensor([1, 2, 3], [True, False]) # shapes don't match. except ValueError as e: print(f"Got expected ValueError: {e}") Piespiedu nemainīgums Pārspīlējiet to un metodes, lai novērstu mutāciju, nodrošinot, ka paplašinājuma tipa vērtības ir nemainīgas. ExtensionType __setattr__ __delattr__ mt = MaskedTensor([1, 2, 3], [True, False, True]) try: mt.mask = [True, True, True] except AttributeError as e: print(f"Got expected AttributeError: {e}") try: mt.mask[0] = False except TypeError as e: print(f"Got expected TypeError: {e}") try: del mt.mask except AttributeError as e: print(f"Got expected AttributeError: {e}") Nosaukums TypeSpec Katrs Klasē ir atbilstība klases, kas tiek izveidota automātiski un saglabāta kā . ExtensionType TypeSpec .Spec Šī klase uztver visu informāciju no vērtības par jebkādiem nested tensors vērtībām. jo īpaši, ka vērtība tiek izveidota, aizstājot jebkuru iebūvēto Tensor, ExtensionType vai CompositeTensor ar . Izņemot TypeSpec TypeSpec class Player(tf.experimental.ExtensionType): name: tf.Tensor attributes: Mapping[str, tf.Tensor] anne = Player("Anne", {"height": 8.3, "speed": 28.1}) anne_spec = tf.type_spec_from_value(anne) print(anne_spec.name) # Records `dtype` and `shape`, but not the string value. print(anne_spec.attributes) # Records keys and TensorSpecs for values. vērtības var būt skaidri konstruētas, vai arī tās var būt izveidotas no Izmantošanas vērtība : TypeSpec ExtensionType tf.type_spec_from_value spec1 = Player.Spec(name=tf.TensorSpec([], tf.float32), attributes={}) spec2 = tf.type_spec_from_value(anne) s izmanto TensorFlow, lai sadalītu vērtības a un a : TypeSpec static component dynamic component Statiskā sastāvdaļa (kas ir fiksēta grafiskās konstrukcijas laikā) ir kodēta ar tf.TypeSpec. Dinamiskais komponents (kas var mainīties katru reizi, kad tiek palaists grafiks) tiek kodēts kā tf.Tensors saraksts. Piemēram, atskaņo savu iesaiņoto funkciju, kad argumentam ir iepriekš neredzams : tf.function TypeSpec @tf.function def anonymize_player(player): print(" >") return Player(" ", player.attributes) # Function gets traced (first time the function has been called): anonymize_player(Player("Anne", {"height": 8.3, "speed": 28.1})) # Function does NOT get traced (same TypeSpec: just tensor values changed) anonymize_player(Player("Bart", {"height": 8.1, "speed": 25.3})) # Function gets traced (new TypeSpec: keys for attributes changed): anonymize_player(Player("Chuck", {"height": 11.0, "jump": 5.3})) Lai iegūtu vairāk informācijas, skatiet . tf.funkcijas rokasgrāmata Customizēt s ExtensionType Paplašinātājs Papildus vienkāršai lauku deklarēšanai un to veidiem paplašinājuma veidi var: Pārrakstiet noklusējuma drukājamo attēlu (__repr__). Definējiet metodes Definējiet klases metodes un statiskās metodes. Definējiet īpašumus Pārrakstiet noklusējuma konstruktoru (__init__). Pārrakstiet noklusējuma vienlīdzības operatoru (__eq__). Definējiet operatorus (piemēram, __add__ un ). Deklarējiet lauku noklusējuma vērtības. Definējiet apakškategorijas. Nospiediet noklusējuma drukājamo attēlu Jūs varat pārvērst šo noklusējuma virknes konversijas operatoru attiecībā uz paplašinājuma veidiem. klases, lai radītu lasāmāku virknes attēlu, kad vērtības tiek drukātas Eager režīmā. MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): """A tensor paired with a boolean mask, indicating which values are valid.""" values: tf.Tensor mask: tf.Tensor # shape=values.shape; false for invalid values. def __repr__(self): return masked_tensor_str(self.values, self.mask) def masked_tensor_str(values, mask): if isinstance(values, tf.Tensor): if hasattr(values, 'numpy') and hasattr(mask, 'numpy'): return f' ' else: return f'MaskedTensor(values={values}, mask={mask})' if len(values.shape) == 1: items = [repr(v) if m else '_' for (v, m) in zip(values, mask)] else: items = [masked_tensor_str(v, m) for (v, m) in zip(values, mask)] return '[%s]' % ', '.join(items) mt = MaskedTensor(values=[[1, 2, 3], [4, 5, 6]], mask=[[True, True, False], [True, False, True]]) print(mt) Metodisko definīciju Paplašinājuma veidi var definēt metodes, tāpat kā jebkura normāla Python klase. Tipi var definēt a metodi, kas atgriež kopiju no ar maskētām vērtībām, kuras aizstāj ar noteiktu vērtību.Metodes var papildināt ar Dekoratīvie . MaskedTensor with_default self default @tf.function class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def with_default(self, default): return tf.where(self.mask, self.values, default) MaskedTensor([1, 2, 3], [True, False, True]).with_default(0) Definīcija S un s classmethod staticmethod Paplašinājuma veidi var definēt metodes, izmantojot un dekoratīvie materiāli, piemēram, Tips var definēt rūpnīcas metodi, kas maskē jebkuru elementu ar noteiktu vērtību: @classmethod @staticmethod MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def __repr__(self): return masked_tensor_str(self.values, self.mask) @staticmethod def from_tensor_and_value_to_mask(values, value_to_mask): return MaskedTensor(values, values != value_to_mask) x = tf.constant([[1, 0, 2], [3, 0, 0]]) MaskedTensor.from_tensor_and_value_to_mask(x, 0) Īpašuma definīcija Paplašinājuma veidi var definēt īpašības, izmantojot kā jebkuru normālu Python klasi, piemēram, Tipi var definēt a Īpašums, kas ir īssavienojums ar No šīm vērtībām: @property MaskedTensor dtype dtype class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor @property def dtype(self): return self.values.dtype MaskedTensor([1, 2, 3], [True, False, True]).dtype Izvēlieties noklusējuma konstruktoru Pielāgotiem konstruktoriem ir jānosaka vērtība katram deklarētajam laukam, un pēc tam, kad pielāgots konstruktors atgriežas, visi lauki tiks pārbaudīti, un vērtības tiks pārvērstas, kā aprakstīts iepriekš. class Toy(tf.experimental.ExtensionType): name: str price: tf.Tensor def __init__(self, name, price, discount=0): self.name = name self.price = price * (1 - discount) print(Toy("ball", 5.0, discount=0.2)) # On sale -- 20% off! Alternatīvi, jūs varat apsvērt iespēju atstāt noklusējuma konstruktoru kā, bet pievienojot vienu vai vairākas rūpnīcas metodes. class Toy(tf.experimental.ExtensionType): name: str price: tf.Tensor @staticmethod def new_toy_with_discount(name, price, discount): return Toy(name, price * (1 - discount)) print(Toy.new_toy_with_discount("ball", 5.0, discount=0.2)) Saskaņā ar likuma “Par nekustamā īpašuma nodokļa atvieglojumiem” ( ) __eq__ Jūs varat novērst defektu operators paplašinājuma veidiem. sekojošais piemērs tiek atjaunināts Nepievērst uzmanību maskētiem elementiem, salīdzinot vienlīdzību. __eq__ MaskedTensor class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor def __repr__(self): return masked_tensor_str(self.values, self.mask) def __eq__(self, other): result = tf.math.equal(self.values, other.values) result = result | ~(self.mask & other.mask) return tf.reduce_all(result) x = MaskedTensor([1, 2, 3, 4], [True, True, False, True]) y = MaskedTensor([5, 2, 0, 4], [False, True, False, True]) print(x == y) Piezīme: Jums parasti nav nepieciešams pārrādīt , jo tā noklusējuma īstenošana vienkārši izsauc __eq__ un noliedz rezultātu. Piezīme: Jums parasti nav nepieciešams pārrādīt , jo tā noklusējuma īstenošana vienkārši izsauc __eq__ un noliedz rezultātu. Izmantojiet nākamās atsauces Ja lauka tips vēl nav definēts, varat izmantot virkni, kas satur tipa nosaukumu. Tiek izmantots, lai atzīmētu Teritorija, jo Vēl nav (pilnībā) noteikts veids. "Node" children Node class Node(tf.experimental.ExtensionType): value: tf.Tensor children: Tuple["Node", ...] = () Node(3, [Node(5), Node(2)]) Subklases definīcija Paplašinājuma veidus var apakšklasificēt, izmantojot standarta Python sintaksi. Paplašinājuma tipa apakšklases var pievienot jaunus laukus, metodes un īpašības; un var pārklasificēt konstruktoru, drukājamo attēlu un vienlīdzības operatoru. Klases, kas izmanto trīs laukus, lai kodētu malu kopumu starp mezgliem. Tas pēc tam definē apakšklasi, kas pievieno laukums, lai ierakstītu "funkcijas vērtību" katram mezglam. apakšklase arī definē metodi funkcijas vērtību izplatīšanai gar malām. TensorGraph Tensor Tensor class TensorGraph(tf.experimental.ExtensionType): num_nodes: tf.Tensor edge_src: tf.Tensor # edge_src[e] = index of src node for edge e. edge_dst: tf.Tensor # edge_dst[e] = index of dst node for edge e. class TensorGraphWithNodeFeature(TensorGraph): node_features: tf.Tensor # node_features[n] = feature value for node n. def propagate_features(self, weight=1.0) -> 'TensorGraphWithNodeFeature': updates = tf.gather(self.node_features, self.edge_src) * weight new_node_features = tf.tensor_scatter_nd_add( self.node_features, tf.expand_dims(self.edge_dst, 1), updates) return TensorGraphWithNodeFeature( self.num_nodes, self.edge_src, self.edge_dst, new_node_features) g = TensorGraphWithNodeFeature( # Edges: 0->1, 4->3, 2->2, 2->1 num_nodes=5, edge_src=[0, 4, 2, 2], edge_dst=[1, 3, 2, 1], node_features=[10.0, 0.0, 2.0, 5.0, -1.0, 0.0]) print("Original features:", g.node_features) print("After propagating:", g.propagate_features().node_features) Privāto lauku definēšana Paplašinājuma tipa lauki var tikt atzīmēti kā privāti, nosakot tos ar apakšpunktu (seko standarta Python konvencijām). Tas neietekmē to, kā TensorFlow jebkādā veidā izturas pret laukiem; tas vienkārši kalpo kā signāls jebkuriem paplašinājuma tipa lietotājiem, ka šie lauki ir privāti. Pielāgojiet to S ir ExtensionType TypeSpec Katrs Klasē ir atbilstība klases, kas tiek izveidota automātiski un saglabāta kā Lai iegūtu vairāk informācijas, skatiet sadaļu “Nested TypeSpec” iepriekš. ExtensionType TypeSpec .Spec Lai pierastu pie , vienkārši definējiet savu nested klases nosaukumu un Tas tiks izmantots kā pamats automātiski izveidotajam Jūs varat pielāgot to No klases līdz: TypeSpec Spec ExtensionType TypeSpec Spec Nospiediet noklusējuma drukājamo attēlu. Izvēlieties defektīvo konstruktoru. Definēt metodes, klases metodes, statiskās metodes un īpašības. Nākamais piemērs norāda uz Klases, lai padarītu to vieglāk izmantot: MaskedTensor.Spec class MaskedTensor(tf.experimental.ExtensionType): values: tf.Tensor mask: tf.Tensor shape = property(lambda self: self.values.shape) dtype = property(lambda self: self.values.dtype) def __repr__(self): return masked_tensor_str(self.values, self.mask) def with_values(self, new_values): return MaskedTensor(new_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) def __repr__(self): return f"MaskedTensor.Spec(shape={self.shape}, dtype={self.dtype})" shape = property(lambda self: self.values.shape) dtype = property(lambda self: self.values.dtype) Piezīme.: Pielāgotā Spec klase var neizmantot nevienu instances mainīgo, kas netika deklarēts sākotnējā ExtensionType. Piezīme.: Pielāgotā Spec klase var neizmantot nevienu instances mainīgo, kas netika deklarēts sākotnējā ExtensionType. 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