notebooks/official/feature_store/online_feature_serving_and_fetching_bigquery_data_with_feature_store_bigtable.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8EcdxqUnftBL"
      },
      "outputs": [],
      "source": [
        "# Copyright 2023 Google LLC\n",
        "#\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "#     https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rbTKH4_6f1ux"
      },
      "source": [
        "## Online feature serving and fetching of BigQuery data with Vertex AI Feature Store\n",
        "\n",
        "\n",
        "<table align=\"left\">\n",
        "\n",
        "  <td>\n",
        "    <a href=\"https://colab.research.google.com/github/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/feature_store/online_feature_serving_and_fetching_bigquery_data_with_feature_store.ipynb\">\n",
        "      <img src=\"https://cloud.google.com/ml-engine/images/colab-logo-32px.png\" alt=\"Colab logo\"> Run in Colab\n",
        "    </a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/feature_store/online_feature_serving_and_fetching_bigquery_data_with_feature_store.ipynb\">\n",
        "      <img src=\"https://cloud.google.com/ml-engine/images/github-logo-32px.png\" alt=\"GitHub logo\">\n",
        "      View on GitHub\n",
        "    </a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://console.cloud.google.com/vertex-ai/workbench/deploy-notebook?download_url=https://raw.githubusercontent.com/GoogleCloudPlatform/vertex-ai-samples/main/notebooks/official/feature_store/online_feature_serving_and_fetching_bigquery_data_with_feature_store.ipynb\">\n",
        "      <img src=\"https://lh3.googleusercontent.com/UiNooY4LUgW_oTvpsNhPpQzsstV5W8F7rYgxgGBD85cWJoLmrOzhVs_ksK_vgx40SHs7jCqkTkCk=e14-rj-sc0xffffff-h130-w32\" alt=\"Vertex AI logo\">\n",
        "      Open in Vertex AI Workbench\n",
        "    </a>\n",
        "  </td>                                                                                               \n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WWNCLbZZ6MLi"
      },
      "source": [
        "## Overview\n",
        "\n",
        "This tutorial demonstrates how to use `Vertex AI Feature Store` for online serving and fetching of feature values in `BigQuery`.\n",
        "\n",
        "Learn more about [Vertex AI Feature Store](https://cloud.google.com/vertex-ai/docs/featurestore/overview)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CBeo3dIqJVDd"
      },
      "source": [
        "### Objective\n",
        "\n",
        "In this tutorial, you learn how to create and use an online feature store instance to host and serve data in `BigQuery` with `Vertex AI Feature Store` in an end to end workflow of feature values serving and fetching user journey.\n",
        "\n",
        "This tutorial uses the following Google Cloud ML services and resources:\n",
        "\n",
        "- `Vertex AI Feature Store`\n",
        "\n",
        "The steps performed include:\n",
        "\n",
        "- Provision an online feature store instance to host and serve data.\n",
        "- Register a `BigQuery` view with the online feature store instance and set up the sync job.\n",
        "- Use the online server to fetch feature values for online prediction."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SbCa7Pcpqgaz"
      },
      "source": [
        "### Dataset\n",
        "\n",
        "This tutorial uses the [theLook_eCommerce](https://pantheon.corp.google.com/marketplace/product/bigquery-public-data/thelook-ecommerce) dataset from the `BigQuery` public datasets.\n",
        "\n",
        "The Look eCommerce has developed a sales prediction model for their merchandise. The model uses the following data:\n",
        "\n",
        "* Product name\n",
        "* Category\n",
        "* Brand\n",
        "* Cost\n",
        "* Retail price\n",
        "* Number of orders over the past 30 days, classified as good or bad based on status\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nrggkyCUrhZM"
      },
      "source": [
        "### Costs\n",
        "\n",
        "This tutorial uses billable components of Google Cloud:\n",
        "\n",
        "* `Vertex AI`\n",
        "* `BigQuery`\n",
        "\n",
        "Learn about [Vertex AI pricing](https://cloud.google.com/vertex-ai/pricing) and\n",
        "[BigQuery pricing](https://cloud.google.com/bigquery/pricing)\n",
        "and use the [Pricing Calculator](https://cloud.google.com/products/calculator/)\n",
        "to generate a cost estimate based on your projected usage."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yTJiDCrYsOmT"
      },
      "source": [
        "## Installation\n",
        "\n",
        "Install the following packages required to execute this notebook."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GAqbE5Z2sTVM"
      },
      "outputs": [],
      "source": [
        "# Install the packages\n",
        "! pip3 install --upgrade --quiet google-cloud-aiplatform\\\n",
        "                                 google-cloud-bigquery\\\n",
        "                                 db-dtypes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "np60_uuCs7X5"
      },
      "source": [
        "### Colab only: Uncomment the following cell to restart the kernel."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_u0aEgaSs-3v"
      },
      "outputs": [],
      "source": [
        "# # Automatically restart kernel after installs so that your environment can access the new packages\n",
        "# import IPython\n",
        "\n",
        "# app = IPython.Application.instance()\n",
        "# app.kernel.do_shutdown(True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mdqw6ADTtJRI"
      },
      "source": [
        "## Before you begin\n",
        "\n",
        "### Set up your Google Cloud project\n",
        "\n",
        "**The following steps are required, regardless of your notebook environment.**\n",
        "\n",
        "1. [Select or create a Google Cloud project](https://console.cloud.google.com/cloud-resource-manager). When you first create an account, you get a $300 free credit towards your compute/storage costs.\n",
        "\n",
        "2. [Make sure that billing is enabled for your project](https://cloud.google.com/billing/docs/how-to/modify-project).\n",
        "\n",
        "3. [Enable the Vertex AI API](https://console.cloud.google.com/flows/enableapi?apiid=aiplatform.googleapis.com).\n",
        "\n",
        "4. If you are running this notebook locally, you need to install the [Cloud SDK](https://cloud.google.com/sdk)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bFANidV0tPbo"
      },
      "source": [
        "#### Set your project ID\n",
        "\n",
        "**If you don't know your project ID**, try the following:\n",
        "* Run `gcloud config list`.\n",
        "* Run `gcloud projects list`.\n",
        "* See the support page: [Locate the project ID](https://support.google.com/googleapi/answer/7014113)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t5cutPRQtQ7m"
      },
      "outputs": [],
      "source": [
        "PROJECT_ID = \"[your-project-id]\"  # @param {type:\"string\"}\n",
        "\n",
        "# Set the project id\n",
        "! gcloud config set project {PROJECT_ID}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lfY8yWnbtZ0K"
      },
      "source": [
        "#### Region\n",
        "\n",
        "You can also change the `REGION` variable used by Vertex AI. Learn more about [Vertex AI regions](https://cloud.google.com/vertex-ai/docs/general/locations). Note that the new API is currently only available in the following regions:\n",
        "* `us-centra1`\n",
        "* `us-east1`\n",
        "* `us-east4`\n",
        "* `us-west1`\n",
        "* `us-west2`\n",
        "* `us-west3`\n",
        "* `europe-west2`\n",
        "* `europe-west3`\n",
        "* `europe-west4`\n",
        "* `europe-west8`\n",
        "* `asia-southeast1`\n",
        "* `asia-northeast2`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G6iMMALZthFM"
      },
      "outputs": [],
      "source": [
        "REGION = \"us-east1\"  # @param {type: \"string\"}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ni5jx6RGtzG3"
      },
      "source": [
        "### Authenticate your Google Cloud account\n",
        "\n",
        "Depending on your Jupyter environment, you may have to manually authenticate. Follow the relevant instructions below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UzsMphY2t4-v"
      },
      "source": [
        "**1. Vertex AI Workbench**\n",
        "* Do nothing as you are already authenticated."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R_OnJm_Yt8bw"
      },
      "source": [
        "**2. Local JupyterLab instance, uncomment and run:**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x4ybIfzhuAOc"
      },
      "outputs": [],
      "source": [
        "# ! gcloud auth login"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gmnRqX6BuBnx"
      },
      "source": [
        "**3. Colab, uncomment and run:**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uN9JoC1buE9P"
      },
      "outputs": [],
      "source": [
        "# from google.colab import auth\n",
        "# auth.authenticate_user()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YNAvMVJjuH5b"
      },
      "source": [
        "**4. Service account or other**\n",
        "* See how to grant Cloud Storage permissions to your service account at https://cloud.google.com/storage/docs/gsutil/commands/iam#ch-examples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OMCl0avIusKl"
      },
      "source": [
        "### Import libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ifbIQuN1uz2r"
      },
      "outputs": [],
      "source": [
        "from google.cloud import aiplatform, bigquery\n",
        "from google.cloud.aiplatform_v1 import (FeatureOnlineStoreAdminServiceClient,\n",
        "                                        FeatureOnlineStoreServiceClient,\n",
        "                                        FeatureRegistryServiceClient)\n",
        "from google.cloud.aiplatform_v1.types import feature as feature_pb2\n",
        "from google.cloud.aiplatform_v1.types import feature_group as feature_group_pb2\n",
        "from google.cloud.aiplatform_v1.types import \\\n",
        "    feature_online_store as feature_online_store_pb2\n",
        "from google.cloud.aiplatform_v1.types import \\\n",
        "    feature_online_store_admin_service as \\\n",
        "    feature_online_store_admin_service_pb2\n",
        "from google.cloud.aiplatform_v1.types import \\\n",
        "    feature_online_store_service as feature_online_store_service_pb2\n",
        "from google.cloud.aiplatform_v1.types import \\\n",
        "    feature_registry_service as feature_registry_service_pb2\n",
        "from google.cloud.aiplatform_v1.types import feature_view as feature_view_pb2\n",
        "from google.cloud.aiplatform_v1.types import \\\n",
        "    featurestore_service as featurestore_service_pb2\n",
        "from google.cloud.aiplatform_v1.types import io as io_pb2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ooJNSOvu6Q5"
      },
      "source": [
        "### Initialize Vertex AI SDK for Python\n",
        "\n",
        "Initialize the Vertex AI SDK for Python for your project."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mLTm3pquu9ar"
      },
      "outputs": [],
      "source": [
        "aiplatform.init(project=PROJECT_ID, location=REGION)\n",
        "\n",
        "API_ENDPOINT = f\"{REGION}-aiplatform.googleapis.com\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X-jc5QHxrV5G"
      },
      "source": [
        "## Set up feature data in BigQuery\n",
        "\n",
        "In this tutorial, you want to recompute and update this data on a daily basis to provide real-time predictions, so that the online prediction application always uses the latest data.\n",
        "\n",
        "Retrieve the number of orders as of the current time and join the retrieved data with the `bigquery-public-data.thelook_ecommerce.products` table:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m7BP5Ft4rV5H"
      },
      "outputs": [],
      "source": [
        "feature_extract_query = \"\"\"\n",
        "WITH\n",
        " product_order_agg AS (\n",
        "   SELECT cast(product_id as string) as entity_id,\n",
        "     countif(status in (\"Shipped\", \"Complete\")) as good_order_count,\n",
        "     countif(status in (\"Returned\", \"Cancelled\")) as bad_order_count\n",
        "   FROM `bigquery-public-data.thelook_ecommerce.order_items`\n",
        "   WHERE\n",
        "     timestamp_trunc(created_at, day) >= timestamp_trunc(timestamp_sub(CURRENT_TIMESTAMP(), interval 30 day), day) and\n",
        "     timestamp_trunc(created_at, day) < timestamp_trunc(CURRENT_TIMESTAMP(), day)\n",
        "   group by 1\n",
        "   order by entity_id),\n",
        " product_basic AS (\n",
        "   SELECT cast(id as string) AS entity_id,\n",
        "     lower(name) as name,\n",
        "     lower(category) as category,\n",
        "     lower(brand) as brand,\n",
        "     cost,\n",
        "     retail_price\n",
        "   FROM   bigquery-public-data.thelook_ecommerce.products)\n",
        "SELECT *, current_timestamp() as feature_timestamp\n",
        "FROM product_basic\n",
        "LEFT OUTER JOIN product_order_agg\n",
        "USING (entity_id)\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ATHTdLGIrV5H"
      },
      "source": [
        "#### View the retrieved data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vX94txQNrV5H"
      },
      "outputs": [],
      "source": [
        "bq_client = bigquery.Client(project=PROJECT_ID)\n",
        "\n",
        "product_data = bq_client.query(feature_extract_query).result().to_dataframe()\n",
        "\n",
        "print(product_data.shape)\n",
        "product_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7qAliA6jrV5I"
      },
      "source": [
        "Now that the data is joined with the BigQuery table, you're ready to set up online serving. You have two options:\n",
        "\n",
        "* Materialize the data into a dedicated table.\n",
        "* Create a BigQuery view that regenerates every time it's queried.\n",
        "\n",
        "This tutorial demonstrates the latter option, that is, how to create a BigQuery view that regenerates with each query.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2PwjwWbxs7SR"
      },
      "source": [
        "## Create BigQuery dataset\n",
        "\n",
        "Create a BigQuery dataset to hold the BigQuery view for the demo. Since the source data for this demo is located in the `US` region, the dataset must also be located in the `US` region. If you use your own data and dataset, you can also use that dataset to create the BigQuery view.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3IDir7vWrV5I"
      },
      "outputs": [],
      "source": [
        "# First, create a dataset if it does not already exist. The source data for this demo is located in the US region, so the dataset must also be located in the US region.\n",
        "\n",
        "BQ_DATASET_ID = \"featurestore_demo\"  # @param {type:\"string\"}\n",
        "dataset = bigquery.Dataset(f\"{PROJECT_ID}.{BQ_DATASET_ID}\")\n",
        "dataset.location = \"US\"\n",
        "dataset = bq_client.create_dataset(\n",
        "    dataset, exists_ok=True, timeout=30\n",
        ")  # Make an API request.\n",
        "# Confirm dataset created.\n",
        "print(f\"Created dataset {dataset}.{BQ_DATASET_ID}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZugQMKdLtYm7"
      },
      "source": [
        "#### Create a BigQuery view"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CN08i_7prV5J"
      },
      "outputs": [],
      "source": [
        "# Now, create the view\n",
        "\n",
        "BQ_VIEW_ID = \"product_features\"  # @param {type:\"string\"}\n",
        "BQ_VIEW_ID_FQN = f\"{PROJECT_ID}.{BQ_DATASET_ID}.{BQ_VIEW_ID}\"\n",
        "view = bigquery.Table(BQ_VIEW_ID_FQN)\n",
        "view.view_query = feature_extract_query\n",
        "view = bq_client.create_table(view, exists_ok=True)\n",
        "\n",
        "print(f\"Created {view.table_type}: {str(view.reference)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lpZjusr9rV5J"
      },
      "source": [
        "## Set up and start online serving\n",
        "\n",
        "Now for the exciting part! To serve data in a feature store, you need to do the following:\n",
        "\n",
        "1. Create an online store cluster to host the data.\n",
        "    * Create a `FeatureOnlineStore` instance with autoscaling.\n",
        "1. Define the data (`FeatureView`) to be served by the newly-created instance. This can either map to\n",
        "    * The BigQuery view that you just created for serving data.\n",
        "    * The `FeatureGroup` and `Feature` we will create to host feature metadata.\n",
        "\n",
        "Bigtable serving latency is affected by the (Bigtable) load. However, when Bigtable is not overloaded, benchmarks show that the expected server-side latency is around 30 ms, measured at around 100 qps. The client-side latency is expected to be more than 5 ms higher than the server-side latency."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZbAVOgZ5KVpi"
      },
      "source": [
        "### Initialize Admin Service Client\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1HGkUlrDrV5P"
      },
      "outputs": [],
      "source": [
        "admin_client = FeatureOnlineStoreAdminServiceClient(\n",
        "    client_options={\"api_endpoint\": API_ENDPOINT}\n",
        ")\n",
        "registry_client = FeatureRegistryServiceClient(\n",
        "    client_options={\"api_endpoint\": API_ENDPOINT}\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GrPQH-KwrV5Q"
      },
      "source": [
        "### Create online store instance\n",
        "\n",
        "To create an online store instance.\n",
        "Create a `FeatureOnlineStore` instance with autoscaling."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ycuXEY_SrV5Q"
      },
      "outputs": [],
      "source": [
        "FEATURE_ONLINE_STORE_ID = \"the_look_demo_unique\"  # @param {type:\"string\"}\n",
        "\n",
        "online_store_config = feature_online_store_pb2.FeatureOnlineStore(\n",
        "    bigtable=feature_online_store_pb2.FeatureOnlineStore.Bigtable(\n",
        "        auto_scaling=feature_online_store_pb2.FeatureOnlineStore.Bigtable.AutoScaling(\n",
        "            min_node_count=1, max_node_count=3, cpu_utilization_target=50\n",
        "        )\n",
        "    )\n",
        ")\n",
        "\n",
        "create_store_lro = admin_client.create_feature_online_store(\n",
        "    feature_online_store_admin_service_pb2.CreateFeatureOnlineStoreRequest(\n",
        "        parent=f\"projects/{PROJECT_ID}/locations/{REGION}\",\n",
        "        feature_online_store_id=FEATURE_ONLINE_STORE_ID,\n",
        "        feature_online_store=online_store_config,\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "igOmzHxx1C0X"
      },
      "source": [
        "### Verify online store instance creation\n",
        "\n",
        "After the long-running operation (LRO) is complete, show the result.\n",
        "\n",
        "> **Note:** This operation might take up to 10 minutes to complete."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zDDZdSVzrV5Q"
      },
      "outputs": [],
      "source": [
        "# Wait for the LRO to finish and get the LRO result.\n",
        "print(create_store_lro.result())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlJ7gMSAH8lm"
      },
      "source": [
        "Verify that the `FeatureOnlineStore` instance is created by listing all online stores for the location."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iIa8IkE_rV5R"
      },
      "outputs": [],
      "source": [
        "# Use list to verify the store is created.\n",
        "admin_client.list_feature_online_stores(\n",
        "    parent=f\"projects/{PROJECT_ID}/locations/{REGION}\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HQr7Q-E0rV5f"
      },
      "source": [
        "### Create feature view instance\n",
        "\n",
        "After creating a `FeatureOnlineStore` instance, you can define the features to serve with it. To do this, create a `FeatureView` instance, which specifies the following:\n",
        "\n",
        "* A data source (BigQuery table or view URI or FeatureGroup/features ) synced to the `FeatureOnlineStore` instance for serving.\n",
        "* The cron schedule to run the sync pipeline.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zWgUtTfcpwxC"
      },
      "source": [
        "#### Option 1: Create featureView directly with BQ source"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r1Uz157IBX__"
      },
      "source": [
        "##### Data source preparation guidelines for BigQuery data source\n",
        "\n",
        "If the feature data for online serving is not already available in a BigQuery table or view, you can create a BigQuery dataset and table, and then load the data into it.\n",
        "\n",
        "Note that if you choose to use BigQuery source, Feature Store only provides the option to snapshot and sync the entire BigQuery table or view for online serving. You need to construct this table or view to reflect the latest data to be served. Therefore, a timestamp column is not needed, since timestamps aren't used to differentiate the feature values.\n",
        "\n",
        "Use the following guidelines to understand the schema and constraints while creating the BigQuery source:\n",
        "\n",
        "* The BigQuery table or view *must* have a column with `string` values to use as the (entity) IDs. You'll need to specify that this column is the ID column during `FeatureView` creation. Note that the size of each value in this column must be less than 4 KB.\n",
        "* Feature Store ignores rows containing the duplicate values in the ID column and arbitrarily picks one to use for online serving. This might occur if the table or view has multiple feature values recorded at different timestamps. In this case, you need to sync the data in your table based on the latest timestamp before serving.\n",
        "* Feature Store considers each row as a complete record. For example, if a feature value is missing in one of the columns, then it's considered as a null value.\n",
        "* Provide values for each feature is a separate column. Supported data types are `bool`, `int`, `double`, `string`, timestamp, arrays of these data types, and bytes. Note that the timestamp data type is converted to `int64` during data sync.\n",
        "* Feature Store validates the schema during `FeatureView` creation. However, it doesn't revalidate the schema during each data sync. Columns with unsupported data types added after `FeatureView` creation time are ignored.\n",
        "* The BigQuery table or view must be in either the same region as the online store, or in a multiregion that overlaps with the online store. For example, if the online store is in `us-central`, the BigQuery source can be in `us-central` or in `US`.\n",
        "\n",
        "![5ZsYcXbUAVp92ad.png](data:image/png;base64,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)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bz478SUUrV5g"
      },
      "outputs": [],
      "source": [
        "FEATURE_VIEW_ID = \"product\"  # @param {type:\"string\"}\n",
        "CRON_SCHEDULE = \"TZ=America/Los_Angeles 56 * * * *\"  # @param {type:\"string\"}\n",
        "\n",
        "big_query_source = feature_view_pb2.FeatureView.BigQuerySource(\n",
        "    uri=f\"bq://{BQ_VIEW_ID_FQN}\", entity_id_columns=[\"entity_id\"]\n",
        ")\n",
        "\n",
        "sync_config = feature_view_pb2.FeatureView.SyncConfig(cron=CRON_SCHEDULE)\n",
        "\n",
        "create_view_lro = admin_client.create_feature_view(\n",
        "    feature_online_store_admin_service_pb2.CreateFeatureViewRequest(\n",
        "        parent=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}\",\n",
        "        feature_view_id=FEATURE_VIEW_ID,\n",
        "        feature_view=feature_view_pb2.FeatureView(\n",
        "            big_query_source=big_query_source,\n",
        "            sync_config=sync_config,\n",
        "        ),\n",
        "    )\n",
        ")\n",
        "\n",
        "# Wait for LRO to complete and show result\n",
        "print(create_view_lro.result())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uLH3NI3bp70w"
      },
      "source": [
        "#### Option 2: Create featureView with FeatureGroups/Feature\n",
        "\n",
        "> **Note:** If you've already created a feature view with BQ source, skip this section and go to [Verify online store instance creation](#scrollTo=igOmzHxx1C0X)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tYrwH7OOc1CY"
      },
      "source": [
        "#### [Optional] Create FeatureGroup/Features\n",
        "\n",
        "Create a FeatureGroup pointing to the created BigQuery view for the demo. We will then create features for each column we would like to register.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XwY5CYLlBYAB"
      },
      "source": [
        "##### Data source preparation guidelines for Feature Registry data source\n",
        "\n",
        "Note that if you choose to use Feature Registry source, Feature Store only provides the option to support time-series sources for which Feature Store will generate latest featureValues.\n",
        "\n",
        "Use the following guidelines to understand the schema and constraints while creating the BigQuery source:\n",
        "\n",
        "* The BigQuery table or view *must* have a column with `string` values to use as the (entity) IDs. You'll need to specify that this column is the ID column during `FeatureGroup` creation. Note that the size of each value in this column must be less than 4 KB.\n",
        "* The BigQuery table or view *must* have a column named `feature_timestamp` with `timestamp` values to use as timestamp column.\n",
        "* Feature Registry sources are treated as sparse by default i.e. a point in time lookup (BQ.ML_FEATURES_AT_TIME()) to generate latest featureValues per entityId.\n",
        "* Provide values for each feature is a separate column. Supported data types are `bool`, `int`, `double`, `string`, timestamp, arrays of these data types, and bytes. Note that the timestamp data type is converted to `int64` during data sync.\n",
        "* Feature Store validates the schema during `FeatureView`/`FeatureGroup`/`Featre` creation. However, it doesn't revalidate the schema during each data sync. Columns with unsupported data types added after `FeatureView` creation time are ignored.\n",
        "* The BigQuery table or view must be in either the same region as the online store, or in a multiregion that overlaps with the online store. For example, if the online store is in `us-central`, the BigQuery source can be in `us-central` or in `US`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7p84qK96c1CY"
      },
      "outputs": [],
      "source": [
        "FEATURE_GROUP_ID = \"product_features_unique\"  # @param {type: \"string\"}\n",
        "FEATURE_IDS = [\n",
        "    \"good_order_count\",\n",
        "    \"bad_order_count\",\n",
        "    \"category\",\n",
        "    \"name\",\n",
        "    \"brand\",\n",
        "    \"cost\",\n",
        "    \"retail_price\",\n",
        "]  # @param"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kijyrLcxc1CZ"
      },
      "outputs": [],
      "source": [
        "# Now, create the featureGroup\n",
        "\n",
        "feature_group_config = feature_group_pb2.FeatureGroup(\n",
        "    big_query=feature_group_pb2.FeatureGroup.BigQuery(\n",
        "        big_query_source=io_pb2.BigQuerySource(input_uri=f\"bq://{BQ_VIEW_ID_FQN}\")\n",
        "    )\n",
        ")\n",
        "\n",
        "create_group_lro = registry_client.create_feature_group(\n",
        "    feature_registry_service_pb2.CreateFeatureGroupRequest(\n",
        "        parent=f\"projects/{PROJECT_ID}/locations/{REGION}\",\n",
        "        feature_group_id=FEATURE_GROUP_ID,\n",
        "        feature_group=feature_group_config,\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kqm2VV90XVTv"
      },
      "source": [
        "After the long-running operation (LRO) is complete, show the result."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kGpPMW6rilCT"
      },
      "outputs": [],
      "source": [
        "print(create_group_lro.result())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8Z8k7ydNXo6k"
      },
      "outputs": [],
      "source": [
        "create_feature_lros = []\n",
        "for id in FEATURE_IDS:\n",
        "    create_feature_lros.append(\n",
        "        registry_client.create_feature(\n",
        "            featurestore_service_pb2.CreateFeatureRequest(\n",
        "                parent=f\"projects/{PROJECT_ID}/locations/{REGION}/featureGroups/{FEATURE_GROUP_ID}\",\n",
        "                feature_id=id,\n",
        "                feature=feature_pb2.Feature(),\n",
        "            )\n",
        "        )\n",
        "    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oTvYojJgXVTv"
      },
      "outputs": [],
      "source": [
        "for lro in create_feature_lros:\n",
        "    print(lro.result())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Cr-UX5_IOGB"
      },
      "source": [
        "Create a `FeatureView` instance for the BigQuery view and FeatureGroup/features you created earlier in this tutorial and set the sync time and frequency to 1:00 AM PST daily."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zhTw5RIugnRp"
      },
      "outputs": [],
      "source": [
        "FEATURE_VIEW_ID = \"registry_product\"  # @param {type:\"string\"}\n",
        "CRON_SCHEDULE = \"TZ=America/Los_Angeles 56 * * * *\"  # @param {type:\"string\"}\n",
        "\n",
        "feature_registry_source = feature_view_pb2.FeatureView.FeatureRegistrySource(\n",
        "    feature_groups=[\n",
        "        feature_view_pb2.FeatureView.FeatureRegistrySource.FeatureGroup(\n",
        "            feature_group_id=FEATURE_GROUP_ID, feature_ids=FEATURE_IDS\n",
        "        )\n",
        "    ]\n",
        ")\n",
        "\n",
        "sync_config = feature_view_pb2.FeatureView.SyncConfig(cron=CRON_SCHEDULE)\n",
        "\n",
        "create_view_lro = admin_client.create_feature_view(\n",
        "    feature_online_store_admin_service_pb2.CreateFeatureViewRequest(\n",
        "        parent=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}\",\n",
        "        feature_view_id=FEATURE_VIEW_ID,\n",
        "        feature_view=feature_view_pb2.FeatureView(\n",
        "            feature_registry_source=feature_registry_source,\n",
        "            sync_config=sync_config,\n",
        "        ),\n",
        "    )\n",
        ")\n",
        "\n",
        "# Wait for LRO to complete and show result\n",
        "print(create_view_lro.result())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wXk90azuJM0z"
      },
      "source": [
        "Verify that the `FeatureView` instance is created by listing all the feature views within the online store."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YXysnbxarV5g"
      },
      "outputs": [],
      "source": [
        "# Again, list all feature view under the FEATURE_ONLINE_STORE_ID to confirm\n",
        "admin_client.list_feature_views(\n",
        "    parent=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H1t0xA5XB_3n"
      },
      "source": [
        "###Note\n",
        "Syncing data into FeatureOnlineStores is a public Preview release. By using the feature, you acknowledge that you're aware of the open issues and that this preview is provided “as is” under the pre-GA terms of service.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "07Qd9tTOrV5h"
      },
      "source": [
        "### Start sync manually\n",
        "\n",
        "The sync pipeline executes according to the schedule specified in the `FeatureView` instance.\n",
        "\n",
        "To skip the wait and execute the sync pipeline immediately, start the sync manually."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pRkwlk-RrV5h"
      },
      "outputs": [],
      "source": [
        "sync_response = admin_client.sync_feature_view(\n",
        "    feature_view=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}/featureViews/{FEATURE_VIEW_ID}\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R6vBr5B-64PI"
      },
      "source": [
        "The `sync_response` contains the ID of the sync job.\n",
        "\n",
        "Use `get_feature_view_sync` to check the status of the job."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kvmoG-99rV5h"
      },
      "outputs": [],
      "source": [
        "import time\n",
        "\n",
        "while True:\n",
        "    feature_view_sync = admin_client.get_feature_view_sync(\n",
        "        name=sync_response.feature_view_sync\n",
        "    )\n",
        "    if feature_view_sync.run_time.end_time.seconds > 0:\n",
        "        status = \"Succeed\" if feature_view_sync.final_status.code == 0 else \"Failed\"\n",
        "        print(f\"Sync {status} for {feature_view_sync.name}.\")\n",
        "        break\n",
        "    else:\n",
        "        print(\"Sync ongoing, waiting for 30 seconds.\")\n",
        "    time.sleep(30)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KUKDx4a72a_M"
      },
      "source": [
        "Use `list_feature_view_syncs` to view all your syncs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NCwJFqYB2X5n"
      },
      "outputs": [],
      "source": [
        "admin_client.list_feature_view_syncs(\n",
        "    parent=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}/featureViews/{FEATURE_VIEW_ID}\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2xThC5K1rV5h"
      },
      "source": [
        "### Start online serving\n",
        "\n",
        "After the data sync is complete, use the `FetchFeatureValues` API to retrieve the data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DzkUeWAYrV5i"
      },
      "outputs": [],
      "source": [
        "data_client = FeatureOnlineStoreServiceClient(\n",
        "    client_options={\"api_endpoint\": API_ENDPOINT}\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iWT2YDU7PgnF"
      },
      "source": [
        "The `FeatureView` already defines the features needed for the model (via the BigQuery view in this demo). To fetch the data, submit a `fetch_feature_values` request specifying the `FeatureView` resource path and the ID of the entity."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DWPvbs9DrV5i"
      },
      "outputs": [],
      "source": [
        "data_client.fetch_feature_values(\n",
        "    request=feature_online_store_service_pb2.FetchFeatureValuesRequest(\n",
        "        feature_view=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}/featureViews/{FEATURE_VIEW_ID}\",\n",
        "        data_key=feature_online_store_service_pb2.FeatureViewDataKey(key=\"28098\"),\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8RcbT6BwV2s0"
      },
      "source": [
        "You can specify the response format using `FetchFeatureValuesRequest.Format`. If you don't specify a format, then the format is set to `KEY_VALUE`, by default. `PROTO_STRUCT` is another supported format."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kXRX7E8bWI3w"
      },
      "outputs": [],
      "source": [
        "data_client.fetch_feature_values(\n",
        "    request=feature_online_store_service_pb2.FetchFeatureValuesRequest(\n",
        "        feature_view=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}/featureViews/{FEATURE_VIEW_ID}\",\n",
        "        data_key=feature_online_store_service_pb2.FeatureViewDataKey(key=\"28098\"),\n",
        "        data_format=feature_online_store_service_pb2.FeatureViewDataFormat.PROTO_STRUCT,\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OR1ve2OyyiKq"
      },
      "source": [
        "## Cleaning up\n",
        "\n",
        "To clean up all Google Cloud resources used in this project, you can [delete the Google Cloud\n",
        "project](https://cloud.google.com/resource-manager/docs/creating-managing-projects#shutting_down_projects) you used for the tutorial.\n",
        "\n",
        "Otherwise, you can delete the individual resources you created in this tutorial."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uTa8-ut-rV5j"
      },
      "outputs": [],
      "source": [
        "# Delete Features\n",
        "for id in FEATURE_IDS:\n",
        "    registry_client.delete_feature(\n",
        "        name=f\"projects/{PROJECT_ID}/locations/{REGION}/featureGroups/{FEATURE_GROUP_ID}/features/{id}\"\n",
        "    )\n",
        "\n",
        "# Delete Featuregroup\n",
        "registry_client.delete_feature_group(\n",
        "    name=f\"projects/{PROJECT_ID}/locations/{REGION}/featureGroups/{FEATURE_GROUP_ID}\"\n",
        ")\n",
        "\n",
        "# Delete FeatureViews\n",
        "admin_client.delete_feature_view(\n",
        "    name=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}/featureViews/{FEATURE_VIEW_ID}\"\n",
        ")\n",
        "\n",
        "# Delete OnlineStore\n",
        "admin_client.delete_feature_online_store(\n",
        "    name=f\"projects/{PROJECT_ID}/locations/{REGION}/featureOnlineStores/{FEATURE_ONLINE_STORE_ID}\",\n",
        "    force=True,\n",
        ")\n",
        "\n",
        "# Delete BigQuery dataset. Uncomment and run the command below if you want to delete the BigQuery set.\n",
        "# Do this only if the dataset is created for this demo.\n",
        "# bq_client.delete_dataset(BQ_DATASET_ID, delete_contents=True, not_found_ok=True)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "online_feature_serving_and_fetching_bigquery_data_with_feature_store_bigtable.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}