Addressed TW comments

Update dashboard instructions

.cloud-build/requirements.txt

@@ -11,3 +11,4 @@ google-cloud-storage
 google-cloud-build
 ratemate
 GitPython
+tqdm

notebooks/notebook_template.ipynb

@@ -74,7 +74,9 @@
       "source": [
         "## Overview\n",
         "\n",
-        "{TODO: Include a paragraph or two explaining what this example demonstrates, who should be interested in it, and what you need to know before you get started.}"
+        "{TODO: Include a paragraph or two explaining what this example demonstrates, who should be interested in it, and what you need to know before you get started.}\n",
+        "\n",
+        "Learn more about [web-doc-title](linkback-to-webdoc-page). {TODO: if more than one primary feature, add tag/linkback for each one}"
       ]
     },
     {

notebooks/notebook_template_review.py

@@ -1144,16 +1144,16 @@ def add_index(path: str,
         if args.desc:
             desc = replace_cl(desc.replace('`', ''))
             print('<br/>')
-            print(f'            {desc}.\n')
+            print(f'            {desc}\n')
             
             
         if args.linkback and linkbacks:
             num = len(tags)
             for _ in range(num):
                 if linkbacks[_].startswith("vertex-ai"):
-                    print(f' Learn more about <a href="https://cloud.google.com/{linkbacks[_]}." target="_blank">{replace_cl(tags[_])}</a>.\n')
+                    print(f' Learn more about <a href="https://cloud.google.com/{linkbacks[_]}" target="_blank">{replace_cl(tags[_])}</a>.\n')
                 else:
-                    print(f' Learn more about <a href="{linkbacks[_]}." target="_blank">{replace_cl(tags[_])}</a>.\n')
+                    print(f' Learn more about <a href="{linkbacks[_]}" target="_blank">{replace_cl(tags[_])}</a>.\n')
                     
         if args.steps:
             print("<devsite-expandable>\n")
@@ -1240,6 +1240,8 @@ def replace_cl(text : str ) -> str:
         'Vertex AI Prediction': '{{vertex_prediction_name}}',
         'Vertex TensorBoard': '{{vertex_tensorboard_name}}',
         'Vertex AI TensorBoard': '{{vertex_tensorboard_name}}',
+        'TensorBoard': '{{vertex_tensorboard_name}}',
+        'Tensorboard': '{{vertex_tensorboard_name}}',
         'Vertex ML Metadata': '{{vertex_metadata_name}}',
         'Vertex Pipelines': '{{vertex_pipelines_name}}',
         'Vertex AI Pipelines': '{{vertex_pipelines_name}}',
@@ -1265,6 +1267,8 @@ def replace_cl(text : str ) -> str:
         'Vertex AI': '{{vertex_ai_name}}',
         
         'Cloud Storage': '{{storage_name}}',
+        'GCS': '{{storage_name}}',
+        'GCP': '{{gcp_name}}',
         'TensorFlow Enterprise': '{{tf4gcp_name}}',
         'TensorFlow': '{{tensorflow_name}}',
     }
@@ -1320,7 +1324,7 @@ if args.web:
     print('            <th width="80px">Open in</th>')
     print('        </tr>')
     print('    </thead>')
-    print('    <tbody>')
+    print('    <tbody class="list">')
 
 if args.notebook_dir:
     if not os.path.isdir(args.notebook_dir):

notebooks/official/automl/get_started_automl_training.ipynb

@@ -64,7 +64,7 @@
         "\n",
         "This tutorial demonstrates how to use AutoML in production. This tutorial covers get started with AutoML training.\n",
         "\n",
-        "Learn more about [Vertex AI for AutoML](https://cloud.google.com/vertex-ai/docs/start/automl-users)."
+        "Learn more about [AutoML training](https://cloud.google.com/vertex-ai/docs/training-overview)."
       ]
     },
     {
@@ -872,6 +872,18 @@
         "The execution of the training pipeline will take upto > 30 minutes."
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3eaba926cdfa"
+      },
+      "outputs": [],
+      "source": [
+        "if os.getenv(\"IS_TESTING\"):\n",
+        "    sys.exit(0)"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,

notebooks/official/custom/custom-tabular-bq-managed-dataset.ipynb

@@ -147,8 +147,7 @@
         "# Install the packages\n",
         "! pip3 install --upgrade google-cloud-aiplatform \\\n",
         "                        google-cloud-storage \\\n",
-        "                        google-cloud-bigquery \\\n",
-        "                        pyarrow"
+        "                        'google-cloud-bigquery[pandas]'"
       ]
     },
     {
@@ -632,12 +631,12 @@
         "    df_train_x, df_train_y = df_train, df_train.pop(LABEL_COLUMN)\n",
         "    df_validation_x, df_validation_y = df_validation, df_validation.pop(LABEL_COLUMN)\n",
         "\n",
-        "    y_train = np.asarray(df_train_y).astype(\"float32\")\n",
-        "    y_validation = np.asarray(df_validation_y).astype(\"float32\")\n",
+        "    y_train = tf.convert_to_tensor(np.asarray(df_train_y).astype(\"float32\"))\n",
+        "    y_validation = tf.convert_to_tensor(np.asarray(df_validation_y).astype(\"float32\"))\n",
         "\n",
         "    # Convert to numpy representation\n",
-        "    x_train = np.asarray(df_train_x) \n",
-        "    x_test = np.asarray(df_validation_x)\n",
+        "    x_train = tf.convert_to_tensor(np.asarray(df_train_x).astype(\"float32\"))\n",
+        "    x_test = tf.convert_to_tensor(np.asarray(df_validation_x).astype(\"float32\"))\n",
         "\n",
         "    # Convert to one-hot representation\n",
         "    num_species = len(df_train_y.unique())\n",
@@ -735,7 +734,7 @@
         "    display_name=JOB_NAME,\n",
         "    script_path=\"task.py\",\n",
         "    container_uri=\"us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-8:latest\",\n",
-        "    requirements=[\"google-cloud-bigquery>=2.20.0\", \"db-dtypes\"],\n",
+        "    requirements=[\"google-cloud-bigquery[pandas]\", \"protobuf<3.20.0\"],\n",
         "    model_serving_container_image_uri=\"us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest\",\n",
         ")\n",
         "\n",

notebooks/official/explainable_ai/sdk_automl_tabular_classification_online_explain.ipynb

@@ -64,7 +64,7 @@
         "\n",
         "This tutorial demonstrates how to use the Vertex AI SDK to create tabular classification models and do online prediction with explanation using a Google Cloud [AutoML](https://cloud.google.com/vertex-ai/docs/start/automl-users) model.\n",
         "\n",
-        "Learn more about [AutoML Tabular](https://cloud.google.com/vertex-ai/docs/tabular-data/overview) and [Vertex Explainable AI](https://cloud.google.com/vertex-ai/docs/explainable-ai/overview)."
+        "Learn more about [Classification for tabular data](https://cloud.google.com/vertex-ai/docs/tabular-data/classification-regression/overview) and [Vertex Explainable AI](https://cloud.google.com/vertex-ai/docs/explainable-ai/overview)."
       ]
     },
     {

notebooks/official/migration/UJ14 Vertex SDK AutoML Video Classification.ipynb

@@ -29,7 +29,7 @@
         "id": "title:migration,new"
       },
       "source": [
-        "# Vertex AI: Vertex AI Migration: AutoML Video Classificaton\n",
+        "# Vertex AI: Vertex AI Migration: AutoML Video Classification\n",
         "\n",
         "<table align=\"left\">\n",
         "\n",
@@ -64,7 +64,7 @@
         "\n",
         "This tutorial demonstrates how to use the Vertex AI SDK for Python to train a AutoML video classification model and do a batch prediction.\n",
         "\n",
-        "Learn more about [Migrate to Vertex AI](https://cloud.google.com/vertex-ai/docs/start/migrating-to-vertex-ai) and [AutoML Video](https://cloud.google.com/vertex-ai/docs/tutorials/video-classification-automl/training)."
+        "Learn more about [Migrate to Vertex AI](https://cloud.google.com/vertex-ai/docs/start/migrating-to-vertex-ai) and [Classification for video data](https://cloud.google.com/vertex-ai/docs/training-overview#classification_for_videos)."
       ]
     },
     {
@@ -568,7 +568,7 @@
       },
       "outputs": [],
       "source": [
-        "IMPORT_FILE = \"gs://automl-video-demo-data/hmdb_split1_5classes_train_inf.csv\""
+        "IMPORT_FILE = \"gs://automl-video-demo-data/hmdb_split1_train_40_mp4_gs.csv\""
       ]
     },
     {
@@ -604,6 +604,19 @@
         "! gsutil cat $FILE | head"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "f483d8d80f64"
+      },
+      "outputs": [],
+      "source": [
+        "import datetime\n",
+        "\n",
+        "start = datetime.datetime.now()"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {
@@ -757,7 +770,19 @@
         "\n",
         "The `run` method when completed returns the `Model` resource.\n",
         "\n",
-        "The execution of the training pipeline will take upto 20 minutes."
+        "The execution of the training pipeline may take over 24 hrs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8f135100f5d9"
+      },
+      "outputs": [],
+      "source": [
+        "if os.getenv(\"IS_TESTING\"):\n",
+        "    sys.exit(0)"
       ]
     },
     {
@@ -806,6 +831,18 @@
         "    INFO:google.cloud.aiplatform.training_jobs:Model available at projects/759209241365/locations/us-central1/models/1899701006099283968"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "48ca7f0980e0"
+      },
+      "outputs": [],
+      "source": [
+        "end = datetime.datetime.now()\n",
+        "end - start"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {

notebooks/official/ml_metadata/sdk-metric-parameter-tracking-for-locally-trained-models.ipynb

@@ -140,7 +140,7 @@
       "outputs": [],
       "source": [
         "! pip install --upgrade -q google-cloud-aiplatform \\\n",
-        "                            tensorflow==2.8 -q"
+        "                            tensorflow -q"
       ]
     },
     {

notebooks/official/model_evaluation/automl_tabular_regression_model_evaluation.ipynb

@@ -92,7 +92,7 @@
         "- Run the `AutoMLTabularTrainingJob` which returns a model\n",
         "- Import a pre-trained `AutoML model resource` into the pipeline\n",
         "- Run a `batch prediction` job in the pipeline\n",
-        "- Evaulate the AutoML model using the `regression evaluation component`\n",
+        "- Evaluate the AutoML model using the `regression evaluation component`\n",
         "- Import the Regression Metrics to the AutoML model resource"
       ]
     },

notebooks/official/model_evaluation/automl_video_classification_model_evaluation.ipynb

@@ -63,7 +63,7 @@
         "\n",
         "This notebook demonstrates how to use the Vertex AI classification model evaluation component to evaluate an AutoML video classification model. Model evaluation helps you determine your model performance based on the evaluation metrics and improve the model if necessary. \n",
         "\n",
-        "Learn more about [Vertex AI Model Evaluation](https://cloud.google.com/vertex-ai/docs/evaluation/introduction) and [AutoML Video](https://cloud.google.com/vertex-ai/docs/video-data/classification/prepare-data)."
+        "Learn more about [Vertex AI Model Evaluation](https://cloud.google.com/vertex-ai/docs/evaluation/introduction) and [Classification for video data](https://cloud.google.com/vertex-ai/docs/training-overview#classification_for_videos)."
       ]
     },
     {
@@ -92,7 +92,7 @@
         "- Train a Automl Video Classification model on the `Vertex AI Dataset` resource.\n",
         "- Import the trained `AutoML Vertex AI Model resource` into the pipeline.\n",
         "- Run a batch prediction job inside the pipeline.\n",
-        "- Evaulate the AutoML model using the classification evaluation component.\n",
+        "- Evaluate the AutoML model using the classification evaluation component.\n",
         "- Import the classification metrics to the AutoML Vertex AI Model resource."
       ]
     },
@@ -792,7 +792,19 @@
         "\n",
         "The `run` method when completed returns the `Model` resource.\n",
         "\n",
-        "The execution of the training pipeline can take over 3 hours to complete."
+        "The execution of the training pipeline can take over 24 hours to complete."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3eaba926cdfa"
+      },
+      "outputs": [],
+      "source": [
+        "if os.getenv(\"IS_TESTING\"):\n",
+        "    sys.exit(0)"
       ]
     },
     {

notebooks/official/model_evaluation/custom_tabular_regression_model_evaluation.ipynb

@@ -93,7 +93,7 @@
         "- Upload the model as a Vertex AI Model resource.\n",
         "- Import a pre-trained `Vertex AI model resource` into the pipeline.\n",
         "- Run a `batch prediction` job in the pipeline.\n",
-        "- Evaulate the model using the `regression evaluation component`.\n",
+        "- Evaluate the model using the `regression evaluation component`.\n",
         "- Import the Regression Metrics to the Vertex AI model resource."
       ]
     },

notebooks/official/model_evaluation/get_started_with_custom_model_evaluation_import.ipynb

@@ -0,0 +1,865 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ur8xi4C7S06n"
+      },
+      "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": "JAPoU8Sm5E6e"
+      },
+      "source": [
+        "# Get started with importing a custom model evaluation to the Vertex AI Model Registry\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/model_evaluation/get_started_with_custom_model_evaluation_import.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/model_evaluation/get_started_with_custom_model_evaluation_import.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/model_evaluation/get_started_with_custom_model_evaluation_import.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 tutorial shows how to use Vertex AI Model Evaluation to import a custom model evaluation to an existing Vertex AI Model Registry entry."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "d975e698c9a4"
+      },
+      "source": [
+        "### Objective\n",
+        "\n",
+        "In this tutorial, you learn how to construct and upload a custom model evaluation, and upload the custom model evaluation to a Model resource entry in Vertex AI Model Registry.\n",
+        "\n",
+        "This tutorial uses the following Google Cloud ML services and resources:\n",
+        "\n",
+        "- Vertex AI Model Evaluation\n",
+        "- Vertex AI Model Registry\n",
+        "\n",
+        "The steps performed include:\n",
+        "\n",
+        "- Import a pretrained (blessed) model to the Vertex AI Model Registry.\n",
+        "- Construct a custom model evaluation.\n",
+        "- Import the model evaluation metrics to the corresponding model in the Vertex AI Model Registry.\n",
+        "- List the model evaluation for the corresponding model in the Vertex AI Model Registry.\n",
+        "- Construct a second custom model evaluation.\n",
+        "- Import the second model evaluation metrics to the corresponding model in the Vertex AI Model Registry.\n",
+        "- List the second model evaluation for the corresponding model in the Vertex AI Model Registry.\n",
+        "\n",
+        "Learn more about [Model Evaluation in Vertex AI](https://cloud.google.com/vertex-ai/docs/evaluation/introduction)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "08d289fa873f"
+      },
+      "source": [
+        "### Model\n",
+        "\n",
+        "This tutorial uses a pre-trained image classification model from TensorFlow Hub, which is trained on ImageNet dataset.\n",
+        "\n",
+        "Learn more about [ResNet V2 pretained model](https://tfhub.dev/google/imagenet/resnet_v2_101/classification/5). "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aed92deeb4a0"
+      },
+      "source": [
+        "### Costs \n",
+        "\n",
+        "This tutorial uses billable components of Google Cloud:\n",
+        "\n",
+        "* Vertex AI\n",
+        "* Cloud Storage\n",
+        "\n",
+        "Learn about [Vertex AI pricing](https://cloud.google.com/vertex-ai/pricing),\n",
+        "and [Cloud Storage pricing](https://cloud.google.com/storage/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": "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",
+        "USER=''\n",
+        "! pip3 install {USER} --upgrade google-cloud-aiplatform \\\n",
+        "                                tensorflow==2.5 \\\n",
+        "                                tensorflow-hub"
+      ]
+    },
+    {
+      "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]\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": "region"
+      },
+      "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": "zgPO1eR3CYjk"
+      },
+      "source": [
+        "### Create a Cloud Storage bucket\n",
+        "\n",
+        "Create a storage bucket to store intermediate artifacts such as datasets.\n",
+        "\n",
+        "- *{Note to notebook author: For any user-provided strings that need to be unique (like bucket names or model ID's), append \"-unique\" to the end so proper testing can occur}*"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "MzGDU7TWdts_"
+      },
+      "outputs": [],
+      "source": [
+        "BUCKET_URI = f\"gs://your-bucket-name-unique-{PROJECT_ID}\"  # @param {type:\"string\"}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-EcIXiGsCePi"
+      },
+      "source": [
+        "**Only if your bucket doesn't already exist**: Run the following cell to create your Cloud Storage bucket."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NIq7R4HZCfIc"
+      },
+      "outputs": [],
+      "source": [
+        "! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "960505627ddf"
+      },
+      "source": [
+        "### Import libraries"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "PyQmSRbKA8r-"
+      },
+      "outputs": [],
+      "source": [
+        "import tensorflow as tf\n",
+        "import tensorflow_hub as hub\n",
+        "from google.cloud import aiplatform\n",
+        "from google.cloud.aiplatform import gapic"
+      ]
+    },
+    {
+      "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": "init_aip:mbsdk,all"
+      },
+      "outputs": [],
+      "source": [
+        "aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "accelerators:training,cpu,prediction,cpu,mbsdk"
+      },
+      "source": [
+        "#### Set hardware accelerators\n",
+        "\n",
+        "You can set hardware accelerators for prediction.\n",
+        "\n",
+        "Set the variables `DEPLOY_GPU/DEPLOY_NGPU` to use a container image supporting a GPU and the number of GPUs allocated to the virtual machine (VM) instance. For example, to use a GPU container image with 4 Nvidia Telsa K80 GPUs allocated to each VM, you would specify:\n",
+        "\n",
+        "    (aip.gapic.AcceleratorType.NVIDIA_TESLA_K80, 4)\n",
+        "\n",
+        "\n",
+        "Otherwise specify `(None, None)` to use a container image to run on a CPU.\n",
+        "\n",
+        "Learn more about [hardware accelerator support for your region](https://cloud.google.com/vertex-ai/docs/general/locations#accelerators), and [GPU pricing](https://cloud.google.com/compute/gpus-pricing)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "accelerators:training,cpu,prediction,cpu,mbsdk"
+      },
+      "outputs": [],
+      "source": [
+        "DEPLOY_GPU, DEPLOY_NGPU = (None, None)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "container:training,prediction"
+      },
+      "source": [
+        "#### Set pre-built containers\n",
+        "\n",
+        "Set the pre-built Docker container image for prediction.\n",
+        "\n",
+        "For the latest list, see [Pre-built containers for prediction](https://cloud.google.com/ai-platform-unified/docs/predictions/pre-built-containers)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "container:training,prediction"
+      },
+      "outputs": [],
+      "source": [
+        "TF = \"2.5\".replace(\".\", \"-\")\n",
+        "\n",
+        "if DEPLOY_GPU:\n",
+        "    DEPLOY_VERSION = \"tf2-gpu.{}\".format(TF)\n",
+        "else:\n",
+        "    DEPLOY_VERSION = \"tf2-cpu.{}\".format(TF)\n",
+        "\n",
+        "DEPLOY_IMAGE = \"{}-docker.pkg.dev/vertex-ai/prediction/{}:latest\".format(\n",
+        "    REGION.split(\"-\")[0], DEPLOY_VERSION\n",
+        ")\n",
+        "\n",
+        "print(\"Deployment:\", DEPLOY_IMAGE, DEPLOY_GPU, DEPLOY_NGPU)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "d8128b8ff025"
+      },
+      "source": [
+        "## Get pretrained model from TensorFlow Hub\n",
+        "\n",
+        "For demonstration purposes, this tutorial uses a pretrained model from TensorFlow Hub (TFHub), which is then uploaded to a `Vertex AI Model` resource. Once you have a `Vertex AI Model` resource, the model can be deployed to a `Vertex AI Endpoint` resource.\n",
+        "\n",
+        "### Download the pretrained model\n",
+        "\n",
+        "First, you download the pretrained model from TensorFlow Hub. The model gets downloaded as a TF.Keras layer. To finalize the model, in this example, you create a `Sequential()` model with the downloaded TFHub model as a layer, and specify the input shape to the model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "c55fa4c826f7"
+      },
+      "outputs": [],
+      "source": [
+        "tfhub_model = tf.keras.Sequential(\n",
+        "    [hub.KerasLayer(\"https://tfhub.dev/google/imagenet/resnet_v2_101/classification/5\")]\n",
+        ")\n",
+        "\n",
+        "tfhub_model.build([None, 32, 32, 3])\n",
+        "\n",
+        "tfhub_model.summary()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "64618c713db9"
+      },
+      "outputs": [],
+      "source": [
+        "MODEL_DIR = BUCKET_URI + \"/model\"\n",
+        "tfhub_model.save(MODEL_DIR)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "e8ce91147c93"
+      },
+      "source": [
+        "### Upload the TensorFlow Hub model to a `Vertex AI Model` resource\n",
+        "\n",
+        "Finally, you upload the model artifacts from the TFHub model into a `Vertex AI Model` resource using the method `upload()`, with the following parameters:\n",
+        "\n",
+        "- `display_name`: A human readable name for the `Model` resource.\n",
+        "- `artifact_uri`: The Cloud Storage location of the model package.\n",
+        "- `serving_container_image_uri`: The serving container image.\n",
+        "\n",
+        "Uploading a model into a Vertex AI Model resource returns a long running operation, since it may take a few moments. \n",
+        "\n",
+        "*Note:* When you upload the model artifacts to a `Vertex AI Model` resource, you specify the corresponding deployment container image."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ad61e1429512"
+      },
+      "outputs": [],
+      "source": [
+        "model = aiplatform.Model.upload(\n",
+        "    display_name=\"resnet\",\n",
+        "    artifact_uri=MODEL_DIR,\n",
+        "    serving_container_image_uri=DEPLOY_IMAGE,\n",
+        "    is_default_version=True,\n",
+        "    version_aliases=[\"v1\"],\n",
+        ")\n",
+        "\n",
+        "print(model)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c11e98ef5391"
+      },
+      "source": [
+        "## Introduction to custom model evaluations\n",
+        "\n",
+        "When training a custom model, one generally performs some form of an evaluation of the trained model. Your custom model evaluation can then be imported to the corresponding model in the Vertex AI Model Registry using the `import_model_evaluation()` method. Once imported, the custom model evaluation can be subsequently retreived with the `list_model_evaluations()` method. \n",
+        "\n",
+        "The Vertex AI Model Registry supports importing multiple model evaluations for a model where each evaluation is distinquished by a unique `display_name`.\n",
+        "\n",
+        "\n",
+        "### Create a model evaluation\n",
+        "\n",
+        "First, you create a model evaluation in a format that corresponds to one of the predefined schemas for model evaluations. In this example, you use the schema for a classification metric, and specify the following subset of evaluation metrics as a dictionary:\n",
+        "\n",
+        "- `logLoss`: The log loss.\n",
+        "- `auPrc`: The accuracy.\n",
+        "\n",
+        "You then construct the `ModelEvaluation` object with the following parameters:\n",
+        "\n",
+        "- `display_name`: The human readable name for the evaluation metric.\n",
+        "- `metrics_schema_uri`: The schema for the specific type of evaluation metrics.\n",
+        "- `metrics`: The dictionary with the evaluation metrics.\n",
+        "\n",
+        "Learn more about [Schemas for evaluation metrics](https://cloud.google.com/vertex-ai/docs/evaluation/introduction#features)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "e9af222db292"
+      },
+      "outputs": [],
+      "source": [
+        "metrics = {\"logLoss\": 1.4, \"auPrc\": 0.85}\n",
+        "print(metrics)\n",
+        "\n",
+        "model_eval = gapic.ModelEvaluation(\n",
+        "    display_name=\"eval\",\n",
+        "    metrics_schema_uri=\"gs://google-cloud-aiplatform/schema/modelevaluation/classification_metrics_1.0.0.yaml\",\n",
+        "    metrics=metrics,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "68870bd8194d"
+      },
+      "source": [
+        "### Upload the evaluation metrics to the Model Registry\n",
+        "\n",
+        "Next, upload the model's evaluation from the custom training job to the corresponding entry in the Vertex AI Model Registry.\n",
+        "\n",
+        "Currently, there is not yet support for this method in the SDK. Instead, you use the lower level GAPIC API interface."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3044788848af"
+      },
+      "outputs": [],
+      "source": [
+        "API_ENDPOINT = f\"{REGION}-aiplatform.googleapis.com\"\n",
+        "client = gapic.ModelServiceClient(client_options={\"api_endpoint\": API_ENDPOINT})\n",
+        "\n",
+        "client.import_model_evaluation(parent=model.resource_name, model_evaluation=model_eval)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "337319a19efe"
+      },
+      "source": [
+        "### List the custom model evaluation\n",
+        "\n",
+        "Now that your custom metric has been uploaded to the corresponding model in the Vertex AI Model Registry, you can retriv"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1b3374e988cf"
+      },
+      "outputs": [],
+      "source": [
+        "evaluation = model.list_model_evaluations()[0]\n",
+        "print(evaluation.gca_resource)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "68870bd8194d"
+      },
+      "source": [
+        "### Upload a second evaluation metrics to the Model Registry\n",
+        "\n",
+        "Next, upload a second model evaluation to the corresponding entry in the Vertex AI Model Registry. In this example, we refer to first evaluation metric as `eval` (from training) and the second as `prod` (from production data)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9b864c0ba07f"
+      },
+      "outputs": [],
+      "source": [
+        "metrics = {\"logLoss\": 1.2, \"auPrc\": 0.87}\n",
+        "print(metrics)\n",
+        "\n",
+        "model_prod = gapic.ModelEvaluation(\n",
+        "    display_name=\"prod\",\n",
+        "    metrics_schema_uri=\"gs://google-cloud-aiplatform/schema/modelevaluation/classification_metrics_1.0.0.yaml\",\n",
+        "    metrics=metrics,\n",
+        ")\n",
+        "\n",
+        "client.import_model_evaluation(parent=model.resource_name, model_evaluation=model_prod)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "337319a19efe"
+      },
+      "source": [
+        "### List a specific custom model evaluation\n",
+        "\n",
+        "Now that your custom second metric has been uploaded to the corresponding model in the Vertex AI Model Registry, you can retrieve this specific evaluation by filtering using the `display_name`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1b3374e988cf"
+      },
+      "outputs": [],
+      "source": [
+        "evaluations = model.list_model_evaluations()\n",
+        "for evaluation in evaluations:\n",
+        "    if evaluation.display_name == \"prod\":\n",
+        "        print(evaluation.gca_resource)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "b3a3993dc813"
+      },
+      "source": [
+        "### Upload version 2 of the TFHub model to the `Vertex AI Model Registry`\n",
+        "\n",
+        "Next, you upload the second version of the TFHub model as a `Model` resource in the `Vertex AI Model Registry`, with the additional following parameters:\n",
+        "\n",
+        "- `parent_model`: The existing `Model` resource for which to add this model as the next model version.\n",
+        "- `is_default_version`: Whether this will be the default version for the `Model` resource. In this example, you change from the default from the first version to the second version of the model.\n",
+        "- `version_ailiases`: User defined list of alternative alias names for the model version, such as `production`.\n",
+        "- `version_description`: User description of the model version.\n",
+        "\n",
+        "When a subsequent model version is created in the `Vertex AI Model Registry`, the property `version_id` will automatically be incremented. In this example, it will be set to 2 (2nd version)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "852be5e5f964"
+      },
+      "outputs": [],
+      "source": [
+        "model_v2 = aiplatform.Model.upload(\n",
+        "    display_name=\"resnet\",\n",
+        "    artifact_uri=MODEL_DIR,\n",
+        "    serving_container_image_uri=DEPLOY_IMAGE,\n",
+        "    parent_model=model.resource_name,\n",
+        "    is_default_version=True,\n",
+        "    version_aliases=[\"v2\"],\n",
+        "    version_description=\"This is the second version of the model\",\n",
+        ")\n",
+        "\n",
+        "print(model_v2)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "68870bd8194d"
+      },
+      "source": [
+        "### Upload an evaluation metrics for version 2 of the model to the Model Registry\n",
+        "\n",
+        "Next, upload a model evaluation to the corresponding model version in the Vertex AI Model Registry. Note, you referenced `model_v2.resource_name` to refer to version 2 of this model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9b864c0ba07f"
+      },
+      "outputs": [],
+      "source": [
+        "metrics = {\"logLoss\": 1.0, \"auPrc\": 0.91}\n",
+        "print(metrics)\n",
+        "\n",
+        "model_eval = gapic.ModelEvaluation(\n",
+        "    display_name=\"eval\",\n",
+        "    metrics_schema_uri=\"gs://google-cloud-aiplatform/schema/modelevaluation/classification_metrics_1.0.0.yaml\",\n",
+        "    metrics=metrics,\n",
+        ")\n",
+        "\n",
+        "client.import_model_evaluation(\n",
+        "    parent=model_v2.resource_name, model_evaluation=model_eval\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "d4e72b21b06b"
+      },
+      "source": [
+        "### List the evaluations for both versions of the model\n",
+        "\n",
+        "Finally, list the number of evaluations for both versions of the model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "369a23d392a4"
+      },
+      "outputs": [],
+      "source": [
+        "evaluations = model.list_model_evaluations()\n",
+        "print(\"Model v1 no. of evaluations\", len(evaluations))\n",
+        "evaluations = model_v2.list_model_evaluations()\n",
+        "print(\"Model v2 no. of evaluations\", len(evaluations))"
+      ]
+    },
+    {
+      "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:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sx_vKniMq9ZX"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "# Delete model resource\n",
+        "model.delete()\n",
+        "\n",
+        "# Delete Cloud Storage objects that were created\n",
+        "delete_bucket = False\n",
+        "if delete_bucket or os.getenv(\"IS_TESTING\"):\n",
+        "    ! gsutil -m rm -r $BUCKET_URI"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "collapsed_sections": [],
+      "name": "get_started_with_custom_model_evaluation_import.ipynb",
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

notebooks/official/pytorch/README.md

@@ -1,20 +0,0 @@
-
-[Training, tuning and deploying a PyTorch text sentiment classification model on Vertex AI](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/pytorch/pytorch-text-sentiment-classification-custom-train-deploy.ipynb)
-
-```
-Learn to build, train, tune and deploy a PyTorch model on [Vertex AI](https://cloud.
-
-The steps performed include:
-
-- Create training package for the text classification model.
-- Train the model with custom training on Vertex AI.
-- Check the created model artifacts.
-- Create a custom container for predictions.
-- Deploy the trained model to a Vertex AI Endpoint using the custom container for predictions.
-- Send online prediction requests to the deployed model and validate.
-- Clean up the resources created in this notebook.
-
-```
-
-   Learn more about [Vertex AI Training](https://cloud.google.com/vertex-ai/docs/training/custom-training).
-

notebooks/official/sdk/SDK_AutoML_Video_Classification.ipynb

@@ -64,7 +64,7 @@
         "\n",
         "Note: you may incur charges for training, prediction, storage or usage of other GCP products in connection with testing this SDK.\n",
         "\n",
-        "Learn more about [AutoML Video](https://cloud.google.com/vertex-ai/docs/tutorials/video-classification-automl/training)."
+        "Learn more about [Classification for video data](https://cloud.google.com/vertex-ai/docs/training-overview#classification_for_videos)."
       ]
     },
     {
@@ -773,7 +773,19 @@
         "\n",
         "The `run` method when completed returns the `Model` resource.\n",
         "\n",
-        "The execution of the training pipeline can take over 2 hours to complete."
+        "The execution of the training pipeline can take over 24 hours to complete."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8f135100f5d9"
+      },
+      "outputs": [],
+      "source": [
+        "if os.getenv(\"IS_TESTING\"):\n",
+        "    sys.exit(0)"
       ]
     },
     {

notebooks/official/tabnet/ai-explanations-tabnet-algorithm.ipynb

@@ -29,7 +29,7 @@
         "id": "JAPoU8Sm5E6e"
       },
       "source": [
-        "# Vertex AI Explainations with TabNet models\n",
+        "# Vertex AI Explanations with TabNet models\n",
         "\n",
         "<table align=\"left\">\n",
         "\n",
@@ -86,7 +86,7 @@
         "- TabNet builtin algorithm\n",
         "\n",
         "The steps performed are:\n",
-        "* Setup the the project.\n",
+        "* Setup the project.\n",
         "* Download the prediction data of pretrain model onf Syn2 data.\n",
         "* Visualize and understand the feature importance based on the masks output.\n",
         "* Clean up the resource created by this tutorial."

notebooks/official/training/xgboost_data_parallel_training_on_cpu_using_dask.ipynb

@@ -830,13 +830,22 @@
         "    !  gcloud builds submit --timeout=1800s --region={REGION} --tag $TRAIN_IMAGE"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "41ZgDYPNfEvt"
+      },
+      "source": [
+        "## Run training job with SDK (Option 1) or with gcloud (Option 2)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {
         "id": "PtUycdZhCJvQ"
       },
       "source": [
-        "### Initialize Vertex AI SDK"
+        "### 1.1 Initialize Vertex AI SDK"
       ]
     },
     {
@@ -860,7 +869,16 @@
         "id": "_GB2j39BCXiy"
       },
       "source": [
-        "### Run a Vertex AI SDK CustomContainerTrainingJob"
+        "### 1.2 Run a Vertex AI SDK CustomContainerTrainingJob"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7udaU3jxfKs8"
+      },
+      "source": [
+        "You can specify the fields enable_web_access and enable_dashboard_access. The enable_web_access enables the interactive shell for the job and enable_dashboard_access allows the dask dashboard to be accessed."
       ]
     },
     {
@@ -887,9 +905,34 @@
         "    base_output_dir=gcs_output_uri_prefix,\n",
         "    replica_count=replica_count,\n",
         "    machine_type=machine_type,\n",
+        "    enable_dashboard_access=True,\n",
+        "    enable_web_access=True,\n",
+        "    sync=False,\n",
         ")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ROqdvgBKFGKL"
+      },
+      "source": [
+        "Wait for a few minutes for the Custom Job to start"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "rBYbvim_FJz0"
+      },
+      "outputs": [],
+      "source": [
+        "import time\n",
+        "\n",
+        "time.sleep(60 * 3)"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -902,13 +945,66 @@
         "print(f\"GCS Output URI Prefix: {gcs_output_uri_prefix}\")"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-0EJdcjPyjDK"
+      },
+      "source": [
+        "You can access the link to the Custom Job in the Cloud Console UI here:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ZMZPrcqsyj0e"
+      },
+      "outputs": [],
+      "source": [
+        "print(\n",
+        "    f\"Custom Training Job URI: {custom_container_training_job._custom_job_console_uri()}\"\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7McPKJGxymLU"
+      },
+      "source": [
+        "Once the job is in the state \"RUNNING\", you can access the web access and dashboard access URIs here:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "tiHdwJs1yoE0"
+      },
+      "outputs": [],
+      "source": [
+        "print(f\"Web Access and Dashboard URIs: {custom_container_training_job.web_access_uris}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9RDh5CzNywIA"
+      },
+      "source": [
+        "The interactive shell has the key with the format \"workerpool0-0\", while the dashboard uri has the key with the format \"workerpool0-0:\" + port number (workerpool0-0:8888 in this example). On the page for your Custom Job in the Cloud Console UI, you can also \"Launch web terminal\" for \"workerpool0-0\" for web access, or click \"Launch web terminal\" for \"workerpool0-0:\" + port number for dashboard access.\n",
+        "\n",
+        "Note that you can only access an interactive shell and dashboard while the job is running. If you don't see Launch web terminal in the UI or the URIs in the output of the Web Access and Dashboard URIs command, this might be because Vertex AI hasn't started running your job yet, or because the job has already finished or failed. If the job's Status is Queued or Pending, wait a minute; then try refreshing the page, or trying the command again."
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {
         "id": "tVktIbToRpmR"
       },
       "source": [
-        "### Access the Dask dashboard"
+        "### 2. Run a CustomContainerTraining Job with gcloud"
       ]
     },
     {
@@ -917,7 +1013,7 @@
         "id": "uVvxLj8GRsM6"
       },
       "source": [
-        "You can also create a training job with gcloud command.  With gcloud command, you can specify the field enableWebAccess and enableDashboardAccess. enableWebAccess enables the interactive shell for the job and enableDashboardAccess allows the dask dashboard to be accessed."
+        "You can also create a training job with the gcloud command.  With the gcloud command, you can specify the field enableWebAccess and enableDashboardAccess. The enableWebAccess enables the interactive shell for the job and enableDashboardAccess allows the dask dashboard to be accessed."
       ]
     },
     {
@@ -975,10 +1071,16 @@
     {
       "cell_type": "markdown",
       "metadata": {
-        "id": "onb40Ge0SVKh"
+        "id": "HAYihHT9ff9q"
       },
       "source": [
-        "Once the job is created. You can use the output `gcloud ai custom-jobs describe` command to print the field webAccessUris. The interactive shell has the key with the format \"workerpool0-0\", while the dashboard uri has the key with the format \"workerpool0-0:\" + port number. Note: You have to access the links while the job is running."
+        "#### Access the dashboard and interactive shell for a gcloud custom job\n",
+        "\n",
+        "Once the job is created, you can access the web access URI and dashboard access URI by using the `gcloud ai custom-jobs describe` command to print the field webAccessUris. The interactive shell has the key with the format \"workerpool0-0\", while the dashboard uri has the key with the format \"workerpool0-0:\" + port number (workerpool0-0:8888 in this example).\n",
+        "\n",
+        "You also can find the links in the Cloud Console UI. In the Cloud Console UI, in the Vertex AI section, go to Training and then Custom Jobs. Click on the name of your custom training job. On the page for your job, click \"Launch web terminal\" for \"workerpool0-0\" for web access, or click \"Launch web terminal\" for \"workerpool0-0:\" + port number for dashboard access.\n",
+        "\n",
+        "Note that you can only access an interactive shell and dashboard while the job is running. If you don't see Launch web terminal in the UI or the URIs in the output of the gcloud command, this might be because Vertex AI hasn't started running your job yet, or because the job has already finished or failed. If the job's Status is Queued or Pending, wait a minute; then try refreshing the page, or trying the gcloud command again."
       ]
     },
     {
@@ -1098,6 +1200,9 @@
       },
       "outputs": [],
       "source": [
+        "import logging\n",
+        "import traceback\n",
+        "\n",
         "# Set this to true only if you'd like to delete your bucket\n",
         "delete_bucket = False\n",
         "\n",
@@ -1106,7 +1211,11 @@
         "if delete_bucket or os.getenv(\"IS_TESTING\"):\n",
         "    ! gsutil rm -r $BUCKET_URI\n",
         "\n",
-        "custom_container_training_job.delete()"
+        "try:\n",
+        "    custom_container_training_job.delete()\n",
+        "except Exception as e:\n",
+        "    logging.error(traceback.format_exc())\n",
+        "    print(e)"
       ]
     }
   ],

notebooks/official/workbench/demand_forecasting/forecasting-retail-demand.ipynb

@@ -89,7 +89,7 @@
         "* Model with BigQuery and the ARIMA model\n",
         "* Evaluate the model\n",
         "* Evaluate the model results using BigQuery ML (on training data)\n",
-        "* Evalute the model results - MAE, MAPE, MSE, RMSE (on test data)\n",
+        "* Evaluate the model results - MAE, MAPE, MSE, RMSE (on test data)\n",
         "* Use the executor feature"
       ]
     },