Machine Learning Problem Types: Regression, Classification, Forecasting, Clustering

1.Framing the problem: what does the model have to output?

Exam questions in this subdomain usually describe a business situation and ask which kind of model fits. The fastest way to answer is to look at the target, the column the model has to produce. Supervised problems learn from rows where the answer is already known. Snowflake's classification documentation states this directly: a suitable training set must include a target column with the labelled class of each data point, plus at least one feature column. Change the target and the problem type changes with it, even when the features stay the same.

Snowflake gives you two ways to build these models. The ML Functions are packaged SQL tools: Snowflake picks the model type for each function, so you don't need to be an ML expert. They split into time-series functions (Forecasting, Anomaly Detection) and functions that work without time-series data (Classification, Top Insights). For problem types that have no ML Function, such as plain linear regression, you train open-source models (scikit-learn, XGBoost, LightGBM, PyTorch) yourself inside Snowflake.

Sources12

2.Linear regression: predicting a continuous number

When the target is a quantity, such as revenue, cost or units, you have a regression problem. Snowflake has no dedicated ML Function for plain regression, so the documentation trains one with scikit-learn. In the Snowpark Python example, a stored procedure running on a Snowpark-optimized warehouse trains a linear regression model on a table called MARKETING_BUDGETS_FEATURES. The target is REVENUE. The features are spend on SEARCH_ENGINE, SOCIAL_MEDIA, VIDEO and EMAIL.

Notice how the code separates the target from the features and keeps a test split back:

# Load features
 df = session.table('MARKETING_BUDGETS_FEATURES').to_pandas()
 X = df.drop('REVENUE', axis = 1)
 y = df['REVENUE']

 # Split dataset into training and test
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = 42)

The procedure returns an R² score for both the training data and the test data, which is a typical way to judge a regression model. Linear regression is only one choice: the Snowflake ML training docs point out that XGBoost and LightGBM can also build classification, regression and ranking models. Either way, a numeric target is what makes this regression.

# Create pipeline and train
 pipeline = Pipeline(steps=[('preprocessor', preprocessor),('classifier',  ? (n_jobs=-1))])
 model = GridSearchCV(pipeline, param_grid={}, n_jobs=-1, cv=10)
 model.fit(X_train, y_train)

Sources34

3.Binary and multi-class classification

Classification sorts rows into classes it learned from labelled examples. The difference between binary and multi-class is just how many classes the target has. Binary means two classes (purchase / no purchase). Multi-class means more than two (not_interested / add_to_wishlist / purchase). SNOWFLAKE.ML.CLASSIFICATION handles both. It runs on a gradient boosting machine, and it trains binary and multi-class problems with different loss functions: an area-under-the-curve loss for binary and a logistic loss for multi-class. You cannot choose the algorithm or set its parameters.

The documentation's example table has both kinds of target side by side: a Boolean label column for the binary case and a string class column for the multi-class case. Training the binary model only requires naming the target:

CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model_binary(
    INPUT_DATA => SYSTEM$REFERENCE('view', 'binary_classification_view'),
    TARGET_COLNAME => 'label'
);

PREDICT returns an object containing the probability of each class and the predicted class, which is the one with the highest probability. The function also enforces limits that define what counts as a classification problem. The label must have more than one distinct value and fewer distinct values than there are rows, and the target can have at most 255 distinct classes. How a feature is treated depends on its data type, and this is where problems get set up wrong:

Sources1

4.Time-series forecasting: a numeric target at future timestamps

Forecasting is still supervised, because the model learns from past values of the target. What sets it apart is that time is the organising variable and the output is a value at timestamps that haven't happened yet. The minimum input is a table or view with one timestamp column and one numeric column. The docs ask for timestamps at a fixed interval without too many gaps. They also note that training can cope with real-world data that has missing, duplicate or misaligned time steps. The model works out the interval itself from the training data.

-- Train your model
CREATE SNOWFLAKE.ML.FORECAST my_model(
  INPUT_DATA => TABLE(my_view),
  TIMESTAMP_COLNAME => 'my_timestamps',
  TARGET_COLNAME => 'my_metric'
);

-- Generate forecasts using your model
SELECT * FROM TABLE(my_model!FORECAST(FORECASTING_PERIODS => 7));

For a multi-series forecast, the docs build one column that combines store_id and item into store_item and pass it as the series column. A single CREATE statement then trains a model for every series. To get forecasts for just one series, pass SERIES_VALUE to the FORECAST method. That is cheaper than generating every series and filtering the results.

Forecasts can also use features such as temperature, humidity or holidays. Any column you don't name as the timestamp or target is assumed to be a feature. There is a catch: once the model is trained on features, you have to supply *future* values of those features when you forecast. The timestamps of the forecast then come from that future-features input, not from FORECASTING_PERIODS. Every forecast comes with LOWER_BOUND and UPPER_BOUND, a prediction interval whose width you can set with prediction_interval. SHOW_EVALUATION_METRICS reports accuracy measured on out-of-sample data.

CREATE SNOWFLAKE.ML.FORECAST model2(
  INPUT_DATA => TABLE(v3),
   ?  => 'store_item',
  TIMESTAMP_COLNAME => 'date',
  TARGET_COLNAME => 'sales'
);

Sources56

5.Unstructured data: image classification and segmentation

Everything so far has used structured, tabular data. The exam guide also lists supervised problems on unstructured data: image classification, where one label is assigned to a whole image, and segmentation. The structured-data tools don't carry over. SNOWFLAKE.ML.CLASSIFICATION accepts numeric, Boolean, string and TIMESTAMP_NTZ inputs, and it does not support even full free text. A picture of a product cannot go through it.

The sources show two other routes. The first is the Cortex AI Functions. Their multimodal capabilities cover documents, images, audio and video, and the documented use cases include classifying images. The second is training your own deep learning model on Snowflake ML's GPU container runtime with PyTorch or TensorFlow, which you would do when you need a custom vision model.

Sources741

6.Unsupervised clustering, and the gap on association models

Take away the target column and the question is no longer "predict this label" but "what natural groups exist in this data?" That is clustering, which the exam guide puts under unsupervised learning. None of the ML Functions covers it: they are Forecasting, Anomaly Detection, Classification and Top Insights. You train clustering models in Snowflake ML with open-source frameworks, and the agentic ML documentation lists clustering next to classification, regression and forecasting as model types you can train.

The Snowflake Feature Store guide walks through a concrete example. A Snowpark-ML Kmeans model is fitted on a training dataset. Before that, the input variables are scaled with min-max scaling, and the scaling is applied at model time because it captures global state (the minimum and maximum of each column) from the training sample. There is no label to compare predictions against, so clustering is evaluated differently from classification. The guide lists Within-Cluster Sum of Squares, Silhouette Score, Gap Statistics and Cross-Validation as validation techniques, and in its notebook it simply plots the clusters and inspects them visually.

The exam guide also lists association models under GenAI. None of the documentation provided for this lesson describes association models: there is no association-rule or market-basket feature, and no definition of the term. The ML Functions overview names only Forecasting, Anomaly Detection, Classification and Top Insights. Top Insights finds dimensions and values that affect a metric in surprising ways, but the documentation does not call it an association model, so don't treat the two as the same thing. For this bullet, study from the current Snowflake documentation rather than this lesson.

Sources892

Exam traps

Each one states something that sounds right. Open it to see what is actually true.

1. 1.If the table contains several stores, CREATE SNOWFLAKE.ML.FORECAST will forecast each store separately automatically.Why is that wrong?

   Separate series have to be declared with SERIES_COLNAME, often a combined column such as store_item. Without it, you don't get one forecast per store.

   Covered in Time-series forecasting: a numeric target at future timestamps

2. 2.A forecast model trained with extra columns such as temperature can still be called with only FORECASTING_PERIODS.Why is that wrong?

   Extra columns become features, and a model trained on features needs their future values passed in as INPUT_DATA at forecast time.

   Covered in Time-series forecasting: a numeric target at future timestamps

3. 3.Numeric category codes (for example region 1, 2, 3) are treated as categories automatically by SNOWFLAKE.ML.CLASSIFICATION.Why is that wrong?

   Numeric features are always treated as continuous. To have them treated as categories, cast them to strings.

   Covered in Binary and multi-class classification

4. 4.Unstructured inputs such as free-text reviews can go straight into the classification ML Function as string features.Why is that wrong?

   String features are treated as categorical values. Full free text is not supported, and images need multimodal or deep learning tooling.

   Covered in Unstructured data: image classification and segmentation

Practise it for real

Train single-series and multi-series forecasting models on the documentation's sample sales data and compare the output

1. 1.Create the sales_data table from the forecasting docs, then create view v1 with SELECT date, sales FROM sales_data WHERE store_id=1 AND item='jacket'.

   Why: A single series needs only one timestamp column and one numeric target.

   You should see: v1 returns daily rows from 2020-01-01, with sales rising by 1 each day.

2. 2.Run CREATE SNOWFLAKE.ML.FORECAST model1 with INPUT_DATA => TABLE(v1), TIMESTAMP_COLNAME => 'date', TARGET_COLNAME => 'sales', then CALL model1!FORECAST(FORECASTING_PERIODS => 3).

   Why: This shows forecasting as supervised learning on past values of the target.

   You should see: Three rows for 2020-01-13 to 2020-01-15 with SERIES NULL and forecasts 14, 15, 16.

3. 3.Create view v3 that combines [store_id, item] AS store_item, train model2 with SERIES_COLNAME => 'store_item', and CALL model2!FORECAST(FORECASTING_PERIODS => 2).

   Why: Declaring the series column is what gives you one forecast per store/item.

   You should see: Two forecast rows each for [ 1, "jacket" ] and [ 2, "umbrella" ].