Delete deprecated LoRA fine-tuning notebooks and related tutorials.

PiperOrigin-RevId: 976392412

.cloud-build/execute_changed_notebooks_helper.py

@@ -365,7 +365,7 @@ def process_and_execute_notebook(
             # Use gcloud to get tail
             try:
                 result.error_message = subprocess.check_output(
-                    ["gsutil", "cat", "-r", "-1000", log_file_uri], encoding="UTF-8"
+                    ["gcloud", "storage", "cat", "--range", "-1000", log_file_uri], encoding="UTF-8"
                 )
             except Exception as error:
                 result.error_message = str(error)

.cloud-build/execute_notebook_helper.py

@@ -56,8 +56,8 @@ def execute_notebook(
     print("\n=== DOWNLOAD EXECUTED NOTEBOOK ===\n")
     print(f"Please debug the executed notebook by downloading the executed notebook:")
 
-    print("Option 1. Using gsutil. Run the following command in your terminal.")
-    print(f'\tgsutil cp "{output_file_or_uri}" .')
+    print("Option 1. Using gcloud storage. Run the following command in your terminal.")
+    print(f'\tgcloud storage cp "{output_file_or_uri}" .')
 
     print("Option 2. Using this link.")
     print(f"\thttps://storage.googleapis.com/{output_file_or_uri[5:]}")

.cloud-build/utils/NotebookProcessors.py

@@ -108,7 +108,7 @@ class VertexAIInstallProprocessor(Preprocessor):
         if "google-cloud-aiplatform" not in content:
             return content
         return (
-            f"gsutil cp {self.vertex_ai_wheel} google-cloud-aiplatform.whl\n" + 
+            f"gcloud storage cp {self.vertex_ai_wheel} google-cloud-aiplatform.whl\n" + 
             content.replace("google-cloud-aiplatform\n", "google-cloud-aiplatform.whl\n")
             .replace("google-cloud-aiplatform ", "google-cloud-aiplatform.whl ")
         )

.cloud-build/utils/util.py

@@ -15,7 +15,7 @@ def download_file(bucket_name: str, blob_name: str, destination_file: str) -> st
     remote_file_path = "".join(["gs://", "/".join([bucket_name, blob_name])])
 
     subprocess.check_output(
-        ["gsutil", "cp", remote_file_path, destination_file], encoding="UTF-8"
+        ["gcloud", "storage", "cp", remote_file_path, destination_file], encoding="UTF-8"
     )
 
     return destination_file
@@ -27,7 +27,7 @@ def upload_file(
 ) -> str:
     """Copies a local file to a GCS path"""
     subprocess.check_output(
-        ["gsutil", "cp", local_file_path, remote_file_path], encoding="UTF-8"
+        ["gcloud", "storage", "cp", local_file_path, remote_file_path], encoding="UTF-8"
     )
 
     return remote_file_path

.github/workflows/ci.yaml

@@ -7,11 +7,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
-        python-version: '3.x'      
+        python-version: '3.12'      
     - name: Fetch pull request branch
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 0      
     - name: Fetch base main branch

.github/workflows/linter/Dockerfile

@@ -4,7 +4,7 @@
 # 2. To lint specific notebooks:
 # docker run -v ${PWD}:/setup/app gcr.io/python-docs-samples-tests/notebook_linter:latest notebooks/1.ipynb notebooks/2.ipynb
 
-FROM python:3.13
+FROM python:3.14
 
 WORKDIR setup
 

.github/workflows/linter/requirements.txt

@@ -2,9 +2,9 @@ git+https://github.com/tensorflow/docs
 ipython
 jupyter
 nbconvert
-black==25.1.0
-pyupgrade==3.20.0
-isort==6.0.1
+black==26.5.1
+pyupgrade==3.21.2
+isort==8.0.1
 flake8==7.3.0
 nbqa==1.9.1
 

README.md

@@ -1,12 +1,12 @@
 # ![Google Cloud](https://avatars.githubusercontent.com/u/2810941?s=60&v=4) Google Cloud Vertex AI Samples
 
-This repository contains notebooks, code samples, sample apps, and other resources that demonstrate how to use, develop and manage machine learning and generative AI workflows using Google Cloud Vertex AI.
+This repository contains notebooks, code samples, sample apps, skills, and other resources that demonstrate how to use, develop and manage machine learning and generative AI workflows using Google Cloud Vertex AI.
 
 ## Overview
 
 [Vertex AI](https://cloud.google.com/vertex-ai) is a fully-managed, unified AI development platform for building and using generative AI. This repository is designed to help you get started with Vertex AI. Whether you're new to Vertex AI or an experienced ML practitioner, you'll find valuable resources here.
 
-For more Vertex AI Generative AI notebook samples, please visit the Vertex AI [Generative AI](https://github.com/GoogleCloudPlatform/generative-ai) GitHub repository.
+⚠️ For more Vertex AI Generative AI notebook samples, please visit the Vertex AI [Generative AI](https://github.com/GoogleCloudPlatform/generative-ai) GitHub repository.
 
 ## Explore, learn and contribute
 
@@ -16,11 +16,11 @@ You can explore, learn, and contribute to this repository to unleash the full po
 
 Explore this repository, follow the links in the header section of each of the notebooks to -
 
-![Colab](https://cloud.google.com/ml-engine/images/colab-logo-32px.png)  Open and run the notebook in [Colab](https://colab.google/)\
-![Colab Enterprise](https://cloud.google.com/ml-engine/images/colab-enterprise-logo-32px.png)  Open and run the notebook in [Colab Enterprise](https://cloud.google.com/colab/docs/introduction)\
-![Workbench](https://lh3.googleusercontent.com/UiNooY4LUgW_oTvpsNhPpQzsstV5W8F7rYgxgGBD85cWJoLmrOzhVs_ksK_vgx40SHs7jCqkTkCk=e14-rj-sc0xffffff-h130-w32)  Open and run the notebook in [Vertex AI Workbench](https://cloud.google.com/vertex-ai/docs/workbench/introduction)\
-![Github](https://cloud.google.com/ml-engine/images/github-logo-32px.png)  View the notebook on Github
-
+- Open and run the notebook in [Colab](https://colab.google/)
+- Open and run the notebook in [Colab Enterprise](https://cloud.google.com/colab/docs/introduction)
+- Open and run the notebook in [Vertex AI Workbench](https://cloud.google.com/vertex-ai/docs/workbench/introduction)
+- View the notebook on Github
+  
 ### Contribute
 
 See the [Contributing Guide](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/master/CONTRIBUTING.md).
@@ -35,7 +35,7 @@ To get started using Vertex AI, you must have a Google Cloud project.
 
 ## Repository structure
 
-```bash
+```text
 ├── notebooks
 │   ├── official - Notebooks demonstrating use of each Vertex AI service
 │   │   ├── automl
@@ -45,7 +45,23 @@ To get started using Vertex AI, you must have a Google Cloud project.
 │   │   ├── model_garden
 │   │   ├── ...
 ├── community-content - Sample code and tutorials contributed by the community
-
+├── docs - Deep-dive documentation and advanced setup guides
+└── skills - Suite of AI Agent "Skills" for Vertex AI
+    ├── README.md               # Developer guide for Vertex AI skills
+    ├── vertex-ai/              # Primary router for Vertex AI tasks
+    │   └── SKILL.md            # Entry point that routes across capabilities
+    ├── genai-sdk/              # Gemini API usage with Gen AI SDK
+    │   └── SKILL.md            # Guides for Python, JS/TS, Go, Java, C#
+    ├── vertex-deploy/          # Deploying models to Endpoints
+    │   └── SKILL.md            # Commands for open models & custom weights
+    ├── vertex-inference/       # Inferencing with GenAI models
+    │   └── SKILL.md            # Code samples for Gemini and OpenMaaS
+    └── vertex-tuning/          # Secondary router for model fine-tuning
+        ├── SKILL.md            # Router for tuning tasks
+        ├── gemini/             # Fine-tuning first-party Gemini models
+        │   └── SKILL.md
+        └── open-model/         # Fine-tuning third-party open models
+            └── SKILL.md
 ```
 ## Examples
 

community-content/CODEOWNERS

@@ -29,4 +29,5 @@
 /vertex_model_garden/model_oss/vllm @kathyyu-google
 /vertex_model_garden/benchmarking_reports @lavraicse
 /vertex_model_garden/model_oss/autogluon @lavraicse
+/vertex_distributed_training/a3mega/llama-3-8b-nemo-pretraining @mstyer-google @erwinh85 @mchrestkha
 

community-content/pipeline_components/google-cloud/Vertex_AI/Models/Upload_PyTorch_model_archive/component.yaml

@@ -148,7 +148,7 @@ implementation:
 
       # Downloading the model archive from GCS
       # TODO: Fix gsutil bugs (requires project ID, has auth issues) and use gsutil instead.
-      # gsutil cp "$model_archive_uri" "$model_archive_local_path"
+      # gcloud storage cp "$model_archive_uri" "$model_archive_local_path"
       pip install google-cloud-storage
       python -c '
       import sys

community-content/pipeline_components/google-cloud/storage/download/component.yaml

@@ -24,12 +24,12 @@ implementation:
 
             # Checking whether the URI points to a single blob, a directory or a URI pattern
             # URI points to a blob when that URI does not end with slash and listing that URI only yields the same URI
-            if [[ "$uri" != */ ]] && (gsutil ls "$uri" | grep --fixed-strings --line-regexp "$uri"); then
+            if [[ "$uri" != */ ]] && (gcloud storage ls "$uri" | grep --fixed-strings --line-regexp "$uri"); then
                 mkdir -p "$(dirname "$output_path")"
-                gsutil -m cp -r "$uri" "$output_path"
+                gcloud storage cp --recursive "$uri" "$output_path"
             else
                 mkdir -p "$output_path" # When source path is a directory, gsutil requires the destination to also be a directory
-                gsutil -m rsync -r "$uri" "$output_path" # gsutil cp has different path handling than Linux cp. It always puts the source directory (name) inside the destination directory. gsutil rsync does not have that problem.
+                gcloud storage rsync --recursive "$uri" "$output_path" # gsutil cp has different path handling than Linux cp. It always puts the source directory (name) inside the destination directory. gsutil rsync does not have that problem.
             fi
         - inputValue: GCS path
         - outputPath: Data

community-content/pytorch_image_classification_distributed_data_parallel_training_with_vertex_sdk/trainer/requirements.txt

@@ -1,3 +1,3 @@
-torch==2.2.0
+torch==2.13.0
 torchvision==0.9.1
 tensorboard==2.5.0

community-content/pytorch_image_classification_single_gpu_with_vertex_sdk_and_torchserve/trainer/requirements.txt

@@ -1,3 +1,3 @@
-torch==2.7.0
+torch==2.13.0
 torchvision==0.9.1
 tensorboard==2.5.0

community-content/pytorch_image_classification_single_gpu_with_vertex_sdk_and_torchserve/vertex_prediction_with_custom_torchserve_container.ipynb

@@ -110,7 +110,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil ls $gcs_output_uri_prefix"
+        "! gcloud storage ls $gcs_output_uri_prefix"
       ]
     },
     {
@@ -192,7 +192,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil cp -r $gcs_output_uri_prefix/model ./model_server/"
+        "! gcloud storage cp --recursive $gcs_output_uri_prefix/model ./model_server/"
       ]
     },
     {
@@ -556,7 +556,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil rm -rf $gcs_output_uri_prefix"
+        "! gcloud storage rm --recursive --continue-on-error $gcs_output_uri_prefix"
       ]
     },
     {

community-content/pytorch_image_classification_single_gpu_with_vertex_sdk_and_torchserve/vertex_training_with_custom_container.ipynb

@@ -412,7 +412,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil ls $gcs_output_uri_prefix"
+        "! gcloud storage ls $gcs_output_uri_prefix"
       ]
     }
   ],

community-content/pytorch_text_classification_using_vertex_sdk_and_gcloud/custom_container/scripts/train-cloud.sh

@@ -77,4 +77,4 @@ echo "After the job is completed successfully, model files will be saved at $JOB
 
 # # Verify the model was exported
 # echo "Verify the model was exported:"
-# gsutil ls ${JOB_DIR}/
+# gcloud storage ls ${JOB_DIR}/

community-content/pytorch_text_classification_using_vertex_sdk_and_gcloud/predictor/Dockerfile.serve

@@ -34,4 +34,4 @@ RUN echo "service_envelope=json\n"     "inference_address=http://0.0.0.0:${AIP_H
 USER model-server
 
 # run Torchserve HTTP serve to respond to prediction requests
-CMD ["echo", "AIP_STORAGE_URI=${AIP_STORAGE_URI}", ";",     "gsutil", "cp", "-r", "${AIP_STORAGE_URI}/${MODEL_NAME}.mar", "/home/model-server/model-store/", ";",     "ls", "-ltr", "/home/model-server/model-store/", ";",     "torchserve", "--start", "--ts-config=/home/model-server/config.properties",     "--models", "${MODEL_NAME}=${MODEL_NAME}.mar",     "--model-store", "/home/model-server/model-store"]
+CMD ["echo", "AIP_STORAGE_URI=${AIP_STORAGE_URI}", ";",     "gcloud", "storage", "cp", "--recursive", "${AIP_STORAGE_URI}/${MODEL_NAME}.mar", "/home/model-server/model-store/", ";",     "ls", "-ltr", "/home/model-server/model-store/", ";",     "torchserve", "--start", "--ts-config=/home/model-server/config.properties",     "--models", "${MODEL_NAME}=${MODEL_NAME}.mar",     "--model-store", "/home/model-server/model-store"]

community-content/pytorch_text_classification_using_vertex_sdk_and_gcloud/python_package/scripts/train-cloud.sh

@@ -67,4 +67,4 @@ echo "After the job is completed successfully, model files will be saved at $JOB
 
 # # Verify the model was exported
 # echo "Verify the model was exported:"
-# gsutil ls ${JOB_DIR}/
+# gcloud storage ls ${JOB_DIR}/

community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/mlops_pipeline_tf_agents_bandits_movie_recommendation/mlops_pipeline_tf_agents_bandits_movie_recommendation.ipynb

@@ -478,8 +478,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil mb -l $REGION $BUCKET_NAME"
-      ]
+        "! gcloud storage buckets create --location $REGION $BUCKET_NAME"      ]
     },
     {
       "cell_type": "markdown",
@@ -498,8 +497,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil ls -al $BUCKET_NAME"
-      ]
+        "! gcloud storage ls --all-versions --long $BUCKET_NAME"      ]
     },
     {
       "cell_type": "markdown",
@@ -582,8 +580,7 @@
       "outputs": [],
       "source": [
         "# Download the sample data into your RAW_DATA_PATH\n",
-        "! gsutil cp \"gs://cloud-samples-data/vertex-ai/community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/u.data\" $RAW_DATA_PATH"
-      ]
+        "! gcloud storage cp \"gs://cloud-samples-data/vertex-ai/community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/u.data\" $RAW_DATA_PATH"      ]
     },
     {
       "cell_type": "code",
@@ -1621,9 +1618,7 @@
         "! gcloud scheduler jobs delete $SIMULATOR_SCHEDULER_JOB --quiet\n",
         "\n",
         "# Delete Cloud Storage objects that were created.\n",
-        "! gsutil -m rm -r $PIPELINE_ROOT\n",
-        "! gsutil -m rm -r $TRAINING_ARTIFACTS_DIR"
-      ]
+        "! gcloud storage rm --recursive $PIPELINE_ROOT\n",        "! gcloud storage rm --recursive $TRAINING_ARTIFACTS_DIR"      ]
     }
   ],
   "metadata": {

community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/mlops_pipeline_tf_agents_bandits_movie_recommendation/src/logger/requirements.txt

@@ -1,4 +1,4 @@
 google-cloud-bigquery==2.20.0
 tensorflow==2.12.1
-pillow==10.3.0
+pillow==12.3.0
 tf-agents==0.8.0

community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/mlops_pipeline_tf_agents_bandits_movie_recommendation/src/prediction_container/requirements.txt

@@ -1,4 +1,4 @@
 google-cloud-pubsub==2.5.0
-pillow==10.3.0
+pillow==12.3.0
 tf-agents==0.8.0
 tensorflow==2.12.1

community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/mlops_pipeline_tf_agents_bandits_movie_recommendation/src/simulator/requirements.txt

@@ -1,5 +1,5 @@
 dataclasses==0.6
 google-cloud-aiplatform==1.8.1
 tensorflow==2.12.1
-pillow==10.3.0
+pillow==12.3.0
 tf-agents==0.8.0

community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/step_by_step_sdk_tf_agents_bandits_movie_recommendation/step_by_step_sdk_tf_agents_bandits_movie_recommendation.ipynb

@@ -398,6 +398,7 @@
         "if not IS_GOOGLE_CLOUD_NOTEBOOK:\n",
         "    if \"google.colab\" in sys.modules:\n",
         "        from google.colab import auth as google_auth\n",
+        "\n",
         "        google_auth.authenticate_user()\n",
         "\n",
         "    # If you are running this notebook locally, replace the string below with the\n",
@@ -472,7 +473,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil mb -l $REGION $BUCKET_NAME"
+        "! gcloud storage buckets create --location $REGION $BUCKET_NAME"
       ]
     },
     {
@@ -492,7 +493,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil ls -al $BUCKET_NAME"
+        "! gcloud storage ls --all-versions --long $BUCKET_NAME"
       ]
     },
     {
@@ -565,7 +566,7 @@
       "outputs": [],
       "source": [
         "# Copy the sample data into your DATA_PATH\n",
-        "! gsutil cp \"gs://cloud-samples-data/vertex-ai/community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/u.data\"  $DATA_PATH"
+        "! gcloud storage cp \"gs://cloud-samples-data/vertex-ai/community-content/tf_agents_bandits_movie_recommendation_with_kfp_and_vertex_sdk/u.data\"  $DATA_PATH"
       ]
     },
     {
@@ -579,11 +580,15 @@
         "# Set hyperparameters.\n",
         "BATCH_SIZE = 8  # @param {type:\"integer\"} Training and prediction batch size.\n",
         "TRAINING_LOOPS = 5  # @param {type:\"integer\"} Number of training iterations.\n",
-        "STEPS_PER_LOOP = 2  # @param {type:\"integer\"} Number of driver steps per training iteration.\n",
+        "STEPS_PER_LOOP = (\n",
+        "    2  # @param {type:\"integer\"} Number of driver steps per training iteration.\n",
+        ")\n",
         "\n",
         "# Set MovieLens simulation environment parameters.\n",
         "RANK_K = 20  # @param {type:\"integer\"} Rank for matrix factorization in the MovieLens environment; also the observation dimension.\n",
-        "NUM_ACTIONS = 20  # @param {type:\"integer\"} Number of actions (movie items) to choose from.\n",
+        "NUM_ACTIONS = (\n",
+        "    20  # @param {type:\"integer\"} Number of actions (movie items) to choose from.\n",
+        ")\n",
         "PER_ARM = False  # Use the non-per-arm version of the MovieLens environment.\n",
         "\n",
         "# Set agent parameters.\n",
@@ -621,7 +626,8 @@
       "source": [
         "# Define RL environment.\n",
         "env = movielens_py_environment.MovieLensPyEnvironment(\n",
-        "    DATA_PATH, RANK_K, BATCH_SIZE, num_movies=NUM_ACTIONS, csv_delimiter=\"\\t\")\n",
+        "    DATA_PATH, RANK_K, BATCH_SIZE, num_movies=NUM_ACTIONS, csv_delimiter=\"\\t\"\n",
+        ")\n",
         "environment = tf_py_environment.TFPyEnvironment(env)\n",
         "\n",
         "# Define RL agent/algorithm.\n",
@@ -631,7 +637,8 @@
         "    tikhonov_weight=TIKHONOV_WEIGHT,\n",
         "    alpha=AGENT_ALPHA,\n",
         "    dtype=tf.float32,\n",
-        "    accepts_per_arm_features=PER_ARM)\n",
+        "    accepts_per_arm_features=PER_ARM,\n",
+        ")\n",
         "print(\"TimeStep Spec (for each batch):\\n\", agent.time_step_spec, \"\\n\")\n",
         "print(\"Action Spec (for each batch):\\n\", agent.action_spec, \"\\n\")\n",
         "print(\"Reward Spec (for each batch):\\n\", environment.reward_spec(), \"\\n\")\n",
@@ -639,7 +646,8 @@
         "# Define RL metric.\n",
         "optimal_reward_fn = functools.partial(\n",
         "    environment_utilities.compute_optimal_reward_with_movielens_environment,\n",
-        "    environment=environment)\n",
+        "    environment=environment,\n",
+        ")\n",
         "regret_metric = tf_bandit_metrics.RegretMetric(optimal_reward_fn)\n",
         "metrics = [regret_metric]"
       ]
@@ -704,35 +712,38 @@
         "    if training_data_spec_transformation_fn is None:\n",
         "        data_spec = agent.policy.trajectory_spec\n",
         "    else:\n",
-        "        data_spec = training_data_spec_transformation_fn(\n",
-        "            agent.policy.trajectory_spec)\n",
-        "    replay_buffer = trainer.get_replay_buffer(data_spec, environment.batch_size,\n",
-        "                                              steps_per_loop)\n",
+        "        data_spec = training_data_spec_transformation_fn(agent.policy.trajectory_spec)\n",
+        "    replay_buffer = trainer.get_replay_buffer(\n",
+        "        data_spec, environment.batch_size, steps_per_loop\n",
+        "    )\n",
         "\n",
         "    # `step_metric` records the number of individual rounds of bandit interaction;\n",
         "    # that is, (number of trajectories) * batch_size.\n",
         "    step_metric = tf_metrics.EnvironmentSteps()\n",
         "    metrics = [\n",
         "        tf_metrics.NumberOfEpisodes(),\n",
-        "        tf_metrics.AverageEpisodeLengthMetric(batch_size=environment.batch_size)\n",
+        "        tf_metrics.AverageEpisodeLengthMetric(batch_size=environment.batch_size),\n",
         "    ]\n",
         "    if additional_metrics:\n",
         "        metrics += additional_metrics\n",
         "\n",
         "    if isinstance(environment.reward_spec(), dict):\n",
-        "        metrics += [tf_metrics.AverageReturnMultiMetric(\n",
-        "            reward_spec=environment.reward_spec(),\n",
-        "            batch_size=environment.batch_size)]\n",
-        "    else:\n",
         "        metrics += [\n",
-        "            tf_metrics.AverageReturnMetric(batch_size=environment.batch_size)]\n",
+        "            tf_metrics.AverageReturnMultiMetric(\n",
+        "                reward_spec=environment.reward_spec(), batch_size=environment.batch_size\n",
+        "            )\n",
+        "        ]\n",
+        "    else:\n",
+        "        metrics += [tf_metrics.AverageReturnMetric(batch_size=environment.batch_size)]\n",
         "\n",
         "    # Store intermediate metric results, indexed by metric names.\n",
         "    metric_results = defaultdict(list)\n",
         "\n",
         "    if training_data_spec_transformation_fn is not None:\n",
-        "        def add_batch_fn(data): return replay_buffer.add_batch(training_data_spec_transformation_fn(data)) \n",
-        "        \n",
+        "\n",
+        "        def add_batch_fn(data):\n",
+        "            return replay_buffer.add_batch(training_data_spec_transformation_fn(data))\n",
+        "\n",
         "    else:\n",
         "        add_batch_fn = replay_buffer.add_batch\n",
         "\n",
@@ -742,10 +753,12 @@
         "        env=environment,\n",
         "        policy=agent.collect_policy,\n",
         "        num_steps=steps_per_loop * environment.batch_size,\n",
-        "        observers=observers)\n",
+        "        observers=observers,\n",
+        "    )\n",
         "\n",
         "    training_loop = trainer.get_training_loop_fn(\n",
-        "        driver, replay_buffer, agent, steps_per_loop)\n",
+        "        driver, replay_buffer, agent, steps_per_loop\n",
+        "    )\n",
         "    saver = policy_saver.PolicySaver(agent.policy)\n",
         "\n",
         "    for _ in range(training_loops):\n",
@@ -783,7 +796,8 @@
         "    environment=environment,\n",
         "    training_loops=TRAINING_LOOPS,\n",
         "    steps_per_loop=STEPS_PER_LOOP,\n",
-        "    additional_metrics=metrics)\n",
+        "    additional_metrics=metrics,\n",
+        ")\n",
         "\n",
         "tf.profiler.experimental.stop()"
       ]
@@ -1092,11 +1106,15 @@
       },
       "outputs": [],
       "source": [
-        "RUN_HYPERPARAMETER_TUNING = True  # Execute hyperparameter tuning instead of regular training.\n",
+        "RUN_HYPERPARAMETER_TUNING = (\n",
+        "    True  # Execute hyperparameter tuning instead of regular training.\n",
+        ")\n",
         "TRAIN_WITH_BEST_HYPERPARAMETERS = False  # Do not train.\n",
         "\n",
         "HPTUNING_RESULT_DIR = \"hptuning/\"  # @param {type: \"string\"} Directory to store the best hyperparameter(s) in `BUCKET_NAME` and locally (temporarily).\n",
-        "HPTUNING_RESULT_PATH = os.path.join(HPTUNING_RESULT_DIR, \"result.json\")  # @param {type: \"string\"} Path to the file containing the best hyperparameter(s)."
+        "HPTUNING_RESULT_PATH = os.path.join(\n",
+        "    HPTUNING_RESULT_DIR, \"result.json\"\n",
+        ")  # @param {type: \"string\"} Path to the file containing the best hyperparameter(s)."
       ]
     },
     {
@@ -1124,7 +1142,7 @@
         "    image_uri: str,\n",
         "    args: List[str],\n",
         "    location: str = \"us-central1\",\n",
-        "    api_endpoint: str = \"us-central1-aiplatform.googleapis.com\"\n",
+        "    api_endpoint: str = \"us-central1-aiplatform.googleapis.com\",\n",
         ") -> None:\n",
         "    \"\"\"Creates a hyperparameter tuning job using a custom container.\n",
         "\n",
@@ -1197,8 +1215,8 @@
         "\n",
         "    # Create job\n",
         "    response = client.create_hyperparameter_tuning_job(\n",
-        "        parent=parent,\n",
-        "        hyperparameter_tuning_job=hyperparameter_tuning_job)\n",
+        "        parent=parent, hyperparameter_tuning_job=hyperparameter_tuning_job\n",
+        "    )\n",
         "    job_id = response.name.split(\"/\")[-1]\n",
         "    print(\"Job ID:\", job_id)\n",
         "    print(\"Job config:\", response)\n",
@@ -1242,7 +1260,8 @@
         "    image_uri=f\"gcr.io/{PROJECT_ID}/{HPTUNING_TRAINING_CONTAINER}:latest\",\n",
         "    args=args,\n",
         "    location=REGION,\n",
-        "    api_endpoint=f\"{REGION}-aiplatform.googleapis.com\")"
+        "    api_endpoint=f\"{REGION}-aiplatform.googleapis.com\",\n",
+        ")"
       ]
     },
     {
@@ -1292,7 +1311,8 @@
         "    name = client.hyperparameter_tuning_job_path(\n",
         "        project=project,\n",
         "        location=location,\n",
-        "        hyperparameter_tuning_job=hyperparameter_tuning_job_id)\n",
+        "        hyperparameter_tuning_job=hyperparameter_tuning_job_id,\n",
+        "    )\n",
         "    response = client.get_hyperparameter_tuning_job(name=name)\n",
         "    return response"
       ]
@@ -1313,7 +1333,8 @@
         "        location=REGION,\n",
         "        api_endpoint=f\"{REGION}-aiplatform.googleapis.com\")\n",
         "    if response.state.name == 'JOB_STATE_SUCCEEDED':\n",
-        "        print(\"Job succeeded.\\nJob Time:\", response.update_time - response.create_time)\n",
+        "        print(\"Job succeeded.\n",
+        "Job Time:\", response.update_time - response.create_time)\n",
         "        trials = response.trials\n",
         "        print(\"Trials:\", trials)\n",
         "        break\n",
@@ -1348,8 +1369,8 @@
         "if trials:\n",
         "    # Dict mapping from metric names to the best metric values seen so far\n",
         "    best_objective_values = dict.fromkeys(\n",
-        "        [metric.metric_id for metric in trials[0].final_measurement.metrics],\n",
-        "        -np.inf)\n",
+        "        [metric.metric_id for metric in trials[0].final_measurement.metrics], -np.inf\n",
+        "    )\n",
         "    # Dict mapping from metric names to a list of the best combination(s) of\n",
         "    # hyperparameter(s). Each combination is a dict mapping from hyperparameter\n",
         "    # names to their values.\n",
@@ -1358,12 +1379,13 @@
         "        # `final_measurement` and `parameters` are `RepeatedComposite` objects.\n",
         "        # Reference the structure above to extract the value of your interest.\n",
         "        for metric in trial.final_measurement.metrics:\n",
-        "            params = {\n",
-        "                param.parameter_id: param.value for param in trial.parameters}\n",
+        "            params = {param.parameter_id: param.value for param in trial.parameters}\n",
         "            if metric.value > best_objective_values[metric.metric_id]:\n",
         "                best_params[metric.metric_id] = [params]\n",
         "            elif metric.value == best_objective_values[metric.metric_id]:\n",
-        "                best_params[param.parameter_id].append(params)  # Handle cases where multiple hyperparameter values lead to the same performance.\n",
+        "                best_params[param.parameter_id].append(\n",
+        "                    params\n",
+        "                )  # Handle cases where multiple hyperparameter values lead to the same performance.\n",
         "    print(\"Best hyperparameter value(s):\")\n",
         "    for metric, params in best_params.items():\n",
         "        print(f\"Metric={metric}: {sorted(params)}\")\n",
@@ -1443,7 +1465,9 @@
       },
       "outputs": [],
       "source": [
-        "PREDICTION_CONTAINER = \"prediction-custom-container\"  # @param {type:\"string\"} Name of the container image."
+        "PREDICTION_CONTAINER = (\n",
+        "    \"prediction-custom-container\"  # @param {type:\"string\"} Name of the container image.\n",
+        ")"
       ]
     },
     {
@@ -1475,7 +1499,7 @@
         "  machineType: 'E2_HIGHCPU_8'\"\"\".format(\n",
         "    PROJECT_ID=PROJECT_ID,\n",
         "    PREDICTION_CONTAINER=PREDICTION_CONTAINER,\n",
-        "    ARTIFACTS_DIR=ARTIFACTS_DIR\n",
+        "    ARTIFACTS_DIR=ARTIFACTS_DIR,\n",
         ")\n",
         "\n",
         "with open(\"cloudbuild.yaml\", \"w\") as fp:\n",
@@ -1592,8 +1616,12 @@
       },
       "outputs": [],
       "source": [
-        "RUN_HYPERPARAMETER_TUNING = False  # Execute regular training instead of hyperparameter tuning.\n",
-        "TRAIN_WITH_BEST_HYPERPARAMETERS = True  # @param {type:\"bool\"} Whether to use learned hyperparameters in training."
+        "RUN_HYPERPARAMETER_TUNING = (\n",
+        "    False  # Execute regular training instead of hyperparameter tuning.\n",
+        ")\n",
+        "TRAIN_WITH_BEST_HYPERPARAMETERS = (\n",
+        "    True  # @param {type:\"bool\"} Whether to use learned hyperparameters in training.\n",
+        ")"
       ]
     },
     {
@@ -1633,10 +1661,12 @@
         "job = aiplatform.CustomContainerTrainingJob(\n",
         "    display_name=\"train-movielens\",\n",
         "    container_uri=f\"gcr.io/{PROJECT_ID}/{HPTUNING_TRAINING_CONTAINER}:latest\",\n",
-        "    command=[\"python3\", \"-m\", \"src.training.task\"] + args,  # Pass in training arguments, including hyperparameters.\n",
+        "    command=[\"python3\", \"-m\", \"src.training.task\"]\n",
+        "    + args,  # Pass in training arguments, including hyperparameters.\n",
         "    model_serving_container_image_uri=f\"gcr.io/{PROJECT_ID}/{PREDICTION_CONTAINER}:latest\",\n",
         "    model_serving_container_predict_route=\"/predict\",\n",
-        "    model_serving_container_health_route=\"/health\")\n",
+        "    model_serving_container_health_route=\"/health\",\n",
+        ")\n",
         "\n",
         "print(\"Training Spec:\", job._managed_model)\n",
         "\n",
@@ -1645,7 +1675,8 @@
         "    replica_count=1,\n",
         "    machine_type=\"n1-standard-4\",\n",
         "    accelerator_type=\"ACCELERATOR_TYPE_UNSPECIFIED\",\n",
-        "    accelerator_count=0)"
+        "    accelerator_count=0,\n",
+        ")"
       ]
     },
     {
@@ -1784,7 +1815,7 @@
         "! gcloud ai models delete $model.name --quiet\n",
         "\n",
         "# Delete Cloud Storage objects that were created\n",
-        "! gsutil -m rm -r $ARTIFACTS_DIR"
+        "! gcloud storage rm --recursive $ARTIFACTS_DIR"
       ]
     }
   ],

community-content/tf_keras_image_classification_distributed_multi_worker_with_vertex_sdk/multi_worker_vertex_training_on_cpu_with_custom_container.ipynb

@@ -324,7 +324,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil ls $gcs_output_uri_prefix"
+        "! gcloud storage ls $gcs_output_uri_prefix"
       ]
     },
     {
@@ -344,7 +344,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil rm -rf $gcs_output_uri_prefix"
+        "! gcloud storage rm --recursive --continue-on-error $gcs_output_uri_prefix"
       ]
     }
   ],

community-content/tf_keras_image_classification_distributed_multi_worker_with_vertex_sdk/multi_worker_vertex_training_on_gpu_with_custom_container.ipynb

@@ -328,7 +328,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil ls $gcs_output_uri_prefix"
+        "! gcloud storage ls $gcs_output_uri_prefix"
       ]
     },
     {
@@ -348,7 +348,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil rm -rf $gcs_output_uri_prefix"
+        "! gcloud storage rm --recursive --continue-on-error $gcs_output_uri_prefix"
       ]
     }
   ],

community-content/tf_keras_text_classification_distributed_single_worker_gpus_with_gcloud_local_run_and_vertex_sdk/vertex_training_with_local_mode_container.ipynb

@@ -341,7 +341,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil ls $gcs_output_uri_prefix"
+        "! gcloud storage ls $gcs_output_uri_prefix"
       ]
     },
     {
@@ -361,7 +361,7 @@
       },
       "outputs": [],
       "source": [
-        "! gsutil rm -rf $gcs_output_uri_prefix"
+        "! gcloud storage rm --recursive --continue-on-error $gcs_output_uri_prefix"
       ]
     }
   ],

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/README.md

@@ -0,0 +1,126 @@
+# Vertex AI Training: Llama 3.1 8B pre-training using Nvidia A3 Mega VMs (H100)
+This document provides a step-by-step guide for pre-training a Llama 3.1 8B model on the `en-wiki` dataset using multiple [Vertex AI Custom Training](https://cloud.google.com/vertex-ai/docs/training/overview) `a3-megagpu-8g` nodes.
+
+We will use a custom container based on NVIDIA's [NeMo Framework](https://docs.nvidia.com/nemo-framework/user-guide/24.07/overview.html) to demonstrate a scalable, multi-node training workflow. All required artifacts and commands are included.
+
+## 1. Prerequisites
+
+### 1.1. Google Cloud Project setup
+- **Enable APIs:** Ensure the Vertex AI API is [enabled for your project](http://console.cloud.google.com/flows/enableapi?apiid=aiplatform.googleapis.com).
+- **H100 Mega Quota:** A3 Mega VMs are powered by H100 GPUs. Request quota for `custom_model_training_nvidia_h100_mega_gpus` in one of the [supported regions](https://cloud.google.com/vertex-ai/docs/general/locations#accelerator_support). If using Spot VMs, request `custom_model_training_preemptible_nvidia_h100_mega_gpus` quota instead.
+- **Reservations (Optional but recommended):** For guaranteed capacity, [create a reservation](https://cloud.google.com/compute/docs/instances/reservations-shared) and ensure the reservation is shared with the Vertex AI service account. This guide requires a minimum of **16 H100 GPUs** (2 full A3 Mega nodes).
+
+### 1.2. GCS bucket
+Create a [Cloud Storage bucket](https://cloud.google.com/storage/docs/creating-buckets) in the same region where you have quota. If you're using Hierarchical Namespace for your bucket, you may need to update permissions of the Vertex AI Custom Code Service Agent .
+
+This bucket is used for:
+- Staging the training application.
+- Storing model checkpoints and logs.
+- Storing data if you use your own data.
+
+
+## 2. Setup & configuration
+
+### 2.1. Clone the repo
+First clone the repo into your development environment.
+
+```bash
+git clone https://github.com/GoogleCloudPlatform/vertex-ai-samples.git
+```
+
+Navigate to the root folder for this sample.
+
+### 2.2. Environment Setup
+First, configure your local environment. These variables are used in subsequent commands.
+
+```bash
+# Required: Update with your values
+export PROJECT_ID="<your-project-id>"
+export REPOSITORY="<your-artifact-registry-repo-name>" # e.g., "my-containers"
+export BUCKET="<your-gcs-bucket-name>"
+
+# Optional: Change if needed
+export REGION="us-central1"
+
+# --- Do not change the lines below ---
+export ARTIFACT_REGISTRY="${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY}"
+export REPO_ROOT=$(git rev-parse --show-toplevel)
+```
+
+## 3. Build and push a docker container image to Artifact Registry
+Normally, you can use any custom training container on Vertex AI Training. In this example you build a NeMo Docker image that is based on the [Nvidia’s NeMo 24.09](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo/tags) image. Use Cloud Build to build and push the container image.
+
+This document picked NeMo as the demonstrating container since it’s a widely adopted GPU LLM training framework providing high performance and versatile training functionalities.
+
+In addition to the base image, some customizations are included to form the final prebuilt image:
+- Some dependencies are installed to integrate with Vertex AI Training.
+- An entrypoint script that sets up required environments and calls the training job.
+- Some patches are applied to the NeMo code to let it  load the dataset from a GCS bucket.
+
+Run this command to build the container and push the container into the Google Artifact Registry.
+
+```bash
+cd "${REPO_ROOT}/community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining"
+export IMAGE_NAME="vertex-nemo-llama"
+gcloud builds submit . \
+    --project="${PROJECT_ID}" \
+    --region="${REGION}" \
+    --config=docker/cloudbuild.yml \
+    --substitutions="_ARTIFACT_REGISTRY=${ARTIFACT_REGISTRY},_IMAGE_NAME=${IMAGE_NAME}" \
+    --timeout="2h" \
+    --machine-type="e2-highcpu-32"
+```
+
+## 4. Launch the Training Job
+
+
+###  4.1. Job Configuration File
+Once the container is built, update the job_config.json to set up the training job.
+File: job_config.json
+```json
+{
+  "project_id": "<project-id>",
+  "region": "<region>",
+  "zone": "<zone if using reservation>",
+  "bucket": "<bucket>",
+  "dataset_bucket": "github-repo/data/third-party/enwiki-latest-pages-articles",
+  "image_uri": "<docker image uri from artifact registry>",
+  "strategy": "spot",
+  "nodes": "2",
+  "machine_type": "a3-megagpu-8g",
+  "gpu_type": "NVIDIA_H100_MEGA_80GB",
+  "gpus_per_node": "8",
+  "recipe_name": "llama3_1_8b_pretrain_a3mega",
+  "job_prefix": "vertex-spot-",
+  "reservation_name": ""
+}
+```
+
+### 4.2 Launch the Training Job
+
+First, create a Python virtual environment using your tool of choice, then install
+the requirements specified in `requirements.txt`. Using `pip`, the command would be:
+```bash
+pip install -r requirements.txt
+```
+
+Now launch the Vertex AI training job using the provided Python script.
+
+```bash
+python3 scripts/launch.py --config_file=job_config.json
+```
+
+This script reads job_config.json, defines the cluster specification (2 nodes, 8 GPUs each), and submits the custom training job to Vertex AI.
+
+## 5. Monitor and Clean Up
+
+### 5.1. Monitoring
+Vertex AI Console: Track the job's status in the Google Cloud Console under Vertex AI > Training > Custom Jobs.
+Logs: View detailed logs in Cloud Logging by filtering for your job name.
+Checkpoints: Model checkpoints are saved to your GCS bucket at the path specified in your training script's configuration.
+
+### 5.2. Cleaning Up
+To avoid ongoing charges, delete the resources you created:
+- The Artifact Registry image.
+- The contents of the GCS bucket (checkpoints, logs).
+- The Vertex AI Custom Job will eventually complete or fail, incurring no further cost.

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/configs/llama3_1_8b_pretrain_a3mega.yaml

@@ -0,0 +1,265 @@
+# Reference:
+# https://github.com/NVIDIA/NeMo-Framework-Launcher/blob/24.07/launcher_scripts/conf/training/llama/llama3_1_8b.yaml
+name: llama3_1_8b_pretrain_a3mega
+restore_from_path: null  # used when starting from a .nemo file
+
+trainer:
+  devices: 8
+  num_nodes: 1
+  accelerator: gpu
+  precision: bf16
+  logger: false  # logger provided by exp_manager
+  enable_checkpointing: false
+  use_distributed_sampler: false
+  max_epochs: -1  # PTL default. In practice, max_steps will be reached first.
+  max_steps: 30  # consumed_samples = global_step * micro_batch_size * data_parallel_size * accumulate_grad_batches
+  log_every_n_steps: 1
+  val_check_interval: null
+  limit_val_batches: 1
+  limit_test_batches: 1
+  accumulate_grad_batches: 1  # do not modify, grad acc is automatic for training megatron models
+  gradient_clip_val: 1.0
+  benchmark: false
+  enable_model_summary: false  # default PTL callback for this does not support model parallelism, instead we log manually
+
+exp_manager:
+  explicit_log_dir: null
+  exp_dir: /data
+  name: ${name}
+  create_dllogger_logger: true
+  dllogger_logger_kwargs:
+    verbose: true
+    stdout: true
+    json_file: "/data/dllogger.json"
+  create_wandb_logger: false
+  wandb_logger_kwargs:
+    project: null
+    name: null
+  resume_if_exists: true
+  resume_ignore_no_checkpoint: true
+  create_checkpoint_callback: false
+  checkpoint_callback_params:
+    monitor: val_loss
+    save_top_k: 3
+    mode: min
+    always_save_nemo: false  # saves nemo file during validation, not implemented for model parallel
+    save_nemo_on_train_end: false  # not recommended when training large models on clusters with short time limits
+    filename: 'megatron_gpt--{val_loss:.2f}-{step}-{consumed_samples}'
+    model_parallel_size: ${multiply:${model.tensor_model_parallel_size}, ${model.pipeline_model_parallel_size}}
+  seconds_to_sleep: 5  # Allows node_rank!=0 to sleep and let node0 to init, like preparing data
+
+model:
+  mcore_gpt: true
+  # specify micro_batch_size, global_batch_size, and model parallelism
+  # gradient accumulation will be done automatically based on data_parallel_size
+  micro_batch_size: 1  # limited by GPU memory
+  global_batch_size: 1024  # will use more micro batches to reach global batch size
+  tensor_model_parallel_size: 1  # intra-layer model parallelism
+  pipeline_model_parallel_size: 2  # inter-layer model parallelism
+  context_parallel_size: 1
+  virtual_pipeline_model_parallel_size: null  # interleaved pipeline
+  ## Sequence Parallelism
+  # Makes tensor parallelism more memory efficient for LLMs (20B+) by parallelizing layer norms and dropout sequentially
+  # See Reducing Activation Recomputation in Large Transformer Models: https://arxiv.org/abs/2205.05198 for more details.
+  sequence_parallel: false
+
+  fsdp: false
+  fsdp_cpu_offload: true
+  fsdp_sharding_strategy: "full"  # Method to shard model states. Available options are 'full', 'hybrid', and 'grad'.
+  fsdp_grad_reduce_dtype: "16"  # Gradient reduction data type.
+  fsdp_sharded_checkpoint: false  # Store and load FSDP shared checkpoint.
+  fsdp_use_orig_params: false  # Set to True to use FSDP for specific peft scheme.
+
+  # Distributed checkpoint setup
+  dist_ckpt_format: "torch_dist"  # Set to 'torch_dist' to use PyTorch distributed checkpoint format.
+  dist_ckpt_load_on_device: true  # whether to load checkpoint weights directly on GPU or to CPU
+  dist_ckpt_parallel_save: true  # if true, each worker will write its own part of the dist checkpoint
+  dist_ckpt_parallel_save_within_dp: false  # if true, save will be parallelized only within a DP group (whole world otherwise), which might slightly reduce the save overhead
+  dist_ckpt_parallel_load: false  # if true, each worker will load part of the dist checkpoint and exchange with NCCL. Might use some extra GPU memory
+  dist_ckpt_torch_dist_multiproc: 2  # number of extra processes per rank used during ckpt save with PyTorch distributed format
+  dist_ckpt_assume_constant_structure: false  # set to True only if the state dict structure doesn't change within a single job. Allows caching some computation across checkpoint saves.
+  dist_ckpt_parallel_dist_opt: true  # parallel save/load of a DistributedOptimizer. 'True' allows performant save and reshardable checkpoints. Set to 'False' only in order to minimize the number of checkpoint files.
+  dist_ckpt_load_strictness: null  # defines checkpoint keys mismatch behavior (only during dist-ckpt load). Choices: assume_ok_unexpected (default - try loading without any check), log_all (log mismatches), raise_all (raise mismatches)
+
+  # model architecture
+  encoder_seq_length: 8192
+  max_position_embeddings: ${.encoder_seq_length}
+  num_layers: 32  # 8b: 32 | 70b: 80 | 405b: 126
+  hidden_size: 4096  # 8b: 4096 | 70b: 8192 | 405b: 16384
+  ffn_hidden_size: 14336  # 8b: 14336 | 70b: 28672 | 405b: 53248
+  num_attention_heads: 32  # 8b: 32 | 70b: 64 | 405b: 128
+  num_query_groups: 8  # Number of query groups for group query attention. If None, normal attention is used. 8b: 8 | 70b: 8 | 405b: 16
+  init_method_std: 0.01  # Standard deviation of the zero mean normal distribution used for weight initialization.  8b: 0.01 | 70b: 0.008944 | 405b: 0.02
+  use_scaled_init_method: true  # use scaled residuals initialization
+  hidden_dropout: 0.0  # Dropout probability for hidden state transformer.
+  attention_dropout: 0.0  # Dropout probability for attention
+  ffn_dropout: 0.0  # Dropout probability in the feed-forward layer.
+  kv_channels: null  # Projection weights dimension in multi-head attention. Set to hidden_size // num_attention_heads if null
+  apply_query_key_layer_scaling: true  # scale Q * K^T by 1 / layer-number.
+  normalization: 'rmsnorm'  # Normalization layer to use. Options are 'layernorm', 'rmsnorm'
+  layernorm_epsilon: 1e-5
+  do_layer_norm_weight_decay: false  # True means weight decay on all params
+  make_vocab_size_divisible_by: 128  # Pad the vocab size to be divisible by this value for computation efficiency.
+  pre_process: true  # add embedding
+  post_process: true  # add pooler
+  persist_layer_norm: true  # Use of persistent fused layer norm kernel.
+  bias: false  # Whether to use bias terms in all weight matrices.
+  activation: 'fast-swiglu'  # Options ['gelu', 'geglu', 'swiglu', 'reglu', 'squared-relu', 'fast-geglu', 'fast-swiglu', 'fast-reglu']
+  headscale: false  # Whether to learn extra parameters that scale the output of the each self-attention head.
+  transformer_block_type: 'pre_ln'  # Options ['pre_ln', 'post_ln', 'normformer']
+  openai_gelu: false  # Use OpenAI's GELU instead of the default GeLU
+  normalize_attention_scores: true  # Whether to scale the output Q * K^T by 1 / sqrt(hidden_size_per_head). This arg is provided as a configuration option mostly for compatibility with models that have been weight-converted from HF. You almost always want to se this to True.
+  position_embedding_type: 'rope'  # Position embedding type. Options ['learned_absolute', 'rope']
+  rotary_percentage: 1.0  # If using position_embedding_type=rope, then the per head dim is multiplied by this.
+  attention_type: 'multihead'  # Attention type. Options ['multihead']
+  share_embeddings_and_output_weights: false  # Share embedding and output layer weights.
+  scale_positional_embedding: true  # This is false for llama3 models. Only used for >= llama3.1.
+
+  # Use GPT2BPETokenizer for test, because the testing dataset is tokenized by this tokenizer.
+  # https://docs.nvidia.com/nemo-framework/user-guide/24.07/playbooks/singlenodepretrain.html#data-download-and-pre-processing
+  tokenizer:
+    library: megatron
+    type: GPT2BPETokenizer
+    model: null  # /path/to/tokenizer.model
+    vocab_file: null
+    merge_file: null
+    delimiter: null  # only used for tabular tokenizer
+    sentencepiece_legacy: false  # Legacy=True allows you to add special tokens to sentencepiece tokenizers.
+
+  # Mixed precision
+  native_amp_init_scale: 4294967296  # 2 ** 32
+  native_amp_growth_interval: 1000
+  hysteresis: 2  # Gradient scale hysteresis
+  fp32_residual_connection: false  # Move residual connections to fp32
+  fp16_lm_cross_entropy: false  # Move the cross entropy unreduced loss calculation for lm head to fp16
+
+  # Megatron O2-style half-precision
+  megatron_amp_O2: true  # Enable O2-level automatic mixed precision using main parameters
+  grad_allreduce_chunk_size_mb: 125
+
+  # Fusion
+  grad_div_ar_fusion: true  # Fuse grad division into torch.distributed.all_reduce. Only used with O2 and no pipeline parallelism..
+  gradient_accumulation_fusion: true  # Fuse weight gradient accumulation to GEMMs. Only used with pipeline parallelism and O2.
+  bias_activation_fusion: true  # Use a kernel that fuses the bias addition from weight matrices with the subsequent activation function.
+  bias_dropout_add_fusion: true  # Use a kernel that fuses the bias addition, dropout and residual connection addition.
+  masked_softmax_fusion: true  # Use a kernel that fuses the attention softmax with it's mask.
+  apply_rope_fusion: true  # Use a kernel to add rotary positional embeddings. Only used if position_embedding_type=rope
+  cross_entropy_loss_fusion: true
+
+  # Miscellaneous
+  seed: 1234
+  resume_from_checkpoint: null  # manually set the checkpoint file to load from
+  use_cpu_initialization: false  # Init weights on the CPU (slow for large models)
+  onnx_safe: false  # Use work-arounds for known problems with Torch ONNX exporter.
+  apex_transformer_log_level: 30  # Python logging level displays logs with severity greater than or equal to this
+  gradient_as_bucket_view: true  # PyTorch DDP argument. Allocate gradients in a contiguous bucket to save memory (less fragmentation and buffer memory)
+  sync_batch_comm: false  # Enable stream synchronization after each p2p communication between pipeline stages
+
+  ## Activation Checkpointing
+  # NeMo Megatron supports 'selective' activation checkpointing where only the memory intensive part of attention is checkpointed.
+  # These memory intensive activations are also less compute intensive which makes activation checkpointing more efficient for LLMs (20B+).
+  # See Reducing Activation Recomputation in Large Transformer Models: https://arxiv.org/abs/2205.05198 for more details.
+  # 'full' will checkpoint the entire transformer layer.
+  activations_checkpoint_granularity: null  # 'selective' or 'full'
+  activations_checkpoint_method: null  # 'uniform', 'block'
+  # 'uniform' divides the total number of transformer layers and checkpoints the input activation
+  # of each chunk at the specified granularity. When used with 'selective', 'uniform' checkpoints all attention blocks in the model.
+  # 'block' checkpoints the specified number of layers per pipeline stage at the specified granularity
+  activations_checkpoint_num_layers: null
+  # when using 'uniform' this creates groups of transformer layers to checkpoint. Usually set to 1. Increase to save more memory.
+  # when using 'block' this this will checkpoint the first activations_checkpoint_num_layers per pipeline stage.
+  num_micro_batches_with_partial_activation_checkpoints: null
+  # This feature is valid only when used with pipeline-model-parallelism.
+  # When an integer value is provided, it sets the number of micro-batches where only a partial number of Transformer layers get checkpointed
+  # and recomputed within a window of micro-batches. The rest of micro-batches in the window checkpoint all Transformer layers. The size of window is
+  # set by the maximum outstanding micro-batch backpropagations, which varies at different pipeline stages. The number of partial layers to checkpoint
+  # per micro-batch is set by 'activations_checkpoint_num_layers' with 'activations_checkpoint_method' of 'block'.
+  # This feature enables using activation checkpoint at a fraction of micro-batches up to the point of full GPU memory usage.
+  activations_checkpoint_layers_per_pipeline: null
+  # This feature is valid only when used with pipeline-model-parallelism.
+  # When an integer value (rounded down when float is given) is provided, it sets the number of Transformer layers to skip checkpointing at later
+  # pipeline stages. For example, 'activations_checkpoint_layers_per_pipeline' of 3 makes pipeline stage 1 to checkpoint 3 layers less than
+  # stage 0 and stage 2 to checkpoint 6 layers less stage 0, and so on. This is possible because later pipeline stage
+  # uses less GPU memory with fewer outstanding micro-batch backpropagations. Used with 'num_micro_batches_with_partial_activation_checkpoints',
+  # this feature removes most of activation checkpoints at the last pipeline stage, which is the critical execution path.
+
+  ## Transformer Engine
+  transformer_engine: true
+  fp8: false  # enables fp8 in TransformerLayer forward
+  fp8_e4m3: false  # sets fp8_format = recipe.Format.E4M3
+  fp8_hybrid: false  # sets fp8_format = recipe.Format.HYBRID
+  fp8_margin: 0  # scaling margin
+  fp8_interval: 1  # scaling update interval
+  fp8_amax_history_len: 1024  # Number of steps for which amax history is recorded per tensor
+  fp8_amax_compute_algo: 'max'  # 'most_recent' or 'max'. Algorithm for computing amax from history
+  ub_tp_comm_overlap: false  # do not turn on because of b/397797926
+  use_flash_attention: true
+  gc_interval: 100
+
+  ## Offloading Activations/Weights to CPU
+  cpu_offloading: false
+  cpu_offloading_num_layers: ${sum:${.num_layers},-1}  # This value should be between [1,num_layers-1] as we don't want to offload the final layer's activations and expose any offloading duration for the final layer
+  cpu_offloading_activations: true
+  cpu_offloading_weights: true
+
+  data:
+    # Path to data must be specified by the user.
+    # Supports List, String and Dictionary
+    # List : can override from the CLI: "model.data.data_prefix=[.5,/raid/data/pile/my-gpt3_00_text_document,.5,/raid/data/pile/my-gpt3_01_text_document]",
+    # Or see example below:
+    # data_prefix:
+    # - .5
+    # - /raid/data/pile/my-gpt3_00_text_document
+    # - .5
+    # - /raid/data/pile/my-gpt3_01_text_document
+    # Dictionary: can override from CLI "model.data.data_prefix"={"train":[1.0, /path/to/data], "validation":/path/to/data, "test":/path/to/test}
+    # Or see example below:
+    # "model.data.data_prefix: {train:[1.0,/path/to/data], validation:[/path/to/data], test:[/path/to/test]}"
+    data_prefix: [1.0, /data/hfbpe_gpt_training_data_text_document]
+    index_mapping_dir: null  # path to save index mapping .npy files, by default will save in the same location as data_prefix
+    data_impl: mmap
+    splits_string: 900,50,50
+    seq_length: ${model.encoder_seq_length}
+    skip_warmup: true
+    num_workers: 2
+    dataloader_type: single  # cyclic
+    reset_position_ids: false  # Reset position ids after end-of-document token
+    reset_attention_mask: false  # Reset attention mask after end-of-document token
+    eod_mask_loss: false  # Mask loss for the end of document tokens
+    validation_drop_last: true  # Set to false if the last partial validation samples is to be consumed
+    no_seqlen_plus_one_input_tokens: false  # Set to True to disable fetching (sequence length + 1) input tokens, instead get (sequence length) input tokens and mask the last token
+    pad_samples_to_global_batch_size: false  # Set to True if you want to pad the last partial batch with -1's to equal global batch size
+    shuffle_documents: true  # Set to False to disable documents shuffling. Sample index will still be shuffled
+
+  # Nsys profiling options
+  nsys_profile:
+    enabled: false
+    start_step: 0  # Global batch to start profiling
+    end_step: 1  # Global batch to end profiling
+    ranks: [0]  # Global rank IDs to profile
+    gen_shape: false  # Generate model and kernel details including input shapes
+
+  memory_profile:
+    enabled: false
+    start_step: 0
+    end_step: 1
+    ranks: [0]
+    output_path: /data  # Must be a dir
+
+  optim:
+    name: distributed_fused_adam  # E.g., fused_adam or set _target_: torch.optim.AdamW field
+    lr: 2e-5
+    weight_decay: 0.01
+    betas:
+    - 0.9
+    - 0.98
+    bucket_cap_mb: 125
+    overlap_grad_sync: true
+    overlap_param_sync: true
+    contiguous_grad_buffer: true
+    contiguous_param_buffer: true
+    sched:
+      name: CosineAnnealing
+      warmup_steps: 400
+      constant_steps: 0
+      min_lr: 2e-6

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/cloudbuild.yml

@@ -0,0 +1,26 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+  args:
+  - 'build'
+  - '--tag=${_ARTIFACT_REGISTRY}/${_IMAGE_NAME}'
+  - '--file=docker/vertex-dist-recipes.Dockerfile'
+  - '.'
+  automapSubstitutions: true
+  env:
+  - 'DOCKER_BUILDKIT=1'
+images:
+- '${_ARTIFACT_REGISTRY}/${_IMAGE_NAME}'

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/patches/24.09/gpu_stats.patch

@@ -0,0 +1,41 @@
+diff --git a/nemo/collections/nlp/parts/megatron_trainer_builder.py b/nemo/collections/nlp/parts/megatron_trainer_builder.py
+index b2c85cde4..a3a9670c3 100644
+--- a/nemo/collections/nlp/parts/megatron_trainer_builder.py
++++ b/nemo/collections/nlp/parts/megatron_trainer_builder.py
+@@ -19,6 +19,7 @@ from lightning_fabric.utilities.exceptions import MisconfigurationException
+ from omegaconf import DictConfig
+ from pytorch_lightning import Trainer
+ from pytorch_lightning.callbacks import ModelSummary
++from pytorch_lightning.callbacks import Callback
+ from pytorch_lightning.plugins.environments import TorchElasticEnvironment
+
+ from nemo.collections.common.metrics.perf_metrics import FLOPsMeasurementCallback
+@@ -38,6 +39,23 @@ from nemo.utils.callbacks.dist_ckpt_io import (
+     AsyncFinalizerCallback,
+     DistributedCheckpointIO,
+ )
++from vmg.util.device_stats import gpu_stats_str
++
++class GpuStatsMon(Callback):
++    def on_train_start(self, trainer, pl_module) -> None:
++        rank=pl_module.global_rank
++        print(f'train_start: {rank=} {gpu_stats_str()}', flush=True)
++
++    def on_train_batch_start(self, trainer, pl_module, batch, batch_idx) -> None:
++        rank=pl_module.global_rank
++        print(f'batch_start: {rank=} {gpu_stats_str()}', flush=True)
++
++    def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx) -> None:
++        rank=pl_module.global_rank
++        print(f'batch_end: {rank=} {gpu_stats_str()}', flush=True)
+
+
+ class MegatronTrainerBuilder:
+@@ -178,6 +196,7 @@ class MegatronTrainerBuilder:
+         if self.cfg.get('exp_manager', {}).get('log_tflops_per_sec_per_gpu', True):
+             callbacks.append(FLOPsMeasurementCallback(self.cfg))
+
++        callbacks.append(GpuStatsMon())
+         return callbacks
+
+     def create_trainer(self, callbacks=None) -> Trainer:

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/patches/24.09/local_rank.patch

@@ -0,0 +1,41 @@
+diff -ruN old-datasets/blended_megatron_dataset_builder.py datasets/blended_megatron_dataset_builder.py
+--- old-datasets/blended_megatron_dataset_builder.py	2025-05-02 04:08:45.369199665 +0000
++++ datasets/blended_megatron_dataset_builder.py	2025-05-02 04:10:47.369119891 +0000
+@@ -2,6 +2,7 @@
+
+ import logging
+ import math
++import os
+ from concurrent.futures import ThreadPoolExecutor
+ from typing import Any, Callable, Iterable, List, Optional, Type, Union
+
+@@ -353,7 +354,7 @@
+         num_dataset_builder_threads = self.config.num_dataset_builder_threads
+
+         if torch.distributed.is_initialized():
+-            rank = torch.distributed.get_rank()
++            rank = int(os.getenv("LOCAL_RANK", "0"))
+             # First, build on rank 0
+             if rank == 0:
+                 num_workers = num_dataset_builder_threads
+@@ -475,7 +476,7 @@
+             Optional[Union[DistributedDataset, Iterable]]: The DistributedDataset instantion, the Iterable instantiation, or None
+         """
+         if torch.distributed.is_initialized():
+-            rank = torch.distributed.get_rank()
++            rank = int(os.getenv("LOCAL_RANK", "0"))
+
+             dataset = None
+
+diff -ruN old-datasets/gpt_dataset.py datasets/gpt_dataset.py
+--- old-datasets/gpt_dataset.py	2025-05-02 04:08:45.369199665 +0000
++++ datasets/gpt_dataset.py	2025-05-02 04:09:30.309170278 +0000
+@@ -351,7 +351,7 @@
+
+         if not path_to_cache or (
+             not cache_hit
+-            and (not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0)
++            and (not torch.distributed.is_initialized() or int(os.getenv("LOCAL_RANK", "0")) == 0)
+         ):
+
+             log_single_rank(

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/patches/24.09/nemo2hf.patch

@@ -0,0 +1,13 @@
+diff --git a/scripts/checkpoint_converters/convert_llama_nemo_to_hf.py b/scripts/checkpoint_converters/convert_llama_nemo_to_hf.py
+index 8da15148d..005cae6c9 100644
+--- a/scripts/checkpoint_converters/convert_llama_nemo_to_hf.py
++++ b/scripts/checkpoint_converters/convert_llama_nemo_to_hf.py
+@@ -104,6 +104,8 @@ def convert(input_nemo_file, output_hf_file, precision=None, cpu_only=False) ->
+     dummy_trainer = Trainer(devices=1, accelerator='cpu', strategy=NLPDDPStrategy())
+     model_config = MegatronGPTModel.restore_from(input_nemo_file, trainer=dummy_trainer, return_config=True)
+     model_config.tensor_model_parallel_size = 1
++    model_config.virtual_pipeline_model_parallel_size = None
++    model_config.sequence_parallel = False
+     model_config.pipeline_model_parallel_size = 1
+     if cpu_only:
+         map_location = torch.device('cpu')

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/patches/24.09/sigabort.patch

@@ -0,0 +1,24 @@
+diff --git a/examples/nlp/language_modeling/tuning/megatron_gpt_finetuning.py b/examples/nlp/language_modeling/tuning/megatron_gpt_finetuning.py
+index bfe8ea359..dfeaf93b5 100644
+--- a/examples/nlp/language_modeling/tuning/megatron_gpt_finetuning.py
++++ b/examples/nlp/language_modeling/tuning/megatron_gpt_finetuning.py
+@@ -13,6 +13,8 @@
+ # limitations under the License.
+
+ import torch.multiprocessing as mp
++import torch.distributed as dist
++
+ from omegaconf.omegaconf import OmegaConf
+
+ from nemo.collections.nlp.models.language_modeling.megatron_gpt_sft_model import MegatronGPTSFTModel
+@@ -76,6 +78,10 @@ def main(cfg) -> None:
+
+     trainer.fit(model)
+
++    if dist.is_available() and dist.is_initialized():
++        dist.barrier()
++        dist.destroy_process_group()
++
+
+ if __name__ == '__main__':
+     main()

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/patches/24.09/throughput_calc.patch

@@ -0,0 +1,13 @@
+diff --git a/src/utils/training_metrics/process_training_results.py b/src/utils/training_metrics/process_training_results.py
+index 3e82a66..e61e1d8 100644
+--- a/src/utils/training_metrics/process_training_results.py
++++ b/src/utils/training_metrics/process_training_results.py
+@@ -134,7 +134,7 @@ def get_average_step_time(file: str, start_step: int, end_step: int) -> float:
+     for line in datajson:
+         if line.get("step") != "PARAMETER":
+             step = line.get("step")
+-            if step >= start_step and step <= end_step:
++            if step >= start_step and step <= end_step and "train_step_timing in s" in line["data"]:
+                 time_step_accumulator += line["data"].get("train_step_timing in s")
+                 num_steps += 1
+     if num_steps == 0:

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/requirements.txt

@@ -0,0 +1,10 @@
+dllogger@git+https://github.com/NVIDIA/dllogger@v1.0.0
+
+# Fixing these libraries versions to avoid conflicting or broken packages.
+immutabledict==4.2.1
+protobuf==5.29.6
+opencv-python-headless==4.11.0.86
+docutils==0.16
+urllib3==2.7.0
+google-cloud-storage==3.0.0
+retrying

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/uninstall.txt

@@ -0,0 +1,18 @@
+# cuml-cu12==24.8.0 was installed in nemo:24.09
+# Removing cuml=24.4.0 to avoid conflicting packages.
+cudf==24.4.0
+cugraph==24.4.0
+cugraph-service-server==24.4.0
+cuml==24.4.0
+dask-cudf==24.4.0
+raft-dask==24.4.0
+cugraph-dgl==24.4.0
+cugraph-pyg==24.4.0
+# The following packages are removed temporarily to avoid conflicting packages
+# and can be brought back if needed.
+tensorrt-llm==0.12.0
+img2dataset==1.45.0
+Sphinx==8.1.3
+sphinxcontrib-bibtex==2.6.3
+torchx==0.7.0
+nemo-run

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/docker/vertex-dist-recipes.Dockerfile

@@ -0,0 +1,66 @@
+# Dockerfile wrapping NeMo.
+#
+# To workaround base nemo docker image using too many layers, we use Multi-stage
+# build to first collect the additional files we'll need.
+FROM alpine:latest AS prep_files
+WORKDIR /workspace
+RUN mkdir -p configs vdt vdt/util
+COPY scripts/*.py vdt/
+COPY scripts/util/*.py vdt/util/
+COPY configs/* configs/
+COPY docker/patches/24.09/* vdt/patches/
+RUN chmod a+rwX -R vdt
+# Copy license.
+RUN wget https://raw.githubusercontent.com/GoogleCloudPlatform/vertex-ai-samples/main/LICENSE
+
+# Available tags
+# https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo/tags
+# It installs NeMo source code in /opt/NeMo folder, with tag=r2.0.0
+FROM nvcr.io/nvidia/nemo:24.09
+
+RUN apt-get update && apt-get install -y sudo zsh tmux && \
+    rm -rf /var/lib/apt/lists*
+
+RUN echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] http://packages.cloud.google.com/apt cloud-sdk main" | \
+    tee -a /etc/apt/sources.list.d/google-cloud-sdk.list && \
+    curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | \
+    apt-key --keyring /usr/share/keyrings/cloud.google.gpg add - && \
+    apt-get update -y && apt-get install google-cloud-sdk -y && \
+    rm -rf /var/lib/apt/lists*
+
+# Install libraries with pip
+ENV PIP_ROOT_USER_ACTION=ignore
+
+# We expect this will be run in the root directory of the vertex-dist-recipes repo
+ARG HOST_SRC_DIR="."
+
+# The pre-installed NeMo introduces a lot of deps conflicts.
+# We uninstall the confilicting libs and reinstall some of them as needed.
+COPY ${HOST_SRC_DIR}/docker/uninstall.txt /tmp/uninstall.txt
+RUN cat /tmp/uninstall.txt | grep -v '#' | xargs pip uninstall -y
+COPY ${HOST_SRC_DIR}/docker/requirements.txt /tmp/requirements.txt
+RUN pip install -r /tmp/requirements.txt
+
+# Make sure there's no inconsistent pip libraries.
+RUN pip check
+
+WORKDIR /workspace
+
+# Copy configs
+COPY ${HOST_SRC_DIR}/configs/* /opt/NeMo/examples/nlp/language_modeling/conf/
+
+# Copy all additional files we need from `prep_files` image.
+COPY --from=prep_files /workspace/ .
+
+# Install for `src/utils/training_metrics/process_training_results.py` to report
+# throughput and MFU numbers.
+RUN git clone https://github.com/AI-Hypercomputer/gpu-recipes.git
+
+# This hack is needed for multi-node training while not using a sharing file system.
+RUN patch --verbose -l -d /opt/megatron-lm/megatron/core/datasets -p1 -i /workspace/vdt/patches/local_rank.patch; \
+    git -C /workspace/gpu-recipes apply /workspace/vdt/patches/throughput_calc.patch; \
+    git -C /opt/NeMo apply /workspace/vdt/patches/nemo2hf.patch; \
+    git -C /opt/NeMo apply /workspace/vdt/patches/sigabort.patch;
+# git -C /opt/NeMo apply /workspace/vdt/patches/gpu_stats.patch;
+
+# Do not put an entrypoint here. Specify the entrypoint in the docker run script.

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/job_config.json

@@ -0,0 +1,16 @@
+{
+  "project_id": "<your_project_id>",
+  "region": "us-central1",
+  "zone": "us-central1-c",
+  "bucket": "<your_bucket",
+  "dataset_bucket": "github-repo/data/third-party/enwiki-latest-pages-articles",
+  "image_uri": "<your_image_uri>",
+  "strategy": "spot",
+  "nodes": "2",
+  "machine_type": "a3-megagpu-8g",
+  "gpu_type": "NVIDIA_H100_MEGA_80GB",
+  "gpus_per_node": "8",
+  "recipe_name": "llama3_1_8b_pretrain_a3mega",
+  "job_prefix": "vertex-ai",
+  "reservation_name": ""
+}

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/requirements.txt

@@ -0,0 +1,49 @@
+absl-py==2.2.2
+annotated-types==0.7.0
+anyio==4.9.0
+black==26.3.1
+cachetools==5.5.2
+certifi==2025.4.26
+charset-normalizer==3.4.2
+click==8.1.8
+docstring_parser==0.16
+google-api-core==2.24.2
+google-auth==2.40.1
+google-cloud-aiplatform==1.133.0
+google-cloud-bigquery==3.31.0
+google-cloud-core==2.4.3
+google-cloud-resource-manager==1.14.2
+google-cloud-storage==2.19.0
+google-crc32c==1.7.1
+google-genai==1.14.0
+google-resumable-media==2.7.2
+googleapis-common-protos==1.70.0
+grpc-google-iam-v1==0.14.2
+grpcio==1.71.0
+grpcio-status==1.71.0
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+idna==3.15
+mypy_extensions==1.1.0
+numpy==2.2.5
+packaging==25.0
+pathspec==0.12.1
+platformdirs==4.3.8
+proto-plus==1.26.1
+protobuf==5.29.6
+pyasn1==0.6.4
+pyasn1_modules==0.4.2
+pydantic==2.11.4
+pydantic_core==2.33.2
+python-dateutil==2.9.0.post0
+pytz==2025.2
+requests==2.33.0
+rsa==4.9.1
+shapely==2.1.0
+six==1.17.0
+sniffio==1.3.1
+typing-inspection==0.4.0
+typing_extensions==4.13.2
+urllib3==2.7.0
+websockets==15.0.1

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/scripts/launch.py

@@ -0,0 +1,173 @@
+"""Launch script for Vertex distributed training"""
+
+# Copy the sample_job_config.json file to job_config.json
+# to define the job parameters.
+#
+# Run like this:
+#
+#   python3 vertex_dist_train/launch.py --config_file=job_config.json
+#
+
+import datetime
+import json
+import os
+import pprint
+from collections.abc import Sequence
+from typing import Any, List
+
+from absl import app, flags
+from google.cloud import aiplatform
+from google.cloud.aiplatform_v1.types.custom_job import Scheduling
+from pytz import timezone
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string("config_file", None, "Path to JSON config file")
+flags.DEFINE_boolean(
+    "debug", False, "Debug mode: just print the command, don't run it."
+)
+
+
+def launch_job(
+    job_name: str,
+    project: str,
+    region: str,
+    gcs_bucket: str,
+    image_uri: str,
+    entrypoint_cmd: List[str],
+    trainer_args: List[Any],
+    num_nodes: int,
+    machine_type: str,
+    num_gpus_per_node: int,
+    gpu_type: str,
+    strategy: str,
+    reservation_name: str = "",
+):
+    assert strategy in ("dws", "spot", "reservation")
+    aiplatform.init(
+        project=project, location=region, staging_bucket=gcs_bucket
+    )
+
+    train_job = aiplatform.CustomContainerTrainingJob(
+        display_name=job_name,
+        container_uri=image_uri,
+        command=entrypoint_cmd,
+    )
+
+    job_args = dict(
+        args=trainer_args,
+        enable_web_access=True,
+        replica_count=num_nodes,
+        machine_type=machine_type,
+        accelerator_type=gpu_type,
+        accelerator_count=num_gpus_per_node,
+        boot_disk_size_gb=1000,
+        restart_job_on_worker_restart=True,
+        #restart_job_on_worker_restart=False,
+    )
+
+    if strategy == "spot":
+        job_args.update({"scheduling_strategy": Scheduling.Strategy.SPOT.name})
+    elif strategy == "dws":
+        job_args.update(
+            {"scheduling_strategy": Scheduling.Strategy.FLEX_START.name}
+        )
+    elif strategy == "reservation":
+        assert reservation_name != "", (
+            "If using a reservation, provide the reservation_name in the "
+            "format `projects/{project_id_or_number}/zones/{zone}/"
+            "reservations/{reservation_name}`"
+        )
+        job_args.update(
+            {
+                "reservation_affinity_type": "SPECIFIC_RESERVATION",
+                "reservation_affinity_key": "compute.googleapis.com/reservation-name",
+                "reservation_affinity_values": [reservation_name],
+            }
+        )
+
+    pprint.pprint(job_args)
+    if not FLAGS.debug:
+        train_job.submit(**job_args)
+
+
+def main(argv: Sequence[str]) -> None:
+    config_file_path = FLAGS.config_file
+    print(f"Reading job config from {config_file_path}")
+    with open(config_file_path, encoding="utf-8") as config_file:
+        config = json.load(config_file)
+
+    project_id = config["project_id"]
+    region = config["region"]
+    zone = config["zone"]
+    bucket = config["bucket"]
+    dataset_bucket = config["dataset_bucket"]
+    n_nodes = int(config["nodes"])
+    machine_type = config["machine_type"]
+    num_gpus_per_node = int(config["gpus_per_node"])
+    gpu_type = config["gpu_type"]
+    reservation_name = config.get("reservation_name")
+    reservation_full_name = (
+        f"projects/{project_id}/zones/{zone}/reservations/{reservation_name}"
+        if "reservation_name" in config
+        else ""
+    )
+
+    strategy = config["strategy"]
+    recipe_name = config["recipe_name"]
+    job_prefix = config["job_prefix"]
+    image_uri = config["image_uri"]
+
+    # Job name
+    timestamp = (
+        datetime.datetime.now()
+        .astimezone(timezone("US/Pacific"))
+        .strftime("%Y%m%d_%H%M%S")
+    )
+    job_name = f"{recipe_name}-{timestamp}"
+    if job_prefix:
+        job_name = f"{job_prefix}-{job_name}"
+
+    base_output_dir = os.path.join("/gcs", bucket, job_name)
+
+    # Training command and args
+    entrypoint_cmd = ["python3", "vdt/run.py"]
+
+    dataset_bucket = f"gs://{config['dataset_bucket']}"
+
+    trainer_args = [
+        f"--train_data_gcs={dataset_bucket}",
+        "/opt/NeMo/examples/nlp/language_modeling/megatron_gpt_pretraining.py",
+        "--config-path=conf/",
+        f"--config-name={recipe_name}.yaml",
+        f"exp_manager.explicit_log_dir={base_output_dir}",
+        f"exp_manager.dllogger_logger_kwargs.json_file={base_output_dir}/dllogger.json",
+        "+exp_manager.create_tensorboard_logger=true",
+        "exp_manager.create_checkpoint_callback=false",
+        f"trainer.num_nodes={n_nodes}",
+        f"trainer.devices={num_gpus_per_node}",
+        "trainer.max_steps=10",
+        "trainer.log_every_n_steps=1",
+        "model.tokenizer.vocab_file=/data/gpt2-vocab.json",
+        "model.tokenizer.merge_file=/data/gpt2-merges.txt",
+        "model.data.data_prefix=[1.0,/data/hfbpe_gpt_training_data_text_document]",
+    ]
+
+    launch_job(
+        job_name=job_name,
+        project=project_id,
+        region=region,
+        gcs_bucket=bucket,
+        image_uri=image_uri,
+        entrypoint_cmd=entrypoint_cmd,
+        trainer_args=trainer_args,
+        num_nodes=n_nodes,
+        machine_type=machine_type,
+        num_gpus_per_node=num_gpus_per_node,
+        gpu_type=gpu_type,
+        strategy=strategy,
+        reservation_name=reservation_full_name,
+    )
+
+
+if __name__ == "__main__":
+    app.run(main)

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/scripts/run.py

@@ -0,0 +1,85 @@
+"""Entrypoint for Vertex Distributed Training container."""
+
+import argparse
+import os
+import sys
+from collections.abc import Sequence
+from subprocess import STDOUT, check_output, run
+
+from absl import app, flags, logging
+from util import cluster_spec
+
+from retrying import retry
+
+# PyTorch barrier call which synchronizes all of the nodes before launching the training process.
+# This makes sure that processes will block until all processes are ready.
+# Improves the reliability of spot VM usage for multi-node training jobs
+
+@retry(stop_max_attempt_number=100, wait_exponential_multiplier=1000)
+def barrier_with_retry() -> None:
+    import torch
+    logging.info("Starting barrier on RANK {}".format(os.environ["RANK"]))
+    torch.distributed.init_process_group()
+    torch.distributed.barrier()
+    torch.distributed.destroy_process_group()
+    logging.info("Finished barrier on RANK {}".format(os.environ["RANK"]))
+
+def main(unused_argv: Sequence[str]) -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--train_data_gcs",
+        type=str,
+        help="Download training data from gcs path",
+    )
+    args, unknown = parser.parse_known_args()
+
+    for key, val in os.environ.items():
+        logging.info("ENV %s=%s", key, val)
+
+    if args.train_data_gcs:
+        local_dir = "/data"
+        if not os.path.exists(local_dir):
+            os.mkdir(local_dir)
+        logging.info("downloading %s to %s...", args.train_data_gcs, local_dir)
+        check_output(
+            [
+                "gcloud",
+                "storage",
+                "cp",
+                "-r",
+                f"{args.train_data_gcs}/*",
+                local_dir,
+            ],
+            stderr=STDOUT,
+        )
+        logging.info("%s downloaded.", args.train_data_gcs)
+
+    primary_node_addr, primary_node_port, node_rank, num_nodes = (
+        cluster_spec.get_cluster_spec()
+    )
+
+    cmd = [
+        "torchrun",
+        "--nproc-per-node=8",
+        f"--nnodes={num_nodes}",
+        f"--node_rank={node_rank}",
+    ]
+    if num_nodes > 1:
+        cmd += [
+            "--max-restarts=3",
+            "--rdzv-backend=static",
+            f'--rdzv_id={os.getenv("CLOUD_ML_JOB_ID", primary_node_port)}',
+            f"--rdzv-endpoint={primary_node_addr}:{primary_node_port}",
+        ]
+    cmd += unknown
+
+    logging.info("launching with cmd: \n%s", " \\\n".join(cmd))
+    barrier_with_retry()
+    run(cmd, stdout=sys.stdout, stderr=sys.stdout, check=True)
+
+
+if __name__ == "__main__":
+    logging.get_absl_handler().python_handler.stream = sys.stdout
+    app.run(
+        main, flags_parser=lambda _args: flags.FLAGS(_args, known_only=True)
+    )

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/scripts/util/cluster_spec.py

@@ -0,0 +1,81 @@
+"""Get cluster info from environment variables."""
+
+import dataclasses
+import json
+import os
+
+from absl import logging
+
+
+@dataclasses.dataclass
+class ClusterInfo:
+    """Contains information about the cluster.
+
+    Attributes:
+      primary_node_addr: The address of the primary node.
+      primary_node_port: The port of the primary node.
+      node_rank: The rank of the node.
+      num_nodes: The number of nodes in the cluster.
+    """
+
+    primary_node_addr: str | None = None
+    primary_node_port: str | None = None
+    node_rank: int = 0
+    num_nodes: int = 1
+
+    # Allows unpacking operation like
+    # primary_node_addr, primary_node_port, _, _ = ClusterInfo()
+    # See https://stackoverflow.com/a/70753113
+    def __iter__(self):
+        return iter(dataclasses.astuple(self))
+
+
+def get_cluster_spec() -> ClusterInfo:
+    """Parses CLUSTER_SPEC environment variable and returns the cluster info.
+
+    Returns:
+      A ClusterInfo object.
+    """
+    cluster_spec = os.getenv("CLUSTER_SPEC", None)
+
+    # If CLUSTER_SPEC is not set, use individual vars to construct cluster info.
+    if not cluster_spec:
+        cluster_info = ClusterInfo(
+            primary_node_addr=os.getenv("MASTER_ADDR", None),
+            primary_node_port=os.getenv("MASTER_PORT", None),
+            node_rank=int(os.getenv("RANK", "0")),
+            num_nodes=int(os.getenv("NNODES", "1")),
+        )
+        return cluster_info
+
+    cluster_data = json.loads(cluster_spec)
+    # Get primary node info
+    primary_node = cluster_data["cluster"]["workerpool0"][0]
+    logging.info("primary node: %s", primary_node)
+    primary_node_addr, primary_node_port = primary_node.split(":")
+    logging.info("primary node address: %s", primary_node_addr)
+    logging.info("primary node port: %s", primary_node_port)
+
+    # Determine node rank of this machine
+    workerpool = cluster_data["task"]["type"]
+    if workerpool == "workerpool0":
+        node_rank = 0
+    elif workerpool == "workerpool1":
+        # Add 1 for the primary node, since `index` is the index of workerpool1.
+        node_rank = cluster_data["task"]["index"] + 1
+    else:
+        raise ValueError(
+            "Only workerpool0 and workerpool1 are supported. Unknown workerpool:"
+            f" {workerpool}"
+        )
+    logging.info("node rank: %s", node_rank)
+
+    # Calculate total nodes.
+    num_nodes = 1  # For the primary node.
+    if "workerpool1" in cluster_data["cluster"]:
+        num_nodes += len(cluster_data["cluster"]["workerpool1"])
+    logging.info("num nodes: %s", num_nodes)
+
+    return ClusterInfo(
+        primary_node_addr, primary_node_port, node_rank, num_nodes
+    )

community-content/vertex-distributed-training/a3mega/llama-3-8b-nemo-pretraining/scripts/util/cluster_spec_test.py

@@ -0,0 +1,59 @@
+"""Add tests for cluster_spec.py."""
+
+import os
+
+from . import cluster_spec
+
+
+# TODO(styer): Use pytest instead
+class ClusterSpecTest(googletest.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.curr_env_var = os.environ.copy()
+
+    def tearDown(self):
+        super().tearDown()
+        os.environ = self.curr_env_var
+
+    def test_get_cluster_spec_from_env_vars(self):
+        os.environ["CLUSTER_SPEC"] = ""
+        os.environ["MASTER_ADDR"] = "127.0.0.1"
+        os.environ["MASTER_PORT"] = "8080"
+        os.environ["RANK"] = "0"
+        os.environ["NNODES"] = "2"
+        cluster_info = cluster_spec.get_cluster_spec()
+        self.assertEqual(cluster_info.primary_node_addr, "127.0.0.1")
+        self.assertEqual(cluster_info.primary_node_port, "8080")
+        self.assertEqual(cluster_info.node_rank, 0)
+        self.assertEqual(cluster_info.num_nodes, 2)
+
+    def test_get_cluster_spec_from_cluster_spec(self):
+        os.environ[
+            "CLUSTER_SPEC"
+        ] = """
+    {
+      "cluster": {
+        "workerpool0": [
+          "127.0.0.1:8080"
+        ],
+        "workerpool1": [
+          "127.0.0.2:8080",
+          "127.0.0.3:8080"
+        ]
+      },
+      "task": {
+        "type": "workerpool1",
+        "index": 0
+      }
+    }
+    """
+        cluster_info = cluster_spec.get_cluster_spec()
+        self.assertEqual(cluster_info.primary_node_addr, "127.0.0.1")
+        self.assertEqual(cluster_info.primary_node_port, "8080")
+        self.assertEqual(cluster_info.node_rank, 1)
+        self.assertEqual(cluster_info.num_nodes, 3)
+
+
+if __name__ == "__main__":
+    googletest.main()

community-content/vertex_model_garden/model_oss/cloudnerf/local_colmap_and_resize.sh

@@ -66,7 +66,7 @@ mkdir -p "$local_folder"
 mkdir -p "$output_folder"
 
 # Download the content from the GCS URI
-gsutil -m cp -r "$gcs_dataset_path"/* "$local_folder/"
+gcloud storage cp --recursive "$gcs_dataset_path"/* "$local_folder/"
 
 # Process files in the local folder
 for file in "$local_folder"/*; do
@@ -122,23 +122,23 @@ cp -r "$output_folder" "$images_folder"/images_2
 pushd "$images_folder"/images_2
 ls | xargs -P 8 -I {} mogrify -resize 50% {}
 popd
-gsutil -m cp -r "$images_folder"/images_2/*  "$gcs_experiment_path"/data/images_2
+gcloud storage cp --recursive "$images_folder"/images_2/*  "$gcs_experiment_path"/data/images_2
 
 cp -r "$output_folder" "$images_folder"/images_4
 pushd "$images_folder"/images_4
 ls | xargs -P 8 -I {} mogrify -resize 25% {}
 popd
-gsutil -m cp -r "$images_folder"/images_4/*  "$gcs_experiment_path"/data/images_4
+gcloud storage cp --recursive "$images_folder"/images_4/*  "$gcs_experiment_path"/data/images_4
 
 cp -r "$output_folder" "$images_folder"/images_8
 pushd "$images_folder"/images_8
 ls | xargs -P 8 -I {} mogrify -resize 12.5% {}
 popd
-gsutil -m cp "$images_folder"/images_8/*  "$gcs_experiment_path"/data/images_8
+gcloud storage cp "$images_folder"/images_8/*  "$gcs_experiment_path"/data/images_8
 
 # Copy images and sparse reconstruction files to gcs experiment folder.
-gsutil -m cp "$images_folder"/images/*  "$gcs_experiment_path"/data/images
-gsutil -m cp -r "$local_folder"/sparse  "$gcs_experiment_path"/data
-gsutil -m cp "$local_folder"/database.db  "$gcs_experiment_path"/data
+gcloud storage cp "$images_folder"/images/*  "$gcs_experiment_path"/data/images
+gcloud storage cp --recursive "$local_folder"/sparse  "$gcs_experiment_path"/data
+gcloud storage cp "$local_folder"/database.db  "$gcs_experiment_path"/data
 
 echo "Processing complete."

community-content/vertex_model_garden/model_oss/cloudnerf/render.sh

@@ -99,14 +99,14 @@ create_dir_if_not_exists "$CHECKPOINTS_PATH"
 touch "$local_experiment_path/$exp_folder_name/log_render.txt"
 
 # Copy experiment from GCS bucket to local
-gsutil -m cp -r "${args[-gcs_experiment_path]}/data" "$local_experiment_path/$exp_folder_name" || exit 1
-gsutil -m cp -r "${args[-gcs_experiment_path]}/checkpoints/${training_job_name}/*" "$CHECKPOINTS_PATH" || exit 1
+gcloud storage cp --recursive "${args[-gcs_experiment_path]}/data" "$local_experiment_path/$exp_folder_name" || exit 1
+gcloud storage cp --recursive "${args[-gcs_experiment_path]}/checkpoints/${training_job_name}/*" "$CHECKPOINTS_PATH" || exit 1
 
 # Check and copy keyframes file.
 if [[ -n ${args[-gcs_keyframes_file]} ]]; then
   keyframes_file_basename=$(basename "${args[-gcs_keyframes_file]}")
   local_keyframes_file="$local_dataset_path/$keyframes_file_basename"
-  gsutil cp "${args[-gcs_keyframes_file]}" "$local_keyframes_file" || exit 1
+  gcloud storage cp "${args[-gcs_keyframes_file]}" "$local_keyframes_file" || exit 1
   echo "Local keyframe file: $local_keyframes_file"
   launch_rendering "$local_keyframes_file"
 else
@@ -114,4 +114,4 @@ else
 fi
 
 # Copy rendered data back to GCS.
-gsutil -m cp -r "$OUTPUT_RENDER_PATH" "${args[-gcs_experiment_path]}/render/${rendering_job_name}"
+gcloud storage cp --recursive "$OUTPUT_RENDER_PATH" "${args[-gcs_experiment_path]}/render/${rendering_job_name}"

community-content/vertex_model_garden/model_oss/cloudnerf/train.sh

@@ -74,7 +74,7 @@ create_dir_if_not_exists "$local_experiment_path"
 create_dir_if_not_exists "$local_experiment_path/$scene_folder_name"
 
 # Copy experiment from GCS bucket to local.
-gsutil -m cp -r "${gcs_experiment_path}/data" "$local_experiment_path/$scene_folder_name" || exit 1
+gcloud storage cp --recursive "${gcs_experiment_path}/data" "$local_experiment_path/$scene_folder_name" || exit 1
 
 echo "GCS Experiment: $gcs_experiment_path"
 echo "Gin Config File: $gin_config_file"
@@ -89,6 +89,6 @@ accelerate launch train.py --gin_configs="$gin_config_file" \
   --gin_bindings="Config.factor = ${factor}" \
   --gin_bindings="Config.max_steps = ${max_training_steps}"
 
-gsutil -m rm -r "${gcs_experiment_path}/checkpoints/${training_job_name}"
-gsutil -m cp -r "$local_experiment_path/$scene_folder_name/config.gin" "${gcs_experiment_path}/${training_job_name}_config.gin"
-gsutil -m cp -r "$local_experiment_path/$scene_folder_name/checkpoints/*/*" "${gcs_experiment_path}/checkpoints/${training_job_name}"
+gcloud storage rm --recursive "${gcs_experiment_path}/checkpoints/${training_job_name}"
+gcloud storage cp --recursive "$local_experiment_path/$scene_folder_name/config.gin" "${gcs_experiment_path}/${training_job_name}_config.gin"
+gcloud storage cp --recursive "$local_experiment_path/$scene_folder_name/checkpoints/*/*" "${gcs_experiment_path}/checkpoints/${training_job_name}"

community-content/vertex_model_garden/model_oss/notebook_util/dataset_validation_util.py

@@ -102,10 +102,10 @@ def download_gcs_uri_to_local(
     if not os.path.exists(destination_dir):
       os.mkdir(destination_dir)
     subprocess.check_output([
-        "gsutil",
-        "-m",
+        "gcloud",
+        "storage",
         "cp",
-        "-r",
+        "--recursive",
         gcs_uri,
         destination_dir,
     ])

community-content/vertex_model_garden/model_oss/peft/train/vmg/dockerfile/requirements.txt

@@ -12,7 +12,7 @@ bitsandbytes==0.43.2
 cloudml-hypertune==0.1.0.dev6
 datasets==2.20.0
 deepspeed==0.15.2
-diffusers==0.25.1
+diffusers==0.38.0
 evaluate==0.4.3
 fsspec==2024.3.1
 gcsfs==2024.3.1

docs/README.md

@@ -0,0 +1,11 @@
+# Agent Platform Training Clusters Blog Series 
+
+This directory contains deep-dive documentation, extended guides, and architectural references for Google Cloud Agent Platform Training Clusters.
+
+## Contents
+- **`vertex-training-cluster/`**: Documentation and setup guides for configuring and managing Agent Platform Training Clusters.
+
+## Blog Posts
+- [Model Distillation Best Practices](https://googlecloudplatform.github.io/vertex-ai-samples/vertex-training-cluster/model_distillation_best_practices): Explores off-policy model distillation, dataset curation, and hyperparameter scaling laws for training student models on Vertex AI.
+- [Forgetting Mitigation via Data Mixing](https://googlecloudplatform.github.io/vertex-ai-samples/vertex-training-cluster/forgetting_mitigation_data_mixing): Discusses catastrophic forgetting in model fine-tuning and how to mitigate it using multi-domain data mixing on Vertex AI.
+- [Multi-Turn Reinforcement Learning for τ²-bench](https://googlecloudplatform.github.io/vertex-ai-samples/vertex-training-cluster/multi_turn_reinforcement_learning_for_tau2_bench): Explores multi-turn RL training for tool-calling agents using GRPO on the τ²-bench customer service benchmark with NeMo RL.

docs/vertex-training-cluster/forgetting_mitigation_data_mixing.md

@@ -0,0 +1,448 @@
+<script type="text/javascript" async
+  src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
+</script><br><br>
+
+# VTC Multi-Domain Dataset: Mitigating Catastrophic Forgetting with Data Mixing
+
+**Author:** [Mayank Sharan](mailto:mayanksharan@google.com)
+
+## Table of Contents
+
+* [Intro](#intro)
+* [Background](#background)
+* [Dataset Curation](#dataset-selection)
+* [Forgetting Mitigation Best Practices](#forgetting-mitigation-best-practices)
+    * [Experimental Setup](#experimental-setup)
+    * [Mitigating Forgetting](#mitigating-forgetting)
+    * [Mixing Ratios](#mixing-ratios)
+    * [Different Starting Models](#different-starting-models)
+* [Acknowledgements](#acknowledgements)
+* [References](#references)
+
+## Intro
+
+In this entry of our blog series on model training best practices for Vertex AI Training Cluster (VTC) customers, we talk about catastrophic forgetting and how to mitigate it. We focus on tuning public models using supervised fine tuning (SFT) with a specialized domain dataset. With both open and closed source models performing well on general tasks the primary goal of training one's own models is to improve the performance on specialized tasks. This typically comes at the cost of the model forgetting general capabilities which can severely limit the utility of the trained model.
+
+There are many possible interventions to limit forgetting, the most effective is mixing the target dataset with the actual dataset used in the model’s training. Since this is not available even for the most open source models, we have curated a multi-domain dataset that delivers the same benefits. This allows Vertex AI Training Cluster (VTC) customers to maintain and surpass frontier level model capabilities while training to further performance on specialized tasks.
+
+<figure align="center" id="fig-teaser">
+<table align="center" width="80%">
+  <tr>
+    <td align="center" width="100%">
+      <img src="images_data_mixing/teaser_forgetting.png" width="100%"><br>
+    </td>
+  </tr>
+</table>
+<figcaption align="left">
+<sub><b>Figure 1: Impact of mixing VTC Post Training dataset on Forgetting (8B model). </b> <i>Comparing SFT runs using only a specialized target dataset (MedMCQA) vs a mix of the target dataset and the VTC Post training dataset. Forgetting across all non-target domains is significantly mitigated with no performance loss on the target metric. Qwen3 Public here is the instruction tuned public Qwen3 8B model and the other two models are trained starting from the base Qwen3 8B model using only the target dataset and a mix of target dataset with the VTC dataset.</i></sub>
+</figcaption>
+</figure>
+
+We provide a thorough set of experiments to serve as a guide for reducing forgetting while post training the Qwen3 open-weight thinking model family, beginning from their base pre-trained checkpoints. Furthermore, we demonstrate the value our datasets provide across model sizes often surpassing the performance of the official Qwen3 models while preserving performance on the specialized task (See [Figure 1](#fig-teaser)). The Qwen3 family was specifically chosen for this study because its diverse range of parameter counts and the availability of both pre-trained and post-trained checkpoints provide an ideal environment for high-fidelity scaling analysis.
+
+To ensure our findings can be applied to a broad set of applications we validate our findings across five model sizes: 0.6B, 1.7B, 4B, 8B and 14B parameters. To support our VTC community in accelerating their own development, all code, datasets, and experiment configurations used in this blog are being made available for use in your training workloads.
+
+## Background
+
+Loss landscapes for neural networks have always been a complex multidimensional manifold rather than the simple convex ones that gradient descent is built for. Forgetting is a well known phenomenon in model customization, the first academically recorded instance being (McCloskey and Cohen, 1989) [<a href="#ref1">1</a>]. These manifolds have become even more complex with the introduction of Large Language Models where the number of parameters being optimized are typically in the billions. This makes it hard to mathematically grasp issues like forgetting. [Figure 2](#fig-loss-landscape) demonstrates a geometric understanding of why forgetting happens and how data mixing can mitigate it.
+
+<figure align="center" id="fig-loss-landscape">
+<table align="center" width="80%">
+  <tr>
+    <td align="center" width="100%">
+      <img src="images_data_mixing/background_loss_landscape.png" width="100%"><br>
+    </td>
+  </tr>
+</table>
+<figcaption align="left">
+<sub><b>Figure 2: Geometric Interpretation of Data Mixing to Mitigate Forgetting. </b> <i>Fine tuning objectives being meaningfully out of distribution from the pre-trained model often drives forgetting. Mixing in a dataset similar to the model distribution adjusts the objective enough to learn the new task without as much forgetting.</i></sub>
+</figcaption>
+</figure>
+
+## Dataset Selection
+
+Our primary requirements for a target dataset to run experiments to validate this were:
+
+1. It should be out of distribution to cause forgetting
+2. It should have an evaluation metric that it directly improves
+3. It should be able to train the model to perform better than the counterpart generalist model
+
+A good heuristic to determine where the data lies with respect to the model distribution is by calculating perplexity on samples from the dataset. Assuming
+- <span>$$X={x_1, x_2, \dots, x_N}$$</span> is a dataset sample represented as sequence of tokens
+- <span>$$P(x_i \mid x_{<i})$$</span> is the model likelihood of the i-th token given the sample till that token
+
+Then the perplexity for this sample can be calculated as follows:
+
+$$\begin{align*}  
+& ppl(X) = \exp \left( -\frac{1}{N} \sum_{i=1}^{N} \log P(x_i \mid x_{<i}) \right) \\
+& = \exp \left( -\frac{1}{N} \log (\prod_{i=1}^{N} P(x_i \mid x_{<i})) \right)
+\end{align*}  $$
+
+The product form of the equation shows that this is a direct measure of the joint probability of this sequence of tokens according to the model. Since this computation has a balancing negative sign to account for the negative log value a lower joint probability results in a higher perplexity value and vice versa. We evaluated the following datasets as out-of-distribution candidates:
+
+- [MedMCQA](https://huggingface.co/datasets/syz-ml2025/medmcqa) : Multiple Choice Questions (MCQ) dataset focusing on the medical domain
+- [BirdSQL](https://huggingface.co/datasets/birdsql/bird23-train-filtered) : Text to SQL generation dataset
+- [HardGen](https://huggingface.co/datasets/Bingguang/HardGen) : Function calling dataset
+
+We also calculate perplexity on [OpenR1-Math-220k](https://huggingface.co/datasets/open-r1/OpenR1-Math-220k) to provide a reference as we expect this to be in distribution for the model given the Qwen3 models are particularly strong in the math domain.
+
+<table id="tab-perplexity" style="margin-left:auto; margin-right:auto;">
+  <thead>
+    <tr>
+      <th>Dataset \ Model</th>
+      <th>Qwen3-0.6B</th>
+      <th>Qwen3-8B</th>
+      <th>Ours-0.6B</th>
+      <th>Ours-8B</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>MedMCQA</td>
+      <td>63.00</td>
+      <td>66.00</td>
+      <td>42.00</td>
+      <td>20.75</td>
+    </tr>
+    <tr>
+      <td>BirdSQL</td>
+      <td>38.50</td>
+      <td>55.50</td>
+      <td>45.50</td>
+      <td>17.00</td>
+    </tr>
+    <tr>
+      <td>HardGen</td>
+      <td>2.23</td>
+      <td>2.03</td>
+      <td>2.28</td>
+      <td>1.79</td>
+    </tr>
+    <tr>
+      <td>OpenR1-Math</td>
+      <td>8.63</td>
+      <td>9.75</td>
+      <td>6.44</td>
+      <td>5.34</td>
+    </tr>
+  </tbody>
+  <caption style="text-align: left;"><b>Table 1:</b> Perplexity score analysis with the public instruction tuned Qwen3 models and Qwen3 base models trained using the VTC dataset (Ours) to identify a suitable target dataset.</caption>
+</table>
+
+We see from [Table 1](#tab-perplexity) that OpenR1-Math-220k as we expected has low perplexity scores and HardGen shows an even lower perplexity score eliminating it from consideration. MedMCQA samples have high perplexity scores across all considered models. This dataset also has the advantage of a straightforward evaluation metric as we can use the validation split in the form of an MCQ verified evaluation.
+
+Based on this analysis we choose MedMCQA as our target dataset for these experiments. Additionally, since we are training a thinking model and the dataset does not have thinking traces we use the Qwen3-235B model to inject thinking traces into the training samples.
+
+## Forgetting Mitigation Best Practices
+
+### Experimental Setup
+
+#### Dataset Mixing
+
+We tested the impact of how forgetting responds to mixing the base dataset in different ratios with the target dataset. The base dataset here refers to the multi domain SFT dataset we have developed (see our [distillation blog post](https://googlecloudplatform.github.io/vertex-ai-samples/vertex-training-cluster/model_distillation_best_practices) [<a href="#ref2">2</a>] for details of the generation process) that can replicate and on certain metrics beat the public Qwen3 models. The target dataset here refers to the MedMCQA dataset. It is important to understand that in all mixing scenarios where the target dataset is present we will use the complete target dataset as that is the reasonable course of action we expect any customer to take. This leads to the total number of samples used in training varying based on the mixing ratio.
+
+We run 2 baseline experiments for each model size: using only the base dataset and only the target dataset. The mixing experiments are the base dataset being mixed in ratios of 0.9:0.1, 0.75:0.25 and 0.5:0.5. (0.9:0.1 means 90% of samples are from the base in-distribution dataset, while 10% are from the target out-of-distribution dataset.)
+
+The base dataset is randomly subsampled for each of these experiments. For simpler reference and analysis let’s define a mixing ratio <span>$$0 \le \alpha < 1$$</span>, such that the final dataset mixture includes <span>$$ N'_{B} = \frac{\alpha}{1 - \alpha} N_T$$</span> samples from the base dataset where <span>$$N_T$$</span> is the number of samples in the target dataset. In each of these mixtures the complete target dataset is used, contributing <span>$$N_T$$</span> samples for a total training dataset size of <span>$$\frac{N_T}{1 - \alpha}$$</span>.
+
+Since, our target dataset has 182,712 samples, this means that:
+
+- 0.9:0.1 ratio (<span>$$\alpha = 0.9$$</span>) : Uses a total of 1,827,120 training samples
+- 0.75:0.25 ratio (<span>$$\alpha = 0.75$$</span>) : Uses a total of 730,849 training samples
+- 0.5:0.5 ratio (<span>$$\alpha = 0.5$$</span>) : Uses a total of 365,425 training samples
+
+#### Evaluation
+
+<table id="tab-eval-setup" style="margin-left:auto; margin-right:auto;">
+  <thead>
+    <tr>
+      <th>Capabilities</th>
+      <th>Benchmarks</th>
+      <th># Test Samples</th>
+      <th>Eval Metrics</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td rowspan="7">Math</td>
+      <td>AIME 24</td>
+      <td>30</td>
+      <td>pass@1 (average of 10)</td>
+    </tr>
+    <tr>
+      <td>AIME 25</td>
+      <td>30</td>
+      <td>pass@1 (average of 10)</td>
+    </tr>
+    <tr>
+      <td>BeyondAIME</td>
+      <td>100</td>
+      <td>pass@1 (average of 5)</td>
+    </tr>
+    <tr>
+      <td>Math 500</td>
+      <td>500</td>
+      <td>pass@1</td>
+    </tr>
+    <tr>
+      <td>HMMT 25</td>
+      <td>30</td>
+      <td>pass@1 (average of 10)</td>
+    </tr>
+    <tr>
+      <td>BRUMO 25</td>
+      <td>30</td>
+      <td>pass@1 (average of 10)</td>
+    </tr>
+    <tr>
+      <td>CMIMC 25</td>
+      <td>40</td>
+      <td>pass@1 (average of 10)</td>
+    </tr>
+    <tr>
+      <td rowspan="3">Science</td>
+      <td>GPQA</td>
+      <td>448</td>
+      <td>pass@1 (average of 5)</td>
+    </tr>
+    <tr>
+      <td>MMLU</td>
+      <td>14042</td>
+      <td>pass@1</td>
+    </tr>
+    <tr>
+      <td>MMLU Pro</td>
+      <td>12032</td>
+      <td>pass@1</td>
+    </tr>
+    <tr>
+      <td rowspan="2">Coding</td>
+      <td>HumanEval</td>
+      <td>164</td>
+      <td>pass@1 (average of 5)</td>
+    </tr>
+    <tr>
+      <td>LiveCodeBench v6</td>
+      <td>175</td>
+      <td>pass@1 (average of 5)</td>
+    </tr>
+    <tr>
+      <td>Instruction Following</td>
+      <td>IFEval</td>
+      <td>541</td>
+      <td>pass@1 (Strict Accuracy)</td>
+    </tr>
+    <tr>
+      <td>Reasoning</td>
+      <td>ARC-AGI 1</td>
+      <td>400</td>
+      <td>pass@1 (average of 5)</td>
+    </tr>
+    <tr>
+      <td>Medical (Target domain)</td>
+      <td>MedMCQA</td>
+      <td>4183</td>
+      <td>pass@1</td>
+    </tr>
+  </tbody>
+  <caption style="text-align: left;"><b>Table 2:</b> Comprehensive overview of task domains, evaluation benchmarks, and associated performance metrics.</caption>
+</table>
+
+Our evaluation benchmarks and metrics are detailed in [Table 2](#tab-eval-setup). To ensure statistical reliability on smaller datasets, we report metrics averaged over multiple independent runs to mitigate variance. For each domain with multiple evaluations, we utilize the average score across the core benchmarks as our primary performance indicator. To maintain a consistent comparison, both our trained models and the official Qwen3 thinking models were evaluated using standardized sampling parameters — `Temperature=0.6`, `Top-P=0.95`, `Top-K=20` and `Max-tokens=32768` — aligning with the recommended [best practices](https://huggingface.co/Qwen/Qwen3-14B#best-practices) from the official Qwen3 model card.
+
+Note that we have separated MedMCQA as a target metric instead of including it in the Science domain. This is to ensure clear outcomes from our experiments and to demonstrate impacts on model performance without any interference.
+
+#### Training
+
+##### Vertex AI Training Cluster
+
+All experiments and results presented were orchestrated using the [Vertex AI Training Cluster (VTC)](https://docs.cloud.google.com/vertex-ai/docs/training/training-clusters/overview). VTC is a managed Google Cloud service designed to simplify and accelerate large-scale AI workloads. It provides a simple managed user experience that enables optimized GPU scheduling, automated fault tolerance, high hardware resiliency, quick start recipes and science tooling which drastically reduces the time from cluster setup to production training and speeds up experimentation.
+
+##### Training Framework and Hyperparameters
+
+We utilize NVIDIA [NeMo RL](https://github.com/NVIDIA-NeMo/RL), an open library from the [NVIDIA NeMo framework](https://github.com/NVIDIA-NeMo/) as the primary training library, leveraging the Megatron backend for distributed scaling. Models are initialized from a Qwen3 Base checkpoint and fine-tuned with a 32,768 context window on curated datasets. Optimization is handled via AdamW (<span>$$\beta_1=0.9$$</span>, <span>$$\beta_2=0.95$$</span>, weight decay=0.1) using a linear warmup and cosine decay schedule. All training is conducted using BF16 mixed precision. There are many model sizes and dataset mixes used in the experimentation so the maximum learning rate is guided by learning rate scaling laws (see [distillation blog post](https://googlecloudplatform.github.io/vertex-ai-samples/vertex-training-cluster/model_distillation_best_practices#hyperparameter-scaling) [<a href="#ref2">2</a>] for more) available as a part of VTC. The value is validated by testing slight adjustments from the recommended value for each dataset mixture.
+
+### Mitigating Forgetting
+
+All models in this experiment are trained starting from the Qwen3 base checkpoint. We explore the impact of dataset mixing by comparing the public Qwen3 instruction tuned model performance with our two baselines — model trained with only the target dataset and model trained only with the base dataset — and with a model trained using a 0.9 ratio mix.
+
+<figure align="center" id="fig3_data_mixing">
+
+<table align="center" width="100%">
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig3_math.png" width="100%"><br>
+      <sub><b>(a)</b> Math</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig3_science.png" width="100%"><br>
+      <sub><b>(b)</b> Science</sub>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig3_coding.png" width="100%"><br>
+      <sub><b>(c)</b> Coding</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig3_ifeval.png" width="100%"><br>
+      <sub><b>(d)</b> IFEval</sub>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig3_arc_agi.png" width="100%"><br>
+      <sub><b>(e)</b> ARC-AGI</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig3_medmcqa.png" width="100%"><br>
+      <sub><b>(f)</b> MedMCQA</sub>
+    </td>
+  </tr>
+</table>
+<figcaption align="left">
+<sub><b>Figure 3: Performance with and without Data Mixing.</b> <i>A comparison across (a) Math, (b) Science, (c) Coding, (d) IFEval, (e) ARC-AGI and (f) MedMCQA benchmarks showing how data mixing impacts forgetting and performance on the target metric.</i></sub>
+</figcaption>
+
+</figure>
+
+[Figure 3](#fig3_data_mixing) shows that for all non-target metrics other than Science using just the target dataset shows significant forgetting. Math and ARC-AGI are almost completely forgotten for all model sizes up to 8B parameters. The mixed dataset recovers the performance to similar levels as the base dataset. The base dataset delivers performance comparable to the public model in all domains and significantly better on ARC-AGI.
+
+The Science domain evaluations do not suffer severe forgetting likely because MedMCQA is very close to this domain. In fact, for the 8B and 14B sizes due to these transfer learning dynamics the <span>$$\alpha = 0.9$$</span> model outperforms both the public instruction-tuned and the base dataset (<span>$$\alpha = 1$$</span>) models.
+
+Performance on the target metric of MedMCQA follows expected behavior with best results achieved by the model when trained only with the target dataset. It is important to note that the <span>$$\alpha = 0.9$$</span> model for all sizes is still significantly better than the public instruction-tuned and base dataset (<span>$$\alpha = 1$$</span>) model and for all sizes other than the 0.6B mostly maintains the performance gains of the target dataset (<span>$$\alpha = 0$$</span>) model.
+
+#### Key Observations
+
+Combining these conclusions we can see that mixing with our base dataset:
+
+- Matches and outperforms the public instruction tuned model on general tasks.
+- Preserves the gains beyond the public model on target tasks.
+- Provides additional gains on tasks from a similar domain.
+
+### Mixing Ratios
+
+Now that we know that mixing the base dataset almost eliminates forgetting it is important to understand how performance changes for different mixing configurations. This is also important to examine as it determines training length and hence the cost. We will compare models trained only with the target dataset to models trained using dataset mixes with <span>$$\alpha = 0.5, 0.75, 0.9$$</span>. The ratio mentioned here refers to the proportion of the dataset from the base dataset.
+
+<figure align="center" id="fig4_mixing_ratios">
+
+<table align="center" width="100%">
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig4_math.png" width="100%"><br>
+      <sub><b>(a)</b> Math</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig4_science.png" width="100%"><br>
+      <sub><b>(b)</b> Science</sub>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig4_coding.png" width="100%"><br>
+      <sub><b>(c)</b> Coding</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig4_ifeval.png" width="100%"><br>
+      <sub><b>(d)</b> IFEval</sub>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig4_arc_agi.png" width="100%"><br>
+      <sub><b>(e)</b> ARC-AGI</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig4_medmcqa.png" width="100%"><br>
+      <sub><b>(f)</b> MedMCQA</sub>
+    </td>
+  </tr>
+</table>
+<figcaption align="left">
+<sub><b>Figure 4: Performance across Mixing Ratios.</b> <i>A comparison across (a) Math, (b) Science, (c) Coding, (d) IFEval, (e) ARC-AGI and (f) MedMCQA benchmarks showing how dataset mixing ratios impact forgetting and performance on the target metric.</i></sub>
+</figcaption>
+
+</figure>
+
+[Figure 4](#fig4_mixing_ratios) shows that for all non-target metrics mixing helps achieve better performance than just using the target dataset even with a <span>$$\alpha = 0.5$$</span> mix. As expected the performance on non target metrics worsens as we lower the ratio of the base dataset. This effect is more pronounced in the smaller size models and for datasets like ARC-AGI where the mixed training provides a lot more gain. These patterns confirm that the gains on non target metrics are directly correlated to the base dataset.
+
+The effect while present for Science domain metrics is much less pronounced due to the cross domain characteristics. Even with lower ratios the performance for models 4B and larger holds, confirming that our target dataset of MedMCQA here contributes to limiting forgetting for this domain.
+
+The performance on the target metric, MedMCQA, stays mostly consistent with dips mostly when going from <span>$$\alpha = 0.75$$</span> mix to <span>$$\alpha = 0.5$$</span> mix. This aligns well as in all cases we are doing a complete epoch on the target dataset. The performance mostly holding at mixing ratios indicates that the tradeoff on the target metrics is relatively low even at an aggressive mixing ratio like 0.5.
+
+#### Key Observations
+
+The mixing ratio comparison shows us that:
+
+- A mixing ratio of 0.9 is the best for achieving gains on target tasks and limiting forgetting.
+- A mixing ratio of even 0.5 limits forgetting well while only doubling the token budget compared to training without any mixing.
+
+### Different Starting Models
+
+We have trained all our models starting from Qwen3 base checkpoints. A natural question here might be: What happens if we train starting from the instruction tuned public Qwen3 checkpoints for our target task? In this section we examine this question and compare the instruction-tuned model tuned with the target dataset and an <span>$$\alpha = 0.9$$</span> mix to the instruction-tuned model itself and the base model tuned with an <span>$$\alpha = 0.9$$</span> mix.
+
+<figure align="center" id="fig5_starting_models">
+
+<table align="center" width="100%">
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig5_math.png" width="100%"><br>
+      <sub><b>(a)</b> Math</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig5_science.png" width="100%"><br>
+      <sub><b>(b)</b> Science</sub>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig5_coding.png" width="100%"><br>
+      <sub><b>(c)</b> Coding</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig5_ifeval.png" width="100%"><br>
+      <sub><b>(d)</b> IFEval</sub>
+    </td>
+  </tr>
+  <tr>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig5_arc_agi.png" width="100%"><br>
+      <sub><b>(e)</b> ARC-AGI</sub>
+    </td>
+    <td align="center" width="50%">
+      <img src="images_data_mixing/fig5_medmcqa.png" width="100%"><br>
+      <sub><b>(f)</b> MedMCQA</sub>
+    </td>
+  </tr>
+</table>
+<figcaption align="left">
+<sub><b>Figure 5: Performance across Starting Models.</b> <i>A comparison across (a) Math, (b) Science, (c) Coding, (d) IFEval, (e) ARC-AGI and (f) MedMCQA benchmarks showing how different starting models impact forgetting and performance on the target metric. Qwen 3 Public is the public instruction tuned Qwen3 model, &alpha;=0 (IT) and &alpha;=0.9 (IT) are the public instruction-tuned Qwen3 model trained only with the target dataset and the &alpha;=0.9 mixed dataset. &alpha;=0.9 (Base) is the base Qwen3 model trained on a 90% VTC dataset and 10% target dataset mix.</i></sub>
+</figcaption>
+
+</figure>
+
+In [Figure 5](#fig5_starting_models), among the non-target metrics other than science we see a common trend that starting with the IT model and using only the target dataset (<span>$$\alpha = 0$$</span>) shows severe forgetting. The base model and the instruction-tuned model trained using the <span>$$\alpha = 0.9$$</span> mix match or surpass the performance of the public model. This shows that starting with an instruction-tuned model while better than starting with the base model is still not a solution to forgetting. This also shows the high quality of our dataset that it can provide further gains on the public instruction-tuned model.
+
+Science domain metrics show different trends based on the model size. The advantage of data mixing is much more apparent in 0.6B and 1.7B models. Overall though there are no disadvantages to mixing across all model sizes. The IT model demonstrating significant forgetting is a clear indication that cross domain characteristics of our target dataset are not enough to mitigate forgetting on its own.
+
+The performance of the target metric, MedMCQA, shows no additional gain when we train using only the target dataset except for the 0.6B model, whether the starting model is a base model or the IT model. For all model sizes other than the 0.6B model we also see that the <span>$$\alpha = 0.9$$</span> mix trained model does not lose any meaningful performance compared to the target dataset only trained models. All the models trained using the target dataset clearly improve on the public model.
+
+#### Key Observations
+
+The comparison of different starting models shows us:
+
+- Using the instruction-tuned model as the starting model is better than the Base model.
+- The IT model also shows catastrophic forgetting and loses performance on non target metrics.
+- The <span>$$\alpha = 0.9$$</span> mix avoids forgetting even with the instruction-tuned starting model showing its robustness.
+
+## Acknowledgements
+
+We would like to express our sincere gratitude to the NVIDIA NeMo RL team–specifically Terry Kong– for their invaluable support throughout this project.
+
+We would also like to express our gratitude to our VTC teammates: Mohammadreza Mohseni, Weiran Zhao, Fei Xia, Youbao Tang, Xuehan Xiong, Joseph Pagadora, Jiuqiang Tang, Bo Wu, Lav Rai, and Minwoo Park for developing the underlying datasets, providing infrastructure support, feedback, and insightful discussions throughout the project. We also thank Ting Yu, Shengyang Dai, Peng Xu, and Saurabh Tiwary for their leadership and support.
+
+## References
+
+<a id="ref1"></a>[1] McCloskey, Michael, and Neal J. Cohen. "Catastrophic interference in connectionist networks: The sequential learning problem." Psychology of learning and motivation. Vol. 24. Academic Press, 1989. 109-165.
+
+<a id="ref2"></a>[2] Google Cloud. "Model Distillation Best Practices." Vertex AI Training Cluster Samples. Google, 2026. https://googlecloudplatform.github.io/vertex-ai-samples/vertex-training-cluster/model_distillation_best_practices.