Utilizzare Vertex AI Feature Store in Vertex AI Knowledge Engine

In questa pagina viene illustrato come configurare Vertex AI Feature Store come database vettoriale da utilizzare con Vertex AI Knowledge Engine.

Vertex AI Knowledge Engine utilizza un database vettoriale integrato basato su Spanner per archiviare e gestire le rappresentazioni vettoriali dei documenti di testo. Il database vettoriale recupera i documenti pertinenti in base alla loro semantica come una determinata query.

Integrando Vertex AI Feature Store come database vettoriale aggiuntivo, Vertex AI Knowledge Engine può utilizzare Vertex AI Feature Store per gestire dati di grandi dimensioni volumi con bassa latenza, che aiuta a migliorare le prestazioni e la scalabilità delle tue applicazioni RAG.

Configurare un Vertex AI Feature Store

Vertex AI Feature Store, un servizio gestito cloud-native, è un componente essenziale di Vertex AI. Semplifica il machine learning la gestione delle caratteristiche (ML) e la pubblicazione online tramite la possibilità di gestire i dati delle caratteristiche. in una tabella o vista BigQuery. In questo modo, è possibile pubblicare funzionalità online a bassa latenza.

Per le istanze FeatureOnlineStore create con la pubblicazione online ottimizzata, puoi usufruire di una ricerca di similarità vettoriale per recuperare un elenco di entità semanticamente simili o correlate, note come vicino più prossimo approssimato.

Le sezioni seguenti mostrano come configurare un'istanza di Vertex AI Feature Store per la tua applicazione RAG.

Creare uno schema della tabella BigQuery

Utilizza la console Google Cloud per creare uno schema di tabella BigQuery. Deve contenere i seguenti campi per poter essere utilizzata come origine dati.

Nome campo Tipo di dati Stato
corpus_id String Obbligatorio
file_id String Obbligatorio
chunk_id String Obbligatorio
chunk_data_type String Ammette valori Null
chunk_data String Ammette valori Null
file_original_uri String Ammette valori Null
embeddings Float Ripetuto

Questo esempio di codice mostra come definire lo schema della tabella BigQuery.

  # Use this sql query as reference for creating the table
  CREATE TABLE `your-project-id.input_us_central1.rag_source_new` (
    `corpus_id` STRING ,
    `file_id` STRING,
    `chunk_id` STRING,
    `chunk_data_type` STRING,
    `chunk_data` STRING,
    `embeddings` ARRAY<FLOAT64>,
    `file_original_uri` STRING,
  );

Esegui il provisioning di un'istanza FeatureOnlineStore

Per abilitare l'erogazione online delle funzionalità, utilizza l'API CreateFeatureOnlineStore Vertex AI Feature Store per configurare un'istanza FeatureOnlineStore. Se stanno eseguendo il provisioning di un FeatureOnlineStore per la prima volta, l'operazione potrebbe richiede circa cinque minuti.

  # TODO(developer): Update and uncomment the following lines:
  # PROJECT_ID = "your-project-id"
  #
  # Set feature_online_store_id.
  # Example: "rag_fos_test"
  # FEATURE_ONLINE_STORE_ID="your-feature-online-store-id"

  # Call CreateFeatureOnlineStore to create a FeatureOnlineStore instance
  curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/featureOnlineStores?feature_online_store_id=${FEATURE_ONLINE_STORE_ID}   -d '{
      "optimized": {},
  }'

  # TODO(developer): Update and uncomment the following lines:
  # Get operation_id returned in CreateFeatureOnlineStore
  # OPERATION_ID="your-operation-id"

  # Poll Operation status until done = true in the response
  curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/operations/${OPERATION_ID}

Crea una risorsa FeatureView

Per collegare la tabella BigQuery, che archivia l'origine dati delle caratteristiche, a l'istanza FeatureOnlineStore, chiama l'API CreateFeatureView per creare FeatureView risorsa. Quando crei una risorsa FeatureView, scegli la metrica della distanza predefinita DOT_PRODUCT_DISTANCE, che è definita come il valore negativo del prodotto scalare (un valore DOT_PRODUCT_DISTANCE più piccolo indica una maggiore somiglianza).

Questo esempio di codice mostra come creare una risorsa FeatureView.

  # TODO(developer): Update and uncomment the following lines:
  # Set feature_view_id
  # Example: "feature_view_test"
  # FEATURE_VIEW_ID = "your-feature-view-id"
  #
  # The big_query_uri generated in the above BigQuery table schema creation step
  # The format should be "bq://" + BigQuery table ID
  # Example: "bq://tester.ragtest1.rag_testdata"
  # BIG_QUERY_URI=YOUR_BIG_QUERY_URI

  # Call CreateFeatureView API to create a FeatureView
  curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" \
  https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/featureOnlineStores/${FEATURE_ONLINE_STORE_ID}/featureViews?feature_view_id=${FEATURE_VIEW_ID} \
    -d '{
          "vertex_rag_source": {
            "uri": '\""${BIG_QUERY_URI}"\"'
          }
      }'

  # Call ListFeatureViews API to verify the FeatureView is created successfully
  curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/featureOnlineStores/${FEATURE_ONLINE_STORE_ID}/featureViews

Caricamento dei dati ed erogazione online

L'API RAG gestisce il caricamento e la pubblicazione online.

Utilizzare Vertex AI Feature Store in Vertex AI Knowledge Engine

Dopo aver configurato l'istanza di Vertex AI Feature Store, procedi come segue viene illustrato come impostarlo come database vettoriale da utilizzare con la finestra RAG un'applicazione.

Utilizza l'istanza di Vertex AI Feature Store come database vettoriale per creare un corpus RAG

Per creare il corpus RAG, devi utilizzare FEATURE_VIEW_RESOURCE_NAME. La Il corpus RAG viene creato e associato automaticamente Vertex AI Feature Store. Le API RAG utilizzano il rag_corpus_id generato per gestire il caricamento dei dati nell'istanza Vertex AI Feature Store e per recuperare i contesti pertinenti dal rag_corpus_id.

Questo esempio di codice mostra come utilizzare Vertex AI Feature Store come database vettoriale per creare un corpus RAG.

REST 

# TODO(developer): Update and uncomment the following lines:
# CORPUS_DISPLAY_NAME = "your-corpus-display-name"
#
# Full feature view resource name
# Format: projects/${PROJECT_ID}/locations/us-central1/featureOnlineStores/${FEATURE_ONLINE_STORE_ID}/featureViews/${FEATURE_VIEW_ID}
# FEATURE_VIEW_RESOURCE_NAME = "your-feature-view-resource-name"

# Call CreateRagCorpus API to create a new RAG corpus
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
 https://us-central1-aiplatform.googleapis.com/v1beta1/projects//{PROJECT_ID}/locations/us-central1/ragCorpora -d '{
      "display_name" : '\""${CORPUS_DISPLAY_NAME}"\"',
      "rag_vector_db_config" : {
              "vertex_feature_store": {
                "feature_view_resource_name":'\""${FEATURE_VIEW_RESOURCE_NAME}"\"'
              }
        }
  }'

# Call ListRagCorpora API to verify the RAG corpus is created successfully
curl -sS -X GET \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/ragCorpora"

Python 

import vertexai
from vertexai.preview import rag
from vertexai.preview.generative_models import GenerativeModel, Tool
# Set Project
PROJECT_ID = "YOUR_PROJECT_ID"  # @param {type:"string"}
vertexai.init(project=PROJECT_ID, location="us-central1")

# Configure a Google first-party embedding model
embedding_model_config = rag.EmbeddingModelConfig(
    publisher_model="text-embedding-004"
)

# Configure a Vertex AI Feature Store instance for the corpus
FEATURE_VIEW_RESOURCE_NAME = "YOUR_FEATURE_VIEW_RESOURCE_NAME"  # @param {type:"string"}
vector_db = rag.VertexFeatureStore(
   resource_name=FEATURE_VIEW_RESOURCE_NAME,
)

# Name your corpus
DISPLAY_NAME = "YOUR_DISPLAY_NAME"  # @param {type:"string"}

rag_corpus = rag.create_corpus(
    display_name=DISPLAY_NAME, embedding_model_config=embedding_model_config, vector_db=vector_db
)

# Check the corpus just created
rag.list_corpora()

Importa file nella tabella BigQuery utilizzando l'API RAG

Utilizza l'API ImportRagFiles per importare file da Google Cloud Storage o Google Drive nella tabella BigQuery dell'istanza Vertex AI Feature Store. I file sono incorporati e archiviati nella tabella BigQuery.

Questo esempio di codice mostra come importare file in BigQuery utilizzando l'API RAG.

REST 

# TODO(developer): Update and uncomment the following lines:
# RAG_CORPUS_ID = "your-rag-corpus-id"
#
# Google Cloud Storage bucket/file location.
# For example, "gs://rag-fos-test/"
# GCS_URIS= "your-gcs-uris"

# Call ImportRagFiles API to embed files and store in the BigQuery table
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/ragCorpora/${RAG_CORPUS_ID}/ragFiles:import \
-d '{
  "import_rag_files_config": {
    "gcs_source": {
      "uris": '\""${GCS_URIS}"\"'
    },
    "rag_file_chunking_config": {
      "chunk_size": 512
    }
  }
}'

# Call ListRagFiles API to verify the files are imported successfully
curl -X GET \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/ragCorpora/${RAG_CORPUS_ID}/ragFiles

Python 

RAG_CORPUS_RESOURCE = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/YOUR_RAG_CORPUS_ID"
GS_BUCKET = "YOUR_GS_BUCKET"

response = rag.import_files(
    corpus_name=RAG_CORPUS_RESOURCE,
    paths=[GS_BUCKET],
    chunk_size=512,  # Optional
    chunk_overlap=100,  # Optional
)

Esegui un processo di sincronizzazione per creare un indice FeatureOnlineStore

Dopo aver caricato i dati nella tabella BigQuery, esegui un processo di sincronizzazione per renderli disponibili per la pubblicazione online. Devi generare un indice FeatureOnlineStore utilizzando FeatureView e il processo di sincronizzazione potrebbe richiedere 20 minuti.

Questo esempio di codice mostra come eseguire un processo di sincronizzazione per creare un indice FeatureOnlineStore.

  # Call Feature Store SyncFeatureView API to run the synchronization process
  curl   "https://us-central1-aiplatform.googleapis.com/v1/${FEATURE_VIEW_RESOURCE_NAME}:sync" \
    -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8"

  # TODO(developer): Update and uncomment the following lines:
  # Call Vertex AI Feature Store GetFeatureViewSync API to check the running synchronization // status
  # FEATURE_VIEW_SYNC_ID = "your-feature-view-sync-id" returned in SyncFeatureView
  curl   "https://us-central1-aiplatform.googleapis.com/v1/${FEATURE_VIEW_RESOURCE_NAME}/featureViewSyncs/${FEATURE_VIEW_SYNC_ID}" \
    -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8"

Recupera i contesti pertinenti utilizzando l'API RAG

Al termine del processo di sincronizzazione, puoi recuperare i contesti pertinenti dall'indice FeatureOnlineStore tramite l'API RetrieveContexts.

REST 

# TODO(developer): Update and uncomment the following lines:
# RETRIEVAL_QUERY="your-retrieval-query"
#
# Full RAG corpus resource name
# Format:
# "projects/${PROJECT_ID}/locations/us-central1/ragCorpora/${RAG_CORPUS_ID}"
# RAG_CORPUS_RESOURCE="your-rag-corpus-resource"

# Call RetrieveContexts API to retrieve relevant contexts
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1:retrieveContexts \
  -d '{
    "vertex_rag_store": {
      "rag_resources": {
          "rag_corpus": '\""${RAG_CORPUS_RESOURCE}"\"',
        },
    },
    "query": {
      "text": '\""${RETRIEVAL_QUERY}"\"',
      "similarity_top_k": 10
    }
  }'
 ```

Python 

RAG_CORPUS_RESOURCE = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/YOUR_RAG_CORPUS_ID"
RETRIEVAL_QUERY = "YOUR_RETRIEVAL_QUERY"

response = rag.retrieval_query(
    rag_resources=[
        rag.RagResource(
             rag_corpus=RAG_CORPUS_RESOURCE,
             # Optional: supply IDs from `rag.list_files()`.
             # rag_file_ids=["rag-file-1", "rag-file-2", ...],
        )
    ],
    text=RETRIEVAL_QUERY,
    similarity_top_k=10,  # Optional
)
print(response)

Generare contenuti utilizzando l'API Gemini di Vertex AI

Chiama l'API Vertex AI GenerateContent per utilizzare i modelli Gemini generare contenuti e specificare RAG_CORPUS_RESOURCE nella richiesta di recupero dati dall'indice FeatureOnlineStore.

REST 

# TODO(developer): Update and uncomment the following lines:
# MODEL_ID=gemini-1.5-flash-001
# GENERATE_CONTENT_PROMPT="your-generate-content-prompt"

# GenerateContent with contexts retrieved from the FeatureStoreOnline index
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json"  https://us-central1-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/publishers/google/models/${MODEL_ID}:generateContent \
-d '{
  "contents": {
    "role": "user",
    "parts": {
      "text": '\""${GENERATE_CONTENT_PROMPT}"\"'
    }
  },
  "tools": {
    "retrieval": {
      "vertex_rag_store": {
        "rag_resources": {
            "rag_corpus": '\""${RAG_CORPUS_RESOURCE}"\"',
          },
        "similarity_top_k": 8,
      }
    }
  }
}'

Python 

RAG_CORPUS_RESOURCE = "projects/{PROJECT_ID}/locations/us-central1/ragCorpora/YOUR_RAG_CORPUS_ID"

rag_resource = rag.RagResource(
    rag_corpus=RAG_CORPUS_RESOURCE,
    # Optional: supply IDs from `rag.list_files()`.
    # rag_file_ids=["rag-file-1", "rag-file-2", ...],
)

rag_retrieval_tool = Tool.from_retrieval(
    retrieval=rag.Retrieval(
        source=rag.VertexRagStore(
            rag_resources=[
                rag.RagResource(
                    rag_corpus=RAG_CORPUS_RESOURCE,
                    # Optional: supply IDs from `rag.list_files()`.
                    # rag_file_ids=["rag-file-1", "rag-file-2", ...],
                )
            ],
            similarity_top_k=10,  # Optional
        ),
    )
)

rag_model = GenerativeModel(
   model_name="gemini-1.5-flash-001", tools=[rag_retrieval_tool]
)

GENERATE_CONTENT_PROMPT="YOUR_GENERATE_CONTENT_PROMPT"

response = rag_model.generate_content(GENERATE_CONTENT_PROMPT)
print(response.text)

Passaggi successivi