Esta página se ha traducido con Cloud Translation API.

Importar valores de funciones por lotes

La importación por lotes le permite importar valores de características en bloque desde una fuente de datos válida. En una solicitud de importación por lotes, puede importar valores de hasta 100 características de un tipo de entidad. Ten en cuenta que solo puedes tener un trabajo de importación por lotes en ejecución por tipo de entidad para evitar conflictos.

En una solicitud de importación por lotes, especifica la ubicación de los datos de origen y cómo se asignan a las funciones de tu featurestore. Como cada solicitud de importación por lotes es para un solo tipo de entidad, los datos de origen también deben ser de un solo tipo de entidad.

Una vez que la importación se haya completado correctamente, los valores de las funciones estarán disponibles para las operaciones de lectura posteriores.

Para obtener información sobre los requisitos de los datos de origen, consulta el artículo Requisitos de los datos de origen.
Para obtener información sobre el tiempo que Vertex AI Feature Store (antigua) conserva tus datos en el almacén offline, consulta Vertex AI Feature Store (antigua) en Cuotas y límites.
Para obtener información sobre la marca de tiempo de valor de característica más antigua que puedes importar, consulta Vertex AI Feature Store (antigua) en Cuotas y límites.
No puede importar valores de características cuyas marcas de tiempo indiquen fechas u horas futuras.

Rendimiento de las tareas de importación

Vertex AI Feature Store (antigua) ofrece una importación de alto rendimiento, pero la latencia mínima puede tardar unos minutos. Cada solicitud a Vertex AI Feature Store (Legacy) inicia un trabajo para completar la tarea. Una tarea de importación tarda unos minutos en completarse, aunque solo importe un registro.

Si quieres ajustar el rendimiento de un trabajo, cambia las dos variables siguientes:

Número de nodos de servicio online de Feature Store.
Número de trabajadores que se han usado en la tarea de importación. Los trabajadores procesan y escriben datos en el almacén de características.

El número de trabajadores recomendado es uno por cada 10 nodos de servicio online del almacén de características. Puedes aumentar este valor si la carga de publicación online es baja. Puedes especificar un máximo de 100 trabajadores. Para obtener más información, consulta el artículo sobre cómo monitorizar y ajustar los recursos para optimizar la importación por lotes.

Si el clúster de servicio online no tiene suficientes recursos, es posible que el trabajo de importación falle. Si se produce un error, vuelve a intentar la solicitud de importación cuando la carga de servicio online sea baja o aumenta el número de nodos de tu almacén de características y, a continuación, vuelve a intentar la solicitud.

Si el almacén de características no tiene un almacén online (cero nodos de servicio online), la tarea de importación solo escribe en el almacén offline y el rendimiento de la tarea depende únicamente del número de trabajadores de importación.

Coherencia de datos

Si los datos de origen se modifican durante la importación, pueden producirse incoherencias. Asegúrate de que se hayan completado todas las modificaciones de los datos de origen antes de iniciar un trabajo de importación. Además, los valores de características duplicados pueden provocar que se sirvan valores diferentes entre las solicitudes online y por lotes. Asegúrese de tener un valor de característica para cada par de ID de entidad y marca de tiempo.

Si falla una operación de importación, es posible que el almacén de características solo tenga datos parciales, lo que puede provocar que se devuelvan valores incoherentes entre las solicitudes de servicio online y por lotes. Para evitar esta incoherencia, vuelve a intentar la misma solicitud de importación y espera hasta que se complete correctamente.

Valores nulos y matrices vacías

Durante la importación, Vertex AI Feature Store (antigua) considera los valores escalares nulos o las matrices vacías como valores vacíos. Por ejemplo, los valores vacíos de una columna de un archivo CSV. Vertex AI Feature Store (antigua) no admite valores nulos no escalares, como el valor null en una matriz.

Durante el servicio online y el servicio por lotes, Vertex AI Feature Store (antigua) devuelve el valor más reciente no nulo o no vacío de la característica. Si no hay disponible ningún valor histórico de la característica, Vertex AI Feature Store (antigua) devuelve null.

Valores NaN

Vertex AI Feature Store (antigua) admite valores NaN (Not a Number) en Double y DoubleArray. Durante la importación, puedes introducir NaN en el archivo CSV de entrada de servicio para representar un valor NaN. Durante el servicio online y el servicio por lotes, Vertex AI Feature Store (antigua) devuelve NaN para los valores NaN.

Importación por lotes

Importa valores en bloque a un almacén de características de una o varias características de un solo tipo de entidad.

UI web

En la sección Vertex AI de la Google Cloud consola, ve a la página Funciones.

Ir a la página Funciones

Selecciona una región en la lista desplegable Región.
En la tabla de características, consulte la columna Tipo de entidad y busque el tipo de entidad que contenga las características de las que quiera importar valores.
Haga clic en el nombre del tipo de entidad.
En la barra de acciones, haga clic en Ingerir valores.
En Fuente de datos, seleccione una de las siguientes opciones:
- Archivo CSV de Cloud Storage: selecciona esta opción para importar datos de varios archivos CSV de Cloud Storage. Especifica la ruta y el nombre del archivo CSV. Para especificar archivos adicionales, haz clic en Añadir otro archivo.
- Archivo AVRO de Cloud Storage: selecciona esta opción para importar datos de un archivo AVRO de Cloud Storage. Especifica la ruta y el nombre del archivo AVRO.
- Tabla de BigQuery: selecciona esta opción para importar datos de una tabla o una vista de BigQuery. Busca y selecciona una tabla o una vista que quieras usar. Debe tener el siguiente formato: PROJECT_ID.DATASET_ID.TABLE_ID
Haz clic en Continuar.
En Asignar columnas a elementos, especifique qué columnas de sus datos de origen se asignan a entidades y elementos de su almacén de elementos.
1. Especifique el nombre de la columna de los datos de origen que contiene los IDs de entidad.
2. En el caso de la marca de tiempo, especifique una columna de marca de tiempo en los datos de origen o una única marca de tiempo asociada a todos los valores de las características que importe.
3. En la lista de características, introduzca el nombre de la columna de datos de origen que se asigna a cada característica. De forma predeterminada, Vertex AI Feature Store (antigua) asume que el nombre de la función y el nombre de la columna coinciden.
Haz clic en Ingerir.

REST

Para importar valores de funciones de funciones ya creadas, envía una solicitud POST mediante el método featurestores.entityTypes.importFeatureValues. Ten en cuenta que, si los nombres de las columnas de datos de origen y los IDs de las características de destino son diferentes, debes incluir el parámetro sourceField.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION_ID: región en la que se crea el almacén de características. Por ejemplo, us-central1.
PROJECT_ID: tu ID de proyecto.
FEATURESTORE_ID: ID del almacén de características.
ENTITY_TYPE_ID: ID del tipo de entidad.
ENTITY_SOURCE_COLUMN_ID: ID de la columna de origen que contiene los IDs de entidad.
FEATURE_TIME_ID: ID de la columna de origen que contiene las marcas de tiempo de las características.
FEATURE_ID: ID de una función del almacén de funciones para importar valores.
FEATURE_SOURCE_COLUMN_ID: ID de la columna de origen que contiene los valores de las funciones de las entidades.
SOURCE_DATA_DETAILS: la ubicación de los datos de origen, que también indica el formato, como "bigquerySource": { "inputUri": "bq://test.dataset.sourcetable" } para una tabla o una vista de BigQuery.
WORKER_COUNT: número de trabajadores que se usarán para escribir datos en el almacén de características.

Método HTTP y URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID:importFeatureValues

Cuerpo JSON de la solicitud:

{
  "entityIdField": "ENTITY_SOURCE_COLUMN_ID",
  "featureTimeField": "FEATURE_TIME_ID",
  SOURCE_DATA_DETAILS,
  "featureSpecs": [{
    "id": "FEATURE_ID",
    "sourceField": "FEATURE_SOURCE_COLUMN_ID"
  }],
  "workerCount": WORKER_COUNT
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID:importFeatureValues"

PowerShell

Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID:importFeatureValues" | Select-Object -Expand Content

Debería ver un resultado similar al siguiente. Puedes usar el OPERATION_ID de la respuesta para obtener el estado de la operación.

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ImportFeatureValuesOperationMetadata",
    "genericMetadata": {
      "createTime": "2021-03-02T00:04:13.039166Z",
      "updateTime": "2021-03-02T00:04:13.039166Z"
    }
  }
}

Python

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API Python.

import datetime
from typing import List, Union

from google.cloud import aiplatform


def import_feature_values_sample(
    project: str,
    location: str,
    entity_type_id: str,
    featurestore_id: str,
    feature_ids: List[str],
    feature_time: Union[str, datetime.datetime],
    gcs_source_uris: Union[str, List[str]],
    gcs_source_type: str,
):

    aiplatform.init(project=project, location=location)

    my_entity_type = aiplatform.featurestore.EntityType(
        entity_type_name=entity_type_id, featurestore_id=featurestore_id
    )

    my_entity_type.ingest_from_gcs(
        feature_ids=feature_ids,
        feature_time=feature_time,
        gcs_source_uris=gcs_source_uris,
        gcs_source_type=gcs_source_type,
    )

Java

Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.AvroSource;
import com.google.cloud.aiplatform.v1.EntityTypeName;
import com.google.cloud.aiplatform.v1.FeaturestoreServiceClient;
import com.google.cloud.aiplatform.v1.FeaturestoreServiceSettings;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.ImportFeatureValuesOperationMetadata;
import com.google.cloud.aiplatform.v1.ImportFeatureValuesRequest;
import com.google.cloud.aiplatform.v1.ImportFeatureValuesRequest.FeatureSpec;
import com.google.cloud.aiplatform.v1.ImportFeatureValuesResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ImportFeatureValuesSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String featurestoreId = "YOUR_FEATURESTORE_ID";
    String entityTypeId = "YOUR_ENTITY_TYPE_ID";
    String entityIdField = "YOUR_ENTITY_FIELD_ID";
    String featureTimeField = "YOUR_FEATURE_TIME_FIELD";
    String gcsSourceUri = "YOUR_GCS_SOURCE_URI";
    int workerCount = 2;
    String location = "us-central1";
    String endpoint = "us-central1-aiplatform.googleapis.com:443";
    int timeout = 300;
    importFeatureValuesSample(
        project,
        featurestoreId,
        entityTypeId,
        gcsSourceUri,
        entityIdField,
        featureTimeField,
        workerCount,
        location,
        endpoint,
        timeout);
  }

  static void importFeatureValuesSample(
      String project,
      String featurestoreId,
      String entityTypeId,
      String gcsSourceUri,
      String entityIdField,
      String featureTimeField,
      int workerCount,
      String location,
      String endpoint,
      int timeout)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    FeaturestoreServiceSettings featurestoreServiceSettings =
        FeaturestoreServiceSettings.newBuilder().setEndpoint(endpoint).build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (FeaturestoreServiceClient featurestoreServiceClient =
        FeaturestoreServiceClient.create(featurestoreServiceSettings)) {
      List<FeatureSpec> featureSpecs = new ArrayList<>();

      featureSpecs.add(FeatureSpec.newBuilder().setId("title").build());
      featureSpecs.add(FeatureSpec.newBuilder().setId("genres").build());
      featureSpecs.add(FeatureSpec.newBuilder().setId("average_rating").build());
      ImportFeatureValuesRequest importFeatureValuesRequest =
          ImportFeatureValuesRequest.newBuilder()
              .setEntityType(
                  EntityTypeName.of(project, location, featurestoreId, entityTypeId).toString())
              .setEntityIdField(entityIdField)
              .setFeatureTimeField(featureTimeField)
              .addAllFeatureSpecs(featureSpecs)
              .setWorkerCount(workerCount)
              .setAvroSource(
                  AvroSource.newBuilder()
                      .setGcsSource(GcsSource.newBuilder().addUris(gcsSourceUri)))
              .build();
      OperationFuture<ImportFeatureValuesResponse, ImportFeatureValuesOperationMetadata>
          importFeatureValuesFuture =
              featurestoreServiceClient.importFeatureValuesAsync(importFeatureValuesRequest);
      System.out.format(
          "Operation name: %s%n", importFeatureValuesFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ImportFeatureValuesResponse importFeatureValuesResponse =
          importFeatureValuesFuture.get(timeout, TimeUnit.SECONDS);
      System.out.println("Import Feature Values Response");
      System.out.println(importFeatureValuesResponse);
      featurestoreServiceClient.close();
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const project = 'YOUR_PROJECT_ID';
// const featurestoreId = 'YOUR_FEATURESTORE_ID';
// const entityTypeId = 'YOUR_ENTITY_TYPE_ID';
// const avroGcsUri = 'AVRO_FILE_IN_THE_GCS_URI';
// const entityIdField = 'ENTITY_ID_FIELD_IN_AVRO';
// const featureTimeField = 'TIMESTAMP_FIELD_IN_AVRO';
// const workerCount = <NO_OF_WORKERS_FOR_INGESTION_JOB>;
// const location = 'YOUR_PROJECT_LOCATION';
// const apiEndpoint = 'YOUR_API_ENDPOINT';
// const timeout = <TIMEOUT_IN_MILLI_SECONDS>;

// Imports the Google Cloud Featurestore Service Client library
const {FeaturestoreServiceClient} = require('@google-cloud/aiplatform').v1;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: apiEndpoint,
};

// Instantiates a client
const featurestoreServiceClient = new FeaturestoreServiceClient(
  clientOptions
);

async function importFeatureValues() {
  // Configure the entityType resource
  const entityType = `projects/${project}/locations/${location}/featurestores/${featurestoreId}/entityTypes/${entityTypeId}`;

  const avroSource = {
    gcsSource: {
      uris: [avroGcsUri],
    },
  };

  const featureSpecs = [{id: 'age'}, {id: 'gender'}, {id: 'liked_genres'}];

  const request = {
    entityType: entityType,
    avroSource: avroSource,
    entityIdField: entityIdField,
    featureSpecs: featureSpecs,
    featureTimeField: featureTimeField,
    workerCount: Number(workerCount),
  };

  // Import Feature Values Request
  const [operation] = await featurestoreServiceClient.importFeatureValues(
    request,
    {timeout: Number(timeout)}
  );
  const [response] = await operation.promise();

  console.log('Import feature values response');
  console.log('Raw response:');
  console.log(JSON.stringify(response, null, 2));
}
importFeatureValues();

Ver tareas de importación

Usa la consola de Google Cloud para ver los trabajos de importación por lotes de un proyecto deGoogle Cloud .

UI web

En la sección Vertex AI de la Google Cloud consola, ve a la página Funciones.

Ir a la página Funciones

Selecciona una región en la lista desplegable Región.
En la barra de acciones, haz clic en Ver trabajos de ingestión para mostrar los trabajos de importación de todos los almacenes de características.
Haga clic en el ID de un trabajo de importación para ver sus detalles, como la fuente de datos, el número de entidades importadas y el número de valores de características importados.

Permiso para sobrescribir datos en una featurestore.

Puede volver a importar valores para sobrescribir los valores de las características si ambos tienen las mismas marcas de tiempo. No es necesario que elimine los valores de las funciones. Por ejemplo, puede que dependas de una fuente de datos subyacente que se haya modificado recientemente. Para que su almacén de características siga siendo coherente con esos datos subyacentes, vuelva a importar los valores de las características. Si las marcas de tiempo no coinciden, los valores importados se consideran únicos y los antiguos siguen existiendo (no se sobrescriben).

Para que haya coherencia entre las solicitudes de publicación online y por lotes, espera a que se complete el trabajo de importación antes de enviar ninguna solicitud de publicación.

Rellenar el historial de datos

Si vas a rellenar datos, es decir, importar valores de características anteriores, inhabilita el servicio online para el trabajo de importación. El servicio online solo se usa para ofrecer los valores de las funciones más recientes, que no se incluyen en el relleno. Inhabilitar el servicio online es útil porque se elimina cualquier carga en los nodos de servicio online y se aumenta el rendimiento del trabajo de importación, lo que puede reducir el tiempo que tarda en completarse.

Puedes inhabilitar el servicio online de las tareas de importación cuando uses la API o las bibliotecas de cliente. Para obtener más información, consulta el campo disableOnlineServing del método importFeatureValue.

Siguientes pasos

Consulta cómo servir funciones mediante el servicio online o el servicio por lotes.
Consulta cómo monitorizar los valores de las funciones importadas a lo largo del tiempo.
Consulta la cuota de trabajos por lotes simultáneos de Vertex AI Feature Store (antigua).
Soluciona problemas habituales de Vertex AI Feature Store (antigua).

Importar valores de funciones por lotes Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Rendimiento de las tareas de importación

Coherencia de datos

Valores nulos y matrices vacías

Valores NaN

Importación por lotes

UI web

REST

curl

PowerShell

Python

Java

Node.js

Ver tareas de importación

UI web

Permiso para sobrescribir datos en una featurestore.

Rellenar el historial de datos

Siguientes pasos

Importar valores de funciones por lotes