xiaohei/model_garden
1
0
Fork 0
mirror of https://github.com/GoogleCloudPlatform/vertex-ai-samples.git synced 2026-09-26 14:42:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: Splitting legacy Feature Store colabs to a separate folder. (#2887)

Browse Source
This commit is contained in:
qijing93
2024-04-19 12:41:34 +00:00
committed by GitHub
parent badf6f4a61
commit b70be17865
5 changed files with 55 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
notebooks/official/feature_store/README.md
-52
View File
@@ -1,19 +1,4 @@
[Streaming ingestion SDK](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/feature_store/feature_store_streaming_ingestion_sdk.ipynb)
```
Learn how to ingest features from a `Pandas DataFrame` into your Vertex AI Feature Store using `write_feature_values` method from the Vertex AI SDK.
The steps performed include:
- Create `Feature Store`
- Create new `Entity Type` for your `Feature Store`
- Ingest feature values from `Pandas DataFrame` into `Feature Store`'s `Entity Types`.
```
   Learn more about [Vertex AI Feature Store](https://cloud.google.com/vertex-ai/docs/featurestore).
[Online feature serving and fetching of BigQuery data with Vertex AI Feature Store](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/feature_store/online_feature_serving_and_fetching_bigquery_data_with_feature_store.ipynb)
@@ -47,41 +32,4 @@ The steps performed include:
   Learn more about [Vertex AI Feature Store](https://cloud.google.com/vertex-ai/docs/featurestore/overview).
[Using Vertex AI Feature Store with Pandas Dataframe](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/feature_store/sdk-feature-store-pandas.ipynb)
```
Learn how to use `Vertex AI Feature Store` with pandas Dataframe.
The steps performed include:
- Create Featurestore, entity types and features.
- Ingest feature values from Pandas DataFrame into Feature Store's Entity types.
- Read Entity feature values from Online Feature Store into Pandas DataFrame.
- Batch serve feature values from your Feature Store into Pandas DataFrame.
- Online serving with updated feature values.
- Point-in-time correctness to fetch feature values for training.
```
   Learn more about [Vertex AI Feature Store](https://cloud.google.com/vertex-ai/docs/featurestore).
[Online and Batch predictions using Vertex AI Feature Store](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/feature_store/sdk-feature-store.ipynb)
```
Learn how to use `Vertex AI Feature Store` to import feature data, and to access the feature data for both online serving and offline tasks, such as training.
The steps performed include:
- Create featurestore, entity type, and feature resources.
- Import feature data into `Vertex AI Feature Store` resource.
- Serve online prediction requests using the imported features.
- Access imported features in offline jobs, such as training jobs.
- Use streaming ingestion to ingest small amount of data.
```
   Learn more about [Vertex AI Feature Store](https://cloud.google.com/vertex-ai/docs/featurestore).
notebooks/official/feature_store/feature_store_streaming_ingestion_sdk.ipynb
-777
View File
@@ -1,777 +0,0 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ur8xi4C7S06n"
},
"outputs": [],
"source": [
"# Copyright 2022 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": "JAPoU8Sm5E6e"
},
"source": [
"# Vertex AI Feature Store (Legacy): Streaming import SDK\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/feature_store_streaming_ingestion_sdk.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/feature_store_streaming_ingestion_sdk.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/feature_store_streaming_ingestion_sdk.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": "24743cf4a1e1"
},
"source": [
"**_NOTE_**: This notebook has been tested in the following environment:\n",
"\n",
"* Python version = 3.9"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "tvgnzT1CKxrO"
},
"source": [
"## Overview\n",
"\n",
"This notebook demonstrates how to use streaming import at the SDK layer in Vertex AI Feature Store (Legacy).\n",
"\n",
"Learn more about [Vertex AI Feature Store](https://cloud.google.com/vertex-ai/docs/featurestore)."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "d975e698c9a4"
},
"source": [
"### Objective\n",
"\n",
"In this tutorial, you learn how to import features from a `Pandas DataFrame` into Vertex AI Feature Store (Legacy) using `write_feature_values` method from the Vertex AI SDK.\n",
"\n",
"This tutorial uses the following Google Cloud ML services and resources:\n",
"\n",
"- Vertex AI Feature Store (Legacy)\n",
"\n",
"\n",
"The steps performed include:\n",
"\n",
"- Create a featurestore.\n",
"- Create a new entity type for your featurestore.\n",
"- Import feature values from `Pandas DataFrame` into the entity type in the featurestore."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "08d289fa873f"
},
"source": [
"### Dataset\n",
"\n",
"The dataset used for this notebook is the penguins dataset from [BigQuery public datasets](https://cloud.google.com/bigquery/public-data). This dataset has the following features: `culmen_length_mm`, `culmen_depth_mm`, `flipper_length_mm`, `body_mass_g`, `species`, and `sex`."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "aed92deeb4a0"
},
"source": [
"### Costs\n",
"\n",
"This tutorial uses billable components of Google Cloud:\n",
"\n",
"* Vertex AI\n",
"\n",
"Learn about [Vertex AI\n",
"pricing](https://cloud.google.com/vertex-ai/pricing) and use the [Pricing\n",
"Calculator](https://cloud.google.com/products/calculator/)\n",
"to generate a cost estimate based on your projected usage.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "i7EUnXsZhAGF"
},
"source": [
"## Installation\n",
"\n",
"Install the following packages required to execute this notebook."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "2b4ef9b72d43"
},
"outputs": [],
"source": [
"# Install the packages\n",
"! pip3 install --upgrade google-cloud-aiplatform\\\n",
" google-cloud-bigquery\\\n",
" numpy\\\n",
" pandas\\\n",
" db-dtypes\\\n",
" pyarrow -q"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "58707a750154"
},
"source": [
"### Colab only: Uncomment the following cell to restart the kernel."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "f200f10a1da3"
},
"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": "BF1j6f9HApxa"
},
"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": "WReHDGG5g0XY"
},
"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": "oM1iC_MfAts1"
},
"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": "region"
},
"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)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "kljmKgilI_de"
},
"outputs": [],
"source": [
"REGION = \"us-central1\" # @param {type: \"string\"}"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "sBCra4QMA2wR"
},
"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": "74ccc9e52986"
},
"source": [
"**1. Vertex AI Workbench**\n",
"* Do nothing as you are already authenticated."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "de775a3773ba"
},
"source": [
"**2. Local JupyterLab instance, uncomment and run:**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "254614fa0c46"
},
"outputs": [],
"source": [
"# ! gcloud auth login"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ef21552ccea8"
},
"source": [
"**3. Colab, uncomment and run:**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "603adbbf0532"
},
"outputs": [],
"source": [
"# from google.colab import auth\n",
"# auth.authenticate_user()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "f6b2ccc891ed"
},
"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": "EsCYkJ4IU-z4"
},
"source": [
"### UUID\n",
"\n",
"If you are in a live tutorial session, you might be using a shared test account or project. To avoid name collisions between users on resources created, you create a uuid for each instance session, and append it onto the name of resources you create in this tutorial."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "4jWj2DSTU9my"
},
"outputs": [],
"source": [
"import random\n",
"import string\n",
"\n",
"\n",
"# Generate a uuid of a specifed length(default=8)\n",
"def generate_uuid(length: int = 8) -> str:\n",
" return \"\".join(random.choices(string.ascii_lowercase + string.digits, k=length))\n",
"\n",
"\n",
"UUID = generate_uuid()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "960505627ddf"
},
"source": [
"### Import libraries"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "PyQmSRbKA8r-"
},
"outputs": [],
"source": [
"import numpy as np\n",
"import pandas as pd\n",
"from google.cloud import aiplatform, bigquery"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "init_aip:mbsdk,all"
},
"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": "0ep8KuQhI_df"
},
"outputs": [],
"source": [
"aiplatform.init(project=PROJECT_ID, location=REGION)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "k5XsEiAuEWUJ"
},
"source": [
"## Download and prepare the data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "rOd7Ixa1pqBY"
},
"outputs": [],
"source": [
"def download_bq_table(bq_table_uri: str) -> pd.DataFrame:\n",
" # Remove bq:// prefix if present\n",
" prefix = \"bq://\"\n",
" if bq_table_uri.startswith(prefix):\n",
" bq_table_uri = bq_table_uri[len(prefix) :]\n",
"\n",
" table = bigquery.TableReference.from_string(bq_table_uri)\n",
"\n",
" # Create a BigQuery client\n",
" bqclient = bigquery.Client(project=PROJECT_ID)\n",
"\n",
" # Download the table rows\n",
" rows = bqclient.list_rows(\n",
" table,\n",
" )\n",
" return rows.to_dataframe()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "SdX_m1Uppkfu"
},
"outputs": [],
"source": [
"BQ_SOURCE = \"bq://bigquery-public-data.ml_datasets.penguins\"\n",
"\n",
"# Download penguins BigQuery table\n",
"penguins_df = download_bq_table(BQ_SOURCE)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "QuQe6mSbFbhm"
},
"source": [
"### Prepare the data\n",
"\n",
"Feature values to be written to the featurestore can take the form of a list of `WriteFeatureValuesPayload` objects, a Python `dict` of the form\n",
"\n",
"`{entity_id : {feature_id : feature_value}, ...},`\n",
"\n",
"or a pandas `Dataframe`, where the `index` column holds the unique entity ID strings and each remaining column represents a feature. In this notebook, since you use a pandas `DataFrame` for ingesting features we convert the index column data type to `string` to be used as `Entity ID`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "cljxzJ3bqDer"
},
"outputs": [],
"source": [
"# Prepare the data\n",
"penguins_df.index = penguins_df.index.map(str)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "GSxrSdSY2ovn"
},
"outputs": [],
"source": [
"# Remove null values\n",
"NA_VALUES = [\"NA\", \".\"]\n",
"penguins_df = penguins_df.replace(to_replace=NA_VALUES, value=np.NaN).dropna()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "vgn4oQmSqdKI"
},
"source": [
"## Create featurestore and define schemas\n",
"\n",
"Vertex AI Feature Store (Legacy) organizes resources hierarchically in the following order:\n",
"\n",
"`Featurestore -> EntityType -> Feature`\n",
"\n",
"You must create these resources before you can import data into Vertex AI Feature Store (Legacy).\n",
"\n",
"Learn more about [Vertex AI Feature Store](https://cloud.google.com/vertex-ai/docs/featurestore)."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "yaHwdbGjZWTq"
},
"source": [
"### Create a featurestore\n",
"\n",
"You create a featurestore using `aiplatform.Featurestore.create` with the following parameters:\n",
"\n",
"* `featurestore_id (str)`: The ID to use for this featurestore, which will become the final component of the `featurestore` resource name. The value must be unique within the project and location.\n",
"* `online_store_fixed_node_count`: Configuration for online serving resources.\n",
"* `project`: Project to create the `EntityType` in. If not set, project set in `aiplatform.init` is used.\n",
"* `location`: Location to create the `EntityType` in. If not set, location set in `aiplatform.init` is used.\n",
"* `sync`: Whether to execute this creation synchronously."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "cImsONglqfxO"
},
"outputs": [],
"source": [
"FEATURESTORE_ID = f\"penguins_{UUID}\"\n",
"\n",
"penguins_feature_store = aiplatform.Featurestore.create(\n",
" featurestore_id=FEATURESTORE_ID,\n",
" online_store_fixed_node_count=1,\n",
" project=PROJECT_ID,\n",
" location=REGION,\n",
" sync=True,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "UfXgSD1VdzKb"
},
"source": [
"##### Verify that the featurestore is created\n",
"Check if the featurestore was successfully created by running the following code block."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "oud1OdfQd52r"
},
"outputs": [],
"source": [
"fs = aiplatform.Featurestore(\n",
" featurestore_name=FEATURESTORE_ID,\n",
" project=PROJECT_ID,\n",
" location=REGION,\n",
")\n",
"print(fs.gca_resource)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ep74rSlJWF3c"
},
"source": [
"### Create an entity type\n",
"\n",
"An entity type is a collection of semantically related features. You define your own entity types, based on the concepts that are relevant to your use case. For example, a movie service might have the entity types `movie` and `user`, which group related features that correspond to movies or users.\n",
"\n",
"Here, you create an entity type entity type named `penguin_entity_type` using `create_entity_type` with the following parameters:\n",
"* `entity_type_id (str)`: The ID to use for the `EntityType`, which will become the final component of the `EntityType` resource name. The value must be unique within a featurestore.\n",
"* `description`: Description of the `EntityType`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "zNzr-FlEr3tI"
},
"outputs": [],
"source": [
"ENTITY_TYPE_ID = f\"penguin_entity_type_{UUID}\"\n",
"\n",
"# Create penguin entity type\n",
"penguins_entity_type = penguins_feature_store.create_entity_type(\n",
" entity_type_id=ENTITY_TYPE_ID,\n",
" description=\"Penguins entity type\",\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CquSdTp7duVw"
},
"source": [
"##### Verify that the entity type is created\n",
"Check if the entity type was successfully created by running the following code block."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "76ocr_hJsG-t"
},
"outputs": [],
"source": [
"entity_type = penguins_feature_store.get_entity_type(entity_type_id=ENTITY_TYPE_ID)\n",
"\n",
"print(entity_type.gca_resource)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2vYV2UUFehwZ"
},
"source": [
"### Create features\n",
"A feature is a measurable property or attribute of an entity type. For example, `penguin` entity type has features such as `flipper_length_mm`, and `body_mass_g`. Features can be created within each entity type.\n",
"\n",
"When you create a feature, you specify its value type such as `DOUBLE`, and `STRING`. This value determines what value types you can import for a particular feature.\n",
"\n",
"Learn more about [Feature Value Types](https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.featurestores.entityTypes.features)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "WQ5EsPPbsSuE"
},
"outputs": [],
"source": [
"penguins_feature_configs = {\n",
" \"species\": {\n",
" \"value_type\": \"STRING\",\n",
" },\n",
" \"island\": {\n",
" \"value_type\": \"STRING\",\n",
" },\n",
" \"culmen_length_mm\": {\n",
" \"value_type\": \"DOUBLE\",\n",
" },\n",
" \"culmen_depth_mm\": {\n",
" \"value_type\": \"DOUBLE\",\n",
" },\n",
" \"flipper_length_mm\": {\n",
" \"value_type\": \"DOUBLE\",\n",
" },\n",
" \"body_mass_g\": {\"value_type\": \"DOUBLE\"},\n",
" \"sex\": {\"value_type\": \"STRING\"},\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AKRXJCPijM8w"
},
"source": [
"You can create features either using `create_feature` or `batch_create_features`. Here, for convinience, you have added all feature configs in one variabel, so we use `batch_create_features`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "tXOI1Onhs46x"
},
"outputs": [],
"source": [
"penguin_features = penguins_entity_type.batch_create_features(\n",
" feature_configs=penguins_feature_configs,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WBx26pZItUN4"
},
"source": [
"### Write features to the featurestore\n",
"Use the `write_feature_values` API to write a feature to the featurestore with the following parameter:\n",
"\n",
"* `instances`: Feature values to be written to the featurestore that can take the form of a list of `WriteFeatureValuesPayload` objects, a Python dict, or a pandas Dataframe.\n",
"\n",
"Streaming import has been introduced in the Vertex AI SDK under the **preview** namespace. Here, you pass the pandas `Dataframe` you created from penguins dataset as `instances` parameter.\n",
"\n",
"Learn more about [Streaming import API](https://github.com/googleapis/python-aiplatform/blob/e6933503d2d3a0f8a8f7ef8c178ed50a69ac2268/google/cloud/aiplatform/preview/featurestore/entity_type.py#L36)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "iUGI-ftltXqE"
},
"outputs": [],
"source": [
"penguins_entity_type.preview.write_feature_values(instances=penguins_df)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "STq67KHO3q_e"
},
"source": [
"## Read back written features\n",
"\n",
"Wait a few seconds for the write to propagate, then do an online read to confirm the write was successful."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "lwoMnze43r9G"
},
"outputs": [],
"source": [
"ENTITY_IDS = [str(x) for x in range(100)]\n",
"penguins_entity_type.read(entity_ids=ENTITY_IDS)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TpV-iwP9qw9c"
},
"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": "sx_vKniMq9ZX"
},
"outputs": [],
"source": [
"penguins_feature_store.delete(force=True)"
]
}
],
"metadata": {
"colab": {
"name": "feature_store_streaming_ingestion_sdk.ipynb",
"toc_visible": true
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
notebooks/official/feature_store/sdk-feature-store-pandas.ipynb
-1201
View File
File diff suppressed because it is too large Load Diff
notebooks/official/feature_store/sdk-feature-store.ipynb
-1362
View File
File diff suppressed because it is too large Load Diff