Aumenta la velocidad de entrenamiento de TensorFlow en un 50% con estos trucos de TPU

Contenido Overview Instalación Iniciación a la TPU Instalación manual del dispositivo Estrategias de distribución Clasificación de los TPU Define el modelo de Keras Cargar el Dataset Entrena el modelo utilizando las API de alto nivel de Keras Entrena el modelo utilizando un loop de entrenamiento personalizado Mejora del rendimiento con múltiples pasos dentro de tf.function Próximos pasos Esta guía muestra cómo realizar la formación básica en y TPU Pods, una colección de dispositivos TPU conectados por interfaces de red dedicadas de alta velocidad, con El entrenamiento de los loops. Unidades de Procesamiento de Tensores (TPU) tf.keras Los TPU son los circuitos integrados específicos de la aplicación (ASIC) desarrollados por Google para acelerar las cargas de trabajo de aprendizaje automático. , el , y . Google Colab Nube de Investigación de TPU Nube de TPU Instalación Antes de ejecutar este notebook Colab, asegúrese de que su acelerador de hardware sea un TPU verificando sus configuraciones de notebook: > > > > > > . Runtime Change runtime type Hardware accelerator TPU Importar algunas bibliotecas necesarias, incluidos los conjuntos de datos de TensorFlow: import tensorflow as tf import os import tensorflow_datasets as tfds 2023-06-09 12:13:32.486552: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT Iniciación TPU Los TPU son típicos trabajadores, que son diferentes del proceso local que ejecuta el programa Python del usuario. Por lo tanto, es necesario realizar algún trabajo de inicialización para conectarse al clúster remoto e inicializar las TPU. El argumento Si está ejecutando su código en Google Compute Engine (GCE), debe pasar en su lugar en el nombre de su Cloud TPU. Nube de TPU tpu tf.distribute.cluster_resolver.TPUClusterResolver Nota: El código de inicialización de TPU debe estar en el inicio de su programa. El código de inicialización de TPU debe estar en el inicio de su programa. Note: resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='') tf.config.experimental_connect_to_cluster(resolver) # This is the TPU initialization code that has to be at the beginning. tf.tpu.experimental.initialize_tpu_system(resolver) print("All devices: ", tf.config.list_logical_devices('TPU')) INFO:tensorflow:Deallocate tpu buffers before initializing tpu system. 2023-06-09 12:13:34.011755: E tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:266] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected INFO:tensorflow:Deallocate tpu buffers before initializing tpu system. INFO:tensorflow:Initializing the TPU system: grpc://10.25.167.66:8470 INFO:tensorflow:Initializing the TPU system: grpc://10.25.167.66:8470 INFO:tensorflow:Finished initializing TPU system. INFO:tensorflow:Finished initializing TPU system. All devices: [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')] Instalación manual del dispositivo Después de la inicialización del TPU, puede utilizar la colocación manual del dispositivo para colocar el cálculo en un solo dispositivo TPU: a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) b = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) with tf.device('/TPU:0'): c = tf.matmul(a, b) print("c device: ", c.device) print(c) c device: /job:worker/replica:0/task:0/device:TPU:0 tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32) Estrategias de distribución Normalmente, ejecutas tu modelo en múltiples TPU de una manera paralela a los datos. Para distribuir tu modelo en múltiples TPU (así como en múltiples GPU o máquinas múltiples), TensorFlow ofrece la API. Puede reemplazar su estrategia de distribución y el modelo se ejecutará en cualquier dispositivo dado (TPU). La guía. tf.distribute.Strategy Entrenamiento distribuido con TensorFlow Usando el Las TPUs proporcionan su propia implementación de eficientes operaciones de reducción y otras operaciones colectivas en múltiples núcleos de TPU, que se utilizan en . tf.distribute.TPUStrategy TPUStrategy Para demostrarlo, se crea un El objeto: tf.distribute.TPUStrategy strategy = tf.distribute.TPUStrategy(resolver) INFO:tensorflow:Found TPU system: INFO:tensorflow:Found TPU system: INFO:tensorflow:*** Num TPU Cores: 8 INFO:tensorflow:*** Num TPU Cores: 8 INFO:tensorflow:*** Num TPU Workers: 1 INFO:tensorflow:*** Num TPU Workers: 1 INFO:tensorflow:*** Num TPU Cores Per Worker: 8 INFO:tensorflow:*** Num TPU Cores Per Worker: 8 INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) Para replicar un cálculo para que pueda ejecutarse en todos los núcleos de TPU, puede pasarlo a la API. A continuación se muestra un ejemplo que muestra a todos los núcleos que reciben las mismas entradas y realizar la multiplicación de matriz en cada núcleo de forma independiente. Los resultados serán los valores de todas las réplicas. Strategy.run (a, b) @tf.function def matmul_fn(x, y): z = tf.matmul(x, y) return z z = strategy.run(matmul_fn, args=(a, b)) print(z) PerReplica:{ 0: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 1: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 2: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 3: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 4: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 5: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 6: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 7: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32) } Clasificación de los TPU Después de cubrir los conceptos básicos, considere un ejemplo más concreto.Esta sección demuestra cómo utilizar la estrategia de distribución. para entrenar un modelo Keras en un TPU en la nube. tf.distribute.TPUStrategy Define el modelo de Keras Comienza con una definición de El modelo Keras para la clasificación de imágenes en el conjunto de datos MNIST. No es diferente de lo que usaría si estuviera entrenando en CPUs o GPUs. Tenga en cuenta que la creación del modelo Keras debe estar dentro del , por lo que las variables se pueden crear en cada dispositivo TPU. Otras partes del código no son necesarias para estar dentro del El escopo. Sequential Strategy.scope Strategy def create_model(): return tf.keras.Sequential( [tf.keras.layers.Conv2D(256, 3, activation='relu', input_shape=(28, 28, 1)), tf.keras.layers.Conv2D(256, 3, activation='relu'), tf.keras.layers.Flatten(), tf.keras.layers.Dense(256, activation='relu'), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10)]) Cargar el Dataset El uso eficiente de la La API es crucial cuando se utiliza una TPU en la nube. Puede aprender más sobre el rendimiento del conjunto de datos en la . tf.data.Dataset Guía de rendimiento de la tubería de entrada Si usted está utilizando , debe almacenar todos los archivos de datos leídos por el TensorFlow en Si usted está utilizando , puede almacenar datos donde quiera. Para más información sobre los nodos de TPU y las VM de TPU, consulte el La documentación. Nódulos de TPU Dataset Servicios de almacenamiento en la nube de Google (GCS) Título VMs Arquitectura del sistema TPU Para la mayoría de los casos de uso, se recomienda convertir sus datos en Formatear y utilizar a Para leerlo, compruebe el No es un requisito difícil y puede utilizar otros lectores de conjuntos de datos, como o . TFRecord tf.data.TFRecordDataset TFRecord y tf.Ejemplo tutorial tf.data.FixedLengthRecordDataset tf.data.TextLineDataset Puede cargar pequeños conjuntos de datos enteros a la memoria utilizando . tf.data.Dataset.cache Independientemente del formato de datos utilizado, se recomienda usar archivos grandes en el orden de 100 MB. Esto es especialmente importante en este entorno de red, ya que la capacidad de abrir un archivo es significativamente mayor. Como se muestra en el código de abajo, debe utilizar los conjuntos de datos de Tensorflow módulo para obtener una copia de los datos de entrenamiento y pruebas de MNIST. está especificado para usar una copia que está disponible en un bucket GCS público. Si no especifica esto, el TPU no podrá acceder a los datos descargados. tfds.load try_gcs def get_dataset(batch_size, is_training=True): split = 'train' if is_training else 'test' dataset, info = tfds.load(name='mnist', split=split, with_info=True, as_supervised=True, try_gcs=True) # Normalize the input data. def scale(image, label): image = tf.cast(image, tf.float32) image /= 255.0 return image, label dataset = dataset.map(scale) # Only shuffle and repeat the dataset in training. The advantage of having an # infinite dataset for training is to avoid the potential last partial batch # in each epoch, so that you don't need to think about scaling the gradients # based on the actual batch size. if is_training: dataset = dataset.shuffle(10000) dataset = dataset.repeat() dataset = dataset.batch(batch_size) return dataset Entrena el modelo utilizando las API de alto nivel de Keras Puedes entrenar tu modelo con Keras y No hay nada específico de TPU en este paso: escribe el código como si estuviera utilizando múltiples GPUs y una En lugar de la Puedes aprender más en la Los tutoriales. Model.fit Model.compile MirroredStrategy TPUStrategy Entrenamiento distribuido con Keras with strategy.scope(): model = create_model() model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['sparse_categorical_accuracy']) batch_size = 200 steps_per_epoch = 60000 // batch_size validation_steps = 10000 // batch_size train_dataset = get_dataset(batch_size, is_training=True) test_dataset = get_dataset(batch_size, is_training=False) model.fit(train_dataset, epochs=5, steps_per_epoch=steps_per_epoch, validation_data=test_dataset, validation_steps=validation_steps) Epoch 1/5 300/300 [==============================] - 17s 32ms/step - loss: 0.1235 - sparse_categorical_accuracy: 0.9620 - val_loss: 0.0462 - val_sparse_categorical_accuracy: 0.9856 Epoch 2/5 300/300 [==============================] - 7s 24ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9894 - val_loss: 0.0401 - val_sparse_categorical_accuracy: 0.9878 Epoch 3/5 300/300 [==============================] - 7s 24ms/step - loss: 0.0186 - sparse_categorical_accuracy: 0.9938 - val_loss: 0.0352 - val_sparse_categorical_accuracy: 0.9900 Epoch 4/5 300/300 [==============================] - 7s 25ms/step - loss: 0.0127 - sparse_categorical_accuracy: 0.9957 - val_loss: 0.0482 - val_sparse_categorical_accuracy: 0.9879 Epoch 5/5 300/300 [==============================] - 7s 24ms/step - loss: 0.0111 - sparse_categorical_accuracy: 0.9962 - val_loss: 0.0448 - val_sparse_categorical_accuracy: 0.9894 Para reducir el exceso de Python y maximizar el rendimiento de su TPU, pase en el El argumento de Keras En este ejemplo, aumenta el rendimiento en aproximadamente el 50%: steps_per_execution Model.compile with strategy.scope(): model = create_model() model.compile(optimizer='adam', # Anything between 2 and `steps_per_epoch` could help here. steps_per_execution = 50, loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['sparse_categorical_accuracy']) model.fit(train_dataset, epochs=5, steps_per_epoch=steps_per_epoch, validation_data=test_dataset, validation_steps=validation_steps) Epoch 1/5 300/300 [==============================] - 14s 45ms/step - loss: 0.1306 - sparse_categorical_accuracy: 0.9591 - val_loss: 0.0420 - val_sparse_categorical_accuracy: 0.9863 Epoch 2/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9900 - val_loss: 0.0502 - val_sparse_categorical_accuracy: 0.9846 Epoch 3/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0193 - sparse_categorical_accuracy: 0.9936 - val_loss: 0.0406 - val_sparse_categorical_accuracy: 0.9879 Epoch 4/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0135 - sparse_categorical_accuracy: 0.9955 - val_loss: 0.0416 - val_sparse_categorical_accuracy: 0.9882 Epoch 5/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0110 - sparse_categorical_accuracy: 0.9962 - val_loss: 0.0463 - val_sparse_categorical_accuracy: 0.9882 Entrena el modelo utilizando un loop de entrenamiento personalizado También puede crear y entrenar su modelo utilizando y APIs directamente. Puedes utilizar el Fuego para distribuir una función de conjunto de datos. Tenga en cuenta que en el ejemplo de abajo el tamaño del lote pasó a es el tamaño del lote por réplica en lugar del tamaño del lote global. Para obtener más información, consulte Los tutoriales. tf.function tf.distribute Strategy.experimental_distribute_datasets_from_function tf.data.Dataset Dataset Formación personalizada con tf.distribute.Strategy Primero, crear el modelo, los conjuntos de datos y S de: tf.function # Create the model, optimizer and metrics inside the `tf.distribute.Strategy` # scope, so that the variables can be mirrored on each device. with strategy.scope(): model = create_model() optimizer = tf.keras.optimizers.Adam() training_loss = tf.keras.metrics.Mean('training_loss', dtype=tf.float32) training_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( 'training_accuracy', dtype=tf.float32) # Calculate per replica batch size, and distribute the `tf.data.Dataset`s # on each TPU worker. per_replica_batch_size = batch_size // strategy.num_replicas_in_sync train_dataset = strategy.experimental_distribute_datasets_from_function( lambda _: get_dataset(per_replica_batch_size, is_training=True)) @tf.function def train_step(iterator): """The step function for one training step.""" def step_fn(inputs): """The computation to run on each TPU device.""" images, labels = inputs with tf.GradientTape() as tape: logits = model(images, training=True) loss = tf.keras.losses.sparse_categorical_crossentropy( labels, logits, from_logits=True) loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(list(zip(grads, model.trainable_variables))) training_loss.update_state(loss * strategy.num_replicas_in_sync) training_accuracy.update_state(labels, logits) strategy.run(step_fn, args=(next(iterator),)) WARNING:tensorflow:From /tmpfs/tmp/ipykernel_9094/1509474074.py:14: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version. Instructions for updating: rename to distribute_datasets_from_function WARNING:tensorflow:From /tmpfs/tmp/ipykernel_9094/1509474074.py:14: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version. Instructions for updating: rename to distribute_datasets_from_function Luego, corra el ciclo de entrenamiento: steps_per_eval = 10000 // batch_size train_iterator = iter(train_dataset) for epoch in range(5): print('Epoch: {}/5'.format(epoch)) for step in range(steps_per_epoch): train_step(train_iterator) print('Current step: {}, training loss: {}, accuracy: {}%'.format( optimizer.iterations.numpy(), round(float(training_loss.result()), 4), round(float(training_accuracy.result()) * 100, 2))) training_loss.reset_states() training_accuracy.reset_states() Epoch: 0/5 Current step: 300, training loss: 0.1465, accuracy: 95.4% Epoch: 1/5 Current step: 600, training loss: 0.035, accuracy: 98.94% Epoch: 2/5 Current step: 900, training loss: 0.0197, accuracy: 99.39% Epoch: 3/5 Current step: 1200, training loss: 0.0126, accuracy: 99.59% Epoch: 4/5 Current step: 1500, training loss: 0.0109, accuracy: 99.64% Mejorar el rendimiento con múltiples pasos dentro tf.function Puede mejorar el rendimiento mediante la ejecución de múltiples pasos dentro de un Esto se consigue mediante la incorporación de la Llamar con una por dentro , y AutoGraph lo convertirá en un en el trabajador de la TPU. Puedes aprender más sobre S en el La guía. tf.function Strategy.run tf.range tf.function tf.while_loop tf.function Mejor rendimiento con tf.function A pesar del rendimiento mejorado, hay compromisos con este método en comparación con la ejecución de un solo paso dentro de Executar múltiples pasos en un es menos flexible: no puede ejecutar las cosas ansiosamente o el código arbitrario de Python dentro de los pasos. tf.function tf.function @tf.function def train_multiple_steps(iterator, steps): """The step function for one training step.""" def step_fn(inputs): """The computation to run on each TPU device.""" images, labels = inputs with tf.GradientTape() as tape: logits = model(images, training=True) loss = tf.keras.losses.sparse_categorical_crossentropy( labels, logits, from_logits=True) loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(list(zip(grads, model.trainable_variables))) training_loss.update_state(loss * strategy.num_replicas_in_sync) training_accuracy.update_state(labels, logits) for _ in tf.range(steps): strategy.run(step_fn, args=(next(iterator),)) # Convert `steps_per_epoch` to `tf.Tensor` so the `tf.function` won't get # retraced if the value changes. train_multiple_steps(train_iterator, tf.convert_to_tensor(steps_per_epoch)) print('Current step: {}, training loss: {}, accuracy: {}%'.format( optimizer.iterations.numpy(), round(float(training_loss.result()), 4), round(float(training_accuracy.result()) * 100, 2))) Current step: 1800, training loss: 0.009, accuracy: 99.72% Próximos pasos Para saber más sobre Cloud TPUs y cómo usarlos: Google Cloud TPU: La página de inicio de Google Cloud TPU. : Google Cloud TPU documentation, which includes: Google Cloud TPU documentation : An overview of working with Cloud TPUs. Introduction to Cloud TPU : Quickstart introductions to working with Cloud TPU VMs using TensorFlow and other main machine learning frameworks. Cloud TPU quickstarts Notas de Google Cloud TPU Colab: ejemplos de capacitación de fin a fin. Guía de rendimiento de Google Cloud TPU: Mejore aún más el rendimiento de Cloud TPU ajustando los parámetros de configuración de Cloud TPU para su aplicación Entrenamiento distribuido con TensorFlow: Cómo utilizar estrategias de distribución, incluyendo tf.distribute.TPUStrategy, con ejemplos que muestran las mejores prácticas. Embeddings de TPU: TensorFlow incluye soporte especializado para embeddings de entrenamiento en TPUs a través de tf.tpu.experimental.embedding. Además, TensorFlow Recommenders tiene tfrs.layers.embedding.TPUEmbedding. Embeddings proporcionan representaciones eficientes y densas, capturando similitudes y relaciones entre características. El soporte de embedding específico de TPU de TensorFlow le permite entrenar embeddings que son mayores que la memoria de un solo dispositivo TPU, y utilizar entradas escasas y ragged en TPUs. TPU Research Cloud (TRC): TRC permite a los investigadores solicitar el acceso a un clúster de más de 1.000 dispositivos TPU en la nube. 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