Day 3 - SageMaker Builtin 2: Text, Images, Time Series, Recommendations

📌 Key Takeaways

• When a question mentions text, images, time series, or sparse data, the answer shifts away from XGBoost toward a specialized builtin.
• BlazingText has two modes. If you have labels and are classifying documents, use supervised mode; if you want word vectors without labels, use Word2Vec.
• The textbook answer for images + insufficient data is use_pretrained_model=1 transfer learning + data augmentation. If you also need object locations, use Object Detection.
• DeepAR trains thousands of related time series together in one model so it can forecast new or short series too, and it outputs P10/P50/P90 probability intervals rather than point estimates.
• Factorization Machines is dedicated to second-order interactions in ultra-high-dimensional sparse data blown up by one-hot encoding, and its recommended input is RecordIO-protobuf (float32).

Data Shape Decides the Algorithm

Yesterday we covered tabular-data algorithms. Today we organize the specialized builtins used when the data has a special shape: text, images, time series, and sparse interactions.

                  [Data is not tabular]
                            │
        ┌───────────┬───────┴────────┬─────────────┐
      Text        Image          Time series     User-item
        │            │               │            (very sparse)
   Labels?      What do you        Many related      │
   ├─ Yes →     want?              series?       Factorization
   │  supervised ├─ Label only →   ├─ Yes →      Machines
   │  (document  │  Image          │  DeepAR    (RecordIO-protobuf)
   │  classif.)  │  Classification └─ No →
   └─ No →       ├─ Location too →    Single-series statistical
      Word2Vec   │  Object            method or Forecast
      (embedding)│  Detection
                 └─ Pixel level →
                    Semantic Segmentation

BlazingText — Text Classification and Word Embeddings

A builtin that accelerates Word2Vec and text classification on GPUs. It has two modes.

• Word2Vec (unsupervised): Embeds words as vectors. Used for finding similar words and generating features for downstream tasks
• Text Classification (supervised): Document → label (sentiment, topic, etc.). Based on fastText

Mode decision:
  Labels exist and you classify documents → supervised (text classification)
  No labels and you only need word vectors → Word2Vec (cbow / skipgram / batch_skipgram)

• Input: Text file (whitespace-tokenized). Supervised mode uses the __label__<label> sentence format
• Strengths: Overwhelming speed on large corpora, multilingual support, and handling of OOV (out-of-vocabulary) words through subwords

BlazingText's Word2Vec places words with similar meanings close together in the vector space by either "guessing the center word from its context (CBOW)" or "guessing the context from the center word (skip-gram)." The learned embeddings themselves can be used for word similarity search, or passed to other models as input features. On the exam, "semantic similarity of words" / "embeddings" is the signal for Word2Vec mode, and "classify documents into categories" is the signal for supervised mode.

⚠️ Trap: In supervised mode, the label prefix in the training file must take the form __label__. An option that puts the label in a column like a regular CSV is wrong.

Image Classification — Image Classification

A builtin that classifies images into one or multiple labels using a CNN (ResNet).

• Use: Single-label/multi-label image classification
• Input: RecordIO or images (.jpg/.png) + a .lst list file
• Key technique: Transfer learning — starting from ImageNet pretrained weights with use_pretrained_model=1 gives good performance even with little data

Key hyperparameters:
  num_classes, num_training_samples
  use_pretrained_model   0 (from scratch) | 1 (transfer learning)
  image_shape, learning_rate, mini_batch_size
  augmentation_type      image augmentation (crop/color, etc.)

• When data is scarce, transfer learning + data augmentation is the textbook approach.
• If you also need the location of objects, use the Object Detection builtin rather than classification; for pixel level, use Semantic Segmentation.

⚠️ Trap: Choosing "train a deeper network from scratch" for "images + insufficient data" is wrong. The less data you have, the more you should borrow pretrained weights and expand the data with augmentation rather than enlarge the model.

DeepAR — Time Series Forecasting

An RNN-based time series forecasting builtin. Its key strength is that it does not model each series separately but learns multiple related series together and shares patterns.

• Use: Forecasting future values of demand, sales, and traffic, with probabilistic (quantile) forecasts
• Input: JSON Lines — each time series has start, target, and optionally cat (category) and dynamic_feat (covariates)
• Strengths: When there are many related series, such as thousands of stores, it is more accurate than modeling each one individually. New or short series (cold start) can also be forecast using patterns learned from similar series

Key hyperparameters:
  context_length      length of the past input window
  prediction_length   length of the forecast window
  epochs, num_cells, num_layers
  likelihood          output distribution (Gaussian, etc.)

Traditional ARIMA and exponential smoothing model each time series separately, whereas DeepAR trains multiple related series in a single model and cross-learns seasonality and trend. That is why a new item with a short history can borrow the patterns of similar items. Because the output is a distribution (quantiles) rather than a point estimate, it provides uncertainty intervals in the form of P10/P50/P90. On the exam, "thousands of related time series" / "new product demand" / "probabilistic forecast intervals" are DeepAR signals. If you need something more managed, Amazon Forecast is the answer.

Conditions Where DeepAR Beats Single-Series Techniques

"Time series forecasting" does not automatically mean DeepAR. If there is only one series and the data is short, deep learning is overkill. DeepAR is confirmed only when there is a clue such as "many related series" or "probability intervals needed."

Factorization Machines — Sparse High-Dimensional Recommendation

It efficiently models second-order interactions between features in data that is very sparse and high-dimensional, such as user-item data.

• Use: Recommendation (click prediction, rating prediction), sparse classification/regression
• Input: RecordIO-protobuf (float32). It is optimized for sparse data, so CSV is not recommended
• Strengths: It learns interactions efficiently even on ultra-high-dimensional sparse input blown up by one-hot encoding

Key hyperparameters:
  num_factors        dimension of the latent factors
  predictor_type     binary_classifier | regressor
  bias/linear/factors   per-term regularization and initialization settings

In a recommendation context, FM is a generalization of collaborative filtering. If you feed in user ID and item ID as one-hot vectors, it behaves like matrix factorization, and you can also feed additional features (time, context) alongside them.

An option that says to use CSV with FM is a wrong-answer signal. Representing sparse high-dimensional data as CSV produces a huge dense table that is mostly zeros, which is inefficient. RecordIO-protobuf (float32) is the correct answer.

Preprocessing and Evaluation Metrics

Specialized builtins have different preprocessing requirements from tabular algorithms. In some cases the very concept of "scaling" does not apply.

Recommendation and click-prediction data is a classic imbalance case, with very few positives (clicks). An option that picks accuracy as the metric here is wrong; AUC, which looks at ranking quality, or PR-AUC, which is honest about the minority class, is the correct direction.

Question Clue → Answer Mapping Table

Tomorrow we cover the unsupervised and anomaly-detection builtins that work without labels (RCF, PCA, IP Insights, LDA/NTM).

📖 Glossary

• fastText: A text classification and embedding technique that breaks words down into substrings (subwords). It is the basis of BlazingText's supervised mode.
• OOV (out-of-vocabulary): A word that was not in the training vocabulary. With subword representations, a vector can be built even for a word seen for the first time.
• cbow / skipgram: A method of guessing the center word from its context / a method of guessing the context from the center word. These are the two training directions of Word2Vec.
• Transfer learning: A technique that starts from weights pretrained on large-scale data and fine-tunes them with a small amount of data.
• Data augmentation: A technique that artificially expands the training images through cropping, color changes, and similar operations to reduce overfitting.
• .lst file: A list file that records image paths and labels line by line, passed to Image Classification.
• JSON Lines: A format that holds one JSON object per line. It is how DeepAR receives one time series per line.
• context_length / prediction_length: The length of the past window DeepAR looks at / the length of the future window to forecast.
• Quantile forecast (P10/P50/P90): A probabilistic forecast that returns the "10%, 50%, and 90% probability lines" together instead of a single value.
• Latent factor: A hidden low-dimensional feature vector that describes users and items. FM's num_factors sets its dimension.