안녕, 미래의 AI 앱 개발자! 👋

커피 한 잔 들고 편하게 앉아봐. 오늘은 좀 신나는 얘기를 해볼 거거든.
혹시 그런 생각해 본 적 없어? "내 앱이 사진 속 고양이 품종을 딱 알려주면 어떨까?", "사용자가 글을 쓰면 기분을 파악해서 이모티콘을 추천해주면 대박이겠다!" 같은 생각 말이야.

예전에는 이런 게 공상과학 영화에나 나오는 얘기 같았지만, 이젠 아니야. 바로 '머신러닝(Machine Learning)' 덕분이지. 그리고 더 놀라운 건, 우리가 매일 사용하는 Swift로 이 모든 걸 구현할 수 있다는 사실! 🤯

"에이, 머신러닝은 수학 천재들이나 하는 거 아냐?" 라고 생각했다면, 그 생각 잠시 접어둬도 좋아. Apple이 우리 같은 개발자들을 위해 정말 엄청난 도구들을 만들어 뒀거든. 마치 레고 블록처럼 가져다 쓰기만 하면 되는, 아주 직관적이고 강력한 도구들을 말이야.

이 글은 머신러닝의 'ㅁ'자도 모르던 내가, 삽질과 유레카를 반복하며 얻은 모든 노하우를 눌러 담은 일종의 '치트키'야. 우리는 오늘 Swift와 Apple의 머신러닝 프레임워크, 특히 Core ML을 가지고 우리 앱을 한 단계, 아니 몇 단계는 더 똑똑하게 만드는 여정을 함께 떠나볼 거야.

이 글을 다 읽고 나면, 넌 더 이상 머신러닝을 막연하게 두려워하지 않게 될 거야. 오히려 "오, 이걸로 뭘 더 만들어볼까?" 하고 신나서 아이디어를 떠올리는 자신을 발견하게 될걸? 자, 그럼 이제 우리 앱에 인공지능이라는 강력한 엔진을 장착하러 가볼까? 🛠️

1. 시작하기 전에: Apple 생태계의 머신러닝 어벤져스 🦸‍♂️

본격적으로 코드를 만지기 전에, 우리가 사용할 무기들에 대해 먼저 알아야겠지? Apple은 개발자들이 쉽게 머신러닝을 사용할 수 있도록 '어벤져스' 팀처럼 강력한 프레임워크 군단을 만들어 놨어. 각자 역할이 뚜렷해서, 이들의 관계만 잘 이해해도 절반은 성공한 거야.

🧠 Core ML: 우리 앱의 '뇌'

Core ML은 이 모든 것의 심장이자 두뇌야. 이미 훈련된 머신러닝 모델을 우리 앱에 탑재해서 실행시켜주는 근본 프레임워크지. 여기서 키워드는 '이미 훈련된' 그리고 '실행'이야. Core ML 자체가 모델을 훈련시키진 않아. 훈련은 다른 곳에서 하고, 그 결과물(모델 파일)을 가져와서 사용하는 거지.

Core ML의 가장 큰 장점은 바로 '온디바이스(On-device)' 구동이야. 서버를 거치지 않고 아이폰, 아이패드, 맥 같은 기기 자체에서 모든 연산을 처리해. 이게 왜 좋냐고?

• 프라이버시 보호: 사용자의 민감한 데이터(사진, 텍스트 등)가 기기 밖으로 나가지 않아. 요즘처럼 개인정보가 중요한 시대에 엄청난 장점이지.
• 속도: 인터넷 연결이 필요 없으니 네트워크 지연 없이 바로바로 결과를 얻을 수 있어. 실시간 처리가 중요한 기능에 딱이야.
• 오프라인 지원: 비행기 안이나 데이터가 안 터지는 곳에서도 내 앱의 인공지능 기능은 쌩쌩 돌아가.
• 비용 절감: 모델 추론을 위한 비싼 서버를 운영할 필요가 없어.

Core ML은 아이폰의 A-시리즈 칩에 내장된 Neural Engine을 최대한 활용하도록 설계되어서, 전력은 적게 쓰면서도 엄청나게 빠른 연산이 가능해. 한마디로 Core ML은 우리 앱에 들어갈 인공지능의 '실행 엔진'이라고 생각하면 돼.

🛠️ Create ML: 나만의 '맞춤형 뇌' 제작소

Core ML이 '실행 엔진'이라면, Create ML은 그 엔진에 들어갈 '맞춤형 부품(모델)'을 만드는 공작소야. 머신러닝의 가장 큰 장벽 중 하나가 바로 '모델 훈련'인데, Create ML은 이 과정을 놀랍도록 쉽게 만들어줘.

코딩 한 줄 없이, 그냥 데이터를 끌어다 놓는 것만으로도 꽤 준수한 성능의 모델을 만들 수 있어. 예를 들어, '강아지' 사진 100장, '고양이' 사진 100장을 준비해서 Create ML 앱에 던져주면, 알아서 이미지를 학습해서 둘을 구분하는 모델을 뚝딱 만들어줘. 물론 Swift 코드로도 모델 훈련 과정을 자동화할 수 있어서 더 정교한 제어도 가능해.

Create ML 덕분에 우리는 더 이상 데이터 과학자에게 의존하지 않고도, 우리 앱에 꼭 맞는 커스텀 모델을 직접 만들 수 있게 된 거야. 이건 정말 혁명적인 변화지!

👀 Vision: '보는 눈'을 담당하는 전문가

Vision 프레임워크는 이름 그대로 이미지나 영상 분석에 특화된 전문가야. Core ML 모델을 직접 다루려면 이미지 데이터를 모델이 원하는 형태로 변환하는 등 귀찮은 사전 작업이 꽤 많아. Vision은 이런 잡다한 일들을 대신 처리해주고, 이미지 처리와 관련된 아주 유용한 기능들을 미리 만들어 놨어.

• 얼굴 인식 및 특징점 검출 (눈, 코, 입 위치)
• 이미지 속 텍스트 인식 (OCR)
• 바코드 및 QR코드 스캔
• 객체 추적 (영상에서 특정 물체가 어떻게 움직이는지 따라가기)
• 이미지 정렬 및 유사도 비교

만약 네가 만들 기능이 '보는 것'과 관련 있다면, Core ML을 직접 쓰는 것보다 Vision 프레임워크를 통해 접근하는 게 훨씬 편하고 효율적일 거야. Vision이 내부적으로 Core ML을 사용해서 실제 연산을 처리하거든. 즉, Vision은 Core ML을 더 쉽게 쓰게 해주는 '고급 조수'인 셈이지.

✍️ Natural Language: '말귀'를 알아듣는 전문가

Vision이 '보는 눈'이라면, Natural Language 프레임워크는 '말과 글을 이해하는 귀와 입'이야. 텍스트 데이터를 분석하고 처리하는 데 필요한 모든 기능이 담겨있어.

• 언어 감지 (이 텍스트가 영어인지, 한국어인지)
* 토큰화 (문장을 단어, 문장 등 의미 있는 단위로 쪼개기) * 품사 태깅 (각 단어가 명사인지, 동사인지 분석) * 개체명 인식 (텍스트에서 인물, 장소, 기관 이름 찾아내기) * 감성 분석 (이 문장이 긍정적인지, 부정적인지 점수 매기기)

채팅 앱에서 욕설을 필터링하거나, 리뷰 글을 분석해서 제품의 평판을 요약하는 기능을 만든다고 상상해봐. Natural Language 프레임워크가 있다면 이런 기능들을 훨씬 쉽게 구현할 수 있어. Vision과 마찬가지로, 이 프레임워크 역시 내부적으로는 Core ML을 활용할 수 있어 더 복잡한 언어 모델을 돌릴 때 강력한 성능을 발휘해.

2. 첫 전투: 남이 만든 모델 가져와 써보기 (Core ML 통합)

백지상태에서 시작하는 것보다, 이미 잘 만들어진 걸 가져와서 써보는 게 가장 빠른 학습법이지. 머신러닝 세계에는 이미 수많은 천재 개발자와 연구자들이 만들어 놓은 강력한 '공개 모델'들이 존재해. 우리는 이걸 우리 앱에 쏙 집어넣기만 하면 돼.

이번 챕터에서는 이미지 분류(Image Classification) 모델을 예시로, Core ML 모델을 Xcode 프로젝트에 통합하고 사용하는 전 과정을 단계별로 따라 해 볼 거야. "이 사진에 있는 게 뭐게?" 하고 물어보면 "음... 87% 확률로 '골든 리트리버'입니다!" 라고 대답하는 기능을 만들어 보자고. 🐶

STEP 1: 우리의 무기(.mlmodel) 구하기

Core ML이 사용하는 모델 파일은 `.mlmodel`이라는 특별한 확장자를 가져. 이 파일 안에는 모델의 구조, 학습된 가중치(weight), 그리고 입출력에 대한 정보까지 모든 게 다 들어있어.

이런 모델은 어디서 구할 수 있을까?

1. Apple 개발자 사이트: Apple이 직접 제공하는 다양한 종류의 고품질 스타터 모델들이 있어. 이미지 분류, 객체 탐지, 텍스트 분석 등 웬만한 건 다 있지. (https://developer.apple.com/machine-learning/models/)
2. Hugging Face 🤗: 전 세계 AI 개발자들의 성지! 수십만 개의 모델이 공유되는 곳이야. Core ML 포맷으로 바로 변환할 수 있는 모델도 많아.
3. TensorFlow Hub, PyTorch Hub: 다른 유명 머신러닝 프레임워크의 모델을 가져와서 `coremltools`라는 파이썬 라이브러리로 변환하는 방법도 있어. 이건 좀 더 고급 과정이니 일단은 이런 게 있다는 것만 알아두자.

우리는 오늘 실습을 위해 Apple 개발자 사이트에서 가장 유명한 이미지 분류 모델 중 하나인 'MobileNetV2'를 다운로드할 거야. 이름에 'Mobile'이 들어간 것에서 알 수 있듯이, 모바일 환경에 최적화된 가볍고 빠른 모델이야.

STEP 2: 모델을 내 프로젝트에 영입하기

자, `MobileNetV2.mlmodel` 파일을 다운로드했다면, 이제 우리 Xcode 프로젝트로 데려올 차례야. 방법은 너무나도 간단해.

그냥 Xcode 네비게이터 영역으로 파일을 드래그 앤 드롭하면 끝!

이때 'Copy items if needed'와 'Add to targets'가 체크되어 있는지 꼭 확인해. 이렇게 파일을 추가하고 나면, Xcode가 우리를 위해 엄청난 일을 자동으로 해줘.

생성된 클래스 정보를 자세히 들여다보면, 이 모델이 어떤 입력을 받고(Inputs) 어떤 출력을 내보내는지(Outputs) 명확하게 알 수 있어. MobileNetV2의 경우:

• Input: `image` (Color 224x224) - 224x224 픽셀 크기의 컬러 이미지를 입력으로 받는다는 뜻이야.
• Output:
  • `classLabelProbs` (Dictionary<String, Double>) - 각 레이블(예: '고양이', '강아지')에 대한 확률값을 담은 딕셔너리.
  • `classLabel` (String) - 가장 확률이 높은 레이블 하나.

이 정보만 알면 이제 코드를 짤 준비가 된 거야!

STEP 3: Swift 코드로 모델과 대화하기

이제 진짜 코딩 시간이야. 사용자가 앨범에서 사진을 선택하면, 그 사진을 MobileNetV2 모델에 넣어서 결과를 화면에 표시하는 간단한 앱을 만들어 볼게.

핵심 로직은 크게 3단계로 나뉘어: 1. 모델 로드 → 2. 입력 데이터 준비 → 3. 예측 실행 및 결과 처리

1. 모델 로드하기

먼저, Xcode가 생성해준 모델 클래스의 인스턴스를 만들어야 해. 이건 아주 간단해.

import CoreML
import Vision // Vision을 함께 사용하는 것이 훨씬 편리해!

// ...

// 모델 인스턴스를 생성. 이 과정에서 모델 로딩에 실패할 수 있으므로 do-catch로 감싸는 것이 안전.
let model: MobileNetV2 = {
    do {
        // Vision 프레임워크와 함께 사용하기 위해 VNCoreMLModel로 한번 감싸주는 것이 베스트 프랙티스!
        let coreMLModel = try MobileNetV2(configuration: MLModelConfiguration()).model
        let visionModel = try VNCoreMLModel(for: coreMLModel)
        return visionModel
    } catch {
        fatalError("Failed to load Core ML model: \(error)")
    }
}()

2. 입력 데이터 준비 및 요청 생성하기

이제 모델에게 "이 이미지 좀 분석해줘!" 라고 요청을 보내야 해. Vision 프레임워크에서는 이 요청을 `VNCoreMLRequest` 객체로 만들어.

// 모델에게 보낼 요청을 생성.
// 예측이 완료되면 실행될 클로저(completion handler)를 함께 정의.
let request = VNCoreMLRequest(model: model) { (request, error) in
    // 3단계: 결과 처리는 여기서!
    guard let results = request.results as? [VNClassificationObservation] else {
        print("Model failed to process image.")
        return
    }

    // 결과 처리 로직 (아래에서 자세히 설명)
    self.processResults(results)
}

// Vision은 이미지를 0~1 사이의 값으로 정규화하는데,
// 대부분의 이미지 분류 모델은 이 옵션을 켜줘야 제대로 동작해.
request.imageCropAndScaleOption = .centerCrop

3. 예측 실행 및 결과 처리하기

요청서(`VNCoreMLRequest`)를 만들었으니, 이제 분석할 이미지와 함께 '요청 처리 담당자'에게 전달하면 돼. Vision에서는 `VNImageRequestHandler`가 그 역할을 해.

// 사용자가 선택한 이미지가 'userSelectedImage'라는 UIImage 변수에 있다고 가정.
guard let uiImage = userSelectedImage, let ciImage = CIImage(image: uiImage) else { return }

// 핸들러를 만들고, 어떤 이미지를 처리할지 알려준다.
let handler = VNImageRequestHandler(ciImage: ciImage)

// 핸들러에게 요청서(request)를 전달하며 "일 시작해!"라고 명령.
// 이 작업은 시간이 걸릴 수 있으므로, 메인 스레드를 막지 않기 위해 백그라운드 큐에서 실행하는 것이 필수!
DispatchQueue.global(qos: .userInitiated).async {
    do {
        try handler.perform([request])
    } catch {
        print("Failed to perform classification: \(error)")
    }
}

// ...

// 예측 완료 후 호출될 결과 처리 함수
func processResults(_ results: [VNClassificationObservation]) {
    // 가장 확률이 높은 결과 몇 개만 추려내자.
    let topResults = results.prefix(3)

    // UI 업데이트는 반드시 메인 스레드에서!
    DispatchQueue.main.async {
        var resultText = ""
        for result in topResults {
            let confidence = result.confidence * 100
            let identifier = result.identifier
            resultText += String(format: "%.1f%%: %@\n", confidence, identifier)
        }
        // 이 텍스트를 UILabel이나 SwiftUI Text에 표시
        self.resultLabel.text = resultText
    }
}

자, 이게 끝이야! 어때, 생각보다 코드 자체는 복잡하지 않지?

흐름을 다시 정리해볼까?

1. `VNCoreMLModel`로 모델을 준비한다.
2. `VNCoreMLRequest`로 "이 모델로 이미지 분류해줘!" 라는 요청서를 만든다. (결과를 받았을 때 뭘 할지도 미리 적어둔다)
3. `VNImageRequestHandler`에게 분석할 이미지와 요청서를 함께 주면서 일을 시킨다. (백그라운드에서!)
4. 일이 끝나면 요청서에 적어뒀던 대로 `processResults` 함수가 호출되고, 우리는 결과를 예쁘게 가공해서 화면에 보여준다. (UI 업데이트는 메인 스레드에서!)

이 패턴만 익혀두면, 다른 종류의 Core ML 모델을 사용하는 것도 크게 다르지 않아. 모델의 입출력 형식에 맞춰 데이터 준비와 결과 처리 부분만 조금씩 바꿔주면 되거든. 이제 너는 어떤 `.mlmodel` 파일이든 두려움 없이 프로젝트에 통합할 수 있는 기본기를 갖추게 된 거야! 축하해! 🎉

3. 레벨 업: 나만의 맞춤 모델 만들기 (Create ML)

기성복이 아무리 좋아도 내 몸에 딱 맞는 맞춤 정장만 할까? 기존 모델을 가져다 쓰는 것도 훌륭하지만, 내 앱의 서비스에 특화된, 세상에 단 하나뿐인 모델을 만들 수 있다면 훨씬 더 강력한 무기가 될 거야. 예를 들어, 중고 거래 앱이라면 '가방 사진'만 보고도 브랜드와 모델명을 알려주는 모델, 교육용 앱이라면 '학생이 쓴 손글씨'를 인식하는 모델처럼 말이야.

이때 등장하는 우리의 히어로가 바로 Create ML이야. Create ML은 복잡한 머신러닝 이론이나 파이썬 코드를 몰라도, Swift 개발자가 직관적인 방법으로 고품질의 커스텀 모델을 훈련시킬 수 있게 해주는 도구야. Create ML을 사용하는 방법은 크게 두 가지가 있어.

1. Create ML 앱: 코딩 없이, 마우스 클릭과 드래그 앤 드롭만으로 모델을 만드는 GUI(그래픽 유저 인터페이스) 방식.
2. Create ML 프레임워크: Swift 코드를 사용해 모델 훈련 과정을 자동화하고 세밀하게 제어하는 방식.

우선은 가장 쉽고 빠르게 결과를 볼 수 있는 Create ML 앱부터 시작해보자. 우리의 목표는 '핫도그'와 '핫도그가 아닌 것'을 구분하는, 실리콘밸리 드라마에도 나왔던 그 유명한 'Hotdog / Not Hotdog' 이미지 분류 모델을 직접 만들어보는 거야! 🌭 vs. 🚫🌭

PART 1: Create ML 앱으로 코딩 없이 모델 만들기

STEP 1: 데이터 준비 - 모든 것은 데이터로부터

머신러닝에서 가장 중요한 건 뭘까? 화려한 알고리즘? 비싼 컴퓨터? 아니, 바로 '양질의 데이터'야. "Garbage in, garbage out." (쓰레기를 넣으면 쓰레기가 나온다) 라는 유명한 말이 있듯이, 데이터의 품질이 모델의 성능을 결정해.

이미지 분류 모델을 위한 데이터 준비는 아주 간단해. 분류하고 싶은 클래스(카테고리)별로 폴더를 만들고, 각 폴더에 해당하는 이미지를 넣어주기만 하면 돼.

- `Training Data` (훈련용 데이터) 폴더를 하나 만들자. - 그 안에 `Hotdog` 폴더와 `Not Hotdog` 폴더를 만들자. - `Hotdog` 폴더에는 다양한 각도와 배경에서 찍은 핫도그 사진을 최대한 많이 (최소 10~20장 이상) 넣자. - `Not Hotdog` 폴더에는 핫도그가 아닌 다른 음식, 사물, 풍경 사진 등을 넣자.

데이터가 많을수록 모델은 더 똑똑해져. 실제 서비스에 사용할 모델이라면 클래스당 수백, 수천 장의 데이터가 필요하지만, 지금은 테스트 목적이니 수십 장만으로도 충분해.

STEP 2: Create ML 프로젝트 생성 및 훈련

이제 Create ML 앱을 켜보자. (Xcode 설치 시 함께 설치되거나, Mac App Store에서 별도로 받을 수 있어.)

1. New Document를 클릭하고, 다양한 템플릿 중에서 Image Classifier를 선택해.
2. 프로젝트 이름(예: HotdogClassifier)을 정하고 저장하면, 아주 심플한 화면이 나타날 거야.
3. 왼쪽의 Training Data 영역에 아까 우리가 만든 `Training Data` 폴더를 통째로 끌어다 놓아봐.
4. 그러면 Create ML이 폴더 안의 이미지들을 분석해서 `Hotdog`와 `Not Hotdog`라는 두 개의 클래스를 자동으로 인식하고, 각 클래스별 이미지 개수를 보여줄 거야.
5. 이제 남은 건 단 하나! 상단의 'Train' 버튼(▶️)을 누르는 것뿐이야.

버튼을 누르면 Create ML이 '알아서' 이미지들의 특징을 추출하고, 패턴을 학습하고, 모델을 최적화하는 과정을 시작해. 이 과정은 데이터의 양과 컴퓨터 성능에 따라 몇 초에서 몇 시간까지 걸릴 수 있어. 훈련이 진행되는 동안 그래프가 실시간으로 업데이트되면서 모델의 정확도가 점점 올라가는 걸 볼 수 있을 거야. 정말 마법 같지? ✨

STEP 3: 모델 평가 및 내보내기

훈련이 끝나면, Create ML은 모델의 성능을 요약해서 보여줘. 'Training' 정확도와 'Validation' 정확도가 나올 텐데, 우리가 주목해야 할 건 Validation(검증) 정확도야. 이게 바로 모델이 처음 보는 데이터에 대해 얼마나 잘 맞추는지를 나타내는 실질적인 성적표거든.

만약 성능이 만족스럽지 않다면, 데이터를 더 추가하거나 품질이 낮은 데이터를 제거하고 다시 훈련하면 돼. 이 과정을 '이터레이션(iteration)'이라고 해.

성능이 만족스럽다면, 이제 이 모델을 우리 앱에서 사용할 수 있도록 내보낼 차례야. Output 탭으로 가서 'Get' 버튼을 누르거나, 모델 파일을 원하는 곳으로 드래그하면 끝! `HotdogClassifier.mlmodel` 파일이 짠! 하고 만들어질 거야.

이제 이 모델 파일을 지난 챕터에서 배운 방법 그대로 Xcode 프로젝트에 추가하고 코드를 작성하면, 나만의 '핫도그 감별사' 앱이 완성되는 거지! 코딩 한 줄 없이, 나만의 아이디어가 담긴 인공지능 모델을 만들었다는 게 믿겨져? 이게 바로 Create ML의 힘이야.

PART 2: Create ML 프레임워크로 코드 기반 훈련하기

GUI 앱은 정말 편리하지만, 몇 가지 한계가 있어. 예를 들어, 매일 새로운 데이터가 쌓일 때마다 모델을 다시 훈련시켜야 한다면? 매번 앱을 켜서 드래그 앤 드롭을 반복하는 건 너무 비효율적이겠지. 이럴 때 필요한 것이 바로 Create ML 프레임워크야.

Swift 코드를 사용해서 모델 훈련의 모든 과정을 자동화할 수 있어. Mac에서 실행되는 스크립트나, 서버에서 주기적으로 실행되는 작업으로 만들 수도 있지. 이건 좀 더 전문적인 영역이지만, 어떤 느낌인지만 한번 맛보자.

Mac용 'Playground'나 'Command Line Tool' 프로젝트를 하나 만들고, 아래 코드를 붙여넣어 봐.

import CreateML
import Foundation

// 1. 데이터 준비
// 데이터가 있는 폴더 경로를 지정.
let trainingDataURL = URL(fileURLWithPath: "/Users/yourname/Desktop/TrainingData")

// Create ML이 데이터를 쉽게 다룰 수 있도록 MLImageClassifier.DataSource로 로드.
// 폴더 구조를 기반으로 자동으로 레이블을 생성해준다.
let trainingDataSource = MLImageClassifier.DataSource(from: trainingDataURL)

// 2. 모델 훈련
// 훈련 파라미터를 설정할 수도 있다. (예: 최대 반복 횟수)
let parameters = MLImageClassifier.ModelParameters(
    featureExtractor: .scenePrint, // 이미지 특징 추출 방법 선택
    validation: .automatic,
    maxIterations: 20 // 훈련 반복 횟수
)

// 지정된 데이터와 파라미터로 이미지 분류 모델 훈련을 시작!
print("Starting model training...")
let imageClassifier = try MLImageClassifier(trainingData: trainingDataSource, parameters: parameters)
print("Training finished!")

// 3. 모델 평가
// 훈련 과정에서 분리된 검증 데이터에 대한 정확도를 확인.
let trainingAccuracy = (1.0 - imageClassifier.trainingMetrics.classificationError) * 100
let validationAccuracy = (1.0 - imageClassifier.validationMetrics.classificationError) * 100

print("Training Accuracy: \(trainingAccuracy)%")
print("Validation Accuracy: \(validationAccuracy)%")

// 4. 모델 저장
// 모델에 대한 메타데이터(설명, 버전 등)를 추가.
let metadata = MLModelMetadata(
    author: "My App Team",
    shortDescription: "A model that classifies images as Hotdog or Not Hotdog.",
    version: "1.0"
)

// 지정된 경로에 .mlmodel 파일로 저장.
let outputURL = URL(fileURLWithPath: "/Users/yourname/Desktop/HotdogClassifier.mlmodel")
try imageClassifier.write(to: outputURL, metadata: metadata)
print("Model saved to \(outputURL.path)")

어때? 코드로 보니까 전체 과정이 훨씬 더 명확하게 보이지? 데이터 로드, 파라미터 설정, 훈련, 평가, 저장까지. 이 스크립트를 실행하면 GUI 앱에서 했던 것과 똑같은 결과물인 `.mlmodel` 파일이 생성돼. 이걸 서버에 올려두고 새로운 이미지가 추가될 때마다 자동으로 실행되도록 만들면, '지속적으로 똑똑해지는 AI'를 만들 수도 있는 거야.

물론 처음부터 프레임워크를 쓸 필요는 없어. 대부분의 커스텀 모델은 Create ML 앱만으로도 충분히 만들 수 있으니까. 하지만 이런 방법도 있다는 걸 알아두면, 나중에 더 복잡한 문제를 해결해야 할 때 분명 큰 도움이 될 거야. 혹시 이 부분이 너무 복잡하게 느껴진다면, 재능넷 같은 플랫폼에서 머신러닝 전문가의 도움을 받아보는 것도 좋은 방법이 될 수 있어. 전문가의 지식을 빌려 내 아이디어를 빠르게 실현하는 것도 현명한 전략이니까!

4. 전문가의 길: Vision & Natural Language 프레임워크 활용하기

지금까지 우리는 Core ML이라는 엔진과 Create ML이라는 공작소를 다루는 법을 배웠어. 이제 한 단계 더 나아가, 이 엔진을 더 부드럽고 효율적으로 다룰 수 있게 도와주는 '고급 컨트롤러'인 Vision과 Natural Language 프레임워크를 제대로 활용하는 법을 알아볼 거야.

앞서 잠깐 언급했듯이, 이 프레임워크들은 특정 도메인(이미지, 텍스트)의 복잡한 작업들을 추상화해서 아주 간단한 API로 제공해줘. 덕분에 우리는 지루한 데이터 전처리나 후처리 과정에 신경 쓸 필요 없이, 오직 '무엇을 할 것인가'에만 집중할 수 있게 돼. "바퀴를 재발명하지 말라"는 개발 세계의 격언을 떠올려봐. Apple의 천재 엔지니어들이 이미 만들어 놓은 최고의 바퀴를 마다할 이유가 없지! 🏎️

👀 Vision: 이미지에 생명을 불어넣다

Vision 프레임워크는 단순히 Core ML 모델을 쉽게 쓰게 해주는 것 이상의 엄청난 기능들을 내장하고 있어. Core ML 모델 없이도, Vision 자체만으로도 강력한 분석이 가능하지. 이번에는 그중 가장 활용도가 높은 '텍스트 인식(OCR)' 기능을 예제로 살펴볼게.

카메라로 메뉴판을 찍으면 텍스트를 추출해서 번역해주거나, 영수증을 찍으면 항목과 금액을 자동으로 입력해주는 앱을 만든다고 상상해봐. Vision 프레임워크가 있다면 이게 놀랍도록 간단해져.

실전 예제: 이미지에서 텍스트 추출하기 (OCR)

Core ML 모델을 쓸 때와 구조는 거의 똑같아. '모델'이 Vision에 내장된 '텍스트 인식 기능'으로 바뀌었을 뿐이야.

1. 요청(Request) 생성: `VNCoreMLRequest` 대신 `VNRecognizeTextRequest`를 사용해.
2. 핸들러(Handler) 생성 및 실행: 이 부분은 이전과 동일하게 `VNImageRequestHandler`를 사용해.
3. 결과(Observation) 처리: 결과 타입이 `VNClassificationObservation`에서 `VNRecognizedTextObservation`으로 바뀌어.

코드로 직접 확인해보자.

import Vision
import UIKit

// 텍스트 인식이 완료되었을 때 호출될 함수
func handleDetectedText(request: VNRequest?, error: Error?) {
    if let error = error {
        print("ERROR: \(error)")
        return
    }
    guard let results = request?.results, results.count > 0 else {
        print("No text found")
        return
    }

    // VNRecognizedTextObservation 배열로 결과를 캐스팅
    guard let observations = results as? [VNRecognizedTextObservation] else { return }

    var detectedText = ""
    for observation in observations {
        // 인식된 텍스트 조각들 중에서 가장 신뢰도 높은 후보를 가져온다.
        guard let topCandidate = observation.topCandidates(1).first else { continue }
        
        detectedText += topCandidate.string + "\n"
    }

    // UI 업데이트는 메인 스레드에서!
    DispatchQueue.main.async {
        // 추출된 텍스트를 UITextView 같은 곳에 표시
        self.textView.text = detectedText
        print(detectedText)
    }
}

// 사용자가 선택한 이미지가 'userSelectedImage'에 있다고 가정
guard let uiImage = userSelectedImage, let cgImage = uiImage.cgImage else { return }

// 1. 텍스트 인식 요청 생성
// 인식 언어, 인식 레벨(빠름 vs 정확) 등을 설정할 수 있다.
let textRecognitionRequest = VNRecognizeTextRequest(completionHandler: handleDetectedText)
textRecognitionRequest.recognitionLevel = .accurate // .fast 옵션도 있음
textRecognitionRequest.recognitionLanguages = ["en-US", "ko-KR"] // 인식할 언어 지정

// 2. 핸들러 생성 및 실행
let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])

// 백그라운드에서 실행
DispatchQueue.global(qos: .userInitiated).async {
    do {
        try handler.perform([textRecognitionRequest])
    } catch {
        print(error)
    }
}

어때? `.mlmodel` 파일을 전혀 사용하지 않았는데도 강력한 OCR 기능이 뚝딱 구현됐지? 이게 바로 Vision 프레임워크의 힘이야. 이 외에도 Vision은 정말 다양한 '요청(Request)' 타입을 제공해.

• `VNDetectFaceRectanglesRequest`: 얼굴 영역 찾기
• `VNDetectFaceLandmarksRequest`: 눈, 코, 입 등 얼굴의 특징점 찾기
• `VNDetectBarcodesRequest`: 바코드, QR코드 인식
• `VNTrackObjectRequest`: 영상에서 특정 객체 추적하기
• `VNDetectHumanBodyPoseRequest`: 사람의 관절 위치를 파악해 자세 추정하기

이런 요청들을 조합하면 정말 무궁무진한 아이디어를 실현할 수 있어. 예를 들어, 얼굴 영역을 찾고(`VNDetectFaceRectanglesRequest`), 그 영역만 잘라내서 우리가 만든 '감정 분석 Core ML 모델'에 넣는 식으로 연계 플레이도 가능하지. Vision은 복잡한 파이프라인을 구축하는 데 최고의 도구야.

✍️ Natural Language: 텍스트의 속마음을 읽다

이제 텍스트의 세계로 넘어가 보자. Natural Language(NL) 프레임워크는 텍스트 데이터에 숨겨진 의미와 구조를 파악하는 데 필요한 모든 도구를 제공해. 사용자가 남긴 리뷰가 긍정적인지 부정적인지, 고객 문의 내용의 핵심 키워드가 무엇인지 등을 알아내는 데 아주 유용하지.

NL 프레임워크의 핵심 클래스는 `NLTagger`야. 이름처럼 텍스트에 '꼬리표(Tag)'를 붙여주는 역할을 해. 예를 들어, "Apple is looking at buying U.K. startup for $1 billion" 라는 문장이 있다면, `NLTagger`는 여기에 다음과 같은 꼬리표들을 붙여줄 수 있어.

• 품사(Part of Speech): 'Apple'(명사), 'is'(동사), 'looking'(동사)...
• 개체명(Named Entity): 'Apple'(기관), 'U.K.'(장소), '$1 billion'(금액)
• 언어(Language): 'English'
• 감성(Sentiment): 'Neutral' (중립)

이런 정보들을 활용하면 단순한 문자열이었던 텍스트가, 의미를 가진 구조화된 데이터로 재탄생하게 돼.

실전 예제: 문장의 긍정/부정 감성 분석하기

사용자가 입력한 문장의 감성 점수를 실시간으로 분석해서 보여주는 기능을 만들어보자. 이 역시 별도의 Core ML 모델 없이 NL 프레임워크만으로 가능해.

import NaturalLanguage

let text = "This movie was absolutely fantastic! The acting was superb and the story was so engaging."
// let text = "I'm so disappointed. It was a complete waste of my time and money."

// 1. NLTagger 인스턴스 생성
// 우리가 원하는 꼬리표 종류(Scheme)를 배열로 지정.
let tagger = NLTagger(tagSchemes: [.sentimentScore])

// 2. 분석할 텍스트 할당
tagger.string = text

// 3. 꼬리표(Tag) 가져오기
// 문장 전체(unit: .paragraph)의 감성 점수를 가져온다.
// tag(at:unit:scheme:) 메서드는 튜플 (Tag?, Range)를 반환.
if let (sentiment, _) = tagger.tag(at: text.startIndex, unit: .paragraph, scheme: .sentimentScore) {
    
    // 감성 점수는 Double 타입의 문자열로 반환되므로 변환이 필요.
    if let score = Double(sentiment.rawValue) {
        print("Sentiment score: \(score)") // 점수는 -1.0 (부정) ~ 1.0 (긍정) 사이의 값

        if score > 0.5 {
            print("Result: Very Positive 😊")
        } else if score > 0.1 {
            print("Result: Positive 🙂")
        } else if score < -0.5 {
            print("Result: Very Negative 😠")
        } else if score < -0.1 {
            print("Result: Negative 🙁")
        } else {
            print("Result: Neutral 😐")
        }
    }
}

결과를 보면, 첫 번째 긍정적인 문장은 0.8~1.0 사이의 높은 점수가, 두 번째 부정적인 문장은 -0.8~-1.0 사이의 낮은 점수가 나오는 걸 확인할 수 있을 거야. 정말 간단하지?

이 기능을 활용하면, 고객 리뷰를 자동으로 분류해서 긍정 리뷰는 마케팅 자료로 활용하고, 부정 리뷰는 담당자에게 바로 알림을 보내는 시스템을 만들 수 있어. `NLTagger`는 이 외에도 다양한 `NLTagScheme`을 제공하니, 필요한 분석에 맞춰 골라 쓰기만 하면 돼.

5. 실전 투입: 현업에서 고려해야 할 것들

자, 이제 우리는 모델을 가져와 쓰고, 직접 만들고, 고급 프레임워크로 다루는 법까지 모두 배웠어. 이론과 실습은 충분히 했으니, 이제 우리가 만든 AI 기능을 실제 앱에 탑재해서 사용자들에게 선보일 시간이야. 하지만 잠깐! 실제 서비스를 운영하는 건 연습 게임과는 달라. 실제 필드에서는 우리가 미처 생각지 못했던 여러 문제와 마주치게 되지. 💥

이번 챕터에서는 모델의 성능 최적화부터 사용자 경험, 그리고 모델을 계속해서 업데이트하는 방법까지, '프로' 개발자라면 반드시 고민해야 할 실전적인 이슈들을 짚어볼 거야.

🚀 성능, 성능, 성능! (Performance)

사용자는 기다려주지 않아. AI 기능 때문에 앱이 버벅거리거나 배터리가 광탈한다면, 아무리 똑똑한 기능이라도 외면받게 될 거야. 온디바이스 ML의 성능을 좌우하는 요소들을 알아보자.

1. 온디바이스(On-Device) vs. 서버(Server-side)

모든 걸 기기에서 처리하는 게 항상 정답은 아니야. 상황에 따라 서버의 힘을 빌리는 것이 더 효율적일 수 있어. 장단점을 명확히 알고 전략적으로 선택해야 해.

결론: 실시간 반응이 중요하고(AR 필터 등), 개인정보를 다루며(얼굴 인식 등), 모델 크기가 비교적 작은 경우엔 온디바이스가 유리해. 반면, 수십 기가바이트에 달하는 거대 언어 모델을 사용하거나, 모든 사용자가 항상 최신 버전의 모델을 사용해야 하는 경우엔 서버가 더 나은 선택일 수 있어. 둘을 혼합한 하이브리드 방식도 좋은 전략이 될 수 있지.

2. CPU, GPU, 그리고 Neural Engine (ANE)

Core ML의 가장 아름다운 점 중 하나는 개발자가 하드웨어에 대해 신경 쓸 필요가 거의 없다는 거야. Core ML은 모델의 연산 특성을 분석해서 자동으로 가장 효율적인 프로세서(CPU, GPU, ANE)에 작업을 할당해줘. 우리는 그냥 `prediction()` 메서드를 호출하기만 하면 돼!

하지만 어떤 하드웨어에서 돌아가는지 궁금하다면, `MLModelConfiguration`을 통해 특정 프로세서만 사용하도록 강제할 수도 있어. (주로 디버깅이나 성능 테스트 목적)

let config = MLModelConfiguration()
config.computeUnits = .cpuOnly // .gpuOnly, .all (기본값), .cpuAndGPU, .cpuAndNeuralEngine
let model = try MyModel(configuration: config)

대부분의 경우 기본값인 `.all`로 두는 것이 최적의 성능을 보장해.

3. 모델 경량화 (Quantization)

모델 파일의 크기는 앱 용량과 직결되고, 메모리 사용량에도 영향을 미쳐. 모델의 성능을 크게 해치지 않으면서 용량을 획기적으로 줄이는 기술을 '경량화'라고 해. 가장 대표적인 방법이 바로 '양자화(Quantization)'야.

일반적으로 모델의 가중치(weight)는 32비트 부동소수점(Float32)으로 저장돼. 이걸 16비트(Float16)나 심지어 8비트 정수(Int8)로 표현 방식을 바꾸는 거야. 정밀도를 약간 희생하는 대신, 용량을 1/2에서 1/4까지 줄일 수 있고, 연산 속도도 더 빨라지는 효과를 얻을 수 있어. Create ML이나 `coremltools`에서 모델을 변환할 때 간단한 옵션 설정만으로 양자화를 적용할 수 있어.

💖 사용자를 위한 배려 (User Experience)

아무리 기술이 뛰어나도 사용자가 불편함을 느끼면 실패한 기능이야. 머신러닝 기능을 통합할 때 UX 관점에서 반드시 고려해야 할 점들이 있어.

1. 메인 스레드는 신성불가!

절대, 무슨 일이 있어도, 메인 스레드에서 모델 예측을 실행하면 안 돼. 모델이 예측을 수행하는 데는 수십 밀리초에서 수 초까지 걸릴 수 있어. 이 시간 동안 메인 스레드가 멈추면 앱 전체가 '얼어붙는' 현상이 발생하고, 사용자는 앱이 죽었다고 생각하고 바로 꺼버릴 거야.

앞선 예제 코드에서 계속 강조했듯이, `handler.perform()` 같은 무거운 작업은 항상 `DispatchQueue.global().async`를 사용해 백그라운드 스레드로 보내야 해. 그리고 예측이 완료된 후 결과를 UI에 업데이트하는 작업만 `DispatchQueue.main.async`를 통해 메인 스레드로 다시 가져와야 한다는 것, 잊지 마!

2. 기다림의 미학: 피드백 제공

백그라운드에서 작업이 돌아가는 동안, 사용자는 지금 무슨 일이 벌어지고 있는지 알 수 없어. "내 사진을 분석하고 있는 건가? 앱이 멈춘 건가?" 하고 불안해하지 않도록, 명확한 시각적 피드백을 줘야 해.

• 분석이 시작되면 로딩 인디케이터(Activity Indicator)나 스켈레톤 UI를 보여주자.
• 진행 상황을 알 수 있다면 프로그레스 바(Progress Bar)를 보여주는 것이 더 좋아.
• "이미지를 분석하고 있어요...", "텍스트에서 키워드를 찾는 중..." 같은 친절한 안내 문구를 함께 보여주면 금상첨화!

3. 실패는 성공의 어머니: 오류 처리

세상에 완벽한 코드는 없어. 모델 로딩에 실패할 수도 있고, 예측 과정에서 메모리 부족 등의 에러가 발생할 수도 있어. 사용자가 선택한 이미지가 모델이 처리할 수 없는 형식일 수도 있지.

모든 `try` 구문에는 `catch` 블록을 충실하게 작성해서, 에러가 발생했을 때 앱이 비정상 종료되지 않도록 해야 해. 그리고 사용자에게는 "죄송합니다, 이미지 분석에 실패했습니다. 다른 사진으로 시도해보시겠어요?" 와 같이 명확하고 친절한 오류 메시지를 보여줘야 해.

🔄 살아있는 모델: 업데이트와 개인화

앱은 계속 발전하는데, 한번 탑재한 AI 모델이 3년 내내 그대로라면 안 되겠지? 모델도 앱의 다른 코드처럼 지속적으로 개선하고 업데이트해야 해.

1. 모델 업데이트 전략

가장 간단한 방법은 새로운 버전의 `.mlmodel` 파일을 포함해서 앱 자체를 업데이트하는 거야. 하지만 사용자가 앱 업데이트를 잘 안 하거나, 더 긴급하게 모델을 바꿔야 할 땐 다른 방법이 필요해.

Core ML은 원격 서버에서 모델을 다운로드해서 동적으로 교체하는 기능을 지원해. 앱이 시작될 때 서버에 최신 모델 버전이 있는지 확인하고, 새 버전이 있다면 백그라운드에서 다운로드한 뒤 다음 실행부터 적용하는 방식이야. 이렇게 하면 앱 업데이트 없이도 모든 사용자가 항상 최신 AI 모델을 사용하게 할 수 있어.

2. 온디바이스 개인화 (On-Device Personalization)

더 나아가, Core ML은 '업데이트 가능한 모델(Updatable Models)'이라는 아주 강력한 기능을 제공해. 이건 모든 사용자에게 동일한 모델을 배포하는 게 아니라, 각 사용자의 기기에서, 사용자 자신의 데이터만을 이용해 모델을 '미세 조정(fine-tuning)'하는 기술이야.

예를 들어, 텍스트 자동 완성 앱이 있다면, 처음에는 일반적인 언어 모델로 시작하지만 사용자가 자주 쓰는 단어나 말투를 학습해서 점점 그 사용자에게 최적화된 추천을 해주게 되는 거지. 이 모든 과정이 기기 안에서만 일어나므로 프라이버시를 완벽하게 지킬 수 있어.

이건 꽤 고급 주제이지만, '궁극의 개인화'를 구현하고 싶다면 도전해볼 만한 가치가 충분한 기능이야. 재능 공유 플랫폼 재능넷 같은 곳에서 관련 프로젝트 경험이 있는 개발자와 협업하여 이 기능을 도입해보는 것도 좋은 시작이 될 수 있겠지.

여기까지 왔다면, 너는 이제 Swift 머신러닝의 기초부터 실전 운영 노하우까지 모두 꿰뚫는 개발자로 거듭난 거야. 이론만 아는 것을 넘어, 실제 사용자에게 가치를 제공하는 '살아있는 AI'를 만들 준비가 된 거지. 정말 대단한 여정이었어! 👏

마치며: 이제 당신의 차례입니다!

와, 정말 긴 여정이었어. 그렇지? 😅
우리는 Apple의 머신러닝 생태계를 이루는 어벤져스 군단(Core ML, Create ML, Vision, NL)을 만나봤고, 남이 만든 모델을 우리 앱에 통합하는 첫 전투도 치러봤어. 거기서 멈추지 않고 Create ML로 우리만의 맞춤 무기를 제작했고, Vision과 NL이라는 전문가들의 도움을 받아 더 세련된 전투 기술까지 익혔지. 마지막으로는 실제 전쟁터에서 살아남기 위한 생존 전략까지 모두 점검했어.

처음 이 글을 시작할 때만 해도 '머신러닝'이라는 단어가 막연하고 거대하게 느껴졌을지 몰라. 하지만 이제는 어때? `.mlmodel` 파일이 더 이상 낯설지 않고, `VNCoreMLRequest` 같은 코드를 보면 어떤 흐름으로 동작할지 머릿속에 그려지지 않아?

그렇다면 성공이야. 이 글의 목표는 너를 하루아침에 머신러닝 박사로 만드는 게 아니었어. 그저 네 안에 있던 '나도 AI 기능을 만들어보고 싶다'는 작은 불씨에, '할 수 있겠다!'는 자신감의 기름을 부어주는 것이었지.

Apple과 Swift는 머신러닝의 높은 진입 장벽을 허물고, 우리 같은 앱 개발자들에게 상상력을 현실로 만들 수 있는 놀라운 도구를 쥐여줬어. 이제 공은 우리에게 넘어온 거야.

오늘 배운 것들을 가지고 작은 토이 프로젝트부터 시작해봐. 내 강아지 사진만 인식하는 분류기, 내가 좋아하는 영화 리뷰의 감성을 분석하는 앱, 뭐든 좋아. 직접 데이터를 모으고, Create ML로 훈련시키고, 앱에 통합해서 내 손안에서 돌아가는 걸 보는 그 순간의 짜릿함은, 아마 그 어떤 경험보다 강렬할 거야.

기억해, 세상의 모든 위대한 앱들도 처음에는 소박한 아이디어와 몇 줄의 코드에서 시작했어. 당신의 다음 앱이, 당신이 오늘 배운 이 기술을 통해 누군가의 삶을 더 편리하고 즐겁게 만들어주는, 그런 멋진 앱이 되기를 진심으로 응원할게.

이제 키보드를 잡고, 당신의 상상력을 코드로 바꿔봐. 미래는 생각보다 훨씬 가까이에 있으니까!