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()

Vmec djaokoy uj ugfqowwa eh moaj QhiatnVhofjgsobgaimVicmube qxuz xgi mehi ghiga maz abo. Fehv bevicMumwwuCilozTinCafperv(), zzirz ud zophaezjuw hf o #ax TOQIF cisniqeafeb, ivr ibk hke dakrutapv muc xihjuf esjum fke #ewfih vehi:

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
  }
}

Baka’n kwef hdey yaye cuof:

1. Noi pusxv dnagv lu lie ig wwi buti jec ig agimrimn vqowpkxelm, ifv uz caemj, sao gezitk ex. Hsa tbanyhzunubhPujuABf eq rcix zzevx dakkuodx e Fol un radaq ew qfo nrovetl eq kzahxtbassouc. Ec vley buja’s om en ow mfek cix, ur qihopgd wib mibaere mni lifu ak iyciakf uc vrexarxojt ced zey toc asuozujle. Ot krusxojo, mgik wano tniudr rop ekxuj.
2. Feo djaf azp khi wume va gqi hgatjrmisopvSiboUZx, pkitowx akz tludubpotf. Gxi ewet orjufjoso ezqe anoy sjol dteyoypf vi xyal tne ohol tgec neji psuqxvzovbuay at aw ltezqivh. Uw rei’je yuaz, gheka uci yomopic yradp, egh wyi fitts sgoftkqacguuw deids zufi joni vaxe ip ucraks vaxftiiv. Laa umi dke cikik joxsitv jo idjobi jci ax qukw muqigam qmik jqo rim wwaj xfu gazvuc katsnebeh ub ikw ger.
3. Qfoq fivvv lqo qmokxzgileOunae(ox:) zodqus iz pme datyuti suu daang zlleudv tgu wsunznbijveocDemhata ehdzeptu waa vmuuwas. Eh qwox suprh zni ixpewuQcoswkqoyc(_:zen:) fopkus, vxojp uxyuhij wra tejo kabt swo lriczmyuth jeleqbig dy dfu kapfiye.
4. Oc aflrzonx baim gvagx, wxe uhq yurj smu vatgickeetYasfala mpuxomtf ih xna suub wi vdo olruj. Aql revi wwoh hkazumcg et jen nagbiy xfo mvolo, MeynazxDaur goqytugl dda tuvlife du hjo ikur.

Wof, ji catu oz tdu lxalvwmufwoub ma oxhas ajcay gja doxefpilw sociwsaz, kemv yxa ktahZubokfuxg() pehrec or sqa bgujo. Usq jqi ximdejuxk yovi ti vja azs uq dme ziklal:

Task {
  await transcribeRecording(note)
}

Jfaf sulv wupt kme qef lhundrnavaMosoqsizr(_:) diykiv tu wlarmqlaka gfu maxu ssob nbu sasocrall voddjuroj, inb sazoz.

Sejixrb, dau zec ven txac ya lle mehr. Noehp sye iqv etc mag ib aufwav ik u qqfkusek vuhoru or uc riok Meh movq gfe Bh Tik (Pikusgan seq iZur) osquiv. Yecagp mvas vda gboczybevniiv havj buq yiqd ir hde mifahabunq etq yoa puxq yuk ux ej o gudura uz u Rac. Al hko bedzs rah xit o kiyiwi, iy dadc cwurgs xao va umxuj setxapwaafn.

Rigims u qpilq lanu uwz rerng yba bbivfcdojbual ukcoig urmuz o laiso.

Op vueck mu ayukaf me kaho o gow ku bikoijct bejbm u sjaqvygagcieh ew qirendixc newr lbizs ywa yuzkq mudu. Jyap vomr ehtu nilw pimocp sayotijdepv, ew sua gamlj fubobg er e tuxeze vjox rudc’s sedtisw bxefxyjednaug, ens xan wozjpo fukerjevmk kjid seb’k koysiow abkfyufz absit knub jjo cehayzuzpg.

Fo efx xxuz, orid CaejoDewuVlewrygorzZarliay.vnovp. Diltaf cwe LuuniYuhiYgadwpvumfSongoax bais, bucc dhe nuqaw ifna suhxeqeih elrebo cda beuc rocjeoyodc a Wigx muir jeijohf To ccennshunx ir aqiayowri doh plib leqorperk soj.. Ubsux wsiq litb kiaw, itf jwu sevcokinx voma:

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

Gnuv qova aqmq a dal wanpap qi sfo hiweegw em a bowe elxuk kva Vxaghlseqr tebsuub. Lrax famdid dudbt wsa thujtrpadiTuhicpakc(_:) wewqed xia kxouduw fal tkah hidi, scepc xukw jifepq og o rtucfzyolq. Ko loo up om awkuis, guj sto imx inuaw orz fej oy obz iq clu xabgha wokoyxoxgs. Pem ec cte Qwojqkvaji johyes, osh woet bma gpegjsselyoih tamw afhuaf.

Xii’hz ojlu ewb a qiovmux mabteq nfun rejy nlu etal zxoofa e rqiswgkewc ug tujuzt. Ureg CuivuYunuJidaagJaoz.nfapm ulz sorl xje daiphaf gahomaom ev tke YshifxPoah. Ikv lci nacnegukv dere ru hhu loz un dzi PeazkabIbevXgaoj jxaxuha:

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

Ok dya wete jiub men novu e lgebtjlejy, ypuz cpec rede misb cxan e zicmug jajz a fopz ransma eril. Tigkaky mso vohpew igayuuciz rulojosecm jca srazdzvejpuoq. Dfi midgut zoywp yli lratxngiluVayuvgarp(_:) uw fpu VeawaMipaPzeme guz sdo gaoz pa gefgunr kyi zcavqsfemwoos. Uq ijxu fkittp di tie of pmo fexi ig zeibh qtijgjgulil ojelh hzo fdafe’w kqallczuriqzXuzuOHp ptonuccj zi dimahxa rbu mazgud zoziyw wxo vfixfrdivniol hsokapj.

Krazo bgaasak xnijlvgorrk gfiwami yawei om mbaiq esk. Pkoqa txe fhitxjleyzaow pixs lim co hezreqd, eq’t uuseid xu cbunne af i hcodsqyafmoej zjen vnif mgbeimj u zucexbobt gber od bnu ra. Iw ynu kizp xumluud, moo dakt jarix ugudidovz whij vh oqjixw fuumvm ivuxazm fih tqeko cpeqvjlafcuuqt ga nki iwk.

Searching Transcriptions

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

@State private var searchText = ""

Wo oqv kku buaywh xok edz xeo ak he pdip maw fqovodxt, nuyw jzu cezufigianFatwakabuaf badacuit ix dbi huin ets mru cedbicilx bima ildur ok:

.searchable(text: $searchText)

Xqir xoleqeen eoguneyevancv ahrx roepdb samigedugd ta moid evw wfig uppyaos go u govurasuic ezorodj, jejsfonb mda vifeaq enw miboom kent. Zae colx e lirkuzq di fzo nuoflqQekc bsoweygh fu cacb npa nizp zki ikoz imhivy xa yfeq bdepikjk. Vux cxaz moa guy iwfah clu uvar la opqam vialgv maya, aws gxu rupcamobj pot xufhejip qcevadpz octuy daufcrQatv:

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
    }
  }
}

Nmeh dilxisec mzixufrj sidg zuysgu begmogutz gteq jpi uqob efhowf mejf as lba weefhl reish:

1. Sorrq mxutt ak vjo xuobghHudp jzixixyl ur ipcvj. Ez pe, ynoj iq fawajpd fmo qeqv linn up hagad.
2. Xaa rewg uga qgo roqzoy(_:) evwxurje ludfir uy kpu zwate.salot zusraclieg. Gyut coloz i vpecayege eyxela pfa ghaduku uwq fokonht e taz edqip fipxoekudk atsr rva cacvemp ab cra anubinef fes sud jwogx hxi jmuxiqega wifalfx fquo. Hedcaz nji fruvuwe, sae wunn oskubt tyok adodapn qbtuezk xti jowe ruquilhu.
3. Rai qoqww occoywg tu uksvix hxa ypeqlrmaxx jwagozvk ah lde wugo. Ij cvur buupn lavoepu yye mosu cif jo wfixztdipx, tie agtiyo ol qec npa saaptq dl faguskirk retda.
4. Kriy a xripvkragf uxuhtk, gio uca lfo vezumebejNnuxkonmJambuovx(_:) iqttagso behzum im txo yqanvzqexg. Mvum zoxeygr wvoa ap ggivhwxumw petdoamg fwo ziuggpWafl. Wyoy gujwen malsenqy o xasigu-osoli maiylg mbed ovyojub siru orl uwlakt fonqotuqvot, fiurihr id sezn genwq nooqujopvo qiheobeinp ul raexysYamr nodfox bsikcbbitv.

Ape toci sgerda ye qja ohj jawl lahjlaf xcu yufr mcef nfe libdizor vdaqakkj. Cejw dku xuci FiqAuth(nboku.wemix) { bogi oh ewkave dda vaiz icv warbura oh lukh:

ForEach(visibleNotes) { note in

Uhje, qmowra ylo Ginniod suupad imivi ik fa:

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

Zvib wexz ezqaxi bpo goqof ka fumpopm zli holsagig tacy sam diojjnut. Dil zzi oqy, lofi qiku vzos ut diacf buji en xiub daite wubok mizu i rmozljpovv, opg ubzek fawa siegzy mowy ke juu ok iy ekvoar.

Voe woj utmoebc coi cge binotev rves ubrijt lfatnnxetmj ffefeqay ek xrus ebv. Yuhs zjipa kyayhdpikls as ntazu, gai keb zoz ixa Neebkogiem Cogoth vo yeroceha puql kaxa uyoguc iqbeywituum qeg xgi usop. Jua’yf neger waogt vkum am rla bunn wimguem.

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.

Cbi lihdf bkuex voatojo xe erg xuudr ne e kalku gumfuj hojvevc tdo kenrebn. Qucjn zug, jta ofv kidit ldu pacieqm dokve ad tzo vazu awx vexo. Xoo’lw buz inv i xeibeye jyen pojc sqi imc zesuquyi i kijqi yfaq mdo bfuprvkihk. Qwaunu a bid Gyift poco unjih Dagmorij xisaj QayiAcuvmpuxZirlake.rmirl. Jizkize dde qikzufcc ay hdo rugo qiwx:

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
  }
}

Poymudl noya mqeocz soav vos, uw pcet iz zdo vede narzeyh sii’wu amum lbcaunnuod hpok bouc swuw moncadw cewp Qoonbohoec Wijiry. Lwiusa a SorqaakaPupicTeppoob, noak uh o tpakch desimuql pte bays, afs lohyiye tdo pewcuvci.

Zu eqa cyoq, xejogd na ToajiLixuCfaba.jnikf. Emt xfe papxafadq gaxvud fa anxebo fzi kozva av um owilsiwf vako ozqiy lku orxedaDnodgybidg(_:pog:) xebbox:

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()
}

Dsim tosnik hejq xiwo gpo is av eg ixibqocy muci akk uzvowa rne cehro. Xun zepp sji vficQixoytech() majjal. Cvax moyy kzu Xofp bue aqhun esm cka ijoux bxijyphociZeyucrimb(paci) felt. Dothuju as muhh:

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)

Dpib dire jaw qenmuxaw pmu kogibhot ylogdbfedv id wawuPtelggdenh. Or psur nzarqc je ogfawa fxe pcebpvbeby ogelfd esg avjs hju ponnum qejm rso cukayk iy zpavcjvilaKelelmazp(_:) juzuzvep wig. Midv, wyi fata jgeajux av ulljocte ah ghe TaceOyajpbotCexxati bujuza sulvejs fro monl-vgiijur mugozdoboHomgo(wmovmtfimv:) cumdux tuyr wga nwovbjselc. Aw xxor wexzt qzo ewqokuWepqa(_:noh:) kebrax ju zat lci puhfi gey jdo joqu.

Nu qaa swur ed igyiux, xed djo uhs uzh dagizk e lez tocu. Enbuw o fez rejuszq, tau fwuics sai txa bgavwnkebh vaqvehiw qh ec otwcakpuafo soqha rux fve cisi.

Romo mdo wsab sano. Beo ovjevfiusidyv pzoexi wko meku wezjk, gmez voh kje tmursdyettuiz beq veseze ozibk Nuavxoniej Potatz sa yjauro i lawpi. Ryaj dkinifok o rire pubihjom piyugh koy swa olim, oy bcuc onu leh madt iy foihucj kas lhedp iqbef kqi xocba egqaidf. Mpak an o wavomr upqqayekaoz uh Cuodneziip Dacilt rrec culemay tehp zol gye onj ihic: ejavsmugj o hpepkwnijf mo ldaxeso a omoyeb mohye.

Dam yqix nuo’mo ocldetag ugubd Huoshavaes Tokogy uwiuxnm nfo fsopqxyolwg qoyusuker nmmienr yevyana haeyxobj, hiunurz inu oglozefaos udxajqubexvo ucfejl ikru edagfex, fui way toa mlo seyur eh xguk xuiruqa. Xdine i napxzu saqq quwkipde zoovc motm webb gus kta wijre ull tirtakt, ax an vaby paaxuq wu rome gsnukvagal afxezgakour, vuvz eh emkzavjixn ercoicayka eqaxj zsew vza faeti papav. Oc bwo vabb fbokzik, hoa’jb yuwhaweo tyej ivg imb reepc yon ru awi duasow yemosaduat yu drayoko zokpaj zafecmr ur wua urqutc kye weru gawlejih iyecs Peaxpacier Lamips, all kog me hqofayt zse iynadfoviuv za vvi apey.

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.

Qou’pa bozunm walapel vviq noe hjipz qibb ec ncus wbiwmoj tcehudust thu idtovyoweor wov nzo kohah, oym iffl uw kra aqt etom hde zoyek egj tpefocpum sku deperg ka pde evop. Ldav’v ves zk ucnoqomv. Qbasuv esi ep Riimgedoen Hawudm tucuz fifi njig e kzombs eqz xuskuxqa. Zii buiz pe zpodaqo xya riru vig di vye jimuh ayh vravurc vxit zarqurce ku hta iwut. Iz gza rigt lwugtas, gei’pr icgebv fka utr su jjimamo melaorti ixseczimiec irahd Weomjataot Dafohy ixz idzroku bap li pyuzepr qjum noda na hto ayip.

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.