TensorFlow extension mga uri na inilarawan sa mga halimbawa

Paglalarawan ng Content ang setup mga extension Pagbibigay ng APIs Mga Requirements mga field Mutabilidad Funksyonal na idinagdag ng ExtensionType ang konstruktor Impresyon ng representasyon Mga Operator ng Equality Ang Validation Method Mga Immutabilidad Tungkol sa TypeSpec Paglalarawan ng mga extension Pumunta ang default printable representation Mga Metodiko Paglalarawan ng mga class methods at staticmethods Definisyon ng Property Paglalarawan ng default constructor Ipinanganak ang default equality operator (eq) Paggamit ng forward references Paglalarawan ng Subclasses Paglalarawan ng mga private fields I-customize ang ExtensionType's TypeSpec ang setup !pip install -q tf_nightly import tensorflow as tf import numpy as np from typing import Tuple, List, Mapping, Union, Optional import tempfile mga extension Ang mga uri ng user-defined ay maaaring gumawa ng mga proyekto na mas mabuti, modular, mabuti. Gayunpaman, ang karamihan ng TensorFlow APIs ay may napaka-limit na suporta para sa user-defined Python types. na ang na ang Ang mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod ( at ang ang tensorflow Dapat gamitin ang mga user-defined object-oriented types na gumagana sa TensorFlow's APIs. Upang bumuo ng isang extension type, basahin lamang ang isang Python class na may Ang base, at ang paggamit I-specify ang type para sa bawat field. Mga Keras Mga Function tf.SavedModel tf.while_loop tf.concat extension types tf.experimental.ExtensionType Mga Anotasyon 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 ang Basic class ay gumagana tulad ng at ang mula sa standard na library ng Python. Halimbawa, itinatag ito ng isang constructor at mga espesyal na mga paraan (tulad ng at ang ) batay sa field type annotations. tf.experimental.ExtensionType typing.NamedTuple @dataclasses.dataclass __repr__ __eq__ Karaniwang, ang mga uri ng extension ay nagtatagumpay sa isa sa dalawang kategorya: Ang mga data structures, na nag-agrupo ng isang koleksyon ng mga katulad na mga halaga, at maaaring magbibigay ng mga gumagamit na operasyon batay sa mga halaga na ito. Ang data structures ay maaaring maging malaki na pangkalahatang (tulad ng halimbawa ng TensorGraph sa itaas); o ang mga ito ay maaaring maging mataas na customized sa isang espesyal na modelo. Ang mga uri ng kategorya na ito ay may isang rank, isang shape, at karaniwang isang dtype; at ito ay makakalimutan upang gamitin ang mga ito sa mga operasyon ng Tensor (tulad ng tf.stack, tf.add, o tf.matmul). MaskedTensor at CSRSparseMatrix ay mga halimbawa ng tensor-like types. Mga Data Structures Mga Tipo ng Tensor Pagbibigay ng APIs Ang mga uri ng extension ay sumusuporta sa pamamagitan ng mga sumusunod na TensorFlow APIs: Keras: Ang mga uri ng extension ay maaaring gamitin bilang mga input at outputs para sa Keras Models at Layers. tf.data.Dataset: Ang mga uri ng extension ay maaaring magagamit sa Datasets, at ibalik sa pamamagitan ng dataset Iterators. TensorFlow Hub: Ang mga uri ng extension ay maaaring gamitin bilang mga input at output para sa tf.hub modules. SavedModel: Ang mga uri ng extension ay maaaring gamitin bilang mga input at output para sa SavedModel function. tf.function: Ang mga uri ng extension ay maaaring gamitin bilang mga argumento at i-return ang mga halaga para sa mga function na binubuo sa @tf.function decorator. While loops: Ang mga uri ng extension ay maaaring gamitin bilang mga variables ng loop sa tf.while_loop, at maaaring gamitin bilang mga arguments at return na mga halaga para sa body ng while-loop. Conditional: Ang mga uri ng extension ay maaaring conditionally piliin gamit ang tf.cond at tf.case. tf.py_function: Ang mga uri ng extension ay maaaring gamitin bilang mga argumento at ibalik ang mga halaga para sa argumento ng funk sa tf.py_function. Tensor ops: Ang mga uri ng extension ay maaaring i-extend upang suportahan ang karamihan ng TensorFlow ops na sumusuporta sa Tensor inputs (tulad ng tf.matmul, tf.gather, at tf.reduce_sum). Distribution Strategy: Ang mga uri ng extension ay maaaring gamitin bilang mga halaga ng per-replica. Para sa karagdagang detalye, tingnan ang seksyon sa "TensorFlow APIs na sumusuporta sa ExtensionTypes" sa ibaba. Mga Requirements mga field Ang lahat ng mga field—instance variables—mga dapat na-declarate, at ang isang type annotation ay dapat na ibinigay para sa bawat field. Ang mga sumusunod na type annotations ay suportahan: 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] Mga integrator ng Python i: int Python ang mga floats f: float Ang mga strings ng Python s: str Ang mga boolean b: bool ang python None n: None Tungkol sa Shapes shape: tf.TensorShape s Mga Tensor dtype dtype: tf.DType Tungkol sa t: tf.Tensor mga extension mt: MyMaskedTensor Mga Tensioner rt: tf.RaggedTensor Mga Tensioner st: tf.SparseTensor Mga indeksasyon s: tf.IndexedSlices Mga Optional Tensioner o: tf.experimental.Optional Tipo ng mga union int_or_float: typing.Union[int, float] ang ganda params: typing.Tuple[int, float, tf.Tensor, int] Mga pahinang tumuturo lengths: typing.Tuple[int, ...] Mga Mapang tags: typing.Mapping[str, tf.Tensor] Mga Optional Value weight: typing.Optional[tf.Tensor] Mutabilidad Ang mga uri ng extension ay kinakailangan na magiging immutable. Ito ay nagbibigay-daan na ang mga ito ay maaaring matatagpuan sa pamamagitan ng TensorFlow's graph-tracking mechanisms. Kung nais mong i-mutate ang mga halaga ng extension type, tingnan ang paglalarawan ng mga paraan na i-transform ang mga halaga. Ang metriko para sa espasyo-panahong Schwarzschild Pwede kang mag-describe a Ang mga paraan na nagpapakita ng isang bagong : 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) Ang functionality ay idinagdag sa Mga extension Mga extension ang Basic class ay nagbibigay ng mga sumusunod na functionality: ExtensionType Ang isang konstruktor (__init__) Ang isang printable representation method (__repr__) Mga Operator ng Equality at Inequality (__eq__) Ang isang paraan ng pag-validate (__validate__) Ang immutabilidad ay inilagay. Ang isang tipiko. Tensor API dispatch ng suporta. Pumunta sa “Customization” s" seksyon sa ibaba para sa karagdagang impormasyon tungkol sa pag-customize ng functionality na ito. ExtensionType ang konstruktor Ang tagagawa ay idinagdag ng nagtatapos sa tuldok ng mga tauhan ng AIJ na magkaroon ng kaligtasan at proteksiyon. ipatupad ito at ipatupad ito at ipatupad ito. Ang mga field ay konverted sa pamamagitan ng sa pamamagitan ng Ang mga field ay na-convert sa S; at ang Ang mga field ay i-convert sa immutable dicts. 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) Ang konstruktor ay nagtatag ng isang kung ang isang halaga ng field ay hindi maaaring i-convert sa kanyang declared type: TypeError try: MaskedTensor([1, 2, 3], None) except TypeError as e: print(f"Got expected TypeError: {e}") Ang default na halaga para sa isang field ay maaaring i-specify sa pamamagitan ng i-set ang kanyang halaga sa antas ng klase: class Pencil(tf.experimental.ExtensionType): color: str = "black" has_erasor: bool = True length: tf.Tensor = 1.0 Pencil() Pencil(length=0.5, color="blue") Impresyon ng representasyon Ang mga imahe kasama sa loob ng file format ( ) na naglalaman ang pangalan ng klase at ang halaga para sa bawat field: ExtensionType __repr__ print(MaskedTensor(values=[1, 2, 3], mask=[True, True, False])) Mga Operator ng Equality Mga pahinang tumuturo sa pagiging maliliit ( at ang Ang mga Tensor fields ay tinatanggap na katumbas kung may parehong shape at may elemental na katumbas para sa lahat ng mga elemento. 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}") Tandaan: Kung ang anumang field ay naglalaman ng isang Tensor, pagkatapos ay ang __eq__ ay maaaring ibalik ng isang scalar boolean Tensor (hindi ng isang Python boolean halaga). Kung ang isang field ay may isang At pagkatapos May return ang isang scalar boolean (Hindi sa isang Python boolean na halaga). Note: Tensor __eq__ Tensor Ang Validation Method Ipasok sa A Ang metriko para sa espasyo-panahong Schwarzschild na may sistemang koordinatong ( ExtensionType __validate__ Ang mga sumusunod na mga update Para sa Validation S at ang S sa kanyang mga lugar: 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}") Mga Immutabilidad Ipinanganak ang at ang ang mga paraan upang mapagpahiwatig ng mutation, na nagbibigay-daan na ang mga halaga ng extension type ay immutable. 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}") Tungkol sa TypeSpec Lahat ng Ang klase ay may isang corresponding ang klase, na ito ay itinatag na automatically at ibinigay bilang . ExtensionType TypeSpec .Spec Ang klase na ito ay nagpapakita ng lahat ng impormasyon mula sa isang halaga Sa mga mas mababang posisyon ay may mga species ng Eurobond fauna, at ang mga altitude ng bundok ay dumarami sa pagtaas ng altitude. Para sa isang halaga ay nilikha sa pamamagitan ng pagbabago ng anumang naka-incorporated Tensor, ExtensionType, o CompositeTensor sa kanyang . sa loob ng 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. ang mga halaga ay maaaring maging eksplicit, o sila ay maaaring maging binubuo mula sa isang Value ng paggamit : TypeSpec ExtensionType tf.type_spec_from_value spec1 = Player.Spec(name=tf.TensorSpec([], tf.float32), attributes={}) spec2 = tf.type_spec_from_value(anne) TensorFlow ay gumagamit para sa pag-divide ng mga halaga sa isang sa a : TypeSpec static component dynamic component Ang static component (ang na fixed sa graph-construction time) ay na-coded sa pamamagitan ng isang tf.TypeSpec. Ang dynamic component (na maaaring magbabago sa bawat pagkakataon ang graph ay i-execute) ay na-coded bilang isang listahan ng tf.Tensors. Halimbawa, ang Nagtataka kung ano ito ay tungkol sa ako nagpasya, inexplicably, na ang pinakamahusay na bagay na gawin ay, hindi upang tumakbo sa banyo, ngunit upang pumunta sa isang pagmumuni-muni. : 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})) Para sa karagdagang impormasyon, tingnan ang . TF.FUNCTION ng Mga Pangwika Customize ang s ExtensionType Mga extension Bukod sa simpleng declaring ng mga field at ang kanilang mga uri, ang mga uri ng extension ay maaaring: Ipinanganak ang default printable representation (__repr__). Ipasok ang mga methods. Ipinapakita ang mga class methods at static methods. Ipasok ang Property. Pumunta ang default constructor (__init__) Pumunta ang default equality operator (__eq__). Ipasok ang mga operator (tulad ng __add__ at ). I-declarate ang default values para sa mga field. Paglalarawan ng mga subclasses Pumunta ang default printable representation Maaari mong i-override ang default string conversion operator na ito para sa mga uri ng extension. Ang sumusunod na halimbawa ay nag-update ang ang klase upang lumikha ng isang mas mabuti na representasyon ng string kapag ang mga halaga ay inilapat sa Eager mode. 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) Mga Metodiko Ang mga uri ng extension ay maaaring ilagay ang mga paraan, tulad ng anumang normal na klase ng Python. Kung paano gamitin ang a ang isang paraan na ibalik ang isang kopya ng sa mga masked na mga katangian ay nahahati ng isang given Ang mga metriko para sa espasyo-panahong Schwarzschild na may sistemang koordinatong ( ang dekorasyon. 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) Definisyon ng S at ang s classmethod staticmethod Ang mga uri ng extension ay maaaring itakda ang mga paraan na gumagamit ng at ang Mga dekorasyon, tulad ng mga Ang type ay maaaring itinatag ng isang factory method na masks ang anumang elemento na may isang ibig sabihin na halaga: @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) Definisyon ng Property Ang mga uri ng extension ay maaaring i-definite ang mga properties na gumagamit ng ang mga katangian, tulad ng lahat ng normal na klase ng Python. Kung paano gamitin ang a Ang property ay isang shorthand para sa Tungkol sa mga Value: @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 Paglalarawan ng default constructor Ang mga Custom constructors ay dapat i-set ang isang halaga para sa bawat declared field; at pagkatapos ang Custom constructor ay bumalik, ang lahat ng mga field ay tip-checked, at ang mga halaga ay i-convert tulad ng inilarawan sa itaas. 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! Sa alternatibo, maaari mong i-consider ang pagbabago ng default na constructor as-is, ngunit magdagdag ng isa o higit pa ng mga factory na mga paraan. 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)) Pumili ng kategorya, gaya ng mga gasolinahan o grocery store, o maghanap ng partikular na uri ng lugar ( ) __eq__ Maaari mong ibalik ang default Operator para sa mga uri ng extension. Ang mga sumusunod na halimbawa ay na-update Ipinanganak ang mga elementong masked sa pagitan para sa kaligtasan. __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) Note: Sa pangkalahatan, hindi mo na kailangang mag-override , dahil ang default na implementasyon nito lamang ay nag-aalok ng __eq__ at hinihintay ang resulta. Note: Sa pangkalahatan, hindi mo na kailangang mag-override , dahil ang default na implementasyon nito lamang ay nag-aalok ng __eq__ at hinihintay ang resulta. Paggamit ng forward references Kung ang uri para sa isang field ay hindi na defined, maaari mong gamitin ang isang string na naglalaman ng pangalan ng uri. Nagtatapos sa tuldok ang dahil sa field na Hindi ko alam kung ano ang (completely) defined. "Node" children Node class Node(tf.experimental.ExtensionType): value: tf.Tensor children: Tuple["Node", ...] = () Node(3, [Node(5), Node(2)]) Paglalarawan ng Subclasses Ang mga uri ng extension ay maaaring subclassed gamit ang standard Python syntax. Ang mga uri ng extension ay maaaring magdagdag ng mga bagong fields, methods, at properties; at maaaring subclassed ang constructor, ang printable representation, at ang equality operator. Ang sumusunod na halimbawa ay nagpapahiwatig ng isang pangunahing Mga klase na gumagamit ng 3 Ang mga sumusunod ay ang mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod na mga sumusunod. Ang subclass ay naglalaman din ng isang paraan upang pagpapadala ang mga halaga ng feature sa paligid ng mga edges. 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) Paglalarawan ng mga private fields Ang mga field ng isang extension type ay maaaring i-mark private sa pamamagitan ng prefixing ang mga field na ito sa isang sub-score (sipasok sa mga standard na konvensyon ng Python). Ito ay hindi nakakaapekto sa paraan na ang TensorFlow ay nagtatrabaho sa mga field sa anumang paraan; ngunit lamang nagtatrabaho bilang isang signal sa anumang mga gumagamit ng extension type na ang mga field na ito ay private. Customize ang ang mga ExtensionType TypeSpec Lahat ng Ang klase ay may isang corresponding ang klase, na ito ay itinatag na automatically at ibinigay bilang Para sa karagdagang impormasyon, tingnan ang seksyon "Nested TypeSpec" sa itaas. ExtensionType TypeSpec .Spec Para sa customization ng , simula ang iyong sarili nested class na tinatawag na at ang Ito ay ginagamit bilang base para sa automatic construction. Maaari mong i-customize ang Mga klase ng: TypeSpec Spec ExtensionType TypeSpec Spec Ipinanganak ang default printable representation. Ipinanganak ang default constructor. Ipasok ang mga methods, classmethods, staticmethods, at properties. Ang mga sumusunod na halimbawa ay naglalaman ng ang klase upang maging mas madaling gamitin ito: 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) Note: Ang Custom Spec class ay hindi maaaring gamitin ang anumang mga variable ng instance na hindi na-declared sa orihinal na ExtensionType. Note: Ang Custom Spec class ay hindi maaaring gamitin ang anumang mga variable ng instance na hindi na-declared sa orihinal na ExtensionType. Nai-publish sa website ng TensorFlow, 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 website ng TensorFlow, 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 Mga TensorFlow