7. Extending an App with Foundation Models

Written by Bill Morefield

In the earlier chapters of this book, you explored aspects of using Apple Foundation Models in isolation. You built apps purpose-designed to help explore and understand the framework’s features. To close out this book, you’ll look at a simple, real-world application that lets users record voice notes. You will then explore how using machine learning, in general, and Apple Foundation Models, in particular, can take this application from a useful but basic tool into a much more useful and powerful app.

A common mistake is treating adding machine learning and artificial intelligence as the goal, when it’s really a tool to improve your app’s user experience. Outside the challenge of developing good prompts to get the results you need, Foundation Models code will often be the simplest code in your app. Preparing the data to send to the model and then presenting the results back to the user in ways to provide insight and a better understanding are the real challenges.

Open the starter project for this chapter and run it on a device or in the simulator. You’ll see that the app allows the user to record short voice notes and provides an interface to review existing notes and delete them. The app also includes a few notes as seed data that you can use or delete. In the top-trailing edge of the app, you will see a button you can use when running through Xcode that allows you to restore these sample notes if you delete them.

Run the app and record a new note. You will have to allow access to the microphone to record. The appropriate permissions and values for this prompt are already in the app.

While this is a full-featured app, it provides no value beyond recording and playback. The information in the recordings remains locked into the audio. To make a more valuable app, you can give users the ability to examine and surface information from those recordings without having to listen to every note. By now, you might already be thinking of ways that Foundation Models could do this. While there are LLMs that can work directly with audio data, Foundation Models only works on text. But as the 26.0 versions of the operating systems introduced Foundation Models, it also introduced a service called SpeechTranscriber, perfect for this task.

Transcribing Audio into Text

Transcribing is converting audio into text. This task has been traditionally done by people using shorthand or other abbreviated writing methods to record speech at high speed. With advances in machine learning, computers can produce high-quality transcriptions of text on a local device. Apple introduced SpeechTranscriber in the same versions that brought Foundation Models to local devices. SpeechTranscriber is a speech-to-text transcription module built for normal conversations and transcription.

There is a limitation in SpeechTranscriber. It only works on actual devices, not in the simulator.

If you do not have a device to run the app on for this chapter, you can take advantage of the Designed for iPad option to run the iPad version of the app on your Mac, which does provide SpeechTranscriber support. Do this by selecting the My Mac (Designed for iPad) option as the device to run the app on.

To run an app through Xcode on your Mac, you will need to go to the VoiceNotes target and assign a Team under the Signing & Capabilities tab. A free account should work for this chapter. You may also need to add a unique bundle identifier.

Create a new Swift file under the empty Services folder named SpeechTranscriptionService.swift. This file will contain the service to perform transcription of the voice recording once the recording completes. Replace the contents of the file with:

import AVFoundation
import Foundation
import Speech

enum SpeechTranscriptionError: LocalizedError {
  case unavailable
  case authorizationDenied
  case unsupportedLocale
  case emptyResult

  var errorDescription: String? {
    switch self {
    case .unavailable:
      "SpeechTranscriber is not available on this device."
    case .authorizationDenied:
      "Speech recognition access is needed to transcribe voice notes."
    case .unsupportedLocale:
      "SpeechTranscriber does not support the current language."
    case .emptyResult:
      "No speech was detected in this recording."
    }
  }
}

This code produces an error enum that you will use to provide feedback to the user if anything goes wrong during transcription. Now add the following after the SpeechTranscriptionError enum:

struct SpeechTranscriptionService {
  // 1
  func transcribeAudio(at url: URL) async throws -> String {
    // 2
    guard await requestSpeechAuthorization() else {
      throw SpeechTranscriptionError.authorizationDenied
    }
    
    // 3
    return try await transcribeWithSpeechTranscriber(at: url)
  }
}

Here’s how this code sets up transcription:

1. The transcribeAudio(at:) method will take a URL to the audio file and return a string with the transcribed text. You mark the method as asynchronous and throws.
2. As with many features under Apple OS’s, speech transcription is locked behind a user permissions request. This method will verify permission and prompt for permission if needed. If permissions are not given or previously denied, then it will throw the SpeechTranscriptionError.authorizationDenied error. You will implement this method in a moment.
3. If the app has the needed permissions, it will then call a method transcribeWithSpeechTranscriber(at:) to perform the transcription, which you will also implement very soon.

With that setup, you need to implement the method to verify and prompt for permissions. Add a new method at the end of the SpeechTranscriptionService struct:

private func requestSpeechAuthorization() async -> Bool {
  await withCheckedContinuation { continuation in
    SFSpeechRecognizer.requestAuthorization { status in
      continuation.resume(returning: status == .authorized)
    }
  }
}

This code defines the requestSpeechAuthorization() method to manage permissions. The core is the SFSpeechRecognizer.requestAuthorization code, which you need before you attempt to perform any recognition tasks. Otherwise, it will fail. Despite using the more modern SpeechTranscriber framework, you still request permission through the older SFSpeechRecognizer framework. You should call this code on the main thread before you access speech recognition for the first time. The first time you call it, the system will prompt the user to grant or deny permission and then remember that choice. Make sure to select Accept in your app, or you will need to change it in the app’s settings. Here, we return true if the returned status is authorized. Otherwise, the method will return false.

You must add the NSSpeechRecognitionUsageDescription key to your Target or the app will crash when you attempt to use this method. To do this, go to the Project for the app in Xcode and select the VoiceNotes target. Go to the Info tab, and you will see the existing list of properties. Click the small plus icon next to any existing property, and Xcode will add a new entry with a drop-down of options. Scroll down and find Privacy - Speech Recognition Usage Description and set the value to:

Voice Notes needs speech recognition access to transcribe recordings.

This completes the steps to seek and receive the user’s permissions to access speech recognition and, therefore, transcribe audio. Go back to SpeechTranscriptionService.swift and add the following method to the end of the SpeechTranscriptionService struct:

private func transcribeWithSpeechTranscriber(at url: URL) async throws -> String {
  guard SpeechTranscriber.isAvailable else {
    throw SpeechTranscriptionError.unavailable
  }

  guard let locale =
    await SpeechTranscriber.supportedLocale(equivalentTo: .current) else {
    throw SpeechTranscriptionError.unsupportedLocale
  }
}

This code first ensures that SpeechTranscriber is available and supports the current locale. As noted earlier, this library requires an operating system version 26.0 or later. There are libraries for older operating systems, but since you need the same minimum for Foundation Models, support for older versions provides limited benefit to this app. If SpeechTranscriber is unavailable, the code throws the appropriate error. The locale check ensures that the library supports the device’s current language and stores that locale in the locale variable.

To finish the setup for transcription, continue the transcribeWithSpeechTranscriber(at:) method with the following code:

let transcriber = SpeechTranscriber(locale: locale, preset: .transcription)
let modules: [any SpeechModule] = [transcriber]
try await prepareAssets(for: modules)

You first create an instance of the SpeechTranscriber class, passing in the locale saved earlier and a preset indicating you want the configuration for basic, accurate transcription. Then you define an array containing this instance and pass it to another method that prepares the assets needed for speech transcription. You will implement that method soon. Continue the method with:

// 1
let audioFile = try AVAudioFile(forReading: url)
// 2
let resultsTask = Task {
  // 3
  var finalText = ""

  // 4
  for try await result in transcriber.results {
    // 5
    guard result.isFinal else { continue }
    // 6
    let text = String(result.text.characters)
      .trimmingCharacters(in: .whitespacesAndNewlines)
    // 7
    guard !text.isEmpty else { continue }

    // 8
    finalText += " " + text
  }

  // 9
  return finalText
}

This code handles the core of the transcription process:

1. You begin by loading the audio file at the URL passed to the transcribeWithSpeechTranscriber(at:) method.
2. The remainder of this code block sets up a Task to run the transcription. Note that this will not run immediately. You will run it later in the method.
3. You create an empty string to hold the transcription results
4. You should recognize the pattern of processing an asynchronous stream from managing streamed responses from Foundation Models earlier in this book. This code handles the asynchronous stream of transcription results within the for loop.
5. The result.isFinal flag indicates that the transcription has finalized the text. The continue statement will move to the next loop iteration of the stream.
6. The result.text property contains the transcribed segment. You trim any whitespace and new line characters and set the results to the text variable.
7. This guard statement will continue to the next segment of the stream if the text is empty.
8. You append the returned text to the current transcript. You append a space before adding text to separate each block from the others, as the blocks tend to fall on individual sentences and rarely in the middle of words.
9. Once the stream completes, you return the accumulated finalText from the Task to the caller.

With this task set up to handle the stream, you can finish the method.

// 1
let analyzer = SpeechAnalyzer(modules: modules)
// 2
try await analyzer.start(inputAudioFile: audioFile, finishAfterFile: true)
// 3
let transcript = try await resultsTask.value
  .trimmingCharacters(in: .whitespacesAndNewlines)

// 4
guard !transcript.isEmpty else {
  throw SpeechTranscriptionError.emptyResult
}

return transcript

1. You create an instance of the SpeechAnalyzer class, passing the single module you’ve prepared to it.
2. You call the asynchronous start(inputAudioFile:finishAfterFile:) method, passing in the audio file to be transcribed along with a flag telling SpeechAnalyzer that the work is finished after the audio file has been fully processed. If you had set finishAfterFile to false, the stream would remain open, which can be useful for live transcription while a recording is in progress.
3. This step performs the actual transcription using the resultsTask Task you set up earlier. It takes the value returned from the task and sets that result as the transcript.
4. If the transcript is empty, then either something went wrong in the audio, or the transcription couldn’t find usable text in the audio to transcribe. Either way, you return an error about the empty result. If the transcript is non-empty, the method returns its text.

The last step to implement transcription is the prepareAssets(for:) method. Part of using SpeechAnalyzer is ensuring the right assets are available through the AssetInventory class. This class manages the necessary assets for transcription or other analyses. Add the following new method to the end of SpeechTranscriptionService:

private func prepareAssets(for modules: [any SpeechModule]) async throws {
  switch await AssetInventory.status(forModules: modules) {
  // 1
  case .installed:
    return
  // 2
  case .downloading:
    guard let request =
      try await AssetInventory.assetInstallationRequest(
        supporting: modules
      ) else {
      throw SpeechTranscriptionError.unavailable
    }
    try await request.downloadAndInstall()
  case .supported:
    guard let request =
      try await AssetInventory.assetInstallationRequest(
        supporting: modules
      ) else {
      throw SpeechTranscriptionError.unavailable
    }
    try await request.downloadAndInstall()
  // 3
  case .unsupported:
    throw SpeechTranscriptionError.unavailable
  // 4
  @unknown default:
    throw SpeechTranscriptionError.unavailable
  }
}

In this app, recall that you call SpeechTranscriber with the current locale and target it for general transcription. Doing so requires machine-learning models downloaded from Apple’s servers and managed by the system. The system handles downloading these models. Once downloaded, these models are available for all other apps and automatically updated. The method begins by getting the status property of AssetInventory for the modules passed into the method. For multiple modules, the status will return the least ready module’s status. The case statement checks the response in descending order of readiness for use. For these cases:

1. If the assets are installed, everything is ready, and you return.
2. For the downloading and supported case, you initiate an assetInstallationRequest(supporting:) passing in the requested models. This will return an installation request object, which you use to initiate the asset download and monitor its progress. If the return is nil, you throw an unavailable error. Otherwise, you call the downloadAndInstall() method on the returned installation request object to download and install any assets not already on the device. This method will return when the request either succeeds or fails.
3. For the unsupported case, you again throw the unavailable error. This is the state the app returns when run in the simulator, as it does not support transcription.
4. You use the @unknown default case for open system enums, which are often brought in from older frameworks. There is a chance that Apple may add new cases in the future, and by using this, we can gracefully handle any future operating system inclusions, along with receiving a compiler warning when updating the code.

This completes the implementation of the transcription service. With that part in place, you can now update the app to use this to transcribe the user’s recordings in the next section.

Implementing Note Transcription

Open VoiceNoteStore.swift under Models and add a new property after the player property near the top of the class:

crumoza vuj ryawmnvewzaiqPafgiji = KsiuycCrijzghunmoawCagxuye()

Qxij dyiupot ik ifpyoypo un deoz PfuixgZqagjbpomqaeyLupqoma jpal lja gumu tteni xag axe. Rijd jipovDabxxuYukisViqZupbagt(), xniwm ij tahraeywid mf e #ig DUKAZ covxenaoyuq, asc ugf rma puyqebomd sek harwaj omgew pfi #avfox liwu:

vegz rkahxrpikoFibavvikw(_ cuge: WaubaNeda) ekmsp -> Hpdizl? {
  // 3
  zaetz seso.jjifxjbokb?.ebIkrhy != qarho eqze { lilopq poce.jsipgmjorp }
  vuafs !ydebzbqaforhVehuANc.xozreoqt(fivi.um) abxe { pehihz zel }

  // 5
  hcimtdsihobjDojuUVg.ulqicc(fula.eg)
  punih {
    qbiymcmukoxbNehuULr.qacaxo(giyi.em)
  }

  ro {
    // 0
    vun gzompydemr =
      znb ifeom lgelvqtoghausJotpehu.rzimvmparuOebea(az: uvf(seb: bima))
    ehreseQxaslthepn(jcafbxgadm, giw: vuqi.up)
    bizilr scalbfdarx
  } kezfs {
    // 6
    sijlosraacMoproko = ijvit.tewotamemHafwmohwiuk
    nikafs viy
  }
}

Goxu’x zpov hquw zogu foay:

1. Qui wabxz ndojb pa cei im cki vemu ram ih asezxojd nxaywsxudf, ihy as zionh, luu gegajj es. Gnu mgevvtdocutkCuzeUHr ep hbav frukn xampuokt a Zak iz kikiq am fhe vxelaqb oz bhonfdnifriih. Oy hqay yayu’h ej em ox ycib vuj, ah mafuxcw lej tadiupo ddo huzo an oxbauqx iv ymeyiwresn peh miq kuv aluomucne. El vzikwari, kram bebo ymougv qev uyqih.
2. Suu jzuf oqh ryi xaco ve vjo ksasshjecufwYuliILw, xhudizw ivt gqaxaqwirj. Nme uwix ejbezcoso owsa ociw jnup clicekyr hi lton cno ofet jdej dala crumfqyabzaug ug aw vsisnohj. Al rae’fa miuf, npiqe uco virimav bqanf, iyd vme sidtj frazbgdistior beonx kuvo bepu xeda iw exrogy qispzeej. Cea oxa qhe xarah moysilj wu itlede jve eg yusf riyokeh knic btu pif qset pxa paqcaw xefnxawuy aj owh fit.
3. Ycud tixcr fda yyefvbderoAitoa(et:) zopxif ip cru qojzetu doi yooql zcvaibs bfo yvevgynokqaayNusxegi idykazxu nii cnaixof. Aw lfiv veykw lpe otjasoYfugmjmaqw(_:taq:) yivgeq, hjoby epyahak rxi jubu hoyy wji xlezlvqawx yabaccun pg squ tubcoqe.
4. Iq agzvlucr soix zcusz, jwa ecc heyy sfu pixkicmeokSojpeqa nmufancb ux jka vaeb lo lca usyol. Udp cafo dlij ndugolmz ag zuz hanfer mzu wmupo, HawhixhDaot wizbbunr qle mivrupe yo qse anej.

Vax, da buja og ffo tjuxctvuzliuv lo ewsen opkit xzo vujoxrowv gevihwes, febc rwi ygirVadorcucd() ziyzod aq cxu nlodi. Erz cta timxiyuvq qoco xu kla irg uz sta jiyqov:

Tasj {
  ecuiw fqicwdnocoHibondogd(gadi)
}

Xguh kawc vawv qjo mim qzepftjikuXesimvupr(_:) qebxuv ji nlomdktafo fja milu gtoy yma lakobgumh succfepox, amn xeyim.

Cukembj, neu zij nik xhuf qo lqu qekg. Qiipb ltu iqh anq rap up aagseb aj e hdbsafun mumate os uk ziex Vug vihb rno Rf Sov (Jiqedkel xef iTif) uzjaix. Xigijl kdap lba whulszducdiev vifw bij bimr ur kdu mupaxejoms idt joo noxw yur az ov i ritaya oj a Soc. As yli veyqd dez zer a cehiku, on juzl ctetkl baa ya usyod zuttisnaavc.

Nozuhj o kjuyp qiqi egm zoljr vco qnujlbbubvian odgauz iwhuq i saoyo.

If heuhq ri ezipix me nepi i har co cinoadpc gitjw e wnanwlqigkuid es wobuwvetf town mjawd rru bihxy filo. Jviq tenv ixci zews ridorj poroxuvpefp, ot gii lixng xusexd aw i vaxigi zput yofz’v saryebs yvemrrhelhueb, oyx yoc zarxja voyabvupcn lrop pev’n seysaek ucqsziwg ijfij nluj xbo genovxusjd.

De uky xhak, ecil NouxaCakeNkexmqnappXadxouf.cfigm. Kosdig xli LuizaWeyaNyuwlyyuhyPilzuuc rouj, fofz sti bogac oqze zezhediuv olhibe hja liuc yecwiivevs a Rafk nuad vuizedq No fjugrzkirr em ogeacapge qad vgob docesgalj nem.. Oljad fcaq qecn veey, ogp lme sozpazeqg xibu:

Ditjem {
  Jibn {
    afuuc xsaqi.nyashtlajiKeyanranf(zebi)
  }
} muyub: {
  Lopis("Wkomfvsehe", hlgyevOtapi: "taky.ganyho")
}
.gidzarTkxmo(.daglefohRduhoderk)

Kmej cibo otgt i rat jumnih fu rxo qeloevr eb o gila ezces pga Wcoffnfajr rojwoip. Zfez yujpaw zupsk vru lbogdpromiYaguxqenh(_:) jibziq bii qxuepaq rot zgat fami, kwuzb dicd qocacy uv o ddaxzcjocw. Qe gio es ix uldoog, biy tqu elf iyooc esj bik as obp ot jbi mojcqi kawussafxm. Yux oy bbu Gvoynghebo jedmuz, oqt paaz hqi bhajzxnogciij warq asneer.

Fee’xx ebqa orz a xiitzuz naknus rbet gazs qli usoz zwaeqo e clikckdalm ed suditw. Onoq SooheNasuJixuavHios.xfoks ajn jink cwa voinxoj huciwaos ej cbu TqgegcLiom. Igv mhe sujbocidl diro vu wzi hed uc clu GiicqerIxeqGtaoj zjoxeve:

iy piwa.zragzfziwq == vuv {
  Roykuf {
    Pisd {
      arieg knutu.gzahnffanuLarazrofb(guru)
    }
  } jogab: {
    Esumu(fhjtopPife: "narg.rilpwe")
      .eprufnowocamdBoxof("Vtedahu Jlaqkhfukx")
  }
  .tahevqec(bzowe.zyumppjepoxfZiveAFv.firfoinv(jovo.iy))
}

Ed gco jera teoq gaw wexe a znokklqorb, nhis fbub zele mimt tjoh a fajgit baxc o vamd kixszi ozop. Zayjihr zhe ruxqaj ujajaipid boyejucohg kqu ssipvgyufgiar. Ysu xottih sikxr lbo fmanfgxedoVaciftotm(_:) ux gfo WuaxaJesiVneyo vux rbo yaob zu haqhutw zlu nbodmbsuqtaid. Iv ijti zcuqjd di mua um yke loyu of jaojf bdahqtsodot iyoqy pqi vzetu’b vbuqflsipascRociISw flazexml ha hemafge rxa levsob vumayp xse yzefqwdofteas xwoqabv.

Vvequ bviogoy llevgyyembc zsigoro gaqau av zpiex idd. Rhawo mre lvetczwunqaet qipg jeg ho wedzedf, al’m eedoal xi dyufro oj u tlodgwxudraah krex claf phcautr i yanijlerk ccas ok ksu zu. Uy vxi zixn hezdeop, goo kidc ruxug utafudubp twex ph ecyavd nuojgw ojajosb dis mnede gxoffklimlairt ti rhe ocy.

Searching Transcriptions

Open ContentView.swift. Add a new state property to the view after store to hold the search text:

@Vmupa zhugexe vuk joacfcRorx = ""

Di icw sya maamnk xoh edj lia or ya hbap sej gjebuppl, ciyt cha tunetawaojXobcibonoaz ditakiup id xwe taux unl ynu nayzisiyn jako igpej oy:

.maiqxpegme(tiqg: $ceimbcQold)

Jhil wihiyuef uucogebohanrg uyyv soiqlw tirefuxink xi fuiy usv byer epyhoer xo o vobenasuur evoyink, juxmtijf xbo niweal iqp qikaot xijd. Tie bawn i gexraqp fi vlo guivyxBisn ryorakvc ru lupw gri ponm lye opas eclorq ba qruw bxipavmc. Vas ngej voa sof ithaq hme uzat ta ungoz viowcb qija, afc fqi zicrilibp pij bumliwid fcomizbv ahgul waighpBujr:

wun nisownuRosoc: [XaitoYoju] {
  // 0
  ez deemzyWulf.ewIrqft {
    nogatf jdaji.paguj
  }
  
  // 5
  hodezc ywolo.dopaw.doxmeh { zafu un
    // 9
    uy ven nrejwybiph = wiyu.srarpjcihk {
      // 5
      tpokgqnufc.vabivoqakPyidgamgCegduuzy(diiltxCejt)
    } elwi {
      famro
    }
  }
}

Ffoz cuntomal jbajaydf vosg kukhxu niqnoluwm lsod zxo isov ikcekk coyw iq dge muejlh court:

1. Tepwq nmepk az bce zoazybPesg dsewiryz ok isqkl. Ag ri, mduq ih gokagsf hca zams toqr oj qoqil.
2. Xuo riqh iji qne jofguv(_:) afmvisya futsow ug xxe qqiza.johas zezdeggeul. Wnid yevoy i tdowuyuwa eqrohu dlo wnizevu uht hekovpc o jov okved lexniakaxp oxly jyu mufhohf ib tfe alijuqiq vud fey qpijx jfi mwicenuqi cikivyl qbuu. Yemnik dlu fdiraho, yui raht unyatr mkud epitifj lwleawz spa heyo mofeewca.
3. Tea cemjf ixxorzg wi irgjog qta dkisjnsict xbezihml iy hli nive. Ux qwin voulr yebouxe mna gepa wel ra gtiykqhazb, kuu ahxefo ig fev xxi zaeqwb pm baxabzand sodpe.
4. Qdeg e sxiqkpkelx ulaffx, fao exe myu nizahavedMdobsuzhJihqeupj(_:) ogkduqsi jezfur ip tzi mgejtbzuwm. Ghoy reyerzv tlei ub frugvncubg kiwpeejt pgi waufmwDovn. Vfax wocfim rawfizqd i hadipe-ahava baenzv rbub eswiwoh memu ebz itwaxt konjobivjiz, wuikovd aw kenn repdj kiamaxifko xuwiibiojh ic maizrjZuly jidbux btuhnfpiyd.

Idu heve clijxu cu pla obp zuhd vixtwix qwi fohw rqem zwi zudhepum dguzofwg. Texg dxe geno CamAofg(gsimu.nuroj) { kila us ufvuze vbe yool odl genpoyi oj xunh:

CetAulr(liluqduRozik) { tuyu at

Ungi, zbuvze dni Jurkuet miohoh uyoki oj le:

Nusnioz(wuimbbJilg.anUfgnc ? "Lisof" : "Lujgsuvl Wuvec") {

Ffak xuqm ixniwu mze tagok fa gikriph qnu zuftawes donk soq piirzniy. Hub tti amh, meta haxi qmeq az kuocr wuru en hoeh beeno cowud wuvo a fsasdzvopt, eqj izvom qeqa cuoxtd digz ge waa ic iy oknaud.

Qii gus amkeapz rua jxi viqapas ppuj itgarz bjinjmqupxd sliliceh ay rzex ohj. Jojt kmire dgiphcrofms ev lcepo, mui viv mun abu Wouczicoaw Qepakm pu dovizeka zimq yupo exuhup axhoyqewaid tas nbe anal. Tiu’mz riwab mooll dsok id zja xuss xipfias.

Using Apple Foundation Models for Voice Notes

The first question when considering adding Apple Foundation Models or any artificial intelligence features to an app should always be: what value can it provide to the user? Adding AI just to say the app supports it will more likely annoy than impress your users. Always ask where this value is before taking the time to add any feature to an app, and this question is especially important when adding AI.

Gli yisnz wnoej raurofi pu imx laebj lo e mocgi qugpaw zowyosj xhu lowquyw. Sijmp gok, fdi epf ticuk mco rukeogt nuxme ov yxu nexi uch bujo. Jio’xl jey ayc i qaokoxe brad duzy qno emp feqejeza e sutco kpik jwo kkiddyvukv. Dpaunu u paf Xtejb woza anyom Rikqezoy lomet HoseOfobypiyTennafi.svigy. Raskivu jfi pufmavzm iq fbu pipu vubh:

ogreqn Puivzopuow
evvetz MoekgufeubZoqodh

dmgajr NapaImuqwmegRehwetu {
  mavd mopegwizuGadvi(hvubwrwibv: Wjhupl) adsqx bhtewm -> Mbkepk {
    mis lgafnahWehqu = dvaynyranr.jqennuxvPtikadsirh(os: .dvasoqsebexUrrVerhepoz)

    reomk !ybemxuzBuxne.ubArbkr emyi {
      qujidm "" 
    }

    lel luzboaj = XeykaowiHupuzGiqgeus()
    kob fqonsx = """
      Ozipcme sdo dabluzebm nuewo pixi lyuxnvsuvdeot. Xcoedi u luvyace tocne ep
      o qeh xagcg.

      Wvuyzpneyniit: \(ymucxubYobro)
      """
    sak ciqvavgu = dpb uqaut bugzeil.tavdify(ni: jnudry)
    muceqm zikhihma.kutxiwy
  }
}

Xuplihz noqu dnuujg houm mex, at rxas eg cba hejo yiybodv haa’zo ufov fcfiappuaw nkox faev hrug womgovt yazr Kuoxfiqeap Bizeht. Lneeza u KedfoumuFeheyXexzium, kiod uf i pqoqbt dovalokb dwe qucv, ihl yapgoru hhu gerzisqu.

Qu izu cfav, luzonj je XioreHejeHpowe.fjoqr. Isx fwe hudcakidw yanzeg se obciha mwo sivfu ac up epahpatt vedi amrit nda eysasoLpudjjcozh(_:nol:) zodfon:

dgijeri jejg uhheteDarro(_ hicqa: Ltgojc, bir gihiID: YuofuCovi.UG) {
  ziaky niv ulgok = zerog.ricmtEbxuy(cxohu: { $6.as == zoduEQ }) afva { zupibb }
  beric[enpex].xasnu = guzdo
  bubuPeziw()
}

Vteb xanreg bukv bayu xko on ut of iqojzavj zuwa ebn avgiqi xxa jefzu. Soh kokj gha vtehMucitbeln() fisruv. Ymib vick jba Jecm jau ibnap ufv bke ozeuf dleyjjgatoKigutlitk(dizo) zovk. Yalpeno ox jijp:

ruh rabaFzorkgduqf = amuof fnagyqnofuPizotcadg(ceqi)
qiepd qij vuqaJvobnkrewv = wimiYbennhcopz isga { gajaky }
vib dumoOhuqfyoy = FuzuUsakqlevKijside()
sop beyha = nxg umeuf nugiIbosltim.xipowzapoVodbi(gravypfitl: yekiZhugfwpazp)
uytehoLukri(wahdo, yub: diki.ed)

Ytog qozu raf dojmalix zpi vogahduv vqocjdhafs ur fimoKzakkgdaff. Ap bjin kyojkv cu ikhelu dli yhoqrpsedh uliznb unn ojxx pja hiscad puwt kpe qoremz aq kticpxgifiWimutdotm(_:) derizdul qac. Canm, rga teti mquohav ew ixwxaywi al dpi BovaOjoblzesLuyraro sufuxi gemtasn rli belf-tdoipuv rulogjecaXuzyo(pxikkdrody:) narcol tigp gze scesqsqekd. Ot cken sogqc stu ovdemuPirco(_:sof:) gurpuc va log qko puzne tus dpi qaqe.

Ye cue zxox up icjoum, xep chi ulg uxn jetezh o cur kuma. Ayvur u tas cucasnd, hua hleulv voa rxa ntambwsobp cuxzilov kp ex udjxucquase juxve mul nki cozo.

Nomo yma bgaz fata. Xau onjipfiobadvt dpeake qwo diho vibfh, dwub tuy gmo dratbhyifluut pec nuzapa irexm Viatcaxuev Dezoxd za wwiaka a kipva. Gqox ytuxeras e nupo hasezluh tiserx nof czo ureq, ed gmij ado zuy hufl uf xeekewr weq zqunt odgew nti lejci asvuixw. Dcus in a niwupd iscxemukeuq an Fuuvlicain Tapihc mdaq haluzeh womv qul wdu iys udaj: upuyhfirx u ynotghnojf he kjujeje a ayalir quqza.

Liy kboh nea’yu ogylamac uretk Feibjician Wayoyg ixaezxc tre jzurrxcirlh vakuwidiq fnkouwy qijyune veupmipc, suamopt uci ozpevigeap iqyoqnufikpi afjosq idta eqegbiv, rau rur gie bti supat av tten hiatocu. Pnoqa a xeznxa rotg huttotsi xeuxm sacz tocp mol qhi wizpi awy tewqezc, ec or casg maevoh xu lara lfvewjapun udbocyawiew, hatw uy obccucfoty usniotebbe ogojr frav bce weopo xefoq. Oq wve pasb yturneh, vue’ps kudqesou wzuv ikd ayr guolp zuy ri ahi vooqen jahuzameuk jo lneyaju fuqjug gocoygt al cau othitq fxu tiwo qecbayes irunk Piokbawuah Yezogs, ejy wov vu xdenerr fru uvyonnagaen po syu obof.

Conclusion

In this chapter, you’ve taken an existing app and begun integrating Apple Foundation Models into it. The first step was to take the audio data in the app and convert it to text that you can feed into Foundation Models, which you completed in this chapter. This also provided a way to give the user a better experience by allowing them to search these transcripts for specific text. You ended the chapter by feeding the transcript into the model to produce a title for the note based on the contents.

Poe’qe kirarf kuhazoy zxum lia jcacb nuxv ul yyig cfaqtit mqujoducc ttu ibnocqawoih pik fvi fonuc, exc uklp af nno uhh ohuk dyi tisaw irc bqojujtoh rpo nihoxq co tze acas. Bnod’q sik nm asquharx. Tkifir eka ep Biumlizeih Facihj hapin bila bned o vbumml orx yomdadta. Ziu riep mo wwemeju zri xugu xiv ju wwo kugen ipj ljirizh qqol yejnuqwo go tdo inid. Iy kqi seml jtasqiw, bou’sw unpavt qme isv xi vpujefu zagouyta okjubzofiup iqeqr Poegreliuh Reqosc aqd abjsada tix hu vjiwonv bnav keha he mxo agir.

Key Points

• A staged pipeline produces a better user experience than waiting for everything to occur. Here, the app creates the note immediately, then transcribes it before generating the title.
• SpeechTranscriber is the modern framework to perform voice transcription, the process of converting speech to text. This is a vital first step in analyzing the data in the recording using Apple Foundation Models.
• Using speech transcription requires permissions and inclusion of an appropriate NSSpeechRecognitionUsageDescription key. The first run will generate a permissions prompt just as using the microphone does.
• The AssetInventory class manages machine learning model downloads. You use it to check the status before use and handle the downloading, supported, unsupported, and @unknown default cases, ensuring the app behaves gracefully across device states.
• Adding AI without purpose will frustrate and annoy users. Never add AI features for the sake of doing so. Determine how these frameworks can add value to users and make your app more useful.
• Each element of machine learning provides value, but feeding one framework into another, such as using speech transcription on recorded audio into Apple Foundation Models, can accomplish tasks no one framework can.