הגדלת תמונות בינה מלאכותית באפליקציות מובייל

import CoreML
import Vision

class ImageUpscaler {
    private let model: VNCoreMLModel

    init() throws {
        let config = MLModelConfiguration()
        config.computeUnits = .cpuAndNeuralEngine // Используем Neural Engine
        let coreMLModel = try RealESRGAN(configuration: config)
        model = try VNCoreMLModel(for: coreMLModel.model)
    }

    func upscale(_ image: UIImage) async throws -> UIImage {
        guard let cgImage = image.cgImage else {
            throw UpscaleError.invalidInput
        }

        return try await withCheckedThrowingContinuation { continuation in
            let request = VNCoreMLRequest(model: model) { request, error in
                if let error = error {
                    continuation.resume(throwing: error)
                    return
                }
                guard let results = request.results as? [VNPixelBufferObservation],
                      let outputBuffer = results.first?.pixelBuffer else {
                    continuation.resume(throwing: UpscaleError.noOutput)
                    return
                }
                let ciImage = CIImage(cvPixelBuffer: outputBuffer)
                let context = CIContext()
                guard let outputCG = context.createCGImage(ciImage, from: ciImage.extent) else {
                    continuation.resume(throwing: UpscaleError.conversionFailed)
                    return
                }
                continuation.resume(returning: UIImage(cgImage: outputCG))
            }
            request.imageCropAndScaleOption = .scaleFit
            let handler = VNImageRequestHandler(cgImage: cgImage)
            try? handler.perform([request])
        }
    }
}

Real-ESRGAN הוא המודל האיכותי ביותר להגדלה פי 4. קיימות גרסאות מומרות ל-Core ML. מגבלה: Real-ESRGAN מצפה לגודל קלט קבוע (בדרך כלל 256×256 או 512×512). לתמונות גדולות יותר, אנו חותכים לריבועים עם חפיפה (16–32 פיקסלים) כדי למנוע תפרים. (Real-ESRGAN: Xintao Wang et al., מאגר GitHub)

func upscaleTiled(_ image: UIImage, tileSize: Int = 256, overlap: Int = 16) async throws -> UIImage {
    let tiles = splitIntoTiles(image: image, tileSize: tileSize, overlap: overlap)
    let upscaledTiles = try await withThrowingTaskGroup(of: (Int, Int, UIImage).self) { group in
        for (row, col, tile) in tiles {
            group.addTask {
                let upscaled = try await self.upscale(tile)
                return (row, col, upscaled)
            }
        }
        var results: [(Int, Int, UIImage)] = []
        for try await result in group {
            results.append(result)
        }
        return results
    }
    return mergeTiles(upscaledTiles, originalSize: image.size, scaleFactor: 4, overlap: overlap)
}

באייפון 15 Pro עם Neural Engine: 512×512 → 2048×2048 לוקח כ-800 אלפיות השנייה. 1024×1024 המחולק לריבועים לוקח 2–4 שניות.

On-Device: ONNX Runtime באנדרואיד

Real-ESRGAN בפורמט ONNX (~15 מגה-בייט למודל הקטן):

class OnnxUpscaler(context: Context) {
    private val session: OrtSession

    init {
        val env = OrtEnvironment.getEnvironment()
        val options = OrtSession.SessionOptions().apply {
            addNnapi() // Используем NNAPI для ускорения
        }
        val modelBytes = context.assets.open("realesrgan_x4.onnx").readBytes()
        session = env.createSession(modelBytes, options)
    }

    fun upscale(bitmap: Bitmap): Bitmap {
        // Конвертируем Bitmap в float тензор [1, 3, H, W], нормализуем в [0, 1]
        val inputTensor = bitmapToTensor(bitmap)
        val inputName = session.inputNames.first()!!
        val output = session.run(mapOf(inputName to inputTensor))
        val outputTensor = output[0].value as Array<*>
        // Конвертируем тензор обратно в Bitmap
        return tensorToBitmap(outputTensor, bitmap.width * 4, bitmap.height * 4)
    }
}

NNAPI במכשירי אנדרואיד מודרניים מספק מהירות גבוהה פי 2–4 מ-CPU. ב-Snapdragon 8 Gen 2 — 512×512 בכ-1.2 שניות.

APIs ענן

כאשר On-Device איטי מדי או שצריך גורם הגדלה גבוה יותר (×8, ×16): Replicate — Real-ESRGAN:

let body: [String: Any] = [
    "version": "...", // real-esrgan model hash
    "input": [
        "image": "data:image/jpeg;base64,\(base64Image)",
        "scale": 4,
        "face_enhance": true // GFPGAN для улучшения лиц
    ]
]

import CoreML import Vision class ImageUpscaler { private let model: VNCoreMLModel init() throws { let config = MLModelConfiguration() config.computeUnits = .cpuAndNeuralEngine // Используем Neural Engine let coreMLModel = try RealESRGAN(configuration: config) model = try VNCoreMLModel(for: coreMLModel.model) } func upscale(_ image: UIImage) async throws -> UIImage { guard let cgImage = image.cgImage else { throw UpscaleError.invalidInput } return try await withCheckedThrowingContinuation { continuation in let request = VNCoreMLRequest(model: model) { request, error in if let error = error { continuation.resume(throwing: error) return } guard let results = request.results as? [VNPixelBufferObservation], let outputBuffer = results.first?.pixelBuffer else { continuation.resume(throwing: UpscaleError.noOutput) return } let ciImage = CIImage(cvPixelBuffer: outputBuffer) let context = CIContext() guard let outputCG = context.createCGImage(ciImage, from: ciImage.extent) else { continuation.resume(throwing: UpscaleError.conversionFailed) return } continuation.resume(returning: UIImage(cgImage: outputCG)) } request.imageCropAndScaleOption = .scaleFit let handler = VNImageRequestHandler(cgImage: cgImage) try? handler.perform([request]) } } } מריץ GFPGAN על גבי Real-ESRGAN — חשוב לפורטרטים כדי למנוע עיוותים. Stability AI Upscale API:

val requestBody = MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("image", "photo.jpg", imageFile.asRequestBody("image/jpeg".toMediaType()))
    .addFormDataPart("output_format", "png")
    .build()

Stability AI מחזיר PNG עם הגדלה פי 4 באמצעות Creative Upscaler (מבוסס SD, מוסיף פרטים) או Conservative Upscaler (פחות שינויים מהמקור).

איך לשלב הגדלת AI: שלב אחר שלב

1. בחירת מודל — Real-ESRGAN ל-On-Device, API ענן לאיכות מקסימלית.
2. המרה לפורמט הנדרש — Core ML ל-iOS, ONNX לאנדרואיד.
3. יישום חיתוך לריבועים — חלוקה לריבועים עם חפיפה, עיבוד מקבילי.
4. שילוב ממשק משתמש — מחוון התקדמות, מחוון לפני/אחרי.
5. בדיקות — במכשירים שונים, עם תמונות מקור מגוונות.

בחירת גישה

בחירה בין הגדלה On-Device לענן

On-Device מהיר וחינמי אך מוגבל על ידי ביצועי המכשיר וגודל המודל. APIs ענן מציעים איכות גבוהה יותר וגורמי הגדלה גדולים יותר אך מוסיפים זמן השהיה ועלות. אם האפליקציה שלך מיועדת לתרחישים ללא אינטרנט או חוסכת רוחב פס, בחר On-Device. לאיכות מקסימלית בפורטרטים או תמונות ישנות, ענן מוצדק. אנו מיישמים גישה היברידית שבוחרת אוטומטית את הנתיב הטוב ביותר.

השוואה: הגדלה On-Device לעומת ענן

למה Real-ESRGAN עדיף על אלגוריתמים סטנדרטיים

Real-ESRGAN מספק איכות גבוהה פי 2–3 מהגדלה ביקובית: הוא משחזר מרקמים, מפחית רעש, ומחדד. בשילוב עם GFPGAN לפנים, עיוותים כמעט מבוטלים. זה מוכח בבדיקות מקיפות ומאושר על ידי המאמר המקורי. אנו משתמשים במודל זה ברוב הפרויקטים, כולל מוצרים עם אלפי משתמשים.

UX: התקדמות והשוואה

הגדלה On-Device צריכה להציג התקדמות חיתוך לריבועים: "מעבד 3 מתוך 12 ריבועים." המשתמש לא חווה הקפאות.

לאחר השלמה, מחוון אינטראקטיבי לפני/אחרי (MagnificationGesture ב-iOS, תצוגת מגע מותאמת באנדרואיד) הוא ממשק סטנדרטי לכל כלי לשיפור תמונות.

מה כלול

• ניתוח דרישות ובחירת גישה אופטימלית (On-Device / ענן / היברידי)
• פיתוח מודול הגדלה מקורי (Swift / Kotlin)
• שילוב המודל הנבחר (Core ML, ONNX, API ענן)
• חיתוך לריבועים עם חפיפה והצגת התקדמות
• מחוון לפני/אחרי
• בדיקות במכשירים אמיתיים עם מפרטים שונים
• תיעוד ומסירת קוד מקור
• חודש תמיכה לאחר השקה

לוח זמנים משוער

הגדלה On-Device עם חיתוך לריבועים ומחוון התקדמות — 5–8 ימים. הגדלת ענן + שיפור פנים + מחוון לפני/אחרי + שמירה לגלריה — 8–12 ימים. היברידי עם הערכת איכות ובחירת נתיב — 3–5 ימים נוספים.

צור קשר להערכת פרויקט: קבל ייעוץ על בחירת גישה ועלות משוערת.