Estás leyendo la publicación: ¿Cómo acelerar los modelos de TensorFlow con el compilador XLA?
XLA es la abreviatura de Álgebra lineal acelerada y es un compilador diseñado para acelerar la convergencia de los modelos de Tensorflow rápidamente. Entonces, XLA es el compilador diseñado para procesar y hacer converger los modelos de TensorFlow en una secuencia de tareas y reducir el consumo de memoria. En este artículo, centrémonos en XLA e intentemos comprender cómo se puede usar como compilador para acelerar los modelos de Tensorflow.
Tabla de contenido
- Introducción a XLA
- ¿Por qué se construyó XLA?
- Trabajo de XLA
- Estudio de caso de XLA
- Resumen
Introducción a XLA
Accelerate Linear Algebra (XLA) es el compilador diseñado para acelerar los modelos de Tensorflow para acelerar el proceso de entrenamiento y reducir el consumo total de memoria. Las operaciones de Tensorflow se dividen en cada unidad, y cada una de las unidades tendrá unidades GPU precompiladas para una convergencia más rápida. Pero es posible que las unidades de GPU no se activen en ciertas plataformas con respecto a las restricciones del acelerador.
¿Está buscando un repositorio completo de bibliotecas de Python utilizadas en ciencia de datos, echa un vistazo aquí.
Considere que hemos diseñado un modelo para realizar algunas operaciones matemáticas. El principio tradicional de Tensorflow activará kernels separados para cada una de las operaciones, lo que provoca un retraso en la recuperación de los resultados. Así que aquí es donde XLA fusiona las operaciones matemáticas en un solo kernel o un kernel de GPU y acelera la recuperación de resultados. La recuperación de resultados y el consumo de memoria se reducen porque las operaciones se fusionan en un único núcleo, lo que reduce el consumo total de memoria. Por otro lado, el consumo reducido de memoria acelera la convergencia del modelo.
XLA también proporciona marcos de compilación externos que se pueden usar en consecuencia para diversas tareas de compilación. A través de esta compilación externa, los parámetros requeridos de los modelos se pueden compilar por prioridad o según los requisitos.
¿Por qué se construyó XLA?
Hay 4 razones principales que llevaron al desarrollo de XLA como un compilador que se puede usar sobre los modelos de Tensorflow. Veamos las 4 razones principales que llevaron al desarrollo del compilador XLA.
i) Velocidad de ejecución mejorada es una de las principales razones que llevaron al desarrollo del compilador XLA. El compilador XLA mejora la velocidad de ejecución al fusionar tareas en un solo kernel de GPU, lo que aumenta la velocidad de ejecución. Las operaciones fusionadas aumentan la recuperación de resultados ya que las operaciones se realizarán en núcleos individuales.
ii) Consumo de memoria reducido es una de las principales ventajas de XLA, ya que los cálculos se fusionan en clústeres únicos y los núcleos de GPU acelerados no imponen un consumo elevado de memoria y conducen al búfer de memoria.
iii) Dependencia reducida en operaciones personalizadas reemplazando las operaciones personalizadas con niveles de operaciones más simples y más bajos que facilitan una ejecución más rápida y reducen las dependencias.
iv) Fácil portabilidad ya que los modelos de Tensorflow compilados y ejecutados con XLA son portátiles en varias plataformas y reducen la decodificación en otras plataformas.
Trabajo de XLA
Como XLA es uno de los compiladores diseñados para acelerar la compilación y ejecución del modelo Tensorflow, intentemos entender el compilador XLA de una manera sencilla. La entrada a XLA son gráficos de tareas fusionadas y se denomina HLO según los términos del compilador XLA. El HLO compila los gráficos en instrucciones de máquina para varias arquitecturas. El compilador XLA es un paquete con varias optimizaciones y procesos de análisis con cierta especificidad para el objetivo.
En general, el compilador se puede enseñar como un clúster integrado del front-end y el back-end. El componente front-end del compilador será responsable de las optimizaciones y análisis independientes del objetivo y en el componente de back-end, se toman las optimizaciones y análisis dependientes del objetivo.
Comprendamos mejor el compilador XLA a través de un caso de estudio.
Estudio de caso de XLA
Comprendamos las principales ventajas de usar XLA a través de un estudio de caso. Al principio, construiremos un modelo simple de aprendizaje profundo y evaluaremos el tiempo que tarda el modelo en adaptarse a 50 épocas y luego pasaremos a usar XLA y evaluar el tiempo que tarda la misma arquitectura del modelo en converger y adaptarse a las épocas mencionadas.
importar tensorflow como tf importar matplotlib.pyplot como plt de tensorflow.keras.layers importar Dense, MaxPooling2D, Conv2D, Flatten de tensorflow.keras.models importar Sequential de tensorflow.keras importar regularizadores de tensorflow.keras.preprocessing.image importar ImageDataGenerator, load_img train_path=”/content/drive/MyDrive/Colab notebooks/Kernel Regularizers with NN/train” plt.figure(figsize=(15,5)) img=load_img(train_path + “/African/af_tr109.jpg”) plt.imshow (img) plt.axis(“off”) plt.title(“Imagen de elefante africano”) plt.show() plt.figure() img=load_img(train_path + “/Asian/as_tr114.jpg”) plt.imshow( img) plt.axis(“off”) plt.title(“Imagen de elefante asiático”) plt.show()
Aquí estamos usando un conjunto de datos de clasificación de elefantes donde tendremos que construir un modelo para clasificar a los elefantes como elefantes africanos o asiáticos. Así que ahora construyamos un modelo para estos datos y ajustemos el modelo para 50 épocas y evaluemos el tiempo que tarda el modelo en ajustar los datos.
img_row=150 img_col=150 modelo1=Secuencial() modelo1.add(Conv2D(64,(5,5),activation=’relu’,input_shape=(img_row,img_col,3))) modelo1.add(MaxPooling2D(pool_size= (2,2))) modelo1.add(Conv2D(32,(5,5),activación=’relu’)) modelo1.add(MaxPooling2D(pool_size=(2,2))) modelo1.add(Conv2D(16 ,(5,5),activación=’relu’)) model1.add(MaxPooling2D(pool_size=(2,2))) model1.add(Flatten()) model1.add(Dense(126,activation=’relu’ )) model1.add(Dense(52,activation=’relu’)) model1.add(Dense(1,activation=’sigmoid’)) model1.compile(loss=”binary_crossentropy”,optimizer=”adam”,metrics=[‘accuracy’]) train_datagen=ImageDataGenerator(rescale=1./255,shear_range=0.2,zoom_range=0.2,horizontal_flip=True) test_datagen=ImageDataGenerator(rescale=1./255) train_set=train_datagen.flow_from_directory(train_path,target_size=(img_row,img_col) , batch_size=64,class_mode=”binary”) test_set=test_datagen.flow_from_directory(test_path,target_size=(img_row,img_col), batch_size=64,class_mode=”binary”) model1_res=%time model1.fit_generator(train_set,steps_per_epoch=840 //64,epochs=50,validation_data=test_set,validation_steps=188//64)
Así que aquí podemos ver que para el modelo con las capas mencionadas, el modelo ha tardado 16 minutos y 57 segundos en ajustar los datos. Ahora ajustemos la misma arquitectura modelo para la misma cantidad de épocas utilizando el compilador XLA en el mismo entorno de trabajo. Evaluemos el tiempo de pared para el modelo después de ajustar el modelo usando el compilador XLA.
Antes de usar XLA Compiler en el entorno de trabajo, es una buena práctica borrar cualquier otra sesión activa en segundo plano. Instancemos el compilador XLA en el entorno de trabajo, como se muestra a continuación.
tf.keras.backend.clear_session() ## para borrar otras sesiones en el entorno tf.config.optimizer.set_jit(True) ## habilitar XLA
Ahora ajustemos la misma arquitectura modelo usando XLA y observemos el tiempo de pared que toma el compilador para ajustar el modelo con el mismo conjunto de configuraciones usado antes.
model2_res=%time model2.fit_generator(train_set,steps_per_epoch=840//64,epochs=50,validation_data=test_set,validation_steps=188//64)
Entonces, aquí podemos ver que después de ajustar el mismo modelo con el mismo conjunto de configuraciones, el tiempo de pared del modelo se ha reducido. El tiempo de pared ha visto una reducción significativa del 50% después de usar el compilador XLA en el entorno de trabajo. Como hemos visto que XLA reduce significativamente el tiempo del reloj para los modelos de TensorFlow, comprendamos el significado del tiempo de pared.
¿Qué es el tiempo de la pared?
Considere que le han dado un reloj de pulsera o le han pedido que controle la hora en el reloj de pared inmediatamente después de colocar el modelo. Por lo tanto, el tiempo de pared se puede interpretar como el tiempo que tarda el modelo en ajustarse y converger para el número mencionado de iteraciones. Por lo tanto, el tiempo de pared se usa como una métrica para estimar el tiempo que tarda el modelo en ajustarse a los datos.
La magnitud del tiempo de pared varía con respecto a las especificaciones del hardware y las especificaciones de la plataforma. Cuanto mayor sea el tiempo de pared, mayor será el tiempo necesario para el cálculo y la convergencia y cuanto menor sea el tiempo de pared, menor será el tiempo necesario para el cálculo y la convergencia.
Entonces, XLA es uno de esos compiladores diseñado para modelos Tensorflow que tienen como objetivo reducir el tiempo de pared y acelerar el proceso de entrenamiento.
Resumen
Los modelos pesados de Tensorflow generalmente toman más tiempo para el entrenamiento y el cálculo, ya que divide las tareas en diferentes núcleos. Aquí es donde el compilador XLA encuentra su principal ventaja, ya que fusiona varias tareas en un solo kernel acelerado y acelera el proceso de capacitación. XLA es un compilador que reduce significativamente el tiempo de pared, y una reducción en el tiempo de pared reduce mucho el tiempo de entrenamiento. XLA facilita el uso de su compilador en varias plataformas y esto ayuda a los ingenieros e investigadores de aprendizaje profundo a acelerar el tiempo de entrenamiento de los grandes modelos de Tensorflow.
