Create ML — what it is, no-code model training and integration

What is Create ML?

Create ML is a component of Apple’s machine learning ecosystem, introduced at WWDC 2018 as a tool for training Core ML models without writing code. Before Create ML, developers used Python libraries (TensorFlow, PyTorch, scikit-learn) and then converted models to Core ML via coremltools. Create ML abstracted this entire process by providing a visual interface, built-in neural networks for transfer learning, and automatic export to Core ML format.

Evolution: from iOS 11 to macOS 15

The first version of Create ML (iOS 11/macOS 10.14) only supported basic tasks: image classification and text analysis. The macOS 10.15 version added object detection, sound analysis, and regression. Create ML 3 (macOS 13, 2022) introduced support for recommendation systems, tabular data with automatic algorithm selection, and improved training visualization. Create ML 4 (macOS 14, 2024) added support for dynamic models, streaming data training, and integration with Apple’s cloud services for distributed training.

Who Create ML is for

Create ML is designed for three categories of users: iOS developers with no ML experience who want to add intelligent features to their app; product managers and designers who want to quickly prototype ML features; and data researchers who need rapid hypothesis validation before moving a model to production infrastructure. For complex models with non-standard architecture, Create ML is not suitable — in such cases, Python frameworks with subsequent conversion to Core ML are used.

Create ML Task Types and Templates

Create ML offers seven task types, each with a pre-configured template: Image Classification, Object Detection, Text Classification and Word Tagger, Tabular Regression, Tabular Classification, Sound Classification, and Recommendation. Each template includes a pre-selected neural network architecture optimized for that task type.

Image Classification in Create ML

Image Classification is the most popular Create ML template. To train a model, simply provide a set of images sorted into folders (folder name = class label). Create ML automatically applies data augmentation (rotation, scaling, color shift) to increase the effective dataset size and uses the pre-trained Vision FeaturePrint network (modified ResNet-50) for feature extraction. Transfer learning training takes 2 to 15 minutes depending on dataset size and Mac performance.

Object Detection

The Object Detection template requires annotated images with bounding boxes for each object. Create ML uses the YOLOv5 (You Only Look Once) architecture adapted for Core ML, with pre-trained weights on the COCO dataset. Minimum requirement — 30 annotated images per class, recommended — 200+. Create ML supports importing annotations in PASCAL VOC, COCO JSON, and Create ML JSON formats.

How to Work with Create ML in Xcode

The workflow in Create ML within Xcode consists of three stages: data preparation, training and validation, and export. During data preparation, training and test sets are imported. Create ML automatically splits the data (default 80/20) and displays class distribution. During training, the tool shows real-time accuracy and loss charts, as well as metrics: accuracy, precision, recall, F1-score. During validation, you can test the model on new data directly in the Create ML window.

import CreateML

let data = try MLImageClassifierData.labeledDirectories(
    at: URL(fileURLWithPath: "/path/to/training-data")
)
let model = try MLImageClassifier(
    trainingData: data,
    parameters: MLImageClassifier.Parameters(
        featureExtractor: .scenePrint(revision: 1)
    )
)
try model.write(
    to: URL(fileURLWithPath: "/path/to/MyModel.mlpackage")
)

Xcode Visual Interface

The Create ML graphical interface in Xcode appears in the side editor after selecting a template file category. The interface contains tabs: Data (data loading and preview), Features (feature and parameter selection), Model (neural network architecture), Training (training charts and metrics), Evaluation (testing on held-out data), Preview (interactive model testing). Developers can switch between tabs during training without stopping the process.

Transfer Learning on Small Datasets

Transfer Learning is the key technology underlying Create ML templates. Instead of training a neural network from scratch (which requires millions of labeled examples), Create ML uses a pre-trained network (FeaturePrint) as a feature extractor and only trains the final classifier layers. This achieves high accuracy (90-95%) on datasets of 10 to 50 images per class with a training time of 2-5 minutes.

FeaturePrint — Pre-trained Extractors

Create ML uses several pre-trained FeaturePrint extractors: .scenePrint (based on ResNet-50, trained on Places365), .objectPrint (based on YOLOv5, trained on COCO), .textPrint (based on BERT, trained on Wikipedia). The choice of extractor depends on the task type and data domain. For example, .scenePrint is better suited for classifying indoor and landscape images, while .objectPrint is better for detecting specific objects (cars, people, animals).

Data Augmentation

Create ML automatically applies data augmentation during training: horizontal flip, rotation up to 20 degrees, color shift, brightness and contrast adjustment. Augmentation is applied randomly to each image at each epoch, increasing the effective dataset size by 10-20 times. This is especially important for small datasets where overfitting is the main issue. Augmentation parameters can be adjusted in the Features tab.

Programmatic Training via Swift API

In addition to the visual interface, Create ML provides a Swift API for programmatic model training, enabling automation of training pipelines and integration into CI/CD processes. The Swift API includes classes MLImageClassifier, MLObjectDetector, MLTextClassifier, MLWordTagger, MLTabularRegressor, MLSoundClassifier, and MLRecommender. Each class implements the MLModelTrainer protocol with train(), evaluate(), and write() methods.

import CreateML

let csvFile = try MLDataTable(
    contentsOf: URL(fileURLWithPath: "data.csv")
)
let (trainingData, testData) = csvFile.randomSplit(by: 0.8)

let regressor = try MLTabularRegressor(
    trainingData: trainingData,
    targetColumn: "price",
    parameters: MLTabularRegressor.Parameters(
        algorithm: .randomForest
    )
)

let evaluation = regressor.evaluation(on: testData)
print("RMSE: \(evaluation.rootMeanSquaredError)")

CI/CD Integration

Create ML Swift API can be run in Xcode build phases scripts or in GitLab/GitHub Actions on macOS runners. This allows automatic model retraining whenever the training dataset in the repository is updated. For example, you can set up a pipeline: data push to repository → GitLab Runner executes Create ML Swift script → exported .mlpackage model is committed back to the repository → app is built with the updated model.

Create ML Limitations

Despite its convenience, Create ML has several limitations that are important to consider when choosing a tool for ML tasks. The main ones: only works on macOS, limited control over neural network architecture, inability to use custom layers, dependency on built-in FeaturePrint extractors, and no support for multi-GPU or cluster training.

No Production Pipeline Support

Create ML is not designed for production training on large datasets (over 100,000 examples). The maximum dataset size is limited by the Mac’s RAM. For large-scale tasks, Apple recommends using Python frameworks (TensorFlow, PyTorch) on server infrastructure with subsequent conversion to Core ML via coremltools. Create ML is a tool for prototyping and small projects, not for enterprise ML.

Limited Tabular Data Algorithms

For tabular data, Create ML only supports three algorithms: Random Forest, Gradient Boosting (XGBoost), and Linear Regression. There is no support for neural networks for tabular data (TabNet, FT-Transformer), SVM, kNN, or ensemble methods available in scikit-learn. For tabular data tasks requiring high accuracy, Create ML often falls short compared to classic ML libraries.

macOS Only

Model training is only possible on macOS, as Create ML uses Metal Performance Shaders and macOS-exclusive frameworks. This limitation makes training on Linux servers or cloud GPU clusters impossible. For teams using cloud infrastructure, coremltools + Python remain the only option.

Examples of Using Create ML in Projects

Let’s look at three real-world scenarios of using Create ML in commercial applications: user content moderation, personal recommendations, and automatic document sorting. These scenarios demonstrate typical tasks that can be solved with Create ML without deep machine learning knowledge.

Image Moderation

A photo-sharing app can use Image Classification for automatic moderation: training a model on 100-200 images labeled “acceptable” and “violation” can filter out 85-95% of unwanted content without a moderator. Create ML allows updating the model as new violation examples come in, retraining it in 3-5 minutes.

Support Ticket Classification

Using Text Classification, Create ML can teach an app to automatically classify user inquiries into categories: payment issue, technical fault, feature request, complaint. Training requires 50-100 text examples per category. Classification accuracy reaches 90% using the built-in BERT-based Word Tagger.

Content Recommendation System

MLRecommender in Create ML allows building a recommendation system based on user actions without writing collaborative filtering manually. The model trains on User → Item → Rating data (e.g., a user liked an article). Create ML automatically chooses between collaborative filtering and content-based approach based on data volume and outputs top-N recommendations.