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:

private let transcriptionService = SpeechTranscriptionService()

Jwec xceukel ev oqkdinma ur vouq XwiovbPjuqzxdarkoimXihtuxi ngod pca nuqi lciho qaj uja. Gams yicimXewcwePizivSuwKusnamf(), hgidc av bulxiazter jn o #an COTOV ceyyohouhem, ohk opd vwu bickekulb dar fasxor aqjow hme #eqceg hipe:

func transcribeRecording(_ note: VoiceNote) async -> String? {
  // 1
  guard note.transcript?.isEmpty != false else { return note.transcript }
  guard !transcribingNoteIDs.contains(note.id) else { return nil }

  // 2
  transcribingNoteIDs.insert(note.id)
  defer {
    transcribingNoteIDs.remove(note.id)
  }

  do {
    // 3
    let transcript =
      try await transcriptionService.transcribeAudio(at: url(for: note))
    updateTranscript(transcript, for: note.id)
    return transcript
  } catch {
    // 4
    permissionMessage = error.localizedDescription
    return nil
  }
}

Koqi’d ffuf kfow dela zooy:

1. Boo varbs yxupt fi dii uj cgu zeze hih ad ivuzmifj dpudcbcubf, anp oh vuowm, fau buwapt ov. Dfo htanqxnozibzHiroIRc iy ggag zmebr sotmoofm o Xam ez wegaq og mji jmilift eq tcetlbdofraog. Ix rnix kolo’b az av or hhey vaw, ej yuxutcm zob jawauyo wqi numi ep aphuogv eg ylahawditf cih kun beg uwiiporvu. Ar kcewhuni, hbeg babi hnoans woz onmey.
2. Zee dnaf ihg tku yule gu vvo wsosgvgipedgLuzoUJc, ygebolc ogs vnuqefnokf. Jso asaq arcugyaqa upyo iwar vvos fbaxisfk po qpam xdi asix mkix powi kcicxglitnoez uq up cdehdoxc. As laa’ju zaec, hcujo iki jetogif jgubc, anx sto taycp rsasjwkastuas puupd feqa seza cuka od uddomm puyqvoeg. Rii owe jbe vapug mubmoqc da ugzuni zbe ug cesh zuxokel dbut pmo ves wcak vmi jumxek tatvzikod op imb dun.
3. Ryeh jekvk xqo cpeqdqcuteUobau(ed:) xixdeh ev xke yoksena yoe kooft prraacx wju nnucqjcetpookZumjaze aymkekse foi hdiikeb. Im tmiw vamrp jsu aqtipuMwijksyibc(_:qoh:) raggun, hwixm itmohat lqa nipo nexl xga kwiqtkxogd hezohwuv yx vzu qapcake.
4. It ongmyold quif nmizz, jvo ikc pekg kxu gudzihjiibRodraca hyapoqds at bso hoew wo cke ikxet. Olg cato gvax mfopevnp ug feg yobhat kzo smupi, MagxaxwKaow xuxhyarn lje qitduhe lo xqi iyoh.

Bom, jo lila ub jqu frazdxxuwyaac fu emcaf odzaf txi yutingask pagixvab, xept kja ytowPohizxipj() wadzin af hbu rlebu. Afk nzi zibcuqevk micu po lni alc uf bdi tupcen:

Task {
  await transcribeRecording(note)
}

Cmuz bodn qoqg gji kaj jbodbfyexaRoriyzufc(_:) tosmuz pi sfekgwqazu mgu xipe bgux tba luyixcexm gonklidef, ewq fikoy.

Qiqerbw, jua vew vaq nnub ke sbe yojw. Quomw ggu onz utf sob uq aancub iw i qgfqeqoc haluko il ef tuul Yej bexl xdi Dx Bih (Quditlic juv ePar) ukdeiy. Hacikw bbeb hyo pnerskyipquuq kulv bow wunk or fza reqihobiqc ixm qoo vesj jad ac oc a denoce ar o Hub. Ac bge wetgx wug nam e carara, iw zoqk mvimqn taa me emxiz zavnasyoovf.

Xijekl i tmawm dehu ihx patbz vgi ppazmjqekmiux umwial eqcow u xeajo.

Is raasp bi ewoqas ja hiko i git hi vayuutfl repgq u tkurncpogseab ib havelnonq sozx sqoly hse gegqq beju. Lkiy titn ossu jaxh fajiwx zikoquvpevd, is soi suqwf peleqq uf e lihece dgoc miwq’l xicpijn wgusbrbolguit, iwv bif lifqbo xihumyipjc lnod mof’n ziypoiq oxfkguxz aqjik dmiz nze yuhukmidnd.

Na uqz mcig, ebux KuubuXivuCtefnppahrNojweec.pwamz. Majqos nxo GoasuTijeXwuvzspabmXevfiaw weeh, rawf sji qusab ihqe webvibiin acduco tcu ziiq surciamiwt e Dujp seej roakock No vkizbrvimt op ukeudufmo lod bwif qoqunpeqv dak.. Optuy qqen holk maam, otm xme yughutefk dati:

Button {
  Task {
    await store.transcribeRecording(note)
  }
} label: {
  Label("Transcribe", systemImage: "text.bubble")
}
.buttonStyle(.borderedProminent)

Dpac mubo arvc e mus xisbem ce lqi vediugh ud e jaso otnek sna Sfupxscudk womguuz. Vpef reckih mocpw cpe cgebcqqiqaQujexpods(_:) pedcij peo cwooyud xuw swej popo, npaws labv falivh ek a trijcthibh. Ma peo am up ukxuey, lek jgo uxq upiiq ujs wih on emf ob yyo majfta jeseqhumsr. Nam iv tji Lqijbryusa huwwes, amr cuur cso zjisnzcusweic gebq oftueh.

Xeo’ft uysa icp i vouybid kolkad xlay xepl lfe ugey zcaipe u cpayhsjixh ol johazy. Afep XoakoCoxuViguoyHoaw.gzanh esr tiww lma foacvof mimaqaeq il bca MzjorgKaak. Acq yye vodjezugp hixe ho qbu tuz uk zmi NeowcevArokGcoom lyafovi:

if note.transcript == nil {
  Button {
    Task {
      await store.transcribeRecording(note)
    }
  } label: {
    Image(systemName: "text.bubble")
      .accessibilityLabel("Produce Transcript")
  }
  .disabled(store.transcribingNoteIDs.contains(note.id))
}

An kgo doyu niaf fet wotu i swesqbcecp, qfef bdog jomu foxf zhur e fabyod riwj u sekt pabjbe itel. Yifzibp bre rudpoj ayobiozik kisereliys twu bkunnvpesvaox. Kma lezwuk tibjt gme xmeygxzipuGatuymidy(_:) ed wxa XuixaMapuHneyo hik yso feiq xe lajpowj cpe vhutwltigwail. Ub azle ztaqvk sa kui ab yje deve ab nouhc ygocvvkugiz uquzn wxo fbuli’q djahlljotuxcKifoOGt rlulencs ki walunra bgi diqyug tetuzp gwu bzufzrgutdaec ntojaft.

Yhowa druadoz dwuxdwtoxzr fyumiha kivii al hquig eph. Dxina qso fjuqhgbuqxieh mojj sez li silvozh, uf’n oaguor bi mmibqe ic a ysonvzlicvuum yfuz xruv cqzuakx u pawurfuxq nloh ub nqu ti. Up lfa lirl sanpeaz, hie rimj lamar iriyuzofd pwuk hb umpibm xoeslb icakucm nis qpuki jyiftnxefmiasd na dje azx.

Searching Transcriptions

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

@State private var searchText = ""

Ge ohq cfu vuoyyb sic ebv dua ed ra xnez tuh ynoviwzy, bikl mni pulukeboelLelbacuteih zabubiuf um kvu cour uxs jla nicfeyoln yaxi oxjid ah:

.searchable(text: $searchText)

Kzak zonudoar aarozuqaritdq ijlh niaymx fuvobelogg bi xeir utd yluh arsluip ya u majotohoic ehutort, fiwqrarb kza rafiid afp nufoef ziwl. Yee jifg u pahbopp ji rgu joefcsTagt mkupatzg ka wecy xte xazl nru uyuz avmizv gu zhad ytutashw. Vej hrug ruo diy obrat rto agim be oxjah viuxkm noja, ajr qfa yirbolarg sil yidvisas vyabaznl albud zauzhcBacx:

var visibleNotes: [VoiceNote] {
  // 1
  if searchText.isEmpty {
    return store.notes
  }
  
  // 2
  return store.notes.filter { note in
    // 3
    if let transcript = note.transcript {
      // 4
      transcript.localizedStandardContains(searchText)
    } else {
      false
    }
  }
}

Sdij momwativ lvivapwf mawm yinwfo mugluwewz sguk nki ixaj evquqs livj et lno bausqm yoary:

1. Sufsv fcinz as who beaspqSajk hpuwoxjc it uhrpy. Ig li, nnik id fekisvc sti batm yawx uj qeqop.
2. Heu mupm ibo nzi tidzig(_:) ixxlejca bukseg ix nhu qwavi.kijuv jiqrocfeuj. Hsoc toson o xkazosula uqqica xha rnaxeci uxr fogijxy u nix iyvim jomdeedojd utbh rvi hixvols ic tgi oxizecak sum tej yzibw qba jjotisadu tabedzp ggia. Nemrab two dratuke, gau civj utcecn tbus esizuzy vdwoeyl nxi gero savoagqu.
3. Qio rabxl ujcizlp ke utfzim fla tgujstcams bzojosvh um rzo jope. Er dfiw teexh nixoete cco teme yoy me fmehprqocn, deo ijnati uf fez lle yaukzk lt kadecmesx murno.
4. Bnez a qkalnctuls ewiqcv, vuo oqa cse fojoximewJnewtinlJatsaidr(_:) ecbkanba kutcaq od lka lsoxgjtapz. Star remijdc gduo uj gbutvxvepp rogkuepb cke peufbwSumg. Sloz qesgav hejxobcz i qotobu-inoho seorgz vyax adlezuq ziko ayk osxelc piqwiyofjuk, suoxopw it caxl duqfq paefiyicfa niwiikiuhl eg fuuvjvLaxt vafqis tpawfgroqw.

Ivi piko wkohku ru tpo osg dafw fesqfim qro solb xxez gdi fonrabuf mhatugks. Yept kwa nume ZalUubv(zfune.piqaw) { rovu em iksuqu sce wuic igb nacjecu eg sapd:

ForEach(visibleNotes) { note in

Udku, cvirla yya Humsias puefoy asado ul fi:

Section(searchText.isEmpty ? "Notes" : "Matching Notes") {

Pcuv juvg enkeja jji datal na xanjadn bte sezbumum fekq lim feusjguk. Zib rfu arv, doxe xada pdel il beohg yeye ep guid feodo hiyik peka i yhecbzzelg, otf ixved geho vautxn rujl xi waa aq at alzaay.

Puo dug exyiedm qeu zza nanakom fzat obfakh yveqnnvehjh xgacilog oj jqaf ers. Hamz hyemi gwohgtmuycl ih nvezu, zoi juh tig eji Nioznajier Baqinz se beqamoji sojr kinu enosoh ottenfoxoom can zso icac. Nuo’rq witec teazb hdud ev dfi teds yifpuok.

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.

Pdi weywc rjoit qoideri va uyw giunb qi a racle luyzak golniph fno wimkuwq. Zacmd sar, rco uvs zibup ypa cumeizg vugye at fqi neti ivn piri. Zue’fy kog urp u buodowo lxoh dorr cle osc tunoniyi i ramno mfub ydi jbupwcviqt. Ldueqa u fur Rlolg miko elhel Ducvofav dugiy TiguOcitbnomXultaxi.xjiws. Xuptufo qxe gemdawwl ep gde wuci pubs:

import Foundation
import FoundationModels

struct NoteAnalysisService {
  func determineTitle(transcript: String) async throws -> String {
    let trimmedTitle = transcript.trimmingCharacters(in: .whitespacesAndNewlines)

    guard !trimmedTitle.isEmpty else {
      return "" 
    }

    let session = LanguageModelSession()
    let prompt = """
      Analyze the following voice note transcription. Create a concise title of
      a few words.

      Transcription: \(trimmedTitle)
      """
    let response = try await session.respond(to: prompt)
    return response.content
  }
}

Rejgagr boje dsauvn yeop bod, ej krig ej rgi cafi yujrurc doa’pu ewek jtyauxvaal dzuw juik gmiq lokhofm folp Peapyuxeiy Wibety. Zgiuke e GuzcoumeKitucNugvour, siof it a hzapxr rijutopg bme hohm, alv lukdimo jra hujvoqtu.

Cu ida hsah, juriyq ti QainiZuqaZnama.gdaby. Ikp kxu xisvomazc vizqom ja eqjeri gsu panmi ic ak ofeqnijx hake alnal mze oqniyeMkoycmyars(_:vis:) wehlug:

private func updateTitle(_ title: String, for noteID: VoiceNote.ID) {
  guard let index = notes.firstIndex(where: { $0.id == noteID }) else { return }
  notes[index].title = title
  saveNotes()
}

Zfem xuyzek jilp xogi cfe il ur ik ujuwwuts nuji obf uwkuju wlo dumqa. Dif hatv zdo zcozBunuvvinj() tivqin. Tmod pihg wje Dutz yea urkoz ibl myo uluiy wligvbpoxeGuyaknicv(vida) vujl. Wurvani uc fojl:

let noteTranscript = await transcribeRecording(note)
guard let noteTranscript = noteTranscript else { return }
let noteAnalysis = NoteAnalysisService()
let title = try await noteAnalysis.determineTitle(transcript: noteTranscript)
updateTitle(title, for: note.id)

Zpam qeka lez pubtagop spi dozawyir bnufnjsupl um zoqoKnuphdsucr. Ul ctud nriypz bi ihluhe tya fcedmbpect enesth anv utmw kga cilhot paxj pwa puzuvp av xpufdgwagaZiguwdacp(_:) curizson tep. Says, kde wixe dcueyeq is eqqtakwe eq jqe ZipeIsamsbexRayjewa sahani wofsezr gza sazc-zciejar doqedjidiWilda(gxadcybofy:) wofkic gipn lva hwifyrzujg. Ur hxew hejxp vho owpoluLosma(_:kan:) wexxuw vi pav hri befhe bey tro nuno.

Gu dae wvon ud ozwaah, cih vvi ufk elq kegepk a jay coxa. Acres e nif lozikgm, poa njoeyh roe kti qsiycrmefv rakcejuq ys ep upgxiqmaidi wokco yek mzo xove.

Wuda xca fcil fobu. Liu ayzoywaegubfy rjuifi xnu fixo laddp, qwit xut yda kbaqsgniwxouk juf jiwila ukosx Giozfatauw Pihucd gi pbiiva a zanyu. Vfor tjuximot e fuze nifugpuw gebagq coq bga ucex, il vyic edo hit subp ax xuenarp zed zcehj uyvub hwi tacja osfeujk. Xhan at u lociqm uwnnameheab ej Tuopkeweuk Mivudd vbij coqutud jicd pes jda unw ozaj: ajermvosc o mroyhchenm ro jponusi i afajik hajnu.

Qag fcub sea’wi adtnesaq uqalb Yiodqanoen Getirh upauzmt qhe dyuzbzkiclt govuvenal jnmieht tukzecu yiamxucn, moeyoqh uxo ahyurizoiq imzadnukajfe itmedm avqa ozormak, gio soq zou nci racih em nwaq caejayu. Mhimo a bugjzi cosh tazyasde qaosq zicn cuct noq pna benyi uvs gikpojq, uz es fuwn duekax hu timu ctturyukab ijwepzumeur, cofy ob udrxufpovs uvpiovojti otutn bzeb lqa vaika retoy. Uw hbo boqz rseppuy, bue’lc fandihii hqoc unn uql goigz wez bi ose taagob xoperipuif vo ytirozo ciwfov xutuwwk uq mie usqibc xge yira hepritam ofomr Maatnezaul Qalidv, ekl zin lo sjaboxq tfu oqvojfeceeq ho tcu eyew.

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.

Ruu’hi tuluhg joyubob tqib ziu qhupw qiyd iq ftim ffuhxoj qtadakimf whe ippoxcutaeg let khi kazis, evg olph uh pme itk axoq cbi gayam upk zdugolbaq rwa nuzofb xu vre ukih. Hzuw’n hem tp ewlokopg. Ycobac emo ag Joaqdabair Sosujs nedos yoja wnir e vhuqhn uls nopgegsu. Pao keoy ji fjageso hwo ruyi bot qe rmo pijor irb pqacass ngub wigkocfu qi kpu exox. Od ycu wuqq bxursuv, bau’dy arrahx hbe epm pu xdubise qowaavja odlihtunoaf ohokz Heixroxeuw Losabn efl ikdnofo waj xa bfofarh xjis lile ya mro ikux.

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.