Study guide
1.4 AutoML on Agent Platform: Tabular, Image, Text and Video Training
Google Cloud Professional Machine Learning Engineer Exam
Track your progress as you read
Finished sections get a check mark.
1 Introduction & Exam Overview
0.1 Exam Overview, Blueprint & Certification Logistics 0.2 Study Strategy, Scenario Mechanics & 8-Week Roadmap
2 Section 1: Architecting Low-Code AI Solutions (~13%)
1.1 BigQuery ML: Model Types, SQL Syntax and In-Database Evaluation 1.2 Feature Engineering and Feature Selection in BigQuery ML 1.3 Generating Predictions with BigQuery ML 1.4 AutoML on Agent Platform: Tabular, Image, Text and Video Training 1.5 Fine-Tuning Gemini Models from BigQuery 1.6 Model Garden: Evaluating and Selecting the Right Model 1.7 Industry-Specific AI APIs: Document AI, Vision, Translate and Speech 1.8 Generative Media and Models as a Service: Gemini, Imagen and Veo 1.9 Optimizing Gemini Applications for Cost, Latency and Availability
3 Section 2: Collaborating Within and Across Teams to Manage Data and Models (~16%)
2.1 Organizing and Exploring Tabular, Text, Image and Video Data 2.2 Choosing the Preprocessing Tool: BigQuery, Dataflow, Spark and In-Memory Python 2.3 Creating and Consolidating Features in Agent Platform Feature Store 2.4 Data Privacy, PII Handling and Sensitive Information 2.5 Notebook Environments: Collaboration and Security Best Practices 2.6 Prototyping in Workbench and Colab Enterprise with PyTorch, scikit-learn and JAX 2.7 Prototyping with Model Garden Foundational and Open Models in Notebooks 2.8 Choosing the Development and Experimentation Environment 2.9 Evaluating Generative Solutions: LLM-as-a-Judge and RAG Evaluation 2.10 Experiment Tracking, Artifact Lineage and Model Registry Governance
4 Section 3: Scaling Prototypes into ML Models (~21%)
3.1 Choosing the Model Type: ARIMA, DNN, LLM and Classical Baselines 3.2 Choosing the Product: AutoML, BigQuery ML, Custom Training and Pipelines 3.3 Choosing the Deployment Strategy at Design Time 3.4 Modeling Techniques for Interpretability Requirements 3.5 Organizing Training Data on Cloud Storage and BigQuery 3.6 Ingesting Structured and Unstructured Data into Training Pipelines 3.7 Training SDKs and Services: Custom Training, Kubeflow on GKE, AutoML and Tabular Workflows 3.8 Troubleshooting ML Model Training Failures 3.9 Hyperparameter Tuning, Bayesian Optimization and Vizier 3.10 Model Evaluation Metrics, Transfer Learning and Fine-Tuning 3.11 Evaluating Compute and Accelerator Options: CPU, GPU and TPU 3.12 Distributed Training Strategies, Hardware Acceleration and Performance Optimization
5 Section 4: Serving and Scaling Models (~20%)
4.1 Batch and Online Inference: Agent Platform, Model Garden, Cloud Run and GKE 4.2 Rollout Strategies: Canary, Traffic Splitting, Shadow and Blue-Green 4.3 Tuning Models for Production: Vector Search and Model Compression 4.4 Deploying Models to Public and Private Endpoints 4.5 Choosing Serving Hardware: CPU, GPU, TPU and Edge 4.6 Scaling the Serving Backend for Throughput
6 Section 5: Automating and Orchestrating ML Pipelines (~18%)
5.1 Validating Data and Models Inside Pipelines 5.2 Agent Platform Pipelines: Kubeflow Pipelines (KFP) and TFX Architecture 5.3 Reusable Pipeline Components, Artifacts and ML Metadata Lineage 5.4 Ray on Agent Platform for Distributed Python Workloads 5.5 MLOps CI/CD Automation, Retraining Triggers and Skew Prevention
7 Section 6: Monitoring AI Solutions (~13%)
6.1 Securing AI Systems: Exfiltration, Malicious Prompting and Model Armor 6.2 Responsible AI, Explainable AI, Fairness Metrics and Model Governance 6.3 Model Monitoring: Feature Skew and Drift Detection 6.4 Operational Troubleshooting, Performance Profiling and Cost Optimization 6.5 Monitoring, Testing and Evaluating Generative AI in Production
1.4 AutoML on Agent Platform: Tabular, Image, Text and Video Training
Key Takeaways Explain This Topic AI
Vertex AI AutoML provides state-of-the-art automated machine learning across Tabular, Vision, NLP, and Video modalities by automating feature preprocessing, model architecture search, and hyperparameter tuning.
AutoML Tabular utilizes Neural Architecture Search (NAS) and constructs weighted meta-ensembles combining gradient-boosted decision trees (XGBoost, LightGBM, CatBoost) and deep neural architectures.
Training budgets are allocated in node hours, and AutoML's built-in early stopping mechanism automatically halts training when validation loss plateaus, charging only for elapsed node hours.
Vertex AI Model Garden serves as a managed enterprise repository for discovering, customizing, and deploying Google foundation models (Gemini, Imagen, Chirp), partner models, and open-weight models (Gemma, Llama 3, Mistral).
Evaluation suites in AutoML provide comprehensive diagnostic metrics including Precision-Recall curves, ROC-AUC, confusion matrices, and explainability feature attributions (Tree SHAP and Integrated Gradients).
Last updated: September 2026
1.4 AutoML on Agent Platform: Tabular, Image, Text and Video Training
In enterprise machine learning engineering, productivity is governed by balancing model customization with development velocity. Google Cloud's Vertex AI AutoML and Vertex AI Model Garden represent complementary paradigms: AutoML empowers teams to produce custom state-of-the-art models from domain-specific labeled data with minimal code, while Model Garden provides a managed hub to discover, test, fine-tune, and deploy pre-trained open-source and proprietary foundation models.
1. Vertex AI AutoML Modalities and Architectural Mechanics
Vertex AI AutoML abstracts away the intricate, time-consuming tasks of data preprocessing, feature engineering, architecture selection, hyperparameter tuning, and model ensembling. Behind the scenes, AutoML pipelines orchestrate containerized worker pools across Google Cloud compute infrastructure to benchmark hundreds of pipeline permutations. +---------------------------------------------------------------------------------------------------------+
- | VERTEX AI AUTOML MODALITIES |
- +------------------------------------+------------------------------------+-------------------------------+
- | AUTOML TABULAR | AUTOML VISION & VIDEO | AUTOML TEXT |
- +------------------------------------+------------------------------------+-------------------------------+
- | * Neural Architecture Search (NAS) | * Image Classification (Single/ML) | * Text Classification |
- | * Gradient Boosted Ensembles | * Object Detection (Bounding Boxes)| * Named Entity Recognition |
- | * Automatic Feature Preprocessing | * Edge Exports (TFLite, Coral) | * Multi-label Sentiment |
- | * Tabular Forecasting & Reg/Class | * Video Action Recognition/Tracking| * Sequence Labeling |
- +------------------------------------+------------------------------------+-------------------------------+
- 1. AutoML Tabular
AutoML Tabular is engineered for structured data stored in BigQuery or Cloud Storage CSV files. It leverages two primary modeling engines:
Neural Architecture Search (NAS) : Dynamically designs, trains, and evaluates deep neural network topologies tailored to the specific dataset schema.
Gradient Boosted Decision Tree (GBDT) Ensembles : Trains and tunes multiple tree variants (XGBoost, LightGBM, CatBoost) simultaneously.
Meta-Ensembling : Blends the top-performing neural and tree-based models into a weighted ensemble stack, consistently outperforming individual handcrafted models.
Automated Transformations in AutoML Tabular :
Numerical Columns : Outlier clipping, log normalization, z-score standardization, and missing value imputation.
Categorical Columns : Frequency encoding, one-hot encoding, target encoding, and dense entity embeddings for high-cardinality features.
Timestamp Columns : Deconstruction into hour, day-of-week, day-of-year, and cyclic trigonometric transforms.
Text Columns : Bag-of-words tokenization, n-gram generation, and pre-trained language model embedding extraction.
2. AutoML Vision & Video
Image Classification : Single-label and multi-label classification. Capable of learning fine-grained visual representations from as few as 100 images per class (minimum 10 per class).
Object Detection : Predicts localized bounding box coordinates [ y min , x min , y max , x max ] [y_{\min}, x_{\min}, y_{\max}, x_{\max}] [ y m i n , x m i n , y m a x , x m a x ] alongside class labels.
Image Segmentation : Pixel-level mask generation for complex spatial boundaries.
Edge Deployment : Supports exporting optimized model artifacts for on-premise or edge execution (TensorFlow Lite for mobile, Coral Edge TPU format, TensorFlow SavedModel, and ONNX).
AutoML Video : Action recognition, video classification, and object tracking across temporal video streams.
3. AutoML Text (NLP)
Text Classification : Document categorization and multi-label tagging across customer inquiries, legal documents, and news feeds.
Named Entity Recognition (NER) / Entity Extraction : Extracts domain-specific entities (e.g., medical IDs, custom product codes) from unstructured text.
Sentiment Analysis : Multi-point sentiment scoring on consumer reviews and communication logs.
- 2. Dataset Splitting, Budgeting & Early Stopping Mechanics
- Dataset Splitting Strategies
To ensure rigorous generalization, Vertex AI AutoML requires a dataset split into Training, Validation, and Test sets (typically 80/10/10):
Splitting Strategy Mechanism Recommended Use Case
Random Split (Default) Randomly assigns rows to 80% Train, 10% Validation, 10% Test. Standard i.i.d. tabular, image, and text classification tasks.
Manual / Predefined Split User designates a specific split column with values TRAIN , VALIDATION , TEST . Benchmarking against fixed organizational holdouts; cross-team reproducibility.
Chronological / Time Split User specifies a timestamp column; older records form Train, newer form Validation, latest form Test. Time-sensitive tabular data and forecasting to prevent future lookahead bias .
Group Split Ensures all observations belonging to a specific identifier (e.g., patient_id or household_id ) stay in the same partition. Preventing data leakage across correlated clustered entities.
Node Hour Budgeting and Early Stopping
Training an AutoML model requires setting a maximum training budget in node hours . A node hour represents the concurrent use of a dedicated compute node for one hour.
Minimum Budgets : Tabular models require a minimum of 1 node hour (recommended 10-20 node hours for datasets with >100,000 rows); Vision/Text models require 8-24 node hours depending on dataset size and resolution.
Early Stopping : Vertex AI AutoML enforces intelligent early stopping . If the optimization objective (e.g., Log Loss or PR-AUC) on the validation set does not improve after successive iterations, the training job terminates automatically.
Important
Exam Fact : If you configure a budget of 20 node hours but AutoML triggers early stopping after 6 node hours, Google Cloud only bills for the 6 node hours consumed . The resulting model artifact is fully optimized and ready for immediate deployment.
3. Vertex AI Model Garden & Foundation Model Management
Vertex AI Model Garden acts as Google Cloud's centralized enterprise catalog for discovering, testing, customizing, and deploying machine learning models across four key tiers: +---------------------------------------------------------------------------------------------------------+
- | VERTEX AI MODEL GARDEN TIERS |
- +------------------------------------+------------------------------------+-------------------------------+
- | FIRST-PARTY GOOGLE FOUNDATION | OPEN-SOURCE / OPEN-WEIGHT | PARTNER & TASK-SPECIFIC |
- +------------------------------------+------------------------------------+-------------------------------+
- | * Gemini 1.5 Pro / Flash | * Gemma 2 (2B, 9B, 27B) | * Anthropic Claude (on Vertex)|
- | * Imagen 3 (Image Generation) | * Meta Llama 3 / 3.1 (8B, 70B, 405B)| * Mistral Large / Codestral |
- | * Chirp (Multilingual Speech) | * Mistral 7B / Mixtral 8x7B | * Specialized Bio/Vision APIs |
- | * Codey / CodeGemma (Code Assist) | * Stable Diffusion XL | * Hugging Face Connectors |
- +------------------------------------+------------------------------------+-------------------------------+
- Foundation Model Lifecycle in Model Garden
One-Click Serverless Deployment : Deploy open-weight foundation models (e.g., Llama 3.1 70B or Gemma 2) onto dedicated Vertex AI Prediction endpoints backed by GPU hardware accelerators (e.g., NVIDIA L4, A100 80GB, or H100) with a single UI click or SDK call.
Parameter-Efficient Fine-Tuning (PEFT / LoRA) : Freeze base foundation model weights and inject low-rank trainable adapter matrices, drastically reducing GPU memory requirements and training costs while specializing the model on internal proprietary corpora.
Full Fine-Tuning & Distillation : Train smaller student models (e.g., Gemma 2B) on outputs generated by massive teacher models (Gemini 1.5 Pro) to achieve microsecond latency and low inference cost.
Private Vertex Model Registry Integration : Manage versions, register lineage metadata, and configure canary rollout policies directly in the Vertex AI Model Registry.
4. Architectural Decision Matrix: Pre-trained APIs vs. AutoML vs. Model Garden vs. Custom Training
Selecting the appropriate path across the GCP ML continuum is a core architectural competency:
Metric / Dimension Pre-Trained AI APIs Vertex AI AutoML Vertex AI Model Garden (OSS/LLM) Vertex AI Custom Training
Target Problem Generic vision, speech, text, OCR Domain-specific tabular, image, text classification Foundation LLMs, image gen, text embeddings Bespoke algorithms, custom graph architectures
Data Requirements Zero labeled data required (zero-shot) Requires labeled dataset (100–100,000+ rows) Unlabeled text for prompt/RAG; small labeled set for LoRA Massive labeled/unlabeled datasets
ML Code Required None (REST / gRPC API calls) Low-code (UI or Python SDK dataset binding) Low-to-medium (Prompting, PEFT tuning configs) High (PyTorch, TensorFlow, JAX, custom Docker)
Model Explainability Fixed API outputs Built-in Tree SHAP / Integrated Gradients Attention maps, logit probabilities Custom Explainable AI SDK configuration
Training Infrastructure Fully managed by Google Fully managed automated worker pools Managed tuning or self-hosted GPU endpoints Custom worker pools, GPU/TPU accelerators, Slurm
Inference Latency SLA Managed cloud multi-tenant SLA Managed endpoints (autoscaling node pools) Dedicated GPU/TPU machine types with vLLM/Triton Custom optimized containers (TensorRT, ONNX Runtime)
Tip
AutoML vs Model Garden Guideline : Use AutoML when you possess labeled domain-specific tabular, vision, or text datasets and require an automated, optimized model without writing custom ML training code. Use Model Garden when you need to leverage or adapt existing foundation models (Gemini, Llama, Gemma) via prompting, RAG, or Parameter-Efficient Fine-Tuning.