Core ML: apa itu, arsitektur framework dan integrasi model

Apa itu Core ML?

Core ML — adalah komponen kunci dari ekosistem machine learning Apple, diperkenalkan di WWDC 2017. Sebelum Core ML, pengembang iOS menggunakan pustaka pihak ketiga (TensorFlow Mobile, Caffe2) atau solusi kustom untuk menjalankan model ML pada perangkat. Core ML menyediakan antarmuka terpadu untuk semua jenis model — dari regresi klasik hingga jaringan saraf dalam — dan menangani optimasi tingkat rendah untuk perangkat tertentu.

Sejarah pengembangan

Versi pertama Core ML (2017) hanya mendukung model statis dengan ukuran input tetap. Core ML 2 (2018) menambahkan dukungan untuk batch prediction dan pembaruan model “secara langsung”. Core ML 3 (2019) membawa pembelajaran pada perangkat dan dukungan untuk puluhan lapisan jaringan saraf baru. Core ML 4 (2021) memperkenalkan dukungan untuk model dengan banyak keluaran dan pemrosesan gambar yang lebih baik. Core ML 5 (2024) menambahkan dukungan untuk jaringan saraf dinamis dan pembelajaran terbimbing pada perangkat menggunakan lapisan ML baru.

ML Pada Perangkat: keuntungan

Menjalankan machine learning pada perangkat memberikan tiga keuntungan utama: kerahasiaan — data tidak meninggalkan perangkat (memenuhi persyaratan GDPR dan HIPAA), kecepatan — inferensi dilakukan dalam milidetik tanpa latensi transmisi data melalui jaringan, ketersediaan offline — model bekerja tanpa koneksi internet. Menurut Apple Privacy Report (2025), lebih dari 90% inferensi ML pada platform Apple dilakukan pada perangkat berkat Core ML.

Arsitektur Core ML dan komputasi backend

Arsitektur Core ML dibangun berdasarkan prinsip multi-lapis: di tingkat atas — API untuk pengembang (MLModel, MLFeatureProvider, MLPredictionOptions), di tingkat menengah — model dalam format .mlpackage, di tingkat bawah — backend komputasi: Apple Neural Engine (ANE), GPU (Metal Shaders), dan CPU (BNNS, Accelerate framework). Core ML secara otomatis memilih backend terbaik berdasarkan model dan perangkat keras.

Apple Neural Engine

Neural Engine (ANE) — adalah neuroprosesor khusus yang tertanam dalam chip Apple A12+ dan M1+. ANE dioptimalkan untuk melakukan operasi jaringan saraf konvolusional (CNN) dan perkalian matriks dengan kinerja hingga 15.8 TOPS pada A17 Pro dan 38 TOPS pada M4. Core ML secara otomatis mendeteksi apakah model dapat dijalankan pada ANE, dan jika ya, memuatnya ke sana. Jika model berisi operasi yang tidak didukung oleh ANE, Core ML mendistribusikan komputasi antara GPU dan CPU.

Metal Performance Shaders

Untuk komputasi pada GPU, Core ML menggunakan Metal Performance Shaders Graph (MPSGraph), sebuah framework untuk membangun dan mengeksekusi grafik komputasi pada GPU. MPSGraph mengambil grafik jaringan saraf dari Core ML dan mengompilasinya menjadi Metal Shaders, dioptimalkan untuk arsitektur GPU tertentu (GPU A17 7-inti atau GPU M4 Ultra 40-inti). Optimasi otomatis MPSGraph meliputi penggabungan lapisan, eliminasi operasi redundan, dan pemilihan format data optimal.

Jenis model dan format yang didukung

Core ML mendukung semua jenis utama model machine learning, dibagi menjadi tiga kategori: jaringan saraf (CNN konvolusional, RNN/LSTM rekuren, transformer), model ensemble (Random Forest, Gradient Boosting, XGBoost, Decision Trees), dan model regresi (regresi linier, SVM, CRF). Setiap jenis model memiliki subprotokol MLModelType sendiri, dan Core ML secara otomatis memilih backend dan format eksekusi yang sesuai.

Lapisan jaringan saraf yang didukung

Core ML mendukung lebih dari 150 jenis lapisan jaringan saraf: Convolution (1D/2D/3D), BatchNormalization, Pooling (Max/Average), Activation (ReLU, Sigmoid, Tanh, LeakyReLU, PReLU), Recurrent (LSTM/GRU/SimpleRNN), Transformers (MultiHeadAttention, LayerNorm), lapisan khusus Metal. Untuk lapisan yang tidak didukung, Core ML menyediakan mekanisme custom layer — kemampuan untuk menulis implementasi lapisan dalam Metal Shading Language atau Swift.

let model = try MLModel(contentsOf: modelURL)
let input = try MLMultiArray(shape: [1, 224, 224, 3], dataType: .float32)
let prediction = try model.prediction(from: input)

Format file model

Hingga tahun 2021, Core ML menggunakan format .mlmodel — file biner yang berisi semua bobot dan metadata model. Mulai Xcode 13 dan Core ML 4, Apple memperkenalkan format baru .mlpackage — struktur paket berbasis direktori yang berisi model, metadata, deskripsi input/output, dan file pra/pasca-pemrosesan dalam format JSON. mlpackage mendukung versioning git, yang memudahkan kerja tim. Konversi .mlmodel ke .mlpackage dilakukan oleh Xcode Model Compiler atau skrip coremltools di Python.

Konversi model ke Core ML

Konversi model dari framework pihak ketiga ke Core ML dilakukan dengan pustaka coremltools di Python. coremltools mendukung impor model dari TensorFlow 1.x/2.x (SavedModel, PB, HDF5), PyTorch (TorchScript, model traced/scripted), Keras (H5), ONNX, dan yang dibuat dengan Create ML. Pipeline konversi standar mencakup tiga langkah: memuat model dalam format asli, konversi ke MIL (Model Intermediate Language) — representasi internal Core ML, dan ekspor ke .mlpackage.

import coremltools as ct

model = ct.converters.pytorch.convert(
    source = "model.pt",
    inputs = [ct.TensorType(shape=(1, 3, 224, 224))]
)
model.author = "IT Sectr"
model.short_description = "Image classifier"
model.save("MyModel.mlpackage")

Verifikasi model setelah konversi

Setelah konversi, perlu memverifikasi akurasi model dengan membandingkan prediksi model asli dan model Core ML yang telah dikonversi pada data yang sama. Selisih yang diizinkan — tidak lebih dari 1e-3 (0.1%) untuk Float32 dan 1e-2 (1%) untuk Float16/Int8. coremltools menyediakan utilitas ct.utils.compare_models() untuk perbandingan otomatis. Jika selisih melebihi batas, masalah mungkin terletak pada operasi yang tidak didukung — operasi tersebut harus diganti dengan custom layers atau model disederhanakan.

Optimasi kinerja Core ML

Optimasi model Core ML adalah proses mengurangi ukuran model dan meningkatkan kecepatan inferensi tanpa kehilangan akurasi yang signifikan. Apple menyediakan beberapa alat optimasi yang terintegrasi dalam coremltools dan Xcode: kuantisasi (pengurangan presisi bobot), pruning (penghapusan neuron yang tidak signifikan), penghapusan lapisan redundan, dan penggabungan lapisan (fusion) untuk mengurangi grafik komputasi.

Kuantisasi ke Float16 dan Int8

Kuantisasi mengurangi ukuran model sekitar 2 kali (Float16) atau 4 kali (Int8) dibandingkan dengan Float32. Core ML mendukung tiga mode kuantisasi: kuantisasi pasca-pelatihan (PTQ) dengan dataset kalibrasi, selama konversi melalui coremltools, dan pelatihan dengan kesadaran kuantisasi (QAT). Untuk sebagian besar model visi komputer, PTQ ke Float16 memberikan kehilangan akurasi kurang dari 0.5% dengan penggandaan kecepatan inferensi.

Profil model di Xcode

Xcode menyediakan alat Core ML Model Profiler yang memungkinkan pengukuran kinerja model pada berbagai perangkat di simulator atau perangkat nyata. Profiler menunjukkan waktu eksekusi setiap lapisan, beban backend (ANE/GPU/CPU), konsumsi memori puncak, dan hambatan model. Menurut Apple Performance Optimization Guide, lebih dari 80% model memiliki setidaknya satu lapisan yang bekerja jauh lebih lambat dari yang lain (anomali lapisan), yang dapat dioptimalkan dengan penggantian atau penggabungan.

Contoh praktis integrasi Core ML

Mari kita lihat integrasi model Core ML yang telah dilatih ke dalam aplikasi iOS di Swift. Setelah menambahkan file .mlpackage ke proyek Xcode (dengan menyeret atau melalui Swift Package Manager), Xcode secara otomatis menghasilkan kelas model di Swift, termasuk input dan output yang diketik. Pengembang tidak perlu mengurai data input secara manual — kelas yang dihasilkan menerima UIImage, MLMultiArray, String, atau tipe lain tergantung pada metadata model.

import CoreML
import Vision

guard let model = try? VNCoreMLModel(
    for: MyImageClassifier().model
) else { return }

let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results
        as? [VNClassificationObservation]
    else { return }

    if let topResult = results.first {
        print("Class: \(topResult.identifier)")
        print("Confidence: \(topResult.confidence)")
    }
}

let handler = VNImageRequestHandler(
    cgImage: image.cgImage!,
    options: [:]
)
try handler.perform([request])

Penanganan kesalahan dan fallback

Saat integrasi Core ML, perlu menyediakan penanganan kesalahan: model mungkin tidak dimuat karena ketidakcocokan dengan perangkat (versi iOS terlalu lama), kekurangan memori, atau kerusakan file model. Disarankan untuk mengimplementasikan logika fallback: jika model tidak dimuat dalam format Int8 terkuantisasi, muat versi Float16, dan jika itu juga tidak dimuat — Float32. Menurut Apple Crash Analytics, lebih dari 5% kegagalan aplikasi ML disebabkan oleh pemuatan model yang tidak benar.

Core ML vs Create ML: apa perbedaannya

Core ML dan Create ML adalah dua alat yang saling melengkapi dalam ekosistem Apple ML. Core ML bertanggung jawab untuk menjalankan model pada perangkat (inferensi), sementara Create ML bertanggung jawab untuk melatih model (training). Model yang dibuat di Create ML diekspor tepat ke format Core ML (.mlpackage) untuk integrasi selanjutnya ke dalam aplikasi. Jika dianalogikan dengan pengembangan web, Core ML adalah browser (eksekusi), dan Create ML adalah IDE untuk menulis kode (pelatihan).