---

name: matlab-use-machine-learning-apps description: "Use when the user wants to train, compare, or export machine learning models using Classification Learner or Regression Learner — including opening the app, loading data, training models, evaluating metrics, comparing results, visualizing plots, testing on held-out data, exploring model interpretability, and exporting trained models. Programmatic access to Classification Learner and Regression Learner apps via AppController." license: https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md metadata: author: MathWorks version: "1.0"

Learner Apps AppController Reference

mlearnapp.internal.appcontroller.AppController provides programmatic access to the Classification Learner and Regression Learner apps. Use it to interact with learner apps and query their state.

Source (loaded at runtime): <skill-base-directory>/scripts/+mlearnapp/+internal/+appcontroller/AppController.p

API Reference (load on demand)

| When you need... | Load this file | |------------------|---------------| | Open/close/save/load app, session setup, create/train/select/delete models, model status, GalleryModels enum | api-session-and-models.md | | Metrics, model spec queries, toolstrip buttons, set feature selection/PCA/optimizer/cost/hyperparameters | api-metrics-and-options.md | | Open/configure standard plots, results table, standard plot data getters | api-plots.md | | PDP, permutation importance, Shapley, LIME, Set Shapley Parameters, explainability plot data getters | api-explainability.md | | Export methods, command logging, diagnostics | api-export-and-diagnostics.md |

Required: Statistics and Machine Learning Toolbox. Optional: Parallel Computing Toolbox (parallel training), Deep Learning Toolbox (only for Deep Learning models introduced in R2026a — FullyConnected, Residual, All; plain Neural Network models added in R2024a ship with Statistics and Machine Learning Toolbox), Simulink (Simulink export), MATLAB Coder (Coder export), MATLAB Compiler SDK (Production Server export).

When to Use

• User wants to train, compare, or export models (to workspace, Simulink, Coder, or Production Server), generate training code, or run advanced hyperparameter tuning (via Experiment Manager) using Classification Learner or Regression Learner
• User asks to open, drive, or automate either learner app
• User wants to compare multiple model types interactively with validation metrics
• User needs to test a model on held-out data or separate test data and export from the app

When NOT to Use

• User wants command-line ML without the app — use fitc*/fitr* functions directly
• Custom deep learning with non-tabular data (images, sequences, text) — use Deep Learning Toolbox directly
• Data preprocessing or cleaning — must be done before importing into the app

IMPORTANT

• Do not expose API to users. This API is for agent's internal use only. Never mention AppController, programmatic access, or automation APIs to the user. Drive the app silently on the user's behalf. When greeting the user after this skill loads, simply ask about their goals (dataset, export target, constraints) without referencing the underlying mechanism.
• Never use closeApp('Force', true) without explicit user permission. Force-closing skips the save confirmation dialog and silently discards all unsaved work — trained models, session state, and results are permanently lost. Always prefer closeApp() (without Force) so the user gets a chance to save. Only use 'Force', true when: (1) the user explicitly permits it, or (2) automated testing where no human is present.

Setup

When this skill is invoked, add the skill's scripts folder to the MATLAB path so that mlearnapp.internal.appcontroller classes are available. The scripts folder is located relative to this skill's base directory at scripts/. Run this via the MATLAB MCP evaluate_matlab_code tool, using the skill's base directory path shown at the top of the skill load message:

addpath('<skill-base-directory>/scripts');

For example, if the skill base directory is C:\MATLAB\AgenticAI\.claude\skills\matlab-use-machine-learning-apps, then:

addpath('C:\MATLAB\AgenticAI\.claude\skills\matlab-use-machine-learning-apps\scripts');

User Goals Inquiry

Before starting any workflow, gather the information below so the session can be configured up front without wasted training cycles. Each item lists what the agent needs to know (internal use) and how to ask the user (in plain terms — avoid ML terminology unless the user's vocabulary shows they're comfortable with it).

1. End goal / where will the model be used?
   • Agent needs to know: target of exportModelTo* — workspace, Simulink, Coder, Production Server, Experiment Manager, or exploratory. Drives constraints (no categorical predictors for Simulink, model support lists for Coder/Simulink, etc.).
   • Ask the user: "How will the model ultimately be used? For example: exploring the data, generating a report or figure, running inside a Simulink simulation, generating C/C++ code for an embedded device, deploying as a web service, or making predictions in MATLAB."
2. Validation scheme.

   • Agent needs to know: Set at session open via openApp, fixed for the session — cannot be changed later without starting a new session. The app default is 5-fold CV ('KFold', 5). Pick based on dataset size × training cost:

     | Scheme | When to pick | Syntax | |--------|-------------|--------| | 5-fold CV | Small-medium data (≤few thousand rows), fast models | 'KFold', 5 (default) | | 20% hold-out | Large data, slow models (ensembles, DL, optimization), or time-constrained | 'HoldOut', 0.2 | | Resubstitution | User explicitly wants fast iteration without accuracy estimate (training-set accuracy, optimistic) | 'CrossVal', 'off' |

   • Ask the user: "Two things, since the validation setting is fixed once we start: (1) roughly how many rows does your dataset have, and (2) is there a training time budget I should keep in mind, or is training time not a concern? I'll pick a validation approach that works for both."

3. Independent test dataset.
   • Agent needs to know: whether to use importTestData with an existing table, reserve a fraction via TestDataFraction (e.g., 0.2), or skip test entirely. Test data is distinct from validation and is used only once on the final model.
   • Ask the user: "Do you have a separate dataset you want to keep aside for a final check, or should we reserve a slice of your data (say, 20%) that we don't train on and use it only at the end?"
4. Performance requirements.
   • Agent needs to know: target metric thresholds (min accuracy, max RMSE), prediction latency, deployment throughput.
   • Ask the user: "Are there specific accuracy or speed targets the model must meet? For example, minimum acceptable accuracy, maximum acceptable prediction time per sample, or throughput on a given device."
5. Model size / deployment environment.
   • Agent needs to know: whether target is embedded / memory-constrained. If so, favor compact learners (linear, single tree, small SVM) and check ModelSizeMetric (general) or ModelSizeCoderMetric (Coder-specific).
   • Ask the user: "Will this model need to run on a small device, embedded system, or in a memory-limited environment? If so, we'll favor smaller/simpler models."
6. Interpretability need.
   • Agent needs to know: whether interpretable model families (trees, linear, discriminant) should be prioritized, and whether to plan interpretability plots (Permutation Importance, PDP, LIME, Shapley) after training.
   • Ask the user: "Will you need to explain the model's decisions to anyone — regulators, auditors, or non-technical stakeholders — or is raw accuracy the only priority?"

Use the answers to configure the session appropriately from the start — choosing the right predictors, validation scheme, model types, and export path without wasted training cycles.

Best Practices

Data & Setup

• Test data splitting: Before opening the app, ask the user whether they want to hold out a portion of the data as an independent test set. If they have a separate test dataset already available in the workspace, use that. If not, offer to split the data using TestDataFraction (e.g., 0.2–0.25) when opening the app, or let the user import test data later. This ensures an unbiased evaluation path is available after training. For openApp syntax and partitioning NV arguments, see references/api-session-and-models.md#opening-the-app.
• Data inspection before training: Before training models, inspect the data for potential issues. Check for: (1) missing values — models handle these differently, and some fail on NaN; (2) class distribution (classification) — use tabulate or groupcounts to detect imbalance; (3) response distribution (regression) — check for skewness or outliers in the response variable that may warrant transformation; (4) outliers in numeric predictors that could skew model performance; (5) constant or near-constant predictors that add no information. Report findings to the user and suggest preprocessing or model choices accordingly.
• ⚠ Preprocessing and data leakage: Any preprocessing that uses aggregate statistics from the dataset — mean/median imputation, IQR- or z-score-based outlier removal, standardization/normalization, target encoding, etc. — leaks information from validation/test folds into training when done before importing into the app, and produces over-optimistic metrics. The app does not perform these operations inside its CV/holdout folds (only feature-selection ranking, PCA, and misclassification cost matrices are applied per-fold). For practical guidance on how to handle this, see references/skill-guidance-details.md#preprocessing-and-data-leakage.
• Class imbalance handling: If the dataset has imbalanced classes (e.g., 90%/10% split), suggest: (1) ClassificationRUSBoostedEnsemble (RUSBoost) which is specifically designed for imbalanced data by undersampling the majority class during boosting, (2) adjusting the cost matrix via app.setModelCostMatrix() to penalize misclassification of the minority class more heavily, (3) using Macro F1 or per-class metrics instead of overall accuracy to evaluate model quality — accuracy can be misleading with imbalanced data. Ask the user which class is more important to get right.

Feature Engineering

• Feature selection and ranking: Suggest when: (1) dataset has many predictors (>20) and training is slow or models overfit, (2) user wants a simpler/more interpretable model, (3) model size must be minimized for deployment, (4) some predictors are known to be irrelevant/redundant. APIs: app.setDefaultFeatureSelectionOptions(...) for all draft models, or app.setModelFeatureSelectionOptions(...) for a specific one. For which ranking method to pick per problem type and goal, see references/skill-guidance-details.md#feature-selection.
• PCA: Suggest PCA when: (1) predictors are highly correlated (multicollinearity), (2) the dataset has many numeric predictors and dimensionality reduction could improve training speed without losing much information, (3) the user wants to reduce model complexity. Do NOT suggest PCA when interpretability is critical (PCA components lose predictor meaning). Note: PCA applies only to numeric predictors — categorical predictors a