Core ML — bu nima, mashina o'rganish modeli va iOS-da ishlash

Core ML nima?

Core ML — Apple tomonidan WWDC 2017 da iPhone, iPad, Mac, Apple Watch va Apple TV uchun ishlab chiqish ekotizimining bir qismi sifatida taqdim etilgan mashina o'rganish freymvorkidir. Core ML qurilmada ML modellarini bajarish uchun ish vaqti muhitini ta'minlaydi, dasturchini apparat optimallashtirish detallaridan abstraksiya qiladi. Freymvork har bir model operatsiyasi uchun eng yaxshi hisoblash mexanizmini — A12+ chiplarida Neural Engine, GPU yoki CPU-ni avtomatik tanlaydi.

Asosiy afzalligi Core ML — Apple Silicon bilan chuqur integratsiya. Neyron tarmoq operatsiyalari protsessorning asosiy yadrolarini yuklamaydigan maxsus Neural Engine-da bajariladi. Apple-ga (WWDC 2025) ko'ra, Core ML modellari o'xshash Android qurilmalaridagi TensorFlow Lite bilan solishtirganda 6 marta tezroq ishlaydi.

Asosiy imkoniyatlar

Core ML mashina o'rganish vazifalarining keng spektrini qo'llab-quvvatlaydi: tasvirlarni tasniflash, obyektlarni aniqlash, semantik segmentatsiya, tabiiy tilni qayta ishlash, tovush tahlili va jadval ma'lumotlari. Freymvork turli xil modellar bilan ishlaydi: neyron tarmoqlar (konvolyutsion, rekurrent, transformatorlar), daraxt ansambllari, chiziqli regressiyalar va Gauss jarayonlari.

Core ML qanday ishlaydi

Core ML kirishda .mlpackage formatida o'qitilgan modelni qabul qiladi, uni ma'lum qurilma uchun optimallashtirilgan mashina kodiga kompilyatsiya qiladi va yagona API orqali inferensni ishga tushiradi. Butun quvur — modelni yuklashdan natija olishgacha — Swift-da 3–5 qator kodni talab qiladi.

.mlpackage model formati

.mlpackage — Apple tomonidan 2020 yilda eskirgan .mlmodel o'rniga joriy qilingan konteyner formatidir. Paket JSON manifesti, MLProgram ikkilik formatidagi model fayli, metadata (muallif, versiya, tavsif) va sinf belgilari kabi resurslar bilan katalogni ifodalaydi. Apple ma'lumotlariga ko'ra, .mlpackage og'irliklarni optimallashtirish hisobiga model hajmini .mlmodel bilan solishtirganda 30–50% kamaytiradi.

Apple Neural Engine

Apple Neural Engine (ANE) — A12 Bionic (2018) dan boshlab Apple chiplariga o'rnatilgan maxsus neyroprotsessor. ANE matritsa operatsiyalarini bir xil energiya sarfida CPU-dan o'nlab marta samaraliroq qayta ishlaydi. ANE unumdorligi A12 da 5 TOPS dan M4 Ultra da (2025) 35 TOPS gacha oshdi, bu milliardlab parametrlarga ega modellarni ishga tushirishga imkon beradi. ANE avtomatik ravishda neyron tarmoq arxitekturasiga ega barcha Core ML modellari uchun ishlatiladi.

Core ML ning muhim xususiyati — aniqlikni yo'qotmasdan modellarni FP16 va INT8 ga kvantlashni qo'llab-quvvatlashidir. Kvantlash model hajmini 2–4 marta kamaytiradi va ANE da inferensni 40–60% tezlashtiradi. Apple optimal aniqlikni avtomatik tanlash uchun Xcode Model Quantization vositasini taqdim etadi: dasturchi modelni yuklaydi, ruxsat etilgan sifat yo'qotilishini (odatda 0.1–0.5%) ko'rsatadi va Xcode eng yaxshi og'irlik ifodalash formatini tanlaydi.

Core ML unumdorligini taqqoslash

Modellarni Core ML-ga konvertatsiya qilish

Aksariyat ML modellari PyTorch yoki TensorFlow da yaratiladi va Core ML da ishlatish uchun .mlpackage formatiga konvertatsiyani talab qiladi. Apple coremltools vositasini — modellarni konvertatsiya qilish, optimallashtirish va validatsiya qilish uchun Python paketini taqdim etadi.

coremltools vositasi

coremltools — ML modellarini konvertatsiya qilish uchun Apple-ning rasmiy vositasidir. PyTorch (torch.onnx orqali yoki to'g'ridan-to'g'ri), TensorFlow (SavedModel, H5, Frozen Graph) va ONNX dan importni qo'llab-quvvatlaydi. Konvertatsiyadan so'ng FP16 yoki INT8 kvantlashni faollashtirish mumkin, bu model hajmini sezilarli aniqlik yo'qotilishisiz 2–4 marta kamaytiradi.

PyTorch dan konvertatsiya namunasi

Keling, coremltools 8.0 versiyasidan foydalanib, o'qitilgan PyTorch modelini Core ML formatiga konvertatsiya qilishni ko'rib chiqaylik. Jarayon Python da 2–3 qadamni oladi.

import torch
import coremltools as ct

# O'qitilgan PyTorch modelini yuklash
model = torch.load('model.pth')
model.eval()

# Modelni namunaviy kirish bilan kuzatish
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# Core ML .mlpackage ga konvertatsiya
mlmodel = ct.convert(
    traced_model,
    convert_to='mlprogram',
    inputs=[ct.TensorType(shape=(1, 3, 224, 224))]
)
mlmodel.save('Model.mlpackage')

Kod o'qitilgan PyTorch modelini yuklaydi, namunaviy kirish bilan JIT-tracingni amalga oshiradi va uni mlprogram formatiga (Core ML ikkilik formati) konvertatsiya qiladi. Olingan .mlpackage Xcode-ga sudrab olib borilishi va Swift kodida darhol ishlatilishi mumkin.

Core ML-ni iOS ilovasiga integratsiya qilish

Model konvertatsiyasidan so'ng uni iOS ilovasiga Swift da integratsiya qilish bir necha qatorda amalga oshiriladi. Xcode .mlpackage metadatasiga asoslanib model uchun avtomatik Swift sinfini yaratadi.

Swift kod namunasi

Keling, Core ML va Vision freymvorkidan foydalanib tasvirni tasniflash misolini ko'rib chiqaylik. Vision avtomatik ravishda tasvirni kerakli o'lcham va piksel formatiga o'zgartiradi.

import CoreML
import Vision

// Core ML modelini yuklash
guard let model = try? VNCoreMLModel(
    for: MobileNetV2.configuration.model
) else { return }

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

    // Top-3 bashoratni chiqarish
    for result in results.prefix(3) {
        print("\(result.identifier):
              \(result.confidence)")
    }
}

// Tasvirni qayta ishlashni ishga tushirish
let handler = VNImageRequestHandler(
    url: imageURL
)
try? handler.perform([request])

Swift kodi MobileNetV2 modelini Vision freymvorki orqali yuklaydi, tasniflash so'rovini yaratadi va natijani — sinf belgilari va foizlarda ishonchlilik bilan VNClassificationObservation obyektlari massivini qayta ishlaydi. Yuklashdan natija olishgacha bo'lgan butun quvur modelga qarab 5–50 ms davom etadi.

Ishga tushirish vaqtini optimallashtirish uchun Core ML modelni birinchi foydalanishda kompilyatsiya qiladi. Oldindan kompilyatsiya (precompiled model) sovuq ishga tushirishni 2–3 soniyadan 100–200 ms gacha kamaytiradi. Modelni kompilyatsiya qilishni dastur birinchi ishga tushirilganda emas, balki Xcode da qurilish bosqichida bajarish tavsiya etiladi. Bu, ayniqsa, bir nechta ML modeliga ega ilovalar uchun muhim — masalan, obyekt deteksiyasi + tasniflash + NLP.

Core ML vs ML Kit

Core ML va ML Kit o'xshash on-device ML vazifalarini hal qiladi, ammo turli ekotizimlarga yo'naltirilgan. Core ML Apple Silicon bilan chuqur integratsiyalangan va faqat Apple platformalarini qo'llab-quvvatlaydi. Google dan ML Kit Android va iOS uchun o'zaro platformali yechimdir.

Ekotizimingiz faqat Apple bo'lsa va ANE orqali maksimal unumdorlik kerak bo'lsa Core ML ni tanlang. Agar o'zaro platformalilik yoki konvertatsiyasiz tayyor API kerak bo'lsa — ML Kit amaliyroq bo'ladi.

Amalda ko'plab loyihalar ikkala freymvorkdan foydalanadi: iOS da Core ML yuqori unumdorlik uchun, Android da esa ML Kit yoki TensorFlow Lite. Yagona PyTorch modeli Apple uchun .mlpackage va Android uchun .tflite formatiga konvertatsiya qilinadi, bu ikkala platformada bir xil ML funksionalligini saqlashga imkon beradi. Bu yondashuv DevOps da biroz ko'proq harakat talab qiladi, lekin maksimal auditoriya qamrovini ta'minlaydi.

Core ML va alternativlar o'rtasida tanlashda rivojlanish narxini hisobga oling: Core ML integratsiya uchun kamroq kod talab qiladi (TFLite da 15–20 qatorga nisbatan 3–5 qator Swift), lekin qurilish uchun Mac va Xcode kerak. ML Kit, aksincha, har qanday platformada ishlaydi, lekin Apple Neural Engine ga kirish yo'qligi sababli iOS da kamroq unumdorlik beradi.