TensorFlow Extension Typer förklaras med exempel

Innehållsöversikt Setup Förlängningstyper Stöd för APIs Krav Fälttyper Mutabilitet Funktioner som läggs till av ExtensionType Konstruktör Tryckbar representation Jämställdhetsoperatörer Valideringsmetod tvingad oföränderlighet Föregående TypSpec Anpassning av förlängningstyper Överrätta den standardtryckbara representationen Definition av metoder Definiera klassmetoder och statiska metoder Definiera fastigheter Överrätta standardkonstruktorn Överrätta standard jämställdhetsoperatören (eq) Använda framåt referenser Definition av underklasser Definiera privata fält Anpassa ExtensionType's TypeSpec Setup !pip install -q tf_nightly import tensorflow as tf import numpy as np from typing import Tuple, List, Mapping, Union, Optional import tempfile Förlängningstyper Användardefinierade typer kan göra projekt mer läsbara, modulära och underhållbara. De flesta TensorFlow-API:er har dock mycket begränsat stöd för användardefinierade Python-typer. och och ) och APIs på lägre nivå (såsom och Om TensorFlow kan användas för att skapa användardefinierade objektorienterade typer som fungerar sömlöst med TensorFlows API. För att skapa en förlängningstyp definierar du helt enkelt en Python-klass med som bas, och använda för att specificera typen för varje fält. Keras tf. funktion tf.SavedModel tf.while_loop tf.concat extension types tf.experimental.ExtensionType Typ av anteckningar 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 den Basklassen fungerar på samma sätt som och från standardbiblioteket Python. I synnerhet lägger den automatiskt till en konstruktör och speciella metoder (såsom och ) baserat på fälttyp anteckningar. tf.experimental.ExtensionType typing.NamedTuple @dataclasses.dataclass __repr__ __eq__ Typiskt, förlängning typer tenderar att falla i en av två kategorier: Datastrukturer, som grupperar ihop en samling relaterade värden och kan ge användbara operationer baserade på dessa värden.Datastrukturer kan vara ganska allmänna (som exempel på TensorGraph ovan), eller de kan vara mycket anpassade till en specifik modell. Typer i denna kategori har en rang, en form, och vanligtvis en dtyp; och det är vettigt att använda dem med Tensor-operationer (såsom tf.stack, tf.add, eller tf.matmul). Datastrukturer Tensorliknande typer Stöd för APIs Tilläggstyperna stöds av följande TensorFlow-API: Keras: Förlängningstyper kan användas som ingångar och utgångar för Keras modeller och lager. tf.data.Dataset: Förlängningstyper kan ingå i datasets och returneras av datasetsiterare. TensorFlow Hub: Förlängningstyper kan användas som ingångar och utgångar för tf.hub-moduler. SavedModel: Tilläggstyper kan användas som ingångar och utgångar för SavedModel-funktioner. tf.funktion: Tilläggstyper kan användas som argument och returnerar värden för funktioner som är förpackade med @tf.funktion dekoratorn. Medan loopar: Förlängningstyper kan användas som loopvariabler i tf.while_loop, och kan användas som argument och returvärden för medan-loopens kropp. Villkor: Förlängningstyper kan väljas villkorligt med tf.cond och tf.case. tf.py_function: Extensionstyper kan användas som argument och returnerar värden för funk-argumentet till tf.py_function. Tensor-optioner: Extensionstyper kan utökas till att stödja de flesta TensorFlow-optioner som accepterar Tensor-inmatningar (t.ex. tf.matmul, tf.gather och tf.reduce_sum). Distributionsstrategi: Extensionstyper kan användas som per-replica värden. Mer information finns i avsnittet "TensorFlow API som stöder ExtensionTypes" nedan. Krav Fälttyper Alla fält – instansvariabler – måste deklareras och en typannotation måste tillhandahållas för varje fält. 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 intecknar i: int Python flödar f: float Python strängar s: str Python booleanska b: bool Python är None n: None Tensorns form shape: tf.TensorShape s Tensorn dtype dtype: tf.DType Tensorer t: tf.Tensor Förlängningstyper mt: MyMaskedTensor Spända spänningar rt: tf.RaggedTensor Spara spänningar st: tf.SparseTensor Indexerade skivor s: tf.IndexedSlices Valfria spänningar o: tf.experimental.Optional Typ av fackföreningar int_or_float: typing.Union[int, float] dubbla params: typing.Tuple[int, float, tf.Tensor, int] Var-längd tuplar lengths: typing.Tuple[int, ...] Kartor tags: typing.Mapping[str, tf.Tensor] Valfria värden weight: typing.Optional[tf.Tensor] Mutabilitet Extensionstyper måste vara oföränderliga. Detta säkerställer att de kan spåras på rätt sätt av TensorFlows graf-spårningsmekanismer. Om du befinner dig i behov av att mutera ett extensionstypvärde, överväga istället att definiera metoder som omvandlar värden. Metod för att ändra a Du kan definiera en Metoden som ger en ny : 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) Funktionalitet läggs till av Förlängningstyp Förlängningstyp den Basic Class erbjuder följande funktionalitet: ExtensionType En konstruktör (__init__) En tryckbar representationsmetod (__repr__) jämställdhets- och ojämlikhetsoperatörer (__eq__) En valideringsmetod (__validate__) Den tvingade oföränderligheten. Ett typiskt nötskal. Tensor API Dispatch stöd. Gå till ”Customizing” s" avsnitt nedan för mer information om att anpassa denna funktionalitet. ExtensionType Konstruktör Tillverkaren har lagt till tar varje fält som ett namngivet argument (i den ordning de listades i klassdefinitionen). Denna konstruktör kommer att skriva-kontrollera varje parameter, och konvertera dem där det behövs. fälten konverteras med hjälp av och Fälten omvandlas till s; och fälten omvandlas till oföränderliga dikter. 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) Tillverkaren höjer en Om ett fältvärde inte kan konverteras till den deklarerade typen: TypeError try: MaskedTensor([1, 2, 3], None) except TypeError as e: print(f"Got expected TypeError: {e}") Standardvärdet för ett fält kan anges genom att ställa in dess värde på klassnivån: class Pencil(tf.experimental.ExtensionType): color: str = "black" has_erasor: bool = True length: tf.Tensor = 1.0 Pencil() Pencil(length=0.5, color="blue") Tryckbar representation Lägg till en standardskrivbar representationsmetod ( ) som innehåller klassnamnet och värdet för varje fält: ExtensionType __repr__ print(MaskedTensor(values=[1, 2, 3], mask=[True, True, False])) Jämställdhetsoperatörer tillägg av standardoperatörer för jämställdhet ( och ) som anser att två värden är lika om de har samma typ och alla deras fält är lika. Tensor fält anses vara lika om de har samma form och är elementvis lika för alla element. 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}") Obs!: Om något fält innehåller en Tensor, kan __eq__ returnera en scalar boolean Tensor (i stället för ett Python boolean-värde). Om ett fält innehåller en Och då kan returnera en scalar boolean (I stället för ett Python boolean värde). Note: Tensor __eq__ Tensor Valideringsmetod Lägg till a Den körs efter att konstruktören har kallats och efter att fälten har typkontrollerats och konverterats till sina deklarerade typer, så att den kan anta att alla fält har sina deklarerade typer. ExtensionType __validate__ Följande exempel uppdateringar För att validera den S och S av sina områden: 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}") tvingad oföränderlighet Överträffar den och metoder för att förhindra mutationer, vilket säkerställer att värdena för förlängningstypen är oföränderliga. 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}") Föregående TypSpec Varje Klassen har en motsvarande klass, som skapas automatiskt och lagras som . ExtensionType TypeSpec .Spec Denna klass fångar all information från ett värde för värdena för alla nestade tensorer. i synnerhet, den för ett värde skapas genom att ersätta någon inbäddad Tensor, ExtensionType eller CompositeTensor med . Förutom 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ärden kan konstrueras explicit, eller de kan byggas från en Värde att använda : TypeSpec ExtensionType tf.type_spec_from_value spec1 = Player.Spec(name=tf.TensorSpec([], tf.float32), attributes={}) spec2 = tf.type_spec_from_value(anne) s används av TensorFlow för att dela upp värden i en och a : TypeSpec static component dynamic component Den statiska komponenten (som är fast vid grafkonstruktionstid) kodas med en tf.TypeSpec. Den dynamiska komponenten (som kan variera varje gång grafen körs) kodas som en lista över tf.Tensors. Till exempel, spårar sin förpackade funktion när ett argument har en tidigare osynlig : 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})) För mer information, se den . tf.funktion guide Anpassar sig s ExtensionType Förlängningstyp Förutom att helt enkelt deklarera fält och deras typer kan tilläggstyper: Överrida den standardskrivbara representationen (__repr__). Definition av metoder. Definiera klassmetoder och statiska metoder. Definiera egenskaper . Överrätta standardkonstruktorn (__init__) Överrätta standard jämställdhetsoperatören (__eq__). Definiera operatörer (såsom __add__ och ). Deklarera standardvärden för fält. Definition av underklasser. Överrätta den standardtryckbara representationen Du kan överrätta den här standardsträngkonverteringsoperatören för tilläggstyper. Följande exempel uppdaterar klass för att generera en mer läsbar strängrepresentation när värden skrivs ut i Eager-läge. 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) Definition av metoder Extensionstyper kan definiera metoder, precis som någon vanlig Python-klass. Typ kan definiera a metod som returnerar en kopia av med maskerade värden ersatta av en given värde. Metoder kan alternativt antecknas med och dekoratör. 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) Definiera S och s classmethod staticmethod Förlängningstyper kan definiera metoder som använder och dekoratörer. till exempel, den Typ kan definiera en fabriksmetod som maskerar något element med ett givet värde: @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) Definiera fastigheter Förlängningstyper kan definiera egenskaper med hjälp av en dekoratör, precis som alla vanliga Python-klasser. Typ kan definiera a Fastigheten som är en förkortning för av de värderingar: @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 Överrätta standardkonstruktorn Anpassade konstruktörer måste ställa in ett värde för varje deklarerat fält, och efter att anpassade konstruktören returnerar alla fält skrivs in och värdena konverteras enligt beskrivningen ovan. 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! Alternativt kan du överväga att lämna standardkonstruktorn som-är, men lägga till en eller flera fabriksmetoder. 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)) Överrätta den standardiserade jämställdhetsoperatören ( ) __eq__ Du kan överbrygga default Operatör för förlängningstyper. Följande exempel uppdaterar att ignorera maskerade element när man jämför för jämställdhet. __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) Obs!: Du behöver i allmänhet inte överrida , eftersom dess standardimplementering helt enkelt kallar __eq__ och förnekar resultatet. Obs!: Du behöver i allmänhet inte överrida , eftersom dess standardimplementering helt enkelt kallar __eq__ och förnekar resultatet. Använda framåt referenser Om typen för ett fält inte har definierats ännu kan du använda en sträng som innehåller namnet på typen i stället. Används för att notera fältet eftersom den Typen har ännu inte (fullständigt) definierats. "Node" children Node class Node(tf.experimental.ExtensionType): value: tf.Tensor children: Tuple["Node", ...] = () Node(3, [Node(5), Node(2)]) Definition av underklasser Utökningstyper kan underklassificeras med hjälp av standard Python-syntaxen. Utökningstypsunderklasser kan lägga till nya fält, metoder och egenskaper; och kan överrätta konstruktören, den utskrivbara representationen och jämställdhetsoperatören. Klass som använder tre fält för att koda en uppsättning kanter mellan noder. Den definierar sedan en underklass som lägger till en fältet för att registrera ett "funktionsvärde" för varje nod. Underklassen definierar också en metod för att sprida funktionsvärdena längs kanterna. 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) Definiera privata fält Fälten för en förlängningstyp kan markeras privat genom att prefixera dem med en underscore (i enlighet med standard Python-konventioner). Detta påverkar inte hur TensorFlow behandlar fälten på något sätt, men fungerar helt enkelt som en signal till alla användare av förlängningstypen att dessa fält är privata. Anpassa den och s ExtensionType TypeSpec Varje Klassen har en motsvarande klass, som skapas automatiskt och lagras som För mer information, se avsnittet "Nested TypeSpec" ovan. ExtensionType TypeSpec .Spec För att anpassa den , helt enkelt definiera din egen fäst klass som heter och kommer att användas som grund för den automatiskt byggda Du kan anpassa den Klasser av : TypeSpec Spec ExtensionType TypeSpec Spec Överskridande av standardtryckbar representation. Överrätta den defekta konstruktören. Definiera metoder, klassmetoder, statiska metoder och egenskaper. Följande exempel uttrycker den Klass för att göra det lättare att använda: 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) Obs!: Den anpassade Spec-klassen kan inte använda några instansvariabler som inte deklarerades i den ursprungliga ExtensionType. Den sedvänja En klass kan inte använda några instansvariabler som inte deklarerades i originalet. . Note: Spec ExtensionType Ursprungligen publicerad på TensorFlow-webbplatsen, visas den här artikeln här under en ny rubrik och är licensierad under CC BY 4.0. Ursprungligen publicerad på TensorFlow-webbplatsen, visas den här artikeln här under en ny rubrik och är licensierad under CC BY 4.0. Tensorflöde Tensorflöde

TensorFlow Extension Typer förklaras med exempel

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps