Partekatu honen bidez:

Realizar la inferencia por lotes mediante un dataframe de Spark

Importante

Los temas de esta página solo son relevantes para escenarios de inferencia por lotes que no usan modelos de base hospedados en Databricks optimizados para escenarios de inferencia por lotes. Consulte Aplicación de inteligencia artificial en datos mediante Azure Databricks AI Functions.

En esta página se describe cómo realizar la inferencia por lotes en un dataframe de Spark mediante un modelo registrado en Databricks. El flujo de trabajo se aplica a varios modelos de aprendizaje automático y aprendizaje profundo, incluidos TensorFlow, PyTorch y scikit-learn. Incluye procedimientos recomendados para la carga de datos, la inferencia de modelos y el ajuste del rendimiento.

Para la inferencia de modelos para aplicaciones de aprendizaje profundo, Azure Databricks recomienda el siguiente flujo de trabajo. Para ver cuadernos de ejemplo que usan TensorFlow y PyTorch, consulte Ejemplos de inferencia de Batch.

Flujo de trabajo de inferencia de modelos

Databricks recomienda el siguiente flujo de trabajo para realizar la inferencia por lotes mediante DataFrames de Spark.

Paso 1: Configuración del entorno

Asegúrese de que el clúster ejecuta una versión compatible de Databricks ML Runtime para que coincida con el entorno de entrenamiento. El modelo, registrado mediante MLflow, contiene los requisitos que se pueden instalar para asegurarse de que coinciden los entornos de entrenamiento e inferencia.

requirements_path = os.path.join(local_path, "requirements.txt")
if not os.path.exists(requirements_path):
    dbutils.fs.put("file:" + requirements_path, "", True)

%pip install -r $requirements_path
%restart_python

Paso 2: Cargar datos en dataFrames de Spark

En función del tipo de datos, use el método adecuado para cargar datos en un dataframe de Spark:

Tipo de dato Método
Tabla del catálogo de Unity (recomendado) table = spark.table(input_table_name)
Archivos de imagen (JPG, PNG) files_df = spark.createDataFrame(map(lambda path: (path,), file_paths), ["path"])
TFRecords df = spark.read.format("tfrecords").load(image_path)
Otros formatos (Parquet, CSV, JSON, JDBC) Cargar utilizando orígenes de datos de Spark.

Paso 3: Carga del modelo desde el registro de modelos

En este ejemplo se usa un modelo del Registro de modelos de Databricks para la inferencia.

predict_udf = mlflow.pyfunc.spark_udf(spark, model_uri)

Paso 4: Realizar la inferencia de modelos mediante las UDFs de Pandas

Las UDF de Pandas aprovechan Apache Arrow para una transferencia de datos eficaz y Pandas para su procesamiento. Los pasos típicos para la inferencia con UDFs de pandas son:

  1. Cargar el modelo entrenado y usar MLflow para crear una UDF de Spark para la inferencia.
  2. Preprocesar los datos de entrada: asegúrese de que el esquema de entrada coincide con los requisitos del modelo.
  3. Ejecutar la predicción del modelo: utilice la función UDF del modelo en el DataFrame.
df_result = df_spark.withColumn("prediction", predict_udf(*df_spark.columns))
  1. (Recomendado) Guarde las predicciones en el catálogo de Unity.

En el ejemplo siguiente se guardan predicciones en el catálogo de Unity.

df_result.write.mode("overwrite").saveAsTable(output_table)

Optimización del rendimiento para la inferencia de modelos

En esta sección se proporcionan algunas sugerencias para depurar y optimizar el rendimiento de la inferencia de modelos en Azure Databricks. Para obtener información general, consulte La inferencia por lotes mediante un dataframe de Spark.

Normalmente hay dos partes principales en la inferencia del modelo: la canalización de entrada de datos y la inferencia del modelo. La tubería de datos es intensiva en E/S de datos y la inferencia del modelo es intensiva en cálculo. Determinar el cuello de botella del flujo de trabajo es sencillo. Estos son algunos enfoques:

  • Reduzca el modelo a un modelo trivial y mida los ejemplos por segundo. Si la diferencia en el tiempo de extremo a extremo entre el modelo completo y el modelo trivial es mínima, es probable que la canalización de entrada de datos sea el cuello de botella; de lo contrario, la inferencia del modelo lo será.
  • Si ejecuta la inferencia del modelo con GPU, compruebe las métricas de uso de GPU. Si el uso de GPU no es constantemente alto, la tubería de entrada de datos puede ser el cuello de botella.

Optimización de la canalización de entrada de datos

El uso de GPU puede optimizar eficazmente la velocidad de ejecución para la inferencia del modelo. A medida que las GPU y otros aceleradores se vuelven más rápidas, es importante que la canalización de entrada de datos se mantenga al día con la demanda. La canalización de entrada de datos lee los datos en DataFrames de Spark, lo transforma y lo carga como entrada para la inferencia del modelo. Si la entrada de datos es el cuello de botella, estas son algunas sugerencias para aumentar el rendimiento de E/S:

  • Establecer el máximo de registros por lote. Un mayor número de registros máximos puede reducir la sobrecarga de E/S para llamar a la función UDF siempre y cuando los registros puedan caber en la memoria. Para establecer el tamaño del lote, establezca la siguiente configuración:

    spark.conf.set("spark.sql.execution.arrow.maxRecordsPerBatch", "5000")

  • Cargar los datos en lotes y capturarlos previamente al preprocesar los datos de entrada en la UDF de Pandas.

    Para TensorFlow, Azure Databricks recomienda usar la API tf.data. Puede analizar el mapa en paralelo estableciendo num_parallel_calls en una función map y llamando a prefetch y batch para la precarga y el procesamiento por lotes.

    dataset.map(parse_example, num_parallel_calls=num_process).prefetch(prefetch_size).batch(batch_size)

    Para PyTorch, Azure Databricks recomienda usar la clase DataLoader. Puede establecer batch_size para el procesamiento por lotes y num_workers para la carga de datos en paralelo.

    torch.utils.data.DataLoader(images, batch_size=batch_size, num_workers=num_process)

Ejemplos de inferencia por lotes

Los ejemplos de esta sección siguen el flujo de trabajo recomendado de inferencia de aprendizaje profundo. En estos ejemplos se muestra cómo realizar la inferencia de modelos mediante un modelo de red neuronal de redes residuales (ResNets) profundas entrenado previamente.

Extracción de datos estructurado e inferencia por lotes mediante UDF de Spark

En el cuaderno de ejemplo siguiente se muestra el desarrollo, el registro y la evaluación de un agente sencillo para la extracción de datos estructurados para transformar datos sin procesar y no estructurados en información organizada y utilizable a través de técnicas de extracción automatizadas. Este enfoque muestra cómo implementar agentes personalizados para la inferencia por lotes mediante la clase de PythonModel MLflow y emplear el modelo de agente registrado como una función (UDF) de Spark User-Defined. En este cuaderno también se muestra cómo aprovechar la evaluación del agente de IA de Mosaico para evaluar la precisión mediante los datos de la verdad del suelo.

Extracción de datos estructurado e inferencia por lotes mediante UDF de Spark

Obtener el cuaderno

  • Last updated on