Budowanie inteligentniejszych modeli z najbardziej niedocenianą funkcją TensorFlow – typami rozszerzeń

Przegląd zawartości Tensor API rozsyłający Przesyłanie do jednego API Wyślij do wszystkich unary elementwise API Dyskusje na temat: binary all elementwise Rodzaje rozszerzeń batchable BatchableExtensionType przykład: Sieć TensorFlow API obsługujące rozszerzenia @tf. funkcja Operacje kontroli przepływu Autograf kontroli przepływu Kerasz Model ratunkowy danych Tensor API rozsyłający Typy rozszerzeń mogą być „tensorowe”, w tym sensie, że specjalizują się lub rozszerzają interfejs zdefiniowany przez Przykłady typów rozszerzeń typu tensor obejmują: , , oraz ... TensorFlow może być używany do zastąpienia domyślnego zachowania operacji TensorFlow, gdy jest stosowany do typów rozszerzeń podobnych do tensorów. tf.Tensor RaggedTensor SparseTensor MaskedTensor Dispatch dekoratorów Dispatch dekoratorów @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) Przesyłanie do jednego API o dekorator pomija domyślne zachowanie określonej operacji TensorFlow, gdy jest wywoływana z określonym podpisem. Na przykład możesz użyć tego dekoratora, aby określić, jak Powinien być proces O wartościach : 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)) Pozwala to na wdrożenie domyślnego Za każdym razem, gdy nazywa się listę wartości (z uwagi na Argumenty są przypisywane ) do : 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]) Aby zezwolić Zarządzanie listami mieszanych i wartości, można udoskonalić typ anotacji dla parametr i odpowiednio zaktualizować ciało funkcji: 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]) Aby uzyskać listę interfejsów API, które można przesunąć, zobacz dokumentację API dla . tf.experimental.dispatch_for_api Wyślij do wszystkich unary elementwise API o dekorator odrzuca domyślne zachowanie unary elementwise ops (takie jak ) zawsze, gdy wartość dla pierwszego argumentu (zazwyczaj nazywa się (zgodne z typem anotacji Funkcja dekoracyjna powinna mieć dwa argumenty: tf.experimental.dispatch_for_unary_elementwise_apis Wszystko tf.math.cos x x_type Wszystko api_func: Funkcja, która bierze jeden parametr i wykonuje operację elementowo (na przykład tf.abs). x: Pierwszy argument do operacji elementarnej. Poniższy przykład aktualizuje wszystkie operacje unary elementwise w celu obsługi Rodzaj : 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) Funkcja ta będzie teraz używana za każdym razem, gdy na . MaskedTensor x = MaskedTensor([1, -2, -3], [True, False, True]) print(tf.abs(x)) print(tf.ones_like(x, dtype=tf.float32)) Dyskusje na temat: binary all elementwise Podobnie można użyć do aktualizacji wszystkich operacji binarnych elementowo, aby zarządzać Rodzaj : 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) Aby uzyskać listę elementarnych interfejsów API, które są przesunięte, przejdź do dokumentacji API dla i . tf.experimental.dispatch_for_unary_elementwise_apis tf.experimental.dispatch_for_binary_elementwise_apis batalionu s ExtensionType Rozszerzenie typu i Jest jeśli pojedynczy przykład może być używany do reprezentowania partii wartości. Zazwyczaj osiąga się to poprzez dodanie wymiarów partii do wszystkich wbudowanych wartości p. Poniższe interfejsy API TensorFlow wymagają, aby wszelkie wejścia typu rozszerzenia były batchable: ExtensionType batalionu Tensor tf.data.Dataset (batch, unbatch, from_tensor_slices) – zestaw danych tf.keras (podać, ocenić i przewidzieć) tf. map_fn W przypadku defektu, tworzy wartości zapasowe poprzez zapasowanie dowolnego zapasowego w s, s i Jeśli nie jest to odpowiednie dla Twojej klasy, będziesz musiał użyć w celu wyeliminowania tego domyślnego zachowania. Na przykład nie byłoby właściwe utworzenie partii wartości poprzez po prostu układanie poszczególnych sparse tensors' , , oraz pola – w większości przypadków nie można nakładać tych tensorów, ponieważ mają one niezgodne kształty; a nawet jeśli można, wynik nie byłby ważny . BatchableExtensionType Tensor CompositeTensor ExtensionType tf.experimental.ExtensionTypeBatchEncoder tf.SparseTensor values indices dense_shape SparseTensor Uwaga: BatchableExtensionTypes nie definiuje automatycznie dystrybutorów dla tf.stack, tf.concat, tf.slice itp. Jeśli Twoja klasa musi być obsługiwana przez te interfejsy API, użyj dekoratorów dystrybucji opisanych powyżej. S do automatycznie definiuje dystrybutorów dla , , , itp. Jeśli Twoja klasa musi być obsługiwana przez te interfejsy API, użyj dekoratorów wysyłki opisanych powyżej. Note: BatchableExtensionType Nie tf.stack tf.concat tf.slice Przykładem jest: BatchableExtensionType Network Przykładem może być prosty klasa używana do bilansowania obciążenia, która śledzi, ile pracy pozostaje do wykonania w każdym węźle i ile pasma jest dostępna do przenoszenia pracy między węzłami: 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]]) Aby uczynić ten typ zbiorczym, zmień typ bazy na , i dostosować kształt każdego pola, aby uwzględnić opcjonalne wymiary partii. w celu utrzymania śladu formy partii. Pole nie jest wymagane lub Ale to Wymagane przez . BatchableExtensionType shape shape tf.data.Dataset tf.map_fn Jest 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}") Następnie możesz użyć aby iterować za pośrednictwem serii sieci: 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}") Możesz również użyć Aby zastosować funkcję do każdego elementu partii: 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, które obsługują s ExtensionType Rozszerzenie typu @tf. funkcja jest dekoratorem, który wstępnie oblicza wykresy TensorFlow dla funkcji Python, co może znacznie poprawić wydajność kodu TensorFlow. Funkcje dekoracyjne . 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) Jeśli chcesz wyraźnie określić dla , możesz to zrobić za pomocą typu rozszerzenia . 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) Konkretne funkcje Konkretne funkcje zawierają poszczególne wykresy śledzone, które są zbudowane przez Typy rozszerzeń mogą być wykorzystywane w sposób przejrzysty z konkretnymi funkcjami. tf.function cf = combine_pastry_features.get_concrete_function(pastry_spec) cf(cookie) Operacje kontroli przepływu Typy rozszerzeń są obsługiwane przez operacje przepływu sterowania TensorFlow: tf. kondycja tf. przypadek tf.w tym czasie_loop tf. tożsamość # 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]) Autograf kontroli przepływu Typy rozszerzeń są również obsługiwane przez wyrażenia przepływu sterowania w (z użyciem autografu) W następującym przykładzie, Oświadczenie oraz Dane są automatycznie konwertowane na i operacje, które obsługują typy rozszerzeń. 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))) Kerasz jest API na wysokim poziomie TensorFlow do budowania i szkolenia modeli głębokiego uczenia się. Typy rozszerzeń mogą być przekazywane jako wejścia do modelu Keras, przekazywane między warstwami Keras i zwracane przez modele Keras. tf. żarówka Muszą być batchable (przejdź do "Batchable ExtensionTypes" powyżej). Muszą mieć pole lub właściwość o nazwie kształt. kształt[0] przyjmuje się jako wymiar partii. Następujące dwie podsekcje przedstawiają przykłady, które pokazują, w jaki sposób typy rozszerzeń można używać z Keras. Przykładem jest: Network Sieć Jako pierwszy przykład należy wziąć pod uwagę klasę zdefiniowaną w „Batchable” s" sekcja powyżej, która może być używana do pracy bilansowania obciążenia między węzłami. 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]]]) Możesz zdefiniować nową warstwę Keras, która w s. 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) Następnie możesz użyć tych warstw, aby utworzyć prosty model. W jednym z modeli możesz użyć Layer z ustawienie na typ rozszerzenia Jeśli model Keras zostanie użyty do przetwarzania partii, to Należy uwzględnić wymiar baterii. 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(), ]) Wreszcie można zastosować model do pojedynczej sieci i do serii sieci. model(single_network) model(batch_of_networks) Tytuł oryginalny: MaskedTensor W tym przykładzie, Rozszerza się na wsparcie ... jest określana jako nieruchomość, która jest obliczana Keras wymaga dodania tej właściwości zarówno do typu rozszerzenia, jak i do jego ... Definicja a Zmiany, które będą wymagane Seryjne wyświetlanie (w dolnej części) 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)) Następnie decoratory dystrybucji są używane do zastąpienia domyślnego zachowania kilku interfejsów API TensorFlow. Ponieważ te interfejsy są używane przez standardowe warstwy Keras (takie jak Umożliwi to nam korzystanie z tych warstw. Dla celów tego przykładu, dla zamaskowanych tensorów definiuje się traktowanie zamaskowanych wartości jako zerów (tj. niewłączenie ich do produktu). 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) Następnie można zbudować model Keras, który akceptuje Wejścia, używając standardowych warstw Keras: 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)) Model ratunkowy a jest serializowanym programem TensorFlow, obejmującym zarówno wagi, jak i obliczenia. Może być zbudowany z modelu Keras lub z modelu niestandardowego. W obu przypadkach typy rozszerzeń mogą być stosowane w sposób przejrzysty z funkcjami i metodami zdefiniowanymi przez SavedModel. Model ratunkowy SavedModel może zapisywać modele, warstwy i funkcje, które przetwarzają typy rozszerzeń, o ile typy rozszerzeń mają Ta nazwa jest używana do rejestrowania typu rozszerzenia, dzięki czemu można go znaleźć podczas ładowania modelu. __name__ Przykład: oszczędzanie modelu Keras Modele Keras, które używają typów rozszerzeń, można zapisać za pomocą . 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) Przykład: oszczędzanie modelu custom SavedModel można również użyć do oszczędzania na zamówienie Podklasy z funkcjami, które przetwarzają typy rozszerzeń. 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])) Ładowanie modelu SavedModel, gdy jest niedostępny Rozszerzenie typu Rozszerzenie typu Jeśli załadujesz a W ten sposób wykorzystuje się Ale to jest niedostępny (tzn. nie został zaimportowany), wtedy otrzymasz ostrzeżenie, a TensorFlow powróci do używania obiektu „anonimowy typ rozszerzenia”. Ten obiekt będzie miał te same pola jak oryginalny typ, ale zabraknie dalszych dostosowania dodanych do tego typu, takich jak metody lub właściwości niestandardowe. SavedModel ExtensionType ExtensionType Używanie Zastosowanie TensorFlow Serving Rozszerzenie typu Rozszerzenie typu W chwili obecnej, (i inni użytkownicy słownika SavedModel "podpisy") wymagają, aby wszystkie wejścia i wyjścia były surowymi tensorami. Jeśli chcesz użyć TensorFlow Serving z modelem, który wykorzystuje typy rozszerzeń, możesz dodać metody wklejania, które tworzą lub rozkładają wartości typu rozszerzenia z tensorów. TensorFlow obsługuje 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 jest API, który pozwala na budowanie złożonych rurociągów wejściowych z prostych, wielokrotnego użytku. , który reprezentuje sekwencję elementów, w której każdy element składa się z jednego lub więcej składników. tf.data tf.data.Dataset Budynek S z typami rozszerzeń Dataset danych Zbiory danych można budować z wartości typu rozszerzenia przy użyciu , , lub : 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 i Unbatching S z typami rozszerzeń danych danych Zbiory danych z typami rozszerzeń mogą być batchand i unbatched przy użyciu i . 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) Pierwotnie opublikowany na stronie internetowej TensorFlow, ten artykuł pojawia się tutaj pod nowym tytułem i jest licencjonowany pod CC BY 4.0. Pierwotnie opublikowany na stronie internetowej TensorFlow, ten artykuł pojawia się tutaj pod nowym tytułem i jest licencjonowany pod CC BY 4.0. TensorFlow TensorFlow