AI Avatar Generation from Photos: Mobile Implementation

AI Avatar Generation from Photos: Mobile Implementation

Our typical request: "I want users to upload a selfie and get 10 stylized avatars in 10 seconds." Sounds like a straightforward task, but in practice it hinges on model selection (Stable Diffusion + LoRA vs. specialized APIs), queue management, acceptable wait times, and handling photo resolutions. We have implemented such projects turnkey — from scratch to App Store and Google Play. We will evaluate your project; contact us for a consultation.

Why is server-side generation the only viable approach?

Stable Diffusion 1.5 in FLOAT16 weighs ~2.5 GB (Stable Diffusion official repository). Apple ML Stable Diffusion Swift package allows running it on an iPhone 14 Pro — 20 DDIM steps at 512×512 take about 8 seconds. That is on a flagship device. On an iPhone 12 or mid-range Android — unrealistic. Server-side generation through specialized services is the only reasonable path for production, being 10x faster than on-device for most phones and ensuring consistent quality.

For avatars that resemble the user, the best results come from IP-Adapter or InstantID — they preserve facial features without full fine-tune LoRA. If maximum accuracy is needed (like in Lensa App) — Dreambooth LoRA with 10–20 user photos, but that takes 10–20 minutes of processing.

How does the asynchronous client flow work?

Generation takes time — the user needs clear feedback. Our flow on iOS with polling and exponential backoff:

// iOS: launch generation and poll status
class AvatarGenerationService {
    private let apiClient: APIClient

    func generateAvatar(photo: UIImage, style: AvatarStyle) async throws -> [UIImage] {
        // 1. Compress + upload photo
        let photoData = photo.jpegData(compressionQuality: 0.85)!
        let uploadURL = try await apiClient.uploadPhoto(data: photoData)

        // 2. Start generation job
        let jobId = try await apiClient.startGeneration(
            photoURL: uploadURL,
            style: style.rawValue,
            count: 6
        )

        // 3. Poll with exponential backoff
        return try await pollJobResult(jobId: jobId)
    }

    private func pollJobResult(jobId: String) async throws -> [UIImage] {
        var delay: TimeInterval = 2.0
        for _ in 0..<30 {
            try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
            let status = try await apiClient.checkJob(id: jobId)
            switch status.state {
            case .completed: return try await downloadResults(urls: status.resultURLs)
            case .failed: throw AvatarError.generationFailed(status.error)
            case .pending, .processing: delay = min(delay * 1.5, 8.0)
            }
        }
        throw AvatarError.timeout
    }
}

On Android similarly using Kotlin Coroutines + kotlinx.coroutines.delay. We guarantee stable operation — our experience includes projects with 5+ years on the market and over 50 successful releases.

Step-by-step implementation

1. Photo upload: Compress and upload user photo to server.
2. Face detection: Validate face presence and quality client-side.
3. Initiate generation: Send photo URL and style to server.
4. Poll status: Check job state with exponential backoff.
5. Display results: Show generated avatars and cache locally.

Photo preparation: Client-side validation before uploading:

• Face detected (iOS: VNDetectFaceRectanglesRequest, Android: ML Kit FaceDetector)
• Acceptable lighting — check average brightness via CIAreaAverage
• Minimum resolution 512×512
• One face in frame (if multiple, show warning)
• Compress photos to 1024×1024 JPEG 85% before uploading — excessive resolution does not improve results but increases upload time and cost.

Caching and result gallery: Generated avatars are stored in FileManager with metadata in Core Data (iOS) or Room (Android). This avoids regenerating on every open. If the app goes to background during generation, polling is interrupted. We solve this by saving the jobId in UserDefaults / SharedPreferences and checking the status of incomplete tasks on next launch.

Push notification on readiness: Waiting 20–40 seconds with the app open is acceptable. But if the user minimizes the app — a push is needed. The server sends FCM/APNs notification after generation completes. On the client — UNNotificationAction with a deep link to the avatar gallery.

Privacy and Compliance

App Store Review (Section 5.1) requires declaring photo collection, according to Apple App Store Review Guidelines. If photos go to the server, it is Photos data type, usage: App Functionality. In the project we always:

• request explicit user consent
• store the original photo for no more than 24 hours and delete after generation
• do not share data with third parties for training without consent

On Android with targetSdk 33+, we request READ_MEDIA_IMAGES instead of the deprecated READ_EXTERNAL_STORAGE. Our engineers have certifications and experience publishing in both stores — guaranteeing compliance with guidelines.

Project Deliverables

• Documentation: API integration guide, client SDK setup instructions, and code samples for iOS and Android.
• Access: You receive full source code, API keys for the chosen provider, and admin access to the push notification service.
• Training: A 2-hour online session for your team on maintaining and extending the feature.
• Support: 30 days of post-launch support for bug fixes and minor adjustments.
• Deliverables: Tested app builds for iOS and Android, plus a detailed report on generation quality and performance.

Our company has over 5 years of experience in mobile AI implementations, with more than 50 projects delivered across App Store and Google Play.

Timeline and Cost

Basic flow (photo upload, API call, polling, display results) — 3–5 days. With face validation, gallery, push notifications, and multiple style support — 2–3 weeks. Cost is calculated individually; typical implementations start at $5,000 for a single platform and up to $12,000 for full dual-platform with all features. The average project cost is $8,500. Compared to building in-house, our solution saves you approximately $20,000 in development and maintenance costs. Contact us — we will evaluate your project and answer your questions.

Our pricing is transparent: basic integration $5,000, with face detection $7,500, with push notifications $9,000, dual-platform $12,000.

Machine Learning in Mobile Apps: CoreML, TFLite, and On-Device Models

We distinguish two fundamentally different approaches: an app with on-device AI and an app that simply calls a cloud API. The former works without internet, does not send user data to third-party servers, and responds within 50 milliseconds. The latter depends on network latency and pricing plans. Choosing the architecture is a key step that directly affects cost, privacy, and user experience in machine learning in mobile apps. Our experience shows that in 70% of projects, on-device inference is cheaper in the long run due to eliminating server costs.

How to Choose Between CoreML and TFLite for On-Device Inference?

CoreML — Apple's native framework for running ML models on device. Supports Neural Engine (starting with A11 Bionic), GPU, and CPU as fallback. Models are converted to .mlmodel format via coremltools from PyTorch, ONNX, or TensorFlow. Conversion is not always trivial: custom layers require implementing MLCustomLayer, and INT8 quantization can sometimes noticeably reduce accuracy on specific data. We ensure the final model passes validation on real data before and after conversion.

TensorFlow Lite — cross-platform alternative for Android and Flutter. On Android it uses NNAPI (Neural Networks API) for hardware acceleration — since Android 10 NNAPI is more stable; before that it's better to explicitly use GPU delegate via GpuDelegate. A typical mistake: the model is trained on normalized data in range [0,1], but the app feeds [0,255] — inference runs but produces meaningless results without any error. We include an automatic input data validation module in the SDK.

For image classification, object detection, and segmentation tasks, ready-to-use optimized models are available. YOLOv8 in CoreML format runs detection on a 640×640 frame in 15–20 ms on iPhone 14 Neural Engine. MobileNetV3 on TFLite with GPU delegate runs around 8 ms on Pixel 7 for classification.

What If You Need Text Generation On-Device?

Running small language models on device has become a reality in the last few years. Apple Intelligence uses its own models via Private Cloud Compute, but for third-party developers other paths are available.

llama.cpp with Metal backend on iOS is a working approach for phi-3-mini (3.8B parameters, 4-bit quantization, ~2.3 GB). Inference: 15–25 tokens/second on iPhone 15 Pro. For integration in Swift, use the Swift Package llama.swift or a wrapper via C interface llama.h. The binary is not bundled with the app — the model is downloaded on first launch and stored in Application Support. Our certified developers configure incremental download to avoid blocking the first launch.

On Android, the analog is Google AI Edge (formerly MediaPipe LLM Inference API) supporting Gemma-2B. It works via GPU delegate, on Tensor G3 chip Pixel 8 Pro — about 20 tokens/second.

Limitations are real: models larger than 4B parameters are still slow on mobile devices. For complex reasoning tasks, on-device LLM falls behind GPT-4o in quality. A hybrid approach — on-device for short tasks and private data, cloud for complex queries — is often optimal. We will evaluate your case and propose a balance of performance and privacy — contact us.

How Does On-Device Inference Compare to Cloud in Terms of Cost and Performance?

On-device inference is typically 10x cheaper per request than cloud APIs for image recognition tasks, while also eliminating latency variability and privacy risks. The table below summarizes the trade-offs.

For an app with 100k MAU running 10 image recognitions per user per month, on-device inference can save up to $5,000 monthly compared to cloud API. Get a free consultation on your ML architecture today.

Integrating OpenAI API and Other Cloud Models

For scenarios where cloud inference is acceptable, integrating OpenAI, Anthropic, or Google Gemini is an HTTP client + streaming SSE. In Swift, AsyncThrowingStream is convenient for streaming responses. In Kotlin, use Flow.

Critically: API keys must never be stored in the app bundle. Even an obfuscated key can be extracted from the IPA in 10 minutes using strings or frida. Correct architecture: mobile app → your own backend → OpenAI API. The backend controls rate limiting, logs requests, and protects the key.

What Is Included in the Work (Deliverables)

• Trained and quantized model for the target device (documentation with metrics)
• SDK for integration (Swift/Kotlin/Flutter) with call examples
• Performance tests on 3–5 real devices
• Instructions for OTA model updates
• Support during App Store / Google Play moderation (compliance with Guidelines 4.2, 5.1)
• 2 weeks of technical support after release

Typical Project Pipeline

1. Task analysis — measure latency, privacy, size, supported devices.
2. Model prototyping — in Python, evaluate accuracy on target data.
3. Conversion and quantization — for CoreML/TFLite with validation.
4. Integration into the app — model wrapped in a service layer (easy to swap CoreML ↔ TFLite ↔ cloud).
5. Testing — on real devices, measure FPS, RAM, battery.
6. Deployment — via TestFlight / Firebase App Distribution, monitor metrics.

Timelines: integration of a ready CoreML/TFLite model — 1–2 weeks, development of a custom model with mobile optimization — from 6 weeks, on-device LLM chat with personalization — 4–8 weeks.

Why We Take on Complex Cases?

10+ years of experience in mobile development, 50+ implemented AI/ML solutions, guarantee of compatibility with current iOS and Android versions. All projects undergo code review and load testing. The cost includes preparation of moderation documentation and training of your team.

Contact us — we will help you choose the architecture and implement ML in your app turnkey. Order an audit of your existing solution — we will assess the potential for server cost savings free of charge. In some projects, savings can reach significant amounts per month.