Esegui la migrazione da Vertex AI Feature Store (legacy) a Bigtable

La migrazione di un carico di lavoro di gestione delle funzionalità di machine learning da Vertex AI Feature Store (legacy) a Bigtable può migliorare le prestazioni e la flessibilità. Questa guida fornisce una panoramica dei concetti correlati e del processo di migrazione.

Vertex AI Feature Store (legacy) è un ambiente gestito che utilizza Bigtable per il livello di pubblicazione online. L'esecuzione della piattaforma AI o del feature store direttamente su Bigtable senza utilizzare Vertex AI Feature Store (legacy) può comportare velocità più elevate e costi ridotti.

Consigliamo un percorso di migrazione minimo e praticabile incentrato sulla migrazione dei dati dalle tabelle Bigtable sottostanti in Vertex AI Feature Store (legacy) a un'istanza Bigtable che crei nel tuo progetto Google Cloud .

Vantaggi della migrazione

La migrazione a Bigtable offre diversi vantaggi strategici e operativi:

  • Efficienza dei costi: elimini il premio per la gestione dei nodi specifico di Vertex AI Feature Store (legacy), riducendo spesso i costi dell'infrastruttura.
  • Controllo diretto: ottieni l'accesso completo alle funzionalità di Bigtable. Il monitoraggio di Bigtable espone molte più metriche rispetto a Vertex AI Feature Store (legacy). Inoltre, hai un maggiore controllo sui layout e sul ridimensionamento dell'architettura personalizzata.
  • Prestazioni elevate: Bigtable supporta carichi di lavoro ad alte prestazioni e funzionalità ad alte prestazioni come l'aggregazione in scrittura e la ricerca vettoriale.

  • Integrazione tra prodotti: hai accesso alle integrazioni di Bigtable, come le tabelle esterne BigQuery, i connettori per Apache Spark, Apache Flink e Kafka Connect e l'ETL inverso da BigQuery.

  • Acquisizione delle modifiche ai dati: puoi attivare i flussi di modifiche per acquisire le modifiche alla tabella del feature store Bigtable man mano che vengono apportate.

Concetti fondamentali

Questa sezione descrive come i concetti principali di Vertex AI Feature Store (legacy) vengono implementati da Bigtable e BigQuery.

Conservazione dei dati

In Bigtable, la conservazione dei dati viene gestita con la garbage collection. La garbage collection è il processo automatico e continuo di rimozione dei dati scaduti e obsoleti dalle tabelle Bigtable. Una norma di Garbage Collection è un insieme di regole che crei per indicare quando i dati in una funzionalità specifica, definita in Bigtable come famiglia di colonne, non sono più necessari. Le norme di garbage collection vengono impostate in base al timestamp associato ai dati o al numero di versioni che vuoi conservare.

La garbage collection è un processo in background asincrono integrato che si svolge durante la compattazione. La garbage collection viene eseguita in base a una pianificazione fissa. Finché i dati non vengono eliminati, vengono visualizzati nei risultati di lettura, ma puoi filtrare le letture per escluderli. Per saperne di più, consulta la panoramica del Garbage Collection.

Inoltre, l'archiviazione a livelli Bigtable può essere una soluzione conveniente per gli store di caratteristiche online che devono conservare i dati storici per l'addestramento dei modelli o la conformità normativa. L'archiviazione a livelli gestisce lo spostamento dei dati a cui si accede raramente dal servizio online sull'archiviazione SSD a un livello di archiviazione a costi inferiori.

Sviluppo di funzionalità

In Bigtable, puoi implementare lo sviluppo di funzionalità online con Bigtable SQL e lo sviluppo di funzionalità offline utilizzando BigQuery DataFrames.

Quando utilizzi Vertex AI Feature Store (legacy), lavori con API per sviluppatori e modelli di dati che mappano le origini dati sottostanti preparate in BigQuery. Poi registri queste origini dati e colonne di caratteristiche specifiche nel registro delle caratteristiche. Con un feature store Bigtable, lavori direttamente con i dati nelle istanze BigQuery e Bigtable sottostanti, senza dover eseguire il mapping al modello dei dati di Vertex AI Feature Store (legacy).

Sviluppo di funzionalità online

Per lo sviluppo di funzionalità online, Bigtable offre diversi strumenti:

  • Libreria client Python: utilizza la libreria client Python per Bigtable per lavorare direttamente con i dati in Bigtable.
  • GoogleSQL: utilizza GoogleSQL per leggere e trasformare i dati in Bigtable. Puoi eseguire query SQL direttamente nella console Bigtable o dalla libreria client Python.
  • Viste materializzate continue: per creare funzionalità quasi in tempo reale che richiedono trasformazioni e aggregazioni ricorrenti, utilizza le viste materializzate continue di Bigtable per eseguire in modo incrementale una query SQL sui dati man mano che vengono inseriti in Bigtable.

Sviluppo di funzionalità offline

Per lo sviluppo di funzionalità offline, BigQuery DataFrames fornisce un'interfaccia Python con oltre 750 API pandas e scikit-learn. Queste API vengono implementate tramite la conversione SQL in BigQuery e API BigQuery ML. La generazione di funzionalità BigQuery DataFrames consente sia funzioni Python integrate che definite dall'utente. Fornisce inoltre la sincronizzazione automatica dei dati con Bigtable per la pubblicazione delle funzionalità create nei processi batch e offline, descritti nella sezione successiva.

Sincronizzazione delle funzionalità online e offline

Quando utilizzi Bigtable direttamente per i carichi di lavoro ML, puoi assicurarti che un valore della funzionalità offline venga importato da BigQuery e che lo stesso valore venga riutilizzato sia per l'addestramento che per la pubblicazione, mantenendo sincronizzati i percorsi del codice per generare funzionalità tra l'addestramento e la pubblicazione. Le seguenti tecnologie consentono la sincronizzazione delle funzionalità:

  • Sincronizzazione batch: l'ETL inversa da BigQuery a Bigtable consente di esportare i risultati di una query BigQuery in Bigtable. Queste query vengono eseguite in batch e possono essere pianificate direttamente da BigQuery.
  • Sincronizzazione in streaming: le query continue di BigQuery sono istruzioni SQL che vengono eseguite continuamente e restituiscono righe in una tabella Bigtable.
  • Sincronizzazione da BigQuery DataFrames: per acquisire le funzionalità offline sviluppate in Python, puoi utilizzare un BigFrames StreamingDataFrame per generare una query continua BigQuery che acquisisce la logica Python per la generazione di funzionalità e sincronizza i risultati dei dati con Bigtable.
  • Sviluppo di funzionalità offline direttamente sui dati Bigtable: puoi creare funzionalità offline in BigQuery in base ai dati archiviati in Bigtable utilizzando una tabella esterna BigQuery. Una tabella esterna rispecchia l'aspetto di una tabella BigQuery e offre la maggior parte delle stesse funzionalità, come join, query pianificate e funzioni SQL avanzate di BigQuery, senza la necessità di spostare i dati di nuovo nello spazio di archiviazione BigQuery. Per evitare di influire sul traffico di pubblicazione delle applicazioni, puoi utilizzare il serverless computing Data Boost quando leggi i dati Bigtable con tabelle esterne BigQuery. L'utilizzo di Data Boost è particolarmente conveniente per le query ad hoc. Per utilizzare Data Boost, specifica un profilo dell'app Data Boost quando crei la definizione della tabella esterna. Per saperne di più su Data Boost, vedi Panoramica di Bigtable Data Boost.

Dopo la migrazione, puoi continuare a utilizzare Vertex AI Model Monitoring per monitorare la qualità dei tuoi modelli.

L'utilizzo combinato di Bigtable e BigQuery è un pattern comune per la creazione di database di analisi in tempo reale.

Fasi della migrazione

Per garantire la continuità del servizio, la migrazione viene in genere eseguita nelle seguenti fasi distinte.

Fase 1: prepara l'infrastruttura

Prima di iniziare la migrazione, configura l'ambiente di destinazione:

Fase 2: definisci la mappatura dello schema tra Vertex AI Feature Store (legacy) e Bigtable

  1. Esamina e comprendi le best practice di progettazione dello schema Bigtable. Di seguito è riportato un mapping generale dell'API Vertex AI Feature Store (legacy) all'API Bigtable:

    Risorsa Vertex AI Feature Store (legacy)

    Componente Bigtable

    FeatureOnlineStore

    Istanza Bigtable

    FeatureView

    Famiglia di colonne

    featureValues (batch)

    Colonna (una cella per chiave)

    featureValues (continuo)

    Colonna (più celle per chiave [controllo delle versioni])

  2. Dopo aver definito la mappatura dello schema, crea una tabella Bigtable che contenga una famiglia di colonne per ogni funzionalità nell'archivio delle funzionalità di origine.

Fase 3: estrazione e sincronizzazione dei dati

In questa fase, esegui la migrazione dei dati utilizzando un approccio a più livelli in base alla frequenza di aggiornamento dei dati.

Sincronizzazione delle funzionalità in tempo reale

Per le funzionalità che stai scrivendo con write_feature_values o chiamate API equivalenti, inizia a scrivere gli stessi dati nella nuova tabella Bigtable.

  1. Installa la libreria client Python per Bigtable.
  2. Configura l'applicazione per scrivere contemporaneamente i dati delle funzionalità in Vertex AI Feature Store (legacy) e Bigtable. Per maggiori informazioni sulla scrittura di dati in Bigtable, consulta Scritture.

Migrazione delle funzionalità batch

A questo punto, esegui la migrazione dei dati archiviati prima di iniziare le scritture duali. Ciò comporta lo spostamento dei dati da Vertex AI Feature Store (legacy) a BigQuery e poi a Bigtable.

  1. Esporta i dati di Feature Store in BigQuery utilizzando le funzionalità di esportazione di Vertex AI Feature Store (legacy), che ti consentono di esportare tutti i valori o gli snapshot. In questo modo BigQuery può fungere da datastore offline di Vertex AI Feature Store (legacy).
  2. Esegui la migrazione dei dati storici da BigQuery a Bigtable utilizzando uno dei seguenti metodi:
    1. ETL inverso
    2. Connettore Bigtable Spark
    3. Modello Dataflow da BigQuery a Bigtable

Fase 4: transizione di applicazioni e SDK

Il passaggio finale consiste nel tagliare il livello dell'applicazione.

  1. Una volta completata e testata la migrazione, interrompi la scrittura in Vertex AI Feature Store (legacy).

  2. Modifica l'applicazione in modo che utilizzi solo la libreria client Python per Bigtable.

    L'esempio seguente mostra l'utilizzo di Python per estrarre una singola funzionalità da Bigtable.

    from google.cloud import bigtable
from google.cloud.bigtable import row_filters
# Replace 'project_id' and 'instance_id' with your actual IDs.
client = bigtable.Client(project=project_id)
instance = client.instance(instance_id)

#return only the latest feature
row_filter = bigtable.row_filters.CellsColumnLimitFilter(1)

# Replace 'user1' and 'feature0` with your actual row key and column qualifier.

print("Getting a single feature by row key.")
key = "user1".encode()

row = table.read_row(key, row_filter)
cell = row.cells[column_family_id.decode("utf-8")][feature0][0]
print(cell.value.decode("utf-8"))

    Per un altro esempio di come leggere e scrivere dati utilizzando le API Bigtable per dati e amministrazione, consulta l'esempio Python Hello World.

    La libreria client Python per Bigtable ti consente anche di utilizzare GoogleSQL per restituire funzionalità che soddisfano i criteri di filtro o per eseguire trasformazioni delle funzionalità. L'esempio seguente mostra come chiamare una query SQL in modo asincrono dalla libreria client Python di Bigtable. Per ulteriori informazioni su GoogleSQL per Bigtable, vedi Esempi di SQL aggiuntivi.

    import asyncio
from google.cloud.bigtable.data_async import BigtableDataClient
from google.cloud.bigtable_v2.types import ExecuteQueryRequest

async def run_bigtable_sql_query(project_id, instance_id, table_id):
    """
    Runs a GoogleSQL query on a Bigtable table using the async client.
    """
    client = BigtableDataClient(project_id=project_id)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    # Example query: Select a specific row and all columns from a column family
    # Replace 'my_table' and 'my_cf' with your actual table and column family IDs.
    # The table name in the SQL must be in the format `dataset.table`,
    # where dataset is the instance ID and table is the table ID (in backticks).
    sql_query = f"SELECT _key, my_cf FROM `{instance_id}`.`{table_id}` WHERE _key = 'user_123'"

    print(f"Executing query: {sql_query}")

    # The client library automatically handles the SQL execution
    try:
        # The query method returns an AsyncPartialRowsIterator
        results_iterator = await table.query(query=sql_query)

        async for row in results_iterator:
            print(f"Row key: {row.row_key.decode('utf-8')}")
            # Iterate through the cells in the row
            for col_family, cells in row.cells.items():
                for cell in cells:
                    print(f"  Column Family: {col_family}, Qualifier: {cell.qualifier.decode('utf-8')}, Value: {cell.value.decode('utf-8')}, Timestamp: {cell.timestamp_micros}")

    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        await client.close()

if __name__ == "__main__":
    # TODO(developer): Replace with your project, instance, and table IDs
    your_project_id = "your-gcp-project-id"
    your_instance_id = "your-bigtable-instance-id"
    your_table_id = "your-bigtable-table-id"

    # Run the asynchronous function
    asyncio.run(run_bigtable_sql_query(your_project_id, your_instance_id, your_table_id))

  3. Inizia a utilizzare le metriche Bigtable per monitorare la latenza e il throughput. Per saperne di più, consulta Monitoraggio.

Best practice

Dopo aver eseguito la migrazione da Vertex AI Feature Store (legacy) a un'implementazione di Bigtable Feature Store, devi replicare la logica di preelaborazione e ottimizzazione interna precedentemente gestita dal servizio per mantenere stabilità e prestazioni.

Limitazione adattiva lato client

Il backend di Vertex AI Feature Store (legacy) utilizza un limitatore adattivo lato client per proteggere le istanze Bigtable sottostanti dal sovraccarico durante i picchi di traffico o quando il backend di archiviazione presenta latenza elevata o errori. Ti consigliamo di implementare un limitatore simile nel codice dell'applicazione per registrare le risposte di backend e limitare in modo proattivo le richieste quando necessario.

Ottimizzazione del partizionamento delle richieste e delle dimensioni del batch

I filtri di riga Bigtable hanno un limite rigido di 20 KB. La richiesta di un numero eccessivo di funzionalità o ID entità in una singola lettura filtrata può causare errori nelle richieste. Per rispecchiare il comportamento di Vertex AI Feature Store (legacy), procedi nel seguente modo:

  • ID funzionalità chunk: limita il numero di ID funzionalità per lettura Bigtable a circa 100.
  • Batch di entità di bilanciamento: per evitare di saturare le risorse client o server quando esegui letture di più entità, prendi le seguenti precauzioni:
    • Partiziona le entità in piccoli batch simultanei, ad esempio 10 entità per batch.
    • Limita il numero massimo di richieste batch simultanee, ad esempio 10-20.

Selezione intelligente dei filtri

Il calcolo e l'applicazione dei filtri delle colonne lato server aggiungono un sovraccarico. Se la tua applicazione in genere richiede quasi tutte le funzionalità in una famiglia di colonne, ad esempio > 99,9%, è più efficiente saltare il filtro delle colonne e leggere l'intera riga, filtrando i risultati lato client.

Concorrenza ed esecuzione asincrona

Per ridurre al minimo il tempo al primo risultato negli scenari di streaming, utilizza pattern asincroni o bundle di thread per recuperare i batch di entità in parallelo. In questo modo l'applicazione può iniziare a elaborare i risultati non appena viene restituito il primo batch, anziché attendere il completamento di una lettura seriale di grandi dimensioni.

Passaggi successivi