iOS 27 Foundation Models: Dynamic Profiles ve Değerlendirme

Apple'ın Foundation Models framework'ü iOS 27 ile birlikte tek bir on-device oturumun ötesine geçti: artık bir session içinde model ve talimat setini çalışma zamanında değiştirebiliyor, kendi model sağlayıcını protokol üzerinden takabiliyor ve prompt'larını sistematik biçimde değerlendirebiliyorsun. Bu yazı Apple Foundation Models framework 2026 güncellemelerinden yalnızca WWDC26 sonrası eklenen üç büyük yeteneğe odaklanıyor: Dynamic Profiles, çoklu-modal prompting ve Performance and evaluation araçları. Temel session kurulumu, @Generable ve streaming API'sini daha önce Apple Foundation Models: On-Device LLM Framework yazısında işledik; burada onları tekrar etmiyoruz, doğrudan üretim senaryolarına, gerçek API imzalarına ve iOS 27 GA sonrası test kontrol listesine geçiyoruz.

💡 Pro Tip: DynamicProfileBuilder tek-aktif-profil kısıtını derleme zamanında zorluyor — paralel if blokları yerine if/else ifadeleri kullan ki derleyici bu kısıtı senin yerine doğrulasın; geçiş mantığını en baştan tek profil döndüren bir ifade olarak kur.

İçindekiler

• iOS 27 ile framework nereye geldi
• Neden bu üçü öncelikli
• Language Model protocol: kendi sağlayıcını takmak
• Ne zaman kendi sağlayıcını takmalısın
• Dynamic Profiles ile oturum içi model/araç değişimi
• Çoklu-modal prompt: Attachment ile görsel analizi
• Pratikte ne değişiyor
• Prompt değerlendirme (Performance and evaluation) ile regresyon yakalama
• On-device mi Private Cloud Compute mu
• Seçim kriteri
• iOS 27 GA sonrası benimseme ve test kontrol listesi
• Geçiş sırası
• SSS
• Apple Foundation Models framework'te Dynamic Profiles ne işe yarar?
• iOS'ta üçüncü parti bir LLM sağlayıcısı Language Model protocol ile nasıl bağlanır?
• On-device model çıktısı nasıl değerlendirilir ve regresyon nasıl yakalanır?
• iOS 27'de Foundation Models ile ne değişti?
• SystemLanguageModel ile PrivateCloudComputeLanguageModel arasında context penceresi farkı ne kadar?
• Sonuç
• Kaynaklar

iOS 27 ile framework nereye geldi

Foundation Models framework'ünün resmi referans sayfasındaki "What's new" bölümü üç yeni makale (ve üç WWDC26 oturumu) listeliyor. Makaleler: Private Cloud Compute ile sunucu taraflı zeka ekleme, talimat ve profillerle dinamik oturumlar kurma, ve görselleri çoklu-modal prompting ile analiz etme. Bu üç başlık iOS 27'nin Foundation Models tarafındaki asıl deltasını oluşturuyor — üçünü de bu yazıda sırayla açıyoruz.

iOS 27, WWDC26'da (8-12 Haziran 2026) duyurulan yeniliklerin ardından 14 Eylül 2026'da genel kullanıma açıldı. GA sürümü bu tarihte yayınlandığı için aşağıdaki API'ler kararlı sürümde kullanılabilir durumda ve beta-flag'e ihtiyaç duymuyor.

Neden bu üçü öncelikli

Apple'ın kendi sıralaması tesadüfi değil: Private Cloud Compute context penceresini büyütüyor, Dynamic Profiles aynı oturumda birden fazla görev moduna izin veriyor, çoklu-modal prompting ise metin-only sınırını kaldırıyor. Üçü birlikte, tek bir LanguageModelSession'ı üretim uygulamasının farklı ekranlarında yeniden kurmak zorunda kalmadan yeniden kullanılabilir hale getiriyor.

Üç makalenin resmi dokümandaki başlıklarını ve bu yazıda hangi bölümde işlendiğini aşağıda özetledim:

Bu üçünün dışında, Custom language model provider ve Performance and evaluation bölümleri "What's new" listesinde ayrı birer madde olarak durmuyor ama ikisi de aynı dokümantasyon ağacının parçası ve üretim kararlarını doğrudan etkiliyor — bu yüzden onları da ayrı başlıklar olarak ele alıyorum.

Language Model protocol: kendi sağlayıcını takmak

Foundation Models artık yalnızca Apple'ın kendi modelleriyle sınırlı değil. Framework, protocol LanguageModel: Sendable adında hafif bir protokol sunuyor; dokümanda birebir şöyle tarif ediliyor: "Implement this protocol to create a bridge between a model and the framework." Sağlayıcı tarafında ağır işi bir Executor üstleniyor — framework tiplerini platforma özgü isteklere çeviriyor ve sonuçları LanguageModelExecutorGenerationChannel üzerinden akıtıyor.

1import FoundationModels
2 
3// Framework bildirimi: protocol LanguageModel: Sendable
4// (gereksinimleri dokümanda: capabilities + Executor konfigürasyonu)
5// Sağlayıcını taktığında çağıran tarafta tek satır değişiyor:
6let session = LanguageModelSession(model: MyCustomServerLanguageModel())

Bu API yüzeyinin en pratik yanı, session.respond(to:) çağrısının sağlayıcı ne olursa olsun aynı kalması. Apple'ın kendi conforming tipleri SystemLanguageModel (on-device) ve PrivateCloudComputeLanguageModel (sunucu taraflı) da bu protokole uyuyor — yani kendi sağlayıcın ile Apple'ın modelleri arasında geçiş yaparken çağıran kodda değişiklik gerekmiyor, yalnızca model: parametresi değişiyor.

Ne zaman kendi sağlayıcını takmalısın

Kurum içi bir fine-tune edilmiş model, üçüncü parti bir API veya regülasyon gereği belirli bir bölgede barındırılması gereken bir servisin varsa, LanguageModel protokolü seni Apple'ın session/tool-calling/streaming altyapısından vazgeçmeden bu modele bağlıyor. Dağıtım tarafında sağlayıcı genelde bir Swift Package olarak paketlenip uygulamaya eklenir.

Dynamic Profiles ile oturum içi model/araç değişimi

Composing dynamic sessions with instructions and profiles makalesi üç katmanlı bir mimari tanımlıyor. Katmanları dokümandaki tanımlarıyla aktarıyorum: "Dynamic instructions: Re-evaluate before every model request and supply the instructions and tools needed at that time." "Profiles: Associate dynamic instructions with session-level properties, like which model to use and the reasoning level." "Dynamic profiles: Orchestrates transitions between multiple profiles and maintains one active profile at a time."

Yani en alt katmanda talimatların kendisi her istekte yeniden değerlendiriliyor:

1import FoundationModels
2 
3struct PresentationInstructions: DynamicInstructions {
4    var body: some DynamicInstructions {
5        // Kullanıcının o anki ekran bağlamına göre talimat metnini üret.
6        Instructions("Sunumunu iyileştirmene yardım et.")
7    }
8}
9 
10let session = LanguageModelSession(
11    dynamicInstructions: PresentationInstructions()
12)

Bir üst katmanda Profile, talimatları model seçimi, sıcaklık ve reasoning seviyesi gibi oturum düzeyi ayarlarla eşliyor:

1Profile {
2    // Yaratıcı bir görev için gereken talimatlar ve araçlar.
3}
4// Üst profilde oluşturduğun PCC modeli örneğini kullan.
5.model(pccModel)
6// Şiir sevenlerde daha yüksek yaratıcılık sıcaklığı kullan.
7.temperature(likesPoetry ? 0.8 : 0.1)
8// Astronomi sevenlerde daha derin reasoning uygula.
9.reasoningLevel(likesAstronomy ? .deep : .light)

reasoningLevel'in alabileceği değerler ContextOptions.ReasoningLevel enum'unda tanımlı ve dört tane: deep, light, moderate ve custom(_:).

En üstte LanguageModelSession.DynamicProfile bir protokol; birden fazla profil arasındaki geçişi yönetmek için bu protokole uyan bir tip yazıyor ve body'sinde profilleri if/else ifadeleriyle seçiyorsun — derleyici tek-aktif-profil kısıtını bu sayede doğruluyor:

1import FoundationModels
2 
3struct PresentationProfile: LanguageModelSession.DynamicProfile {
4    // Sunucu modeline bir örnek oluştur.
5    var pccModel = PrivateCloudComputeLanguageModel()
6 
7    // Profilin veri kaynağı.
8    var isEditingImage = true
9    var isEditingAnimation = false
10 
11    // Mevcut duruma göre hangi profilin yükleneceğini belirle.
12    var body: some LanguageModelSession.DynamicProfile {
13        if isEditingImage {
14            Profile {
15                Instructions("Görsel düzenleme adımlarında yardımcı ol.")
16            }
17        } else if isEditingAnimation {
18            Profile {
19                Instructions("Animasyon zamanlamasını iyileştir.")
20            }
21            .model(pccModel)
22            .temperature(0.2)
23            .reasoningLevel(.light)
24        } else {
25            Profile {
26                Instructions("Sunumunu iyileştirmene yardım et.")
27            }
28            .temperature(0.8)
29        }
30    }
31}
32 
33let session = LanguageModelSession(profile: PresentationProfile())

Sohbet geçmişini profil değişse bile makul bir uzunlukta tutmak için historyTransform modifier'ını profilin üzerine uyguluyorsun:

1Profile {
2    Instructions("Kitap fikirleri üretmene yardım et.")
3}
4.historyTransform { history in
5    // Modele istek atmadan önce yerel bir dönüşüm uygula; bu dönüşüm
6    // transkriptin global durumunu değiştirmez.
7    Array(history.suffix(20))
8}

Profil geçişlerinde tekrar eden davranışı soyutlamak istersen protocol DynamicProfileModifier devreye giriyor; tek gereksinimi func body(content: Self.Content) -> Self.Body imzasına sahip bir tip tanımlamak. Doküman bunu, model seçimi ve sıcaklık gibi traitleri tek bir self-contained modifier'da toplamanın yolu olarak tarif ediyor. Pratikte bunu, örneğin "araştırma modu" ile "özetleme modu" arasında ortak bir düşük-sıcaklık + onResponse loglama davranışını tek yerde tanımlamak için kullanabilirsin; dokümandaki DebugProfileModifier örneği tam olarak bunu yapıyor, .temperature(0.0) ve .onResponse { ... } traitlerini tek bir modifier'da birleştiriyor.

Çoklu-modal prompt: Attachment ile görsel analizi

Analyzing images with multimodal prompting makalesi, görselleri metinle birlikte prompt'a eklemek için Attachment struct'ını tanımlıyor. Dokümandaki örnek, metin prompt'unu ve iki görseli aynı istekte birleştiriyor; gerektiğinde yönlendirme (orientation) bilgisini de veriyorsun.

1import CoreGraphics
2import FoundationModels
3 
4func compareImages(imageOne: CGImage, imageTwo: CGImage) async throws -> String {
5    let session = LanguageModelSession()
6    let response = try await session.respond {
7        "Compare these two images by using three bullet points:"
8 
9        Attachment(imageOne)
10 
11        // Görselde uygulanmış bir rotasyon yoksa, modele göndermeden önce
12        // orientation ile dönüşüm yaptır.
13        Attachment(imageTwo, orientation: .right)
14    }
15    return response.content
16}

Dokümanın verdiği örnek senaryolar dört ana kullanım biçimini kapsıyor: görsel sınıflandırma, bir doküman fotoğrafını özetleme, erişilebilirlik için görsel açıklaması üretme ve bir buzdolabı fotoğrafından tarif fikri çıkarma. Bu dördü de aynı Attachment API'si üzerinden çalışıyor. Dokümanın "Use built-in image analysis tools" bölümü şunu ekliyor: "The Vision framework provides optical character recognition (OCR) and barcode tools that you can add to a session in the Foundation Models framework." Yani metin çıkarman gerekiyorsa OCRTool'u, barkod okuman gerekiyorsa BarcodeReaderTool'u aynı oturuma ekleyebilirsin; tool kullanırken Attachment/label(_:) vermen öneriliyor.

Pratikte ne değişiyor

Önceki temel yazımızda yalnızca metin prompt'ları ile @Generable çıktı üretimini görmüştük. Çoklu-modal prompting ile artık aynı LanguageModelSession üzerinden, kullanıcının kamerayla çektiği bir fotoğrafı doğrudan prompt'a ekleyip yapılandırılmış bir yanıt (örneğin bir tarif nesnesi veya erişilebilirlik açıklaması metni) alabiliyorsun; metin çıkarma/barkod gerektiren akışlarda ise aynı oturuma Vision tool'unu ekliyorsun.

Prompt değerlendirme (Performance and evaluation) ile regresyon yakalama

Foundation Models referansında ilgili konu grubunun resmi adı "Performance and evaluation" ve bu bölüm üç makaleden oluşuyor: Evaluating prompts to measure performance and improve model responses, Evaluating language model responses, ve Analyzing the runtime performance of your Foundation Models app. Ortadaki madde seni iOS 27 ile gelen ayrı bir framework'e, Evaluations'a götürüyor; Apple'ın Private Cloud Compute rehberi de aynı aracı işaret ediyor: "Start with the on-device model and evaluate it with the Evaluations framework." Yani Foundation Models tarafındaki rehber neyi test edeceğini, Evaluations ise bunu veri setleri ve metriklerle nasıl ölçeceğini anlatıyor. Evaluation makalesinden birebir alıntı: "Prompt evaluation is the practice of thoroughly testing your prompts against real-world scenarios to measure quality, catch failures early, and confidently improve your feature over time."

Bu tanımın pratik sonucu şu: Dynamic Profiles ile bir profili (örneğin reasoningLevel(.deep) kullanan araştırma modunu) değiştirdiğinde, o profile bağlı prompt'ları gerçek dünya senaryolarına karşı yeniden test etmen gerekiyor — aksi halde bir profil geçişinin diğerini sessizce bozup bozmadığını fark edemezsin. Apple bu iş akışını Python tarafında da destekliyor: dokümanda github.com/apple/python-apple-fm-sdk adlı Python Foundation Models SDK'sına referans veriliyor, yani bu setleri Swift dışında da kurabiliyorsun; ben CI'a bağlamayı tercih ederim.

Runtime performans tarafında ise Instruments üzerinden prompt/yanıt döngüsünün token tüketimini ve yanıt sürelerini incelemek mümkün — bu, özellikle Private Cloud Compute'a geçince context penceresinin büyümesiyle artan gecikmeyi ölçmek için önemli.

On-device mi Private Cloud Compute mu

Adding server-side intelligence with Private Cloud Compute makalesi, iki model arasındaki farkı bir tabloda özetliyor. Aşağıdaki tablo bu farkları birebir aktarıyor:

Platform şartı dokümanda net: "PrivateCloudComputeLanguageModel is available on iOS 27, macOS 27, watchOS 27, and visionOS 27 or later." Yani bu modele geçiş, availability guard'ı olmadan derlenmiyor:

1func makeSession() -> LanguageModelSession {
2    if #available(iOS 27.0, macOS 27.0, watchOS 27.0, visionOS 27.0, *) {
3        return LanguageModelSession(model: PrivateCloudComputeLanguageModel())
4    }
5    return LanguageModelSession(model: SystemLanguageModel())
6}

Seçim kriteri

Context penceresi 4K'yı aşan uzun doküman özetleme veya çok adımlı reasoning gerektiren görevlerde Private Cloud Compute'a geçmek mantıklı; ama günlük kullanım limitine tabi olduğun için, kısa ve yüksek hacimli isteklerde (örneğin anlık öneri üretme) on-device SystemLanguageModel'de kalmak hem gecikmeyi hem maliyeti düşük tutuyor. Dynamic Profiles tam olarak bu ikisi arasında, aynı oturumda ve kullanıcı fark etmeden geçiş yapmanı sağlıyor.

iOS 27 GA sonrası benimseme ve test kontrol listesi

iOS 27 GA olduğuna göre (14 Eylül 2026), üretim uygulamanda Dynamic Profiles ve Private Cloud Compute'u devreye almadan önce kontrol etmen gereken maddeler:

• Availability guard'ı unutma: PrivateCloudComputeLanguageModel yalnızca iOS 27/macOS 27/watchOS 27/visionOS 27 ve sonrasında var; eski OS'te çalışan kullanıcılar için SystemLanguageModel fallback'i şart.
• Her profil için ayrı evaluation seti kur: bir DynamicProfile içindeki her Profile farklı temperature/reasoningLevel kombinasyonu taşıyabilir, dolayısıyla tek bir evaluation setiyle tüm profilleri kapsayamazsın.
• historyTransform ile geçmiş büyümesini sınırla: profil geçişleri sık oluyorsa, Array(history.suffix(20)) gibi bir kesme olmadan context penceresi (özellikle 4K'lık on-device sınırda) hızla dolabilir.
• Attachment kullanılan akışları ayrı test et: çoklu-modal prompt'lar metin-only prompt'lardan farklı bir gecikme profiline sahip, bu yüzden Instruments ile ayrı ölçülmeli.
• Kendi LanguageModel sağlayıcını üretime almadan önce Executor katmanını izole test et: LanguageModelExecutorGenerationChannel üzerinden akan sonuçların, session.respond(to:) çağıran koddan bağımsız olarak doğru şekilde stream edildiğini doğrula.
• Evaluation setini CI'a bağla (tavsiye): dokümanda referans verilen Python Foundation Models SDK'sı (github.com/apple/python-apple-fm-sdk) bu seti Swift dışında kurmanı mümkün kılıyor; ben genelde build pipeline'ına ekleyip her profil değişikliğinde otomatik çalıştırırım, böylece regresyon manuel test beklemeden yakalanır.
• Runtime performans ölçümünü göz ardı etme: Analyzing the runtime performance of your Foundation Models app makalesi Instruments üzerinden token tüketimi ve yanıt sürelerini izlemeyi öneriyor; Private Cloud Compute'a geçen profillerde bu ölçümü ayrı tutmak, günlük kullanım limitine ne kadar yaklaştığını erken görmeni sağlar.

Geçiş sırası

Yukarıdaki maddeleri tek seferde değil, sıralı uygulaman daha güvenli: önce availability guard'ları ve fallback'i kur, ardından her profil için evaluation setini yaz, sonra Attachment akışlarını ve Executor katmanını izole test et, en son da evaluation setini CI'a bağlayıp runtime ölçümünü sürekli hale getir. Bu sıralama, bir önceki maddeyi atlayıp bir sonrakine geçtiğinde ortaya çıkan hataların (örneğin availability guard'ı olmadan Private Cloud Compute'u test ortamında denemek) erken fark edilmesini sağlıyor.

SSS

Apple Foundation Models framework'te Dynamic Profiles ne işe yarar?

Dynamic Profiles, bir LanguageModelSession içinde model, talimatlar ve oturum ayarlarını çalışma zamanında uygulamanın durumuna göre değiştirmeni sağlayan üç katmanlı bir API'dir: en altta her istekte yeniden değerlendirilen Dynamic Instructions, ortada talimatları model seçimi ve reasoning seviyesi gibi ayarlarla ilişkilendiren Profile, en üstte ise birden fazla profil arasındaki geçişi yöneten ve aynı anda yalnızca bir profili aktif tutan DynamicProfile bulunur.

iOS'ta üçüncü parti bir LLM sağlayıcısı Language Model protocol ile nasıl bağlanır?

Sağlayıcı, protocol LanguageModel: Sendable'a uyan bir tip tanımlar; asıl çeviri işini framework tiplerini platforma özgü isteklere çeviren ve sonuçları LanguageModelExecutorGenerationChannel üzerinden akıtan bir Executor üstlenir. Kullanıcı tarafında entegrasyon tek satırdır: LanguageModelSession(model: MyCustomServerLanguageModel()), ardından aynı session.respond(to:) API yüzeyi kullanılmaya devam eder.

On-device model çıktısı nasıl değerlendirilir ve regresyon nasıl yakalanır?

Apple, "Performance and evaluation" başlığı altında üç resmi rehber sunuyor: Evaluating prompts to measure performance and improve model responses, prompt'larını gerçek dünya senaryolarına karşı sistematik test etmeni anlatıyor; Evaluating language model responses, iOS 27 ile gelen Evaluations framework'üyle örnek seti üzerinde yanıt puanlamayı gösteriyor; Analyzing the runtime performance of your Foundation Models app ise Instruments ile token tüketimi ve yanıt sürelerini ölçmeyi kapsıyor. Bu setleri Python Foundation Models SDK'sı (github.com/apple/python-apple-fm-sdk) ile Swift dışında da kurabilirsin; ben CI'a bağlamayı tercih ederim.

iOS 27'de Foundation Models ile ne değişti?

"What's new" bölümüne göre üç şey eklendi: Private Cloud Compute ile sunucu taraflı zeka (daha büyük context penceresi ve çoklu seviye reasoning), Dynamic Profiles ile çalışma zamanında talimat/model değişimi, ve çoklu-modal prompting ile görsellerin metinle birlikte analiz edilmesi. iOS 27, WWDC26'da (8-12 Haziran 2026) duyurulduktan sonra 14 Eylül 2026'da genel kullanıma açıldı.

SystemLanguageModel ile PrivateCloudComputeLanguageModel arasında context penceresi farkı ne kadar?

SystemLanguageModel 4K context penceresiyle çevrimdışı ve sınırsız kullanımla çalışırken, PrivateCloudComputeLanguageModel 32K context penceresi ve çoklu seviye reasoning sunuyor, ama günlük kullanım limitine tabi ve çevrimdışı çalışmıyor; ayrıca yalnızca iOS 27/macOS 27/watchOS 27/visionOS 27 ve sonrasında kullanılabiliyor.

Sonuç

iOS 27, Foundation Models'ı tek-model tek-talimat sınırından çıkarıp çalışma zamanında değişebilen, kendi sağlayıcını takabildiğin ve sistematik değerlendirilebilen bir platforma dönüştürdü. Dynamic Profiles ile aynı oturumda görev moduna göre model/talimat değiştirebiliyor, Attachment ile görselleri prompt'a katabiliyor, Performance and evaluation rehberleriyle de bu değişikliklerin regresyona yol açmadığını doğrulayabiliyorsun.

Temel session/@Generable/streaming API'sine hakim değilsen önce Apple Foundation Models: On-Device LLM Framework yazısına bak. On-device pipeline'ı Core ML tarafından kurmak istersen Apple Intelligence ve Core ML ile On-Device AI Pipeline konuyu tamamlıyor. Cross-platform bir on-device model karşılaştırması için Gemini Nano: iOS/Android Cross-Platform On-Device AI yazısı iyi bir referans. Foundation Models öncesi genel on-device ML altyapısı için iOS'ta On-Device Machine Learning ve Core ML entegrasyonunun detayları için Core ML ile On-Device Machine Learning yazılarına da göz atabilirsin.

Kaynaklar

• Foundation Models — Apple Developer Documentation — framework'ün ana referans sayfası, "What's new" bölümü iOS 27 eklentilerini listeliyor.
• LanguageModel protocol — özel model sağlayıcılarını takmak için kullanılan protokol ve Executor deseni.
• Composing dynamic sessions with instructions and profiles — Dynamic Instructions, Profile ve DynamicProfile'ın resmi tanımı ve kod örnekleri.
• Analyzing images with multimodal prompting — Attachment API'si ve kullanım senaryoları.
• Adding server-side intelligence with Private Cloud Compute — on-device/PCC karşılaştırma tablosu ve platform şartları.
• Evaluating prompts to measure performance and improve model responses — Performance and evaluation rehberi.
• iOS 27 — Wikipedia — GA tarihi (14 Eylül 2026) ve WWDC26 duyuru tarihinin çapraz doğrulaması.