Construir modelos más inteligentes con la característica más subestimada de TensorFlow: tipos de extensiones

Contenido Overview Descargar Tensor API Dispatch para una única API Dispatch para todas las APIs unary elementwise Dispatch para todas las APIs binarias elementales Tipos de extensiones batchables BatchableExtensionType ejemplo: Red API de TensorFlow que admiten ExtensionTypes @tf.función Operaciones de control de flujo Control de flujo de autógrafos Keras Modelo Salvaje Datos Descargar Tensor API Los tipos de extensión pueden ser "tensor-like", en el sentido de que especializan o amplían la interfaz definida por la Exemplos de tipos de extensión similares a tensores incluyen , de , y . el Puede utilizarse para suprimir el comportamiento predeterminado de las operaciones de TensorFlow cuando se aplica a los tipos de extensión similares a los tensores. tf.Tensor RaggedTensor SparseTensor MaskedTensor Descargar Decoradores Descargar Decoradores @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) Dispatch para una única API El el decorador supera el comportamiento predeterminado de una operación TensorFlow especificada cuando se llama con la firma especificada. El proceso debe Los Valores: 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)) Esto supera la aplicación por defecto para Cada vez que se llama con una lista de Los valores (desde el El argumento está anotado con ) de : 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]) Para permitir Gestionar listas de mezclas y valores, puede refinar el tipo de anotación para el parámetro y actualizar el cuerpo de la función de manera apropiada: 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]) Para una lista de APIs que se pueden superponer, consulte la documentación de la API para . tf.experimental.dispatch_for_api Dispatch para todas las APIs unary elementwise El el decorador desvía el comportamiento defectuoso de unary elementwise ops (como ) siempre que el valor para el primer argumento (típicamente llamado ) coincide con el tipo de anotación La función decorada debe tener dos argumentos: tf.experimental.dispatch_for_unary_elementwise_apis todo tf.math.cos x x_type todo api_func: Una función que toma un único parámetro y realiza la operación elemental (por ejemplo, tf.abs). x: El primer argumento de la operación elemental. El siguiente ejemplo actualiza todas las operaciones elementales unarias para manejar el Tipo de: 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) Esta función se utilizará cada vez que se llama una operación elemental unaria en una . MaskedTensor x = MaskedTensor([1, -2, -3], [True, False, True]) print(tf.abs(x)) print(tf.ones_like(x, dtype=tf.float32)) Dispatch para todas las APIs binarias elementales De igual manera, puede ser utilizado para actualizar todas las operaciones binarias elementales para manejar el Tipo de: 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) Para obtener una lista de las APIs elementales que se superponen, vaya a la documentación de la API para y . tf.experimental.dispatch_for_unary_elementwise_apis tf.experimental.dispatch_for_binary_elementwise_apis Batchable s Extensiones Extensiones y es si se puede utilizar una instancia única para representar un lote de valores. Por lo general, esto se logra añadiendo dimensiones de lote a todos los Las siguientes APIs de TensorFlow requieren que cualquier entrada de tipo de extensión sea batchable: ExtensionType Batchable Tensor tf.data.Dataset (batch, unbatch, from_tensor_slices) tf.keras (ajustar, evaluar y predecir) tf.mapa_fn por defecto, crea valores batidos al batir cualquier nido de S, S, y Si esto no es adecuado para su clase, entonces tendrá que usar para superar este comportamiento predeterminado. Por ejemplo, no sería apropiado crear un lote de valores mediante la simple acumulación de tensores escasos individuales , de , y campos - en la mayoría de los casos, no se pueden empacar estos tensores, ya que tienen formas incompatibles; y incluso si se podía, el resultado no sería un valor válido . BatchableExtensionType Tensor CompositeTensor ExtensionType tf.experimental.ExtensionTypeBatchEncoder tf.SparseTensor values indices dense_shape SparseTensor Nota: BatchableExtensionTypes no define automáticamente los dispatchers para tf.stack, tf.concat, tf.slice, etc. Si su clase necesita ser soportada por estas APIs, use los decoratores de dispatch descritos anteriormente. S en Definir automáticamente los dispatchers para , de , de , etc. Si su clase necesita ser soportada por estas APIs, use los decoradores de envío descritos anteriormente. Note: BatchableExtensionType no tf.stack tf.concat tf.slice El ejemplo: BatchableExtensionType Network Por ejemplo, considere una simple clase utilizada para el equilibrio de carga, que rastrea cuánto trabajo queda por hacer en cada nodo, y cuánto ancho de banda está disponible para mover el trabajo entre los nodos: 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]]) Para hacer que este tipo sea batchable, cambie el tipo de base a , y ajuste la forma de cada campo para incluir dimensiones de lote opcionales. para mantener el seguimiento de la forma del batch. este El campo no se requiere de o Pero esto requerido por . BatchableExtensionType shape shape tf.data.Dataset tf.map_fn es 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}") Entonces puedes utilizar Para ir iterando a través de un lote de redes: 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}") También puedes utilizar Para aplicar una función a cada elemento de batch: 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) APIs de TensorFlow que soportan s Extensiones Extensiones @tf.función es un decorador que pre-calcula los gráficos de TensorFlow para las funciones de Python, lo que puede mejorar sustancialmente el rendimiento de su código de TensorFlow. Funciones decorativas. 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) Si desea especificar explícitamente el por , entonces puede hacerlo utilizando el tipo de extensión . 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) Funciones concretas Funciones concretas encapsulan gráficos rastreados individuales que son construidos por Los tipos de extensión se pueden utilizar de forma transparente con funciones concretas. tf.function cf = combine_pastry_features.get_concrete_function(pastry_spec) cf(cookie) Operaciones de control de flujo Los tipos de extensión son compatibles con las operaciones de flujo de control de TensorFlow: TF.Cond TF. el caso tf.while_loop Tf. identidad # 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]) Control de flujo de autógrafos Los tipos de extensión también son compatibles con las declaraciones de flujo de control en (utilizando el autógrafo).En el siguiente ejemplo, el Declaración y Las declaraciones se convierten automáticamente en y operaciones que soportan los tipos de extensión. 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))) Keras es la API de alto nivel de TensorFlow para construir y entrenar modelos de aprendizaje profundo. Los tipos de extensión pueden ser pasados como entradas a un modelo Keras, pasados entre las capas Keras y devueltos por los modelos Keras. Tf. de Keras Deben ser batchables (ir a "Tipos de extensión batchables" arriba). Deben tener un campo o propiedad llamado forma. forma[0] se asume que es la dimensión del lote. Las siguientes dos subsecciones dan ejemplos que muestran cómo se pueden usar los tipos de extensión con Keras. Es un ejemplo: Redes Redes En primer lugar, considere el clase definida en el "Batchable s" sección anterior, que se puede utilizar para el trabajo de equilibrio de carga entre nodos. su definición se repite aquí: 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]]]) Puede definir una nueva capa de Keras que procesa de 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) Puedes usar estas capas para crear un modelo simple. En un modelo, se puede utilizar un Layer con Especifica el tipo de extensión Si el modelo Keras se utilizará para procesar lotes, entonces el Debe incluir la dimensión del batch. 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(), ]) Por último, puede aplicar el modelo a una sola red y a un lote de redes. model(single_network) model(batch_of_networks) Título del libro: MaskedTensor En este ejemplo, Se ha ampliado el soporte . el se define como una propiedad que se calcula a partir de la Keras requiere que agregue esta propiedad tanto al tipo de extensión como a su . el También define a variables, que serán necesarias para de la serie (abajo). 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)) A continuación, los decoratores de envío se utilizan para superponer el comportamiento predeterminado de varias APIs de TensorFlow. Puesto que estas APIs son utilizadas por las capas Keras estándar (como la la capa), superando estos nos permitirá utilizar esas capas con Para los fines de este ejemplo, para tensores enmascarados se define a tratar los valores enmascarados como nulos (es decir, a no incluirlos en el producto). 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) Puedes crear un modelo que acepte Ingresos, utilizando las capas Keras estándar: 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)) Modelo Salvaje a es un programa serializado TensorFlow, que incluye tanto pesos como cálculos. Puede ser construido a partir de un modelo Keras o de un modelo personalizado. En ambos casos, los tipos de extensión se pueden utilizar de forma transparente con las funciones y métodos definidos por un SavedModel. Modelo Salvaje SavedModel puede guardar modelos, capas y funciones que procesan tipos de extensión, siempre que los tipos de extensión tengan una Este nombre se utiliza para registrar el tipo de extensión, por lo que se puede localizar cuando se carga el modelo. __name__ Ejemplo: ahorrar un modelo Keras Los modelos Keras que usan tipos de extensión se pueden guardar utilizando . 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) Ejemplo: guardar un modelo personalizado SavedModel también se puede usar para guardar custom subclases con funciones que procesan tipos de extensión. 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])) Cargar un SavedModel cuando el No está disponible Extensiones Extensiones Si se carga a Esto utiliza un Pero eso no está disponible (es decir, no ha sido importado), entonces recibirá una advertencia y TensorFlow volverá a usar un objeto "tipo de extensión anónimo".Este objeto tendrá los mismos campos que el tipo original, pero carecerá de cualquier otra personalización que haya añadido para el tipo, como métodos o propiedades personalizadas. SavedModel ExtensionType ExtensionType Uso S con TensorFlow Serving Extensiones Extensiones En la actualidad, (y otros consumidores del diccionario "signaturas" de SavedModel) requieren que todas las entradas y salidas sean tensores crudos. Si desea utilizar TensorFlow Serving con un modelo que utiliza tipos de extensión, entonces puede agregar métodos de envuelta que componen o descomponen valores de tipo de extensión de los tensores. TensorFlow Servicio 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 es una API que le permite construir tuberías de entrada complejas a partir de piezas simples y reutilizables. , que representa una secuencia de elementos, en la que cada elemento consiste en uno o más componentes. tf.data tf.data.Dataset Edificio S con tipos de extensión Datos Datos Los conjuntos de datos se pueden construir a partir de valores de tipo de extensión utilizando , de , o : 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 y Unbatching S con tipos de extensión Datos Datos Los conjuntos de datos con tipos de extensión pueden ser batchand y unbatched usando y . 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) Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. TensorFlow TensorFlow

Construir modelos más inteligentes con la característica más subestimada de TensorFlow: tipos de extensiones

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps