Introduction

When people ask for "MAE as the objective" in XGBoost, they often mean two different things: optimizing with absolute error during training, or simply reporting MAE while training a different loss. Those are not the same, and the right answer depends on your XGBoost version and how stable you need the optimization to be.

Objective vs Evaluation Metric

The objective controls how XGBoost updates the model. The eval_metric controls what gets reported on validation data. You can use MAE as an evaluation metric without training on an MAE objective:

1from xgboost import XGBRegressor
2
3model = XGBRegressor(
4    objective="reg:squarederror",
5    eval_metric="mae",
6    n_estimators=200,
7    learning_rate=0.05,
8    max_depth=4,
9    random_state=42,
10)

This setup still optimizes squared error, but it shows validation performance in MAE units. That is useful when MAE is the business-facing metric, yet you want the smoother optimization behavior of squared loss.

Using a True MAE Objective in Modern XGBoost

Current XGBoost releases support an absolute-error regression objective named reg:absoluteerror. Official documentation notes that this objective was added in version 1.7.0. If your environment is recent enough, the simplest solution is:

1from sklearn.datasets import make_regression
2from sklearn.model_selection import train_test_split
3from xgboost import XGBRegressor
4
5X, y = make_regression(n_samples=500, n_features=8, noise=15.0, random_state=42)
6X_train, X_test, y_train, y_test = train_test_split(
7    X, y, test_size=0.2, random_state=42
8)
9
10model = XGBRegressor(
11    objective="reg:absoluteerror",
12    eval_metric="mae",
13    n_estimators=300,
14    learning_rate=0.05,
15    max_depth=5,
16    subsample=0.9,
17    colsample_bytree=0.9,
18    random_state=42,
19)
20
21model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
22predictions = model.predict(X_test)
23print(predictions[:5])

This trains the model with L1 loss and also reports MAE during evaluation. For many tabular regression tasks, that is the most direct answer.

Why MAE Used to Be Awkward

Absolute error is less smooth than squared error. Around zero residual, its derivative changes abruptly, which makes optimization more awkward for methods that rely on gradient and Hessian information. That is why older XGBoost advice often said "use MAE only as an evaluation metric" or "use a custom approximation instead."

You will still see older examples using reg:squarederror plus eval_metric="mae" because:

• older XGBoost versions did not expose reg:absoluteerror
• some teams prefer the training stability of squared loss
• distributed training has special notes around how leaf values are refreshed for absolute error

So if you read conflicting answers online, check the library version first.

What to Do on Older Versions

If you are pinned to an older XGBoost release, you have two practical options.

First, keep the training objective as squared error and track MAE as the validation metric:

1from xgboost import XGBRegressor
2
3model = XGBRegressor(
4    objective="reg:squarederror",
5    eval_metric="mae",
6    random_state=42,
7)

Second, if you truly need a custom loss, use a differentiable approximation such as pseudo-Huber loss:

1from xgboost import XGBRegressor
2
3model = XGBRegressor(
4    objective="reg:pseudohubererror",
5    eval_metric="mae",
6    n_estimators=250,
7    learning_rate=0.05,
8    random_state=42,
9)

Pseudo-Huber behaves like a smoothed form of absolute error. It is not identical to MAE, but it is often a practical compromise when you want robustness to outliers without the sharp corner of plain L1 loss.

A Version Check You Can Run

Before choosing an approach, confirm what version is installed:

import xgboost as xgb

print(xgb.__version__)

If that prints a version older than 1.7.0, using reg:absoluteerror may fail with an "unknown objective" style error.

Choosing Between the Options

Use reg:absoluteerror when:

• you are on a recent XGBoost release
• MAE is genuinely the loss you want to optimize
• a slightly different training behavior is acceptable

Use reg:squarederror with eval_metric="mae" when:

• you mostly care about MAE for reporting
• your codebase is on an older release
• you want more conventional optimization behavior

Use reg:pseudohubererror when:

• you want robustness similar to MAE
• you need a smoother alternative
• plain squared error is too sensitive to outliers

Common Pitfalls

• Setting eval_metric="mae" does not change the training objective by itself.
• Copying old examples without checking xgboost.__version__ can lead to outdated advice.
• Assuming MAE is always better for outliers ignores the fact that optimization and convergence behavior also matter.
• Using a custom objective when a built-in one exists adds unnecessary complexity.
• Comparing models trained with different objectives but only one metric can hide tradeoffs in stability and calibration.

Summary

• In XGBoost, objective and eval_metric solve different problems.
• Modern XGBoost supports true L1 training with objective="reg:absoluteerror".
• Older versions often need either eval_metric="mae" with squared error or a smoother approximation such as reg:pseudohubererror.
• Check your installed version before choosing an answer from older tutorials.
• If you only need MAE for reporting, using it as the evaluation metric is often enough.