Entrenar un modelo de previsión

Google Cloud consola

1. En la Google Cloud consola, en la sección Vertex AI, vaya a la página Conjuntos de datos.

   Ve a la página Conjuntos de datos.

2. Haga clic en el nombre del conjunto de datos que quiera usar para entrenar su modelo y abra su página de detalles.

3. Si tu tipo de datos usa conjuntos de anotaciones, selecciona el que quieras usar en este modelo.

4. Haz clic en Entrenar un modelo nuevo.

5. Selecciona Otro.

6. En la página Método de entrenamiento, configure lo siguiente:

   1. Selecciona el método de entrenamiento del modelo. Para obtener más información, consulta Métodos de entrenamiento de modelos.

   2. Haz clic en Continuar.

7. En la página Detalles del modelo, configure lo siguiente:

   1. Introduce el nombre visible del nuevo modelo.

   2. Selecciona la columna de destino.

      La columna de destino es el valor que pronosticará el modelo. Más información sobre los requisitos de la columna de destino

   3. Si no has definido las columnas Identificador de serie y Marca de tiempo en tu conjunto de datos, selecciónalas ahora.

   4. Selecciona la granularidad de los datos. Selecciona Daily si quieres usar el modelo de efectos de festivos. Consulta cómo elegir la granularidad de los datos.

   5. Opcional: En el desplegable Regiones festivas, elige una o varias regiones geográficas para habilitar la modelización de los efectos de los días festivos. Durante el entrenamiento, Vertex AI crea funciones categóricas de festivos en el modelo en función de la fecha de la columna Timestamp y las regiones geográficas especificadas. Solo puedes seleccionar esta opción cuando Granularidad de los datos esté definida como Daily. De forma predeterminada, la modelización de efectos festivos está inhabilitada. Para obtener información sobre las regiones geográficas que se usan para modelizar el efecto de las fiestas, consulta Regiones de fiestas.

   6. Introduce los valores de Ventana de contexto y Horizonte de previsión.

      El horizonte de previsión determina hasta qué punto en el futuro el modelo prevé el valor objetivo de cada fila de datos de inferencia. El Horizonte de previsión se especifica en unidades de Granularidad de los datos.

      La ventana de contexto define cuánto tiempo atrás se remonta el modelo durante el entrenamiento (y para las previsiones). Es decir, en cada punto de datos de entrenamiento, la ventana de contexto determina cuánto tiempo atrás busca el modelo patrones predictivos. La ventana de contexto se especifica en unidades de granularidad de los datos.

      Más información

   7. Si quiere exportar su conjunto de datos de prueba a BigQuery, marque Export test dataset to BigQuery (Exportar conjunto de datos de prueba a BigQuery) e indique el nombre de la tabla.

   8. Si quieres controlar manualmente la división de los datos o configurar el periodo de previsión, abre las opciones avanzadas.

   9. La división de datos predeterminada es cronológica, con los porcentajes estándar 80/10/10. Si quieres especificar manualmente qué filas se asignan a cada división, selecciona Manual y especifica la columna de división de datos.

      Consulta más información sobre las divisiones de datos.

   10. Selecciona una estrategia de ventana móvil para la generación de la ventana de previsión. La estrategia predeterminada es Recuento.

       • Recuento: define el valor del número máximo de ventanas en el cuadro de texto proporcionado.
       • Zancada: define el valor de la longitud de la zancada en el cuadro de texto correspondiente.
       • Columna: seleccione el nombre de columna adecuado en el menú desplegable.

       Para obtener más información, consulta Estrategias de ventana de acumulación.

   11. Haz clic en Continuar.

8. En la página Opciones de entrenamiento, configure lo siguiente:

   1. Si aún no lo has hecho, haz clic en Generar estadísticas.

      Al generar estadísticas, se rellenan los menús desplegables de Transformación.

   2. Revisa la lista de columnas y excluye del entrenamiento las que no deban usarse para entrenar el modelo.

      Si usas una columna de división de datos, debe incluirse.

   3. Revisa las transformaciones seleccionadas para las funciones incluidas y haz los cambios necesarios.

      Las filas que contienen datos no válidos para la transformación seleccionada se excluyen del entrenamiento. Más información sobre las transformaciones

   4. En cada columna que haya incluido para el entrenamiento, especifique el Tipo de característica para indicar cómo se relaciona esa característica con su serie temporal y si está disponible en el momento de la previsión. Más información sobre el tipo y la disponibilidad de las funciones

   5. Si quieres especificar una columna de ponderación, cambiar el objetivo de optimización predeterminado o habilitar la previsión jerárquica, abre Opciones avanzadas.

   6. Opcional. Si quiere especificar una columna de peso, selecciónela en la lista desplegable. Más información sobre las columnas de peso

   7. Opcional. Si quieres seleccionar el objetivo de optimización, elígelo de la lista. Más información sobre los objetivos de optimización

   8. Opcional. Si quieres usar la previsión jerárquica, selecciona Habilitar previsión jerárquica. Puedes elegir entre tres opciones de agrupación:

      • No grouping
      • Group by columns
      • Group all

      También puede definir los siguientes pesos de pérdida agregados:

      • Group total weight. Este campo solo se puede definir si selecciona la opción Group by columns o Group all.
      • Temporal total weight.
      • Group temporal total weight. Este campo solo se puede definir si selecciona la opción Group by columns o Group all.

      Más información sobre las previsiones jerárquicas

   9. Haz clic en Continuar.

9. En la página Compute and pricing (Computación y precios), configure lo siguiente:

   1. Introduce el número máximo de horas que quieres que se entrene el modelo. Este ajuste te ayuda a limitar los costes de entrenamiento. El tiempo transcurrido real puede ser superior a este valor, ya que hay otras operaciones implicadas en la creación de un modelo.

      El tiempo de entrenamiento sugerido está relacionado con el tamaño del horizonte de previsión y los datos de entrenamiento. En la siguiente tabla se muestran algunos ejemplos de ejecuciones de entrenamiento de previsión y el intervalo de tiempo de entrenamiento necesario para entrenar un modelo de alta calidad.

      Filas	Funciones	Horizonte de previsión	Tiempo de entrenamiento
      12 millones	10	6	3-6 horas
      20 millones	50	13	De 6 a 12 horas
      16 millones	30	365	24 - 48 horas

      Para obtener información sobre los precios de entrenamiento, consulta la página de precios.

   2. Haz clic en Start Training (Iniciar entrenamiento).

      El entrenamiento del modelo puede llevar muchas horas, en función del tamaño y la complejidad de los datos, así como del presupuesto de entrenamiento, si has especificado uno. Puedes cerrar esta pestaña y volver a ella más adelante. Recibirás un correo cuando tu modelo haya terminado de entrenarse.

API

Selecciona la pestaña correspondiente a tu idioma o entorno:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/trainingPipelines

{
    "displayName": "TRAINING_PIPELINE_DISPLAY_NAME",
    "trainingTaskDefinition": "TRAINING_TASK_DEFINITION",
    "trainingTaskInputs": {
        "targetColumn": "TARGET_COLUMN",
        "timeColumn": "TIME_COLUMN",
        "timeSeriesIdentifierColumn": "TIME_SERIES_IDENTIFIER_COLUMN",
        "weightColumn": "WEIGHT_COLUMN",
        "trainBudgetMilliNodeHours": TRAINING_BUDGET,
        "dataGranularity": {"unit": "GRANULARITY_UNIT", "quantity": GRANULARITY_QUANTITY},
        "hierarchyConfig": {"groupColumns": GROUP_COLUMNS, "groupTotalWeight": GROUP_TOTAL_WEIGHT, "temporalTotalWeight": TEMPORAL_TOTAL_WEIGHT, "groupTemporalTotalWeight": GROUP_TEMPORAL_TOTAL_WEIGHT}
        "holidayRegions" : ["HOLIDAY_REGIONS_1", "HOLIDAY_REGIONS_2", ...]
        "forecast_horizon": FORECAST_HORIZON,
        "context_window": CONTEXT_WINDOW,
        "optimizationObjective": "OPTIMIZATION_OBJECTIVE",
        "quantiles": "QUANTILES",
        "enableProbabilisticInference": "PROBABILISTIC_INFERENCE",
        "time_series_attribute_columns": ["TIME_SERIES_ATTRIBUTE_COL_1", "TIME_SERIES_ATTRIBUTE_COL_2", ...]
        "available_at_forecast_columns": ["AVAILABLE_AT_FORECAST_COL_1", "AVAILABLE_AT_FORECAST_COL_2", ...]
        "unavailable_at_forecast_columns": ["UNAVAILABLE_AT_FORECAST_COL_1", "UNAVAILABLE_AT_FORECAST_COL_2", ...]
        "transformations": [
            {"TRANSFORMATION_TYPE_1":  {"column_name" : "COLUMN_NAME_1"} },
            {"TRANSFORMATION_TYPE_2":  {"column_name" : "COLUMN_NAME_2"} },
            ...
    },
    "modelToUpload": {"displayName": "MODEL_DISPLAY_NAME"},
    "inputDataConfig": {
      "datasetId": "DATASET_ID",
    }
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/trainingPipelines"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/trainingPipelines" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/trainingPipelines/TRAINING_PIPELINE_ID",
  "displayName": "myModelName",
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/automl_tabular_1.0.0.yaml",
  "modelToUpload": {
    "displayName": "myModelName"
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-08-18T01:22:57.479336Z",
  "updateTime": "2020-08-18T01:22:57.479336Z"
}

def create_training_pipeline_forecasting_time_series_dense_encoder_sample(
    project: str,
    display_name: str,
    dataset_id: str,
    location: str = "us-central1",
    model_display_name: str = "my_model",
    target_column: str = "target_column",
    time_column: str = "date",
    time_series_identifier_column: str = "time_series_id",
    unavailable_at_forecast_columns: List[str] = [],
    available_at_forecast_columns: List[str] = [],
    forecast_horizon: int = 1,
    data_granularity_unit: str = "week",
    data_granularity_count: int = 1,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    budget_milli_node_hours: int = 8000,
    timestamp_split_column_name: str = "timestamp_split",
    weight_column: str = "weight",
    time_series_attribute_columns: List[str] = [],
    context_window: int = 0,
    export_evaluated_data_items: bool = False,
    export_evaluated_data_items_bigquery_destination_uri: Optional[str] = None,
    export_evaluated_data_items_override_destination: bool = False,
    quantiles: Optional[List[float]] = None,
    enable_probabilistic_inference: bool = False,
    validation_options: Optional[str] = None,
    predefined_split_column_name: Optional[str] = None,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    # Create training job
    forecasting_tide_job = aiplatform.TimeSeriesDenseEncoderForecastingTrainingJob(
        display_name=display_name,
        optimization_objective="minimize-rmse",
    )

    # Retrieve existing dataset
    dataset = aiplatform.TimeSeriesDataset(dataset_id)

    # Run training job
    model = forecasting_tide_job.run(
        dataset=dataset,
        target_column=target_column,
        time_column=time_column,
        time_series_identifier_column=time_series_identifier_column,
        unavailable_at_forecast_columns=unavailable_at_forecast_columns,
        available_at_forecast_columns=available_at_forecast_columns,
        forecast_horizon=forecast_horizon,
        data_granularity_unit=data_granularity_unit,
        data_granularity_count=data_granularity_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        predefined_split_column_name=predefined_split_column_name,
        timestamp_split_column_name=timestamp_split_column_name,
        weight_column=weight_column,
        time_series_attribute_columns=time_series_attribute_columns,
        context_window=context_window,
        export_evaluated_data_items=export_evaluated_data_items,
        export_evaluated_data_items_bigquery_destination_uri=export_evaluated_data_items_bigquery_destination_uri,
        export_evaluated_data_items_override_destination=export_evaluated_data_items_override_destination,
        quantiles=quantiles,
        enable_probabilistic_inference=enable_probabilistic_inference,
        validation_options=validation_options,
        budget_milli_node_hours=budget_milli_node_hours,
        model_display_name=model_display_name,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Controlar la división de datos mediante REST

Tú controlas cómo se dividen tus datos de entrenamiento entre los conjuntos de entrenamiento, validación y prueba. Usa una columna de división para especificar manualmente la división de datos de cada fila y proporciónala como parte de un objeto PredefinedSplit Split en el inputDataConfig de la solicitud JSON.

DATA_SPLIT_COLUMN es la columna que contiene los valores divididos de los datos (TRAIN, VALIDATION y TEST).

"predefinedSplit": {
  "key": DATA_SPLIT_COLUMN
},

Más información sobre las divisiones de datos

Configurar la estrategia de ventana de acumulación mediante REST

Proporciona un objeto windowConfig para configurar una estrategia de ventana móvil para la generación de ventanas de previsión. La estrategia predeterminada es maxCount.

• Para usar la opción maxCount, añade lo siguiente a trainingTaskInputs de la solicitud JSON. MAX_COUNT_VALUE hace referencia al número máximo de ventanas.

    "windowConfig": {
      "maxCount": MAX_COUNT_VALUE
    },
    ```
  

• Para usar la opción strideLength, añade lo siguiente a trainingTaskInputs de la solicitud JSON. STRIDE_LENGTH_VALUE hace referencia al valor de la longitud de zancada.

    "windowConfig": {
      "strideLength": STRIDE_LENGTH_VALUE
    },
    ```
  

• Para usar la opción column, añade lo siguiente a trainingTaskInputs de la solicitud JSON. COLUMN_NAME hace referencia al nombre de la columna con valores True o False.

    "windowConfig": {
      "column": "COLUMN_NAME"
    },
    ```
  

Para obtener más información, consulta Estrategias de ventana de acumulación.