שילוב ML במכשיר עם ONNX Runtime לאפליקציות מובייל

תארו לעצמכם אפליקציה לנייד שחייבת לעבד תמונות, טקסט או קול ללא גישה לרשת. זמן השהייה של השרת אינו מקובל, פרטיות הנתונים היא קריטית. כל מגה-בייט נוסף של תעבורה עולה למשתמש. למידת מכונה על-המכשיר פותרת את הבעיות האלה, וONNX Runtime הוא הכלי המרכזי לפריסה חוצת-פלטפורמות. אנו משלבים אותו כך שהמודל רץ באותה מהירות גם ב-iOS וגם ב-Android. המעבר לעיבוד על-המכשיר יכול להפחית את עלויות תשתית השרת בעד 90%, ולחסוך מאות דולרים בחיסכון חודשי של כ-9–13 דולרים בעומסים גבוהים.

ONNX Runtime Mobile מושך בטיעון אחד: מודל אחד, שתי פלטפורמות. המירו את PyTorch או TensorFlow ל-ONNX, הוסיפו onnxruntime-android ו-onnxruntime-objc, והריצו את אותו קובץ .onnx. בפועל, ההבדל בספקי הביצוע בין iOS ל-Android עדיין דורש קוד ספציפי לפלטפורמה, אבל המודל עצמו מאוחד. הניסיון שלנו: מעל 5 שנים ב-ML לנייד, עשרות פרויקטים של inference על-המכשיר. צרו קשר להערכת המודל שלכם ולהצעת מחיר ראשונית.

איך להכין מודל לנייד

ייצוא ONNX סטנדרטי מ-PyTorch:

import torch
import onnx
from onnxsim import simplify  # onnx-simplifier для оптимизации графа

model = MyModel()
model.eval()
dummy = torch.zeros(1, 3, 224, 224)
torch.onnx.export(
    model,
    dummy,
    "model.onnx",
    opset_version=17,
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}}
)

# Упрощение графа — убирает лишние reshape, transpose, делает граф чище
model_onnx = onnx.load("model.onnx")
model_simplified, check = simplify(model_onnx)
onnx.save(model_simplified, "model_simplified.onnx")

בנוסף לנייד — קוונטיזציה באמצעות import torch import onnx from onnxsim import simplify # onnx-simplifier для оптимизации графа model = MyModel(); model.eval() dummy = torch.zeros(1, 3, 224, 224) torch.onnx.export( model, dummy, "model.onnx", opset_version=17, input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}} ) # Упрощение графа — убирает лишние reshape, transpose, делает граф чище model_onnx = onnx.load("model.onnx") model_simplified, check = simplify(model_onnx) onnx.save(model_simplified, "model_simplified.onnx") :

from onnxruntime.quantization import quantize_dynamic, QuantType
quantize_dynamic(
    "model_simplified.onnx",
    "model_int8.onnx",
    weight_type=QuantType.QInt8
)
# Размер модели уменьшается в ~4× против FP32

איזה ספק ביצוע מספק ביצועים מקסימליים?

Android: NNAPI לעומת XNNPACK

ב-Android, בחירת ספק הביצוע תלויה בחומרה. NNAPI מפנה פעולות ל-NPU/DSP, ומספק האצה של עד פי 2 בפעולות נתמכות. XNNPACK הוא backend CPU מותאם המשתמש בהוראות SIMD, ומאיץ עד פי 2 על CPU אך ללא גישה ל-NPU. בפרויקט עם זיהוי עצמים על MediaTek Dimensity, קיבלנו 45 ms עם NNAPI לעומת 80 ms עם XNNPACK. אנו ממליצים להשתמש ב-NNAPI למכשירים עם NPU, ו-XNNPACK כגיבוי.

iOS: ספק ביצוע CoreML

onnxruntime.quantization ב-iOS 13+ מפנה פעולות נתמכות ל-Core ML, ומקבל גישה ל-ANE. פעולות שאינן נתמכות על ידי Core ML רצות אוטומטית על CPU. בבדיקות על iPhone 12, קיבלנו שיפור של 35% במהירות לעומת CPU על ResNet-50. CoreML EP נוח לפריסה מהירה חוצת-פלטפורמות, אבל לביצועים מקסימליים, שקלו Core ML מקורי.

מתי ONNX Runtime עדיף על פורמטים מקוריים?

השתמשו ב-ONNX Runtime לאב-טיפוס, פרויקטים חוצי-פלטפורמות, מודלים עם פעולות מותאמות אישית ש-coremltools לא יכול להמיר, ועדכוני מודל תכופים ללא בנייה מחדש של צינור ההמרה. אם אתם צריכים ביצועים מקסימליים בפלטפורמה אחת, בחרו בפורמט המקורי: ב-iOS — Core ML עם האצת ANE מלאה (בדרך כלל מהיר ב-20–40% מ-ORT+CoreML EP), ב-Android — TFLite + GPU Delegate (לפעמים מהיר יותר מ-ORT+NNAPI). לפריסה בפלטפורמה אחת וביצועים קריטיים, הפורמט המקורי עדיף.

איך לשלב ONNX Runtime ב-Android וב-iOS

Android: הגדרה ו-Inference

// build.gradle
implementation("com.microsoft.onnxruntime:onnxruntime-android:1.18.0")

// Создание сессии
val sessionOptions = OrtSession.SessionOptions().apply {
    // NNAPI Execution Provider для Android NPU/DSP
    addNnapi(NNAPIFlags.USE_FP16) // FP16 режим в NNAPI
    // Или: addXnnpack(mapOf()) для XNNPACK (CPU SIMD)
    setOptimizationLevel(OrtSession.SessionOptions.OptLevel.ALL_OPT)
    setIntraOpNumThreads(4)
}

val env = OrtEnvironment.getEnvironment()
val session = env.createSession(
    context.assets.open("model_simplified.onnx").readBytes(),
    sessionOptions
)

// Инференс
val inputTensor = OnnxTensor.createTensor(
    env,
    FloatBuffer.wrap(preprocessedArray),
    longArrayOf(1, 3, 224, 224)
)
val results = session.run(mapOf("input" to inputTensor))
val outputArray = (results["output"]?.value as Array<FloatArray>)[0]

// Освобождение ресурсов — обязательно
inputTensor.close()
results.close()

דליפות מ-from onnxruntime.quantization import quantize_dynamic, QuantType quantize_dynamic( "model_simplified.onnx", "model_int8.onnx", weight_type=QuantType.QInt8 ) # Размер модели уменьшается в ~4× против FP32 ו-appendCoreMLExecutionProvider שלא נסגרו הן נפוצות. ב-Kotlin, השתמשו בבלוק // build.gradle implementation("com.microsoft.onnxruntime:onnxruntime-android:1.18.0") // Создание сессии val sessionOptions = OrtSession.SessionOptions().apply { // NNAPI Execution Provider для Android NPU/DSP addNnapi(NNAPIFlags.USE_FP16) // FP16 режим в NNAPI // Или: addXnnpack(mapOf()) для XNNPACK (CPU SIMD) setOptimizationLevel(OrtSession.SessionOptions.OptLevel.ALL_OPT) setIntraOpNumThreads(4) } val env = OrtEnvironment.getEnvironment() val session = env.createSession( context.assets.open("model_simplified.onnx").readBytes(), sessionOptions ) // Инференс val inputTensor = OnnxTensor.createTensor( env, FloatBuffer.wrap(preprocessedArray), longArrayOf(1, 3, 224, 224) ) val results = session.run(mapOf("input" to inputTensor)) val outputArray = (results["output"]?.value as Array<FloatArray>)[0] // Освобождение ресурсов — обязательно inputTensor.close() results.close() : OnnxTensor.

iOS: שילוב ObjC/Swift

// Package.swift или Podfile: pod 'onnxruntime-objc'
import onnxruntime_objc

// Настройка
let env = try ORTEnv(loggingLevel: ORTLoggingLevel.warning)
let options = try ORTSessionOptions()
try options.setIntraOpNumThreads(4)

// На iOS — CoreML Execution Provider
try options.appendCoreMLExecutionProvider(withFlags: [.enableOnSubgraphs])

let session = try ORTSession(
    env: env,
    modelPath: Bundle.main.path(forResource: "model_simplified", ofType: "onnx")!,
    sessionOptions: options
)

// Подготовка входа
let inputShape: [NSNumber] = [1, 3, 224, 224]
let inputData = Data(bytes: preprocessedFloats, count: preprocessedFloats.count * MemoryLayout<Float>.size)
let inputTensor = try ORTValue(
    tensorData: NSMutableData(data: inputData),
    elementType: .float,
    shape: inputShape
)

let outputs = try session.run(
    withInputs: ["input": inputTensor],
    outputNames: ["output"],
    runOptions: nil
)

let outputTensor = outputs["output"]!
let outputData = try outputTensor.tensorData() as Data
let floats = outputData.withUnsafeBytes { Array($0.bindMemory(to: Float.self)) }

למה קוונטיזציה קריטית ל-Inference בנייד

קוונטיזציה מקטינה את גודל המודל פי 4 (50 MB → 12 MB), מורידה את צריכת הזיכרון, ומאיצה את ה-inference על CPU ב-30-40%. קוונטיזציה דינמית אינה דורשת נתוני כיול אך מספקת שיפור מהירות מעט נמוך יותר מסטטית. בפועל, אנו משתמשים בקוונטיזציה סטטית עם מערך נתונים מייצג — היא נותנת שיפור יציב ללא אובדן דיוק משמעותי (0.5-2%).

מה אם פעולה אינה נתמכת?

# Проверить, какие операции поддерживает NNAPI Execution Provider
python -m onnxruntime.tools.check_nnapi_supported_ops --model model.onnx
# Если операция не поддерживается — она выполнится на CPU (fallback)
# Это не краш, но может обнулить всё ускорение от NNAPI

כדי לזהות צווארי בקבוק, השתמשו ב-ORT Profiling API. הוא מתעד תזמון לכל אופרטור. הפעילו דרך OrtSession.Result — זה יוצר JSON שניתן לצפייה ב-use {} של Chrome. פרופילינג במכשירי יעד עוזר לבחור את ספק הביצוע האופטימלי. לדוגמה, בפרויקט אחד עברנו מ-NNAPI ל-XNNPACK עבור מודל עם 80% פעולות לא נתמכות, והפחתנו את ה-inference מ-300 ms ל-120 ms.

מה העבודה שלנו כוללת

• ייצוא ופישוט גרף ONNX, קוונטיזציה ל-Int8.
• שילוב ONNX Runtime ב-iOS וב-Android עם ספקי ביצוע אופטימליים.
• פרופילינג ביצועים על צי של 10+ מכשירים אמיתיים, כולל ישנים יותר.
• השוואה לפורמטים מקוריים (Core ML, TFLite) והמלצה על הפתרון הטוב ביותר.
• תיעוד לבנייה ועדכון המודל, קוד מקור לשילוב.
• הבטחת פעולה יציבה ונעילת זמן inference.

הניסיון שלנו ב-ML לנייד

מעל 5 שנים בפריסת ML על-המכשיר ביישומים מסחריים — מקמעונאות ועד בריאות. השלמנו 20+ פרויקטים עם ONNX Runtime, Core ML ו-TFLite. המהנדסים שלנו מחזיקים בהסמכות של Apple ו-Google. אנו מבטיחים שהמודל יעבוד על כל המכשירים המוצהרים. קבלו ייעוץ על שילוב ONNX Runtime — נבדוק את הפרויקט שלכם ונציע פתרון סוהר אופטימלי. הזמינו שילוב ONNX Runtime לאפליקציה שלכם — בואו נדון בפרטים.

הערכות זמנים

שילוב ONNX Runtime בסיסי חוצה-פלטפורמות: 2–3 שבועות. עם אופטימיזציה של EP, פרופילינג ובדיקות על צי מכשירים: 4–6 שבועות. העלות מחושבת באופן אישי לאחר ניתוח המודל ודרישות הביצועים.