TensorFlow's Most Underrated Feature - Extension Types සමඟ වඩාත් බුද්ධිමත් ආකෘති ගොඩනැගීම

Content සමාලෝචන Tensor API සැපයුම තනි API සඳහා Dispatch සියලුම unary elementwise API සඳහා Dispatch BINARY ALL ELEMENTVISELY APIs සඳහා Dispatch Batchable දිගුකාලීන BatchableExtensionType උදාහරණයක්: Network ExtensionTypes සහතික කරන TensorFlow API @tf.සංස්කරණය Flow Control ක්රියාකාරකම් Autograph Control Flow කිරීම කැරැල්ල සුරතල් දත්ත Tensor API සැපයුම Extension types can be "tensor-like", meaning that they specialize or extend the interface defined by the tensor-like interface. උදාහරණයක් ලෙස Tensor-like extension types , සහ TensorFlow මෙහෙයුම් වල මූලික හැසිරීම TensorFlow වැනි ප්රතිපත්තිය වර්ග වලට යෙදුන විට පරාසය කිරීමට භාවිතා කළ හැක.TensorFlow දැනට ප්රතිපත්තිය ප්රතිපත්තිය ප්රතිපත්තිය තුනක් සකස් කරයි: tf.Tensor RaggedTensor SparseTensor MaskedTensor Decorator ප්රදර්ශන Decorator ප්රදර්ශන @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) තනි API සඳහා Dispatch ඒ නිශ්චිත TensorFlow ක්රියාකාරීතාවයේ මූලික හැසිරීම, නිශ්චිත අත්සන් සහිතව ඇමතුමක් ලැබෙන විට, decorator විසින් නොසලකා හැරෙනු ඇත. ක් රියාවලිය විය යුතුය වටිනාකම : 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)) මේ අනුව, default implementation for කියා සැමටම ආරාධනා කළ; වටිනාකම (Thanks to the ප් රශ්නය සටහන් කර ඇත with ) : 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]) ඉඩ දෙන්න ලැයිස්තුවක් හුවමාරු කිරීම සඳහා සහ අගය, ඔබ ඒ සඳහා වර්ගීකරණ ප්රවේශය වර්ගීකරණය කළ හැකිය ප්රමාණයන් සහ නිවැරදිව ක්රියාකාරකම් ශරීරය යාවත්කාලීන කිරීම: 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]) පාවිච්චි කළ හැකි API ලැයිස්තුවක් සඳහා, API ලැයිස්තුව බලන්න. . tf.experimental.dispatch_for_api සියලුම unary elementwise API සඳහා Dispatch ඒ ඩෙංගු හැසිරීම විවේචනය කිරීම unary elementwise ops (එවැනි ආකාරයට ) පළමු අමුද්රව්ය සඳහා වටිනාකම (සමහර විට නම (Type Annotation එක ගැලපෙනවා Decorated function යනු ප්රශ්න දෙකක් විය යුතුය: tf.experimental.dispatch_for_unary_elementwise_apis සියලු tf.math.cos x x_type සියලු api_func: තනි ප්රමාණයක් ගනිමින් elementwise මෙහෙයුම සිදු කරන කාර්යය (උදාහරණයක් ලෙස tf.abs). x: Elementwise මෙහෙයුම සඳහා පළමු ප්රශ්නය. පහත දැක්වෙන උදාහරණයේ සියලුම unary elementwise ක්රියාකාරකම් යාවත්කාලීන වේ. වර්ගය : 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) මෙම කාර්යය දැන් භාවිතා කරනු ඇත සෑම අවස්ථාවකදීම unary elementwise ක්රියාකාරකම් මත ඇමතුමක් . MaskedTensor x = MaskedTensor([1, -2, -3], [True, False, True]) print(tf.abs(x)) print(tf.ones_like(x, dtype=tf.float32)) BINARY ALL ELEMENTVISELY APIs සඳහා Dispatch එසේම, සියලුම binary elementwise ක්රියාකාරකම් යාවත්කාලීන කිරීම සඳහා භාවිතා කළ හැකිය වර්ගය : 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) ප් රචණ්ඩත්වය සිදුවේ, නමුත් අපි පාපයට එරෙහිව ශුද්ධ විනිශ්චය සහ අපි පුද්ගලිකව අකමැති අයට එරෙහි වන පුරපැම අතර වෙනස අප හඳුනාගත යුතුය, එය උඩඟුකමේ අනිවාර්ය ප් රතිපලයයි (ගීතාවලිය 73). සහ . tf.experimental.dispatch_for_unary_elementwise_apis tf.experimental.dispatch_for_binary_elementwise_apis බෝට්ටු s ExtensionType පුළුල් කිරීම ඇන් ද තනි උදාහරණයක් වටිනාකමක් රැස්වීම සඳහා භාවිතා කළ හැක්කේ නම් සාමාන් යයෙන්, මෙම ප්රමාණයන් සියලුම නඩත්තු කර ඇති කොටස් ප්රමාණයන් එකතු කිරීමෙන් ලබා ගත හැකිය. s. පහත දැක්වෙන TensorFlow API වලට අවශ් ය වන්නේ ඕනෑම ආකෘති වර්ගයේ ආදායමක් පැටවුම් කළ හැකි බවයි: ExtensionType බෝට්ටු Tensor tf.data.Dataset (batch, unbatch, from_tensor_slices) - පරිගණක සංකේතය tf.keras (fit, evaluate, predict) – අනුකූලව, අනුකූලව, අනුකූලව මෘදුකාංගය_fn අසාමාන් ය ලෙස, සෑම අංගයක්ම සකස් කිරීමෙන් පැටවුම් වටිනාකම් නිර්මාණය කරයි එස් , s, සහ s. මෙය ඔබේ පන්තිය සඳහා සුදුසු නොවේ නම්, ඔබ භාවිතා කළ යුතුය උදාහරණයක් වශයෙන්, මෙම මෘදුකාංගයක් නිර්මාණය කිරීම සුදුසු නැත. තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි තනි , සහ ක්ෂේත්ර - බොහෝ අවස්ථාවලදී, ඔබ මෙම tensors තැබිය නොහැක, ඔවුන් අනුකූල නොවන ආකෘති ඇති නිසා; ඔබ කළ හැකි වුණත්, ප්රතිඵල සාධාරණ නොවේ . BatchableExtensionType Tensor CompositeTensor ExtensionType tf.experimental.ExtensionTypeBatchEncoder tf.SparseTensor values indices dense_shape SparseTensor සටහන: BatchableExtensionTypes ස්වයංක්රීයව tf.stack, tf.concat, tf.slice ආදිය සඳහා විනිශ්චයකරුවන් සකස් නොකරයි.If your class needs to be supported by these APIs, then use the dispatch decorators described above. දෝ ස්වයංක්රීයව Defines Dispatchers for , , , ආදිය.ඔබේ පන්තියේ මෙම API වලින් සහාය ලබා ගත යුතු නම්, ඉහත විස්තර කරන ලද ප් රවාහන decorators භාවිතා කරන්න. Note: BatchableExtensionType නෑ tf.stack tf.concat tf.slice උදාහරණයක් : BatchableExtensionType Network උදාහරණයක් ලෙස, සරල load balancing සඳහා භාවිතා කරන පන්තිය, කොපමණ රැකියාවක් සෑම නඩුවක සිදු කිරීමට ඉතිරි වන අතර, කොපමණ bandwidth එකක රැකියාව මාරු කිරීම සඳහා ලබා ගත හැකිද: 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]]) මෙම වර්ගය batchable කිරීම සඳහා, පදනම වර්ගය වෙනස් කරන්න , සහ ඕනෑම ක්ෂේත්රයේ ප්රමාණයන් ඇතුළත් කිරීම සඳහා සෑම ක්ෂේත්රයේ ආකෘතිය අනුකූල කරන්න. මේ පින්තූරයේ පින්තූරයේ පින්තූරයේ පින්තූරයේ පින්තූරය.This ක්ෂේත් රය අවශ් ය නැත හෝ නමුත් එය අවශ් යතා . BatchableExtensionType shape shape tf.data.Dataset tf.map_fn ද 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}") එවිට ඔබට භාවිතා කළ හැක අන්තර්ජාලයක් හරහා සන්නිවේදනය කිරීම සඳහා: 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}") ඔබ ද භාවිතා කළ හැක සෑම කොටස් අංගයක් සඳහා ක්රියාත්මක කිරීම සඳහා: 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 s ExtensionType පුළුල් කිරීම @tf.සංස්කරණය Python කාර්යයන් සඳහා TensorFlow ග්රැෆිස් precalculates වන, ඔබේ TensorFlow කේතයේ කාර්ය සාධනය ප්රමාණයෙන් වැඩි දියුණු කළ හැකිය. Dekorative කාර්යයන් 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) ඔබ පැහැදිලිව සඳහන් කිරීමට අවශ්ය නම් සඳහා , එවිට ඔබ එය භාවිතා කළ හැක extension type's . 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) සැබෑ කාර්යයන් සංකේත ක්රියාකාරකම් විසින් ගොඩනැගිලි කරන තනි traced graphs encapsulate which are built by ප්රමාණය වර්ග ක්රියාකාරකම් සමග විවෘතව භාවිතා කළ හැක. tf.function cf = combine_pastry_features.get_concrete_function(pastry_spec) cf(cookie) Flow Control ක්රියාකාරකම් TensorFlow හි Control-Flow ක්රියාකාරකම් මගින් ප්රතිශත වර්ග සහාය වේ: TF.COND TF නඩුව tf.while_ලෝකය Identity - අනන් යතාව # 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 Control Flow කිරීම Extension types are also supported by control flow statements (විශේෂ ප් රවේශ ප් රවේශ ප් රවේශ වර්ග) (උදාහරණයක් ලෙස, ඊළඟ උදාහරණයට අනුව, ප් රකාශනය සහ ප් රකාශන ස්වයංක්රීයව පරිවර්තනය කරනු ලැබේ සහ Extensions ආකෘති සහාය දක්වන ක්රියාකාරකම් 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))) කැරැල්ල TensorFlow හි උසස් මට්ටමේ API ක්රියාත්මක කිරීම සහ ගැඹුරු ඉගෙනුම් ආකෘති පුහුණු කිරීම සඳහා වේ.විශාල ආකෘති වර්ග Keras ආකෘතියට ආදායම් ලෙස, Keras ආකෘති අතර ප්රවාහනය කළ හැකි අතර, Keras ආකෘති විසින් ආපසු ලබා ගත හැකිය. ටී.කෙරෝ ඔවුන් පැටවුම් කළ යුතුය (අද "Batchable ExtensionTypes" වෙත යන්න). ඒවායේ ක්ෂේත් රයක් හෝ ප් රභේදයක් විය යුතුය. shape[0] නම් කොටස් ප්රමාණය බව අනුමත කර ඇත. ඊළඟ දෙපාර්තමේන්තුවේ උදාහරණ දෙකෙන් පෙන්නුම් කර ගත හැක.The following two subsections give examples showing how extension types can be used with Keras. උදාහරණයක් ලෙස: ජාලය ජාලය ප් රථම උදාහරණයක් ලෙස, සලකා බලමු class defined in the "බැට්චාබේ" s" ඉහත පරිච්ඡේදය, කොන්දේසි අතර load balancing වැඩ සඳහා භාවිතා කළ හැකි. Its definition is repeated here: 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]]]) ඔබ ක්රියාත්මක කරන නව Keras මාලාවක් සකස් කළ හැක එස් 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) එවිට ඔබට සරල ආකෘතිය නිර්මාණය කිරීම සඳහා මෙම මට්ටම් භාවිතා කළ හැකිය. උදාහරණයක් ලෙස, ඔබ භාවිතා කළ හැක a Layer සමග Extension type එකකට දාන්න Keras ආකෘතිය පැති පරිශීලක කිරීම සඳහා භාවිතා කරනු ලැබේ නම්, එවිට බැටරි ප් රමාණය ඇතුළත් විය යුතුය. 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(), ]) අවසාන වශයෙන්, ඔබ තනි ජාලය හා ජාල ප්රමාණයක් සඳහා ආකෘතිය භාවිතා කළ හැකිය. model(single_network) model(batch_of_networks) උදාහරණයක් ලෙස: MaskTensor මේ උදාහරණයෙන්, සහාය සඳහා පුළුල් කිරීම එය ගණනය කරන දේපල ලෙස හැඳින්වේ. Keras අවශ්ය වන්නේ ඔබ මෙම ප්රතිලාභය ප්රතිලාභ වර්ගය සහ එහි ප්රතිලාභය දෙකම එකතු කිරීමට ය. ඒ වගේම A defines ඒ සඳහා අවශ් ය වන වෙනස්කම් ශ් රීලනිපය ( පහත දැක්වෙන්නේ 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)) ඊළඟට, ඩෙස්ප්ටොක්ඩෝටර්ස් භාවිතා කරන්නේ විවිධ TensorFlow API වල මූලික හැසිරීම නොසලකා හැරීමයි. මේවා පාවිච්චි කරන්න පුළුවන් නම් අපි මේ පාවිච්චි කරන්න පුළුවන් පාවිච්චි කරන්න පුළුවන්. මේ උදාහරණයට අනුව, masked tensors සඳහා, masked වටිනාකම් zeros ලෙස ප්රතිකාර කිරීම (එනම්, නිෂ්පාදිතය තුළ ඒවා ඇතුළත් නොකිරීම). 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) එවිට ඔබට පිළිගන්නා Keras ආකෘතිය නිර්මාණය කළ හැකිය Standard Keras Layers භාවිතා කිරීම: 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)) සුරතල් A TensorFlow යනු බර සහ පරිගණක දෙකම ඇතුළත් කර ඇති සමීප TensorFlow වැඩසටහනකි. එය Keras ආකෘතියෙන් හෝ Custom ආකෘතියෙන් ගොඩනැගිය හැකිය. සුරතල් SavedModel මගින් ආකෘති, මට්ටම් සහ ආකෘති ගබඩා කළ හැකි අතර, ආකෘති වර්ගවල ආකෘති වර්ගයක් ඇත.SavedModel can save models, layers, and functions that process extension types, as long as the extension types have a මෙම නාමය ප්රතිපත්තිය වර්ගය ලියාපදිංචි කිරීම සඳහා භාවිතා වේ, එබැවින් එය ආකෘතිය උඩුගත කරන විට ස්ථාපනය කළ හැකිය. __name__ උදාහරණයක් ලෙස: Save a Keras model Extension types භාවිතා කරන Keras ආකෘති භාවිතා කළ හැක . 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) උදාහරණයක්: Save a custom model SavedModel ද භාවිතා කළ හැක Custom Save කිරීමට පුළුල් කිරීම් වර්ග ක්රියාත්මක කරන කාර්යයන් සහිත සඟරාවකි. 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])) SavedModel ආලේප කරන විට නොපැමිණිය පුළුල් කිරීම පුළුල් කිරීම ඔබ ලියාපදිංචි වූ විට A මෙය භාවිතා කරන්නේ an නමුත් ඒ ඔබට අනතුරු ඇඟවීමක් ලැබෙන විට, TensorFlow නැවත "නිර්මානුකූල ප්රතිපත්තිය වර්ගය" ක්ෂේත් රයක් භාවිතා කරනු ඇත.මේ ක්ෂේත් රයේ මූලික වර්ගය මෙන්ම ක්ෂේත් රයන් ඇත, නමුත් ඔබ මෙම වර්ගය සඳහා එකතු කර ඇති ඕනෑම තවදුරටත් පෞද්ගලිකත්වයක් නැති වනු ඇත, උදාහරණයක් ලෙස පෞද්ගලික ක්රම හෝ ලක්ෂණ. SavedModel ExtensionType ExtensionType භාවිතය TensorFlow Serving භාවිතා කිරීම පුළුල් කිරීම පුළුල් කිරීම දැනට , (අද SavedModel "කැණවුම්" කථාවේ අනෙකුත් පරිශීලකයින්) සියලු ආදායම් සහ ආදායම් රතු tensors බව අවශ්ය වේ.TensorFlow Serving භාවිතා කරන ආකෘතිය සමඟ භාවිතා කිරීමට ඔබට අවශ් ය නම්, ඔබ ආකෘති වර්ග භාවිතා කරන ආකෘති වලින් ආකෘති වර්ග අගය කිරීම හෝ බෙදා හැරීම සඳහා wrapper ක්රම එකතු කළ හැකිය.උදා: 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 එය ඔබට සරල, නැවත භාවිතා කළ හැකි කොටස් වලින් සංකීර්ණ ප්රතිපත්තිය pipelines ගොඩනඟා ගැනීමට ඉඩ සලසයි. , සෑම අමුද් රව් යයක්ම එක හෝ තවත් අමුද් රව් ය වලින් සමන්විත වන අමුද් රව් ය සංඛ් යාවයි. , representing a sequence of elements, in which each element consists of one or more components. tf.data tf.data.Dataset ගොඩනැගිල්ල s with extension වර්ග දත්ත දත්ත Data sets can be built from extension type values භාවිතා කිරීම , හෝ : 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 සහ Unbatching s with extension වර්ග දත්ත දත්ත Extension types with data sets can be batch and unbatched සහ . 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) මුල් වශයෙන් TensorFlow වෙබ් අඩවියේ ප්රකාශයට පත් කරන ලද මෙම ලිපිය මෙහි නව මාතෘකාවක් යටතේ පෙනී ඇත සහ CC BY 4.0 යටතේ බලපත්රයක් ඇත. මුල් වශයෙන් TensorFlow වෙබ් අඩවියේ ප්රකාශයට පත් කරන ලද මෙම ලිපිය මෙහි නව මාතෘකාවක් යටතේ පෙනී ඇත සහ CC BY 4.0 යටතේ බලපත්රයක් ඇත. TensorFlow TensorFlow