지원하는 변환 도구들:

• coremltools: TensorFlow, PyTorch, Keras 모델 변환
• Create ML: Xcode에서 직접 모델 학습
• Turi Create: 파이썬으로 모델 만들고 변환

import coremltools as ct

# TensorFlow 모델 로드
tf_model = tf.keras.models.load_model('my_model.h5')

# Core ML 형식으로 변환
coreml_model = ct.convert(tf_model)

# 저장
coreml_model.save('MyImageClassifier.mlmodel')

import CoreML

// 모델 인스턴스 생성
let model = try! MobileNetV2()

// 예측 실행
let prediction = try! model.prediction(image: pixelBuffer)

// 결과 확인
print("분류 결과: \(prediction.classLabel)")
print("확률: \(prediction.classLabelProbs)")

import Vision
import CoreML

// Core ML 모델을 Vision 모델로 래핑
let model = try! VNCoreMLModel(for: MyClassifier().model)

// Vision 요청 생성
let request = VNCoreMLRequest(model: model) { request, error in
    guard let results = request.results as? [VNClassificationObservation] else {
        return
    }
    
    // 결과 처리
    for result in results {
        print("\(result.identifier): \(result.confidence)")
    }
}

// 이미지 처리
let handler = VNImageRequestHandler(cgImage: image)
try! handler.perform([request])

import Vision

func detectFaces(in image: CGImage) {
    // 얼굴 감지 요청 생성
    let faceDetectionRequest = VNDetectFaceRectanglesRequest { request, error in
        guard let observations = request.results as? [VNFaceObservation] else {
            return
        }
        
        print("감지된 얼굴 수: \(observations.count)")
        
        for face in observations {
            // 얼굴 위치 (정규화된 좌표)
            let boundingBox = face.boundingBox
            print("얼굴 위치: \(boundingBox)")
            
            // 신뢰도
            print("신뢰도: \(face.confidence)")
        }
    }
    
    // 얼굴 랜드마크도 함께 감지
    let landmarkRequest = VNDetectFaceLandmarksRequest { request, error in
        guard let observations = request.results as? [VNFaceObservation] else {
            return
        }
        
        for face in observations {
            if let landmarks = face.landmarks {
                // 눈, 코, 입 등의 위치
                if let leftEye = landmarks.leftEye {
                    print("왼쪽 눈 위치: \(leftEye.normalizedPoints)")
                }
                if let nose = landmarks.nose {
                    print("코 위치: \(nose.normalizedPoints)")
                }
            }
        }
    }
    
    // 요청 실행
    let handler = VNImageRequestHandler(cgImage: image, options: [:])
    try? handler.perform([faceDetectionRequest, landmarkRequest])
}

// Xcode 프로젝트에 .mlmodel 파일 추가
// 자동으로 Swift 클래스 생성됨

import CoreML

class ImageClassifier {
    let model: VNCoreMLModel
    
    init() {
        // 모델 로드
        guard let mlModel = try? MobileNetV2(configuration: MLModelConfiguration()).model,
              let visionModel = try? VNCoreMLModel(for: mlModel) else {
            fatalError("모델 로드 실패")
        }
        self.model = visionModel
    }
}

import Vision
import UIKit

class ImageClassifier {
    let model: VNCoreMLModel
    
    init() {
        guard let mlModel = try? MobileNetV2(configuration: MLModelConfiguration()).model,
              let visionModel = try? VNCoreMLModel(for: mlModel) else {
            fatalError("모델 로드 실패")
        }
        self.model = visionModel
    }
    
    func classify(image: UIImage, completion: @escaping ([Classification]) -> Void) {
        guard let ciImage = CIImage(image: image) else {
            completion([])
            return
        }
        
        // Vision 요청 생성
        let request = VNCoreMLRequest(model: model) { request, error in
            guard let results = request.results as? [VNClassificationObservation] else {
                completion([])
                return
            }
            
            // 상위 5개 결과만 추출
            let topResults = results.prefix(5).map { observation in
                Classification(
                    label: observation.identifier,
                    confidence: observation.confidence
                )
            }
            
            completion(topResults)
        }
        
        // 이미지 방향 설정
        request.imageCropAndScaleOption = .centerCrop
        
        // 요청 실행
        let handler = VNImageRequestHandler(ciImage: ciImage, options: [:])
        DispatchQueue.global(qos: .userInitiated).async {
            try? handler.perform([request])
        }
    }
}

struct Classification {
    let label: String
    let confidence: Float
    
    var confidencePercentage: String {
        return String(format: "%.1f%%", confidence * 100)
    }
}

import SwiftUI

struct ContentView: View {
    @State private var selectedImage: UIImage?
    @State private var classifications: [Classification] = []
    @State private var isAnalyzing = false
    @State private var showImagePicker = false
    
    let classifier = ImageClassifier()
    
    var body: some View {
        VStack(spacing: 20) {
            // 이미지 표시
            if let image = selectedImage {
                Image(uiImage: image)
                    .resizable()
                    .scaledToFit()
                    .frame(maxHeight: 300)
                    .cornerRadius(12)
                    .shadow(radius: 5)
            } else {
                RoundedRectangle(cornerRadius: 12)
                    .fill(Color.gray.opacity(0.2))
                    .frame(height: 300)
                    .overlay(
                        Text("사진을 선택하세요")
                            .foregroundColor(.gray)
                    )
            }
            
            // 분석 버튼
            Button(action: {
                showImagePicker = true
            }) {
                Label("사진 선택", systemImage: "photo.on.rectangle")
                    .font(.headline)
                    .foregroundColor(.white)
                    .padding()
                    .background(Color.blue)
                    .cornerRadius(10)
            }
            
            // 분석 중 표시
            if isAnalyzing {
                ProgressView("분석 중...")
                    .padding()
            }
            
            // 결과 표시
            if !classifications.isEmpty {
                VStack(alignment: .leading, spacing: 12) {
                    Text("분석 결과")
                        .font(.headline)
                        .padding(.top)
                    
                    ForEach(classifications.indices, id: \.self) { index in
                        HStack {
                            Text("\(index + 1).")
                                .font(.caption)
                                .foregroundColor(.gray)
                            
                            Text(classifications[index].label)
                                .font(.body)
                            
                            Spacer()
                            
                            Text(classifications[index].confidencePercentage)
                                .font(.caption)
                                .foregroundColor(.blue)
                        }
                        .padding(.vertical, 4)
                    }
                }
                .padding()
                .background(Color.gray.opacity(0.1))
                .cornerRadius(10)
            }
            
            Spacer()
        }
        .padding()
        .sheet(isPresented: $showImagePicker) {
            ImagePicker(image: $selectedImage, onImageSelected: analyzeImage)
        }
    }
    
    func analyzeImage() {
        guard let image = selectedImage else { return }
        
        isAnalyzing = true
        classifications = []
        
        classifier.classify(image: image) { results in
            DispatchQueue.main.async {
                self.classifications = results
                self.isAnalyzing = false
            }
        }
    }
}

import coremltools as ct

# 모델 로드
model = ct.models.MLModel('MyModel.mlmodel')

# 16비트로 양자화
model_fp16 = ct.models.neural_network.quantization_utils.quantize_weights(
    model, 
    nbits=16
)

# 저장
model_fp16.save('MyModel_FP16.mlmodel')

// 배치 예측 설정
let model = try! MobileNetV2()
let batchProvider = try! MLArrayBatchProvider(array: images)

// 한 번에 처리
let predictions = try! model.predictions(from: batchProvider)

// 결과 확인
for i in 0..<predictions.count {
    let prediction = predictions.features(at: i)
    // 처리...
}

class ModelManager {
    static let shared = ModelManager()
    
    private let model: VNCoreMLModel
    
    private init() {
        // 앱 시작 시 한 번만 로드
        guard let mlModel = try? MobileNetV2().model,
              let visionModel = try? VNCoreMLModel(for: mlModel) else {
            fatalError("모델 로드 실패")
        }
        self.model = visionModel
    }
    
    func getModel() -> VNCoreMLModel {
        return model
    }
}

// 사용
let model = ModelManager.shared.getModel()

func processImage(_ image: UIImage) {
    // 백그라운드 큐에서 처리
    DispatchQueue.global(qos: .userInitiated).async {
        // 무거운 작업
        let result = self.analyzeImage(image)
        
        // UI 업데이트는 메인 스레드에서
        DispatchQueue.main.async {
            self.updateUI(with: result)
        }
    }
}

import Vision

class ObjectTracker {
    private var lastObservation: VNDetectedObjectObservation?
    private let sequenceHandler = VNSequenceRequestHandler()
    
    func track(in pixelBuffer: CVPixelBuffer) -> CGRect? {
        guard let lastObservation = lastObservation else {
            // 첫 프레임: 객체 감지
            return detectInitialObject(in: pixelBuffer)
        }
        
        // 추적 요청 생성
        let request = VNTrackObjectRequest(
            detectedObjectObservation: lastObservation
        ) { [weak self] request, error in
            guard let observation = request.results?.first as? VNDetectedObjectObservation else {
                return
            }
            
            // 다음 프레임을 위해 저장
            self?.lastObservation = observation
        }
        
        // 추적 정확도 설정
        request.trackingLevel = .accurate
        
        // 요청 실행
        try? sequenceHandler.perform([request], on: pixelBuffer)
        
        return lastObservation?.boundingBox
    }
    
    private func detectInitialObject(in pixelBuffer: CVPixelBuffer) -> CGRect? {
        // 초기 객체 감지 로직
        // ...
        return nil
    }
}

import Vision
import VisionKit

class DocumentScanner {
    func scanDocument(image: CGImage, completion: @escaping (String) -> Void) {
        var recognizedText = ""
        
        // 텍스트 인식 요청
        let request = VNRecognizeTextRequest { request, error in
            guard let observations = request.results as? [VNRecognizedTextObservation] else {
                completion("")
                return
            }
            
            // 인식된 텍스트 결합
            recognizedText = observations.compactMap { observation in
                observation.topCandidates(1).first?.string
            }.joined(separator: "\n")
            
            completion(recognizedText)
        }
        
        // 인식 레벨 설정 (accurate가 더 정확하지만 느림)
        request.recognitionLevel = .accurate
        
        // 언어 설정
        request.recognitionLanguages = ["ko-KR", "en-US"]
        
        // 자동 언어 감지
        request.usesLanguageCorrection = true
        
        // 요청 실행
        let handler = VNImageRequestHandler(cgImage: image, options: [:])
        try? handler.perform([request])
    }
}

import CoreML
import CoreImage

class StyleTransfer {
    let model: VNCoreMLModel
    
    init() {
        // 스타일 트랜스퍼 모델 로드
        guard let mlModel = try? StyleTransferModel().model,
              let visionModel = try? VNCoreMLModel(for: mlModel) else {
            fatalError("모델 로드 실패")
        }
        self.model = visionModel
    }
    
    func applyStyle(to image: UIImage, completion: @escaping (UIImage?) -> Void) {
        guard let ciImage = CIImage(image: image) else {
            completion(nil)
            return
        }
        
        let request = VNCoreMLRequest(model: model) { request, error in
            guard let results = request.results as? [VNPixelBufferObservation],
                  let pixelBuffer = results.first?.pixelBuffer else {
                completion(nil)
                return
            }
            
            // 픽셀 버퍼를 UIImage로 변환
            let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
            let context = CIContext()
            
            if let cgImage = context.createCGImage(ciImage, from: ciImage.extent) {
                let styledImage = UIImage(cgImage: cgImage)
                completion(styledImage)
            } else {
                completion(nil)
            }
        }
        
        let handler = VNImageRequestHandler(ciImage: ciImage)
        DispatchQueue.global(qos: .userInitiated).async {
            try? handler.perform([request])
        }
    }
}

import Vision

class PoseEstimator {
    func detectPose(in image: CGImage, completion: @escaping ([VNHumanBodyPoseObservation]) -> Void) {
        let request = VNDetectHumanBodyPoseRequest { request, error in
            guard let observations = request.results as? [VNHumanBodyPoseObservation] else {
                completion([])
                return
            }
            
            completion(observations)
        }
        
        let handler = VNImageRequestHandler(cgImage: image)
        try? handler.perform([request])
    }
    
    func analyzePose(_ observation: VNHumanBodyPoseObservation) {
        // 주요 관절 위치 가져오기
        guard let recognizedPoints = try? observation.recognizedPoints(.all) else {
            return
        }
        
        // 왼쪽 팔꿈치
        if let leftElbow = recognizedPoints[.leftElbow] {
            print("왼쪽 팔꿈치 위치: \(leftElbow.location)")
            print("신뢰도: \(leftElbow.confidence)")
        }
        
        // 오른쪽 무릎
        if let rightKnee = recognizedPoints[.rightKnee] {
            print("오른쪽 무릎 위치: \(rightKnee.location)")
        }
        
        // 각도 계산 등 추가 분석 가능
    }
}

// Compute Units 설정 예시
let config = MLModelConfiguration()
config.computeUnits = .cpuAndGPU  // 또는 .cpuOnly, .all

let model = try! MobileNetV2(configuration: config)

// Autorelease Pool 사용
for image in images {
    autoreleasepool {
        let result = processImage(image)
        // 처리...
    }  // 여기서 메모리 자동 해제
}

let model = try! MobileNetV2()

// 모델 메타데이터
print("모델 이름: \(model.model.modelDescription.metadata[.description] ?? "")")
print("입력 형식: \(model.model.modelDescription.inputDescriptionsByName)")
print("출력 형식: \(model.model.modelDescription.outputDescriptionsByName)")

// 예상 입력 크기
if let imageConstraint = model.model.modelDescription
    .inputDescriptionsByName["image"]?
    .imageConstraint {
    print("입력 크기: \(imageConstraint.pixelsWide) x \(imageConstraint.pixelsHigh)")
}

import os.signpost

let log = OSLog(subsystem: "com.myapp.ml", category: "Performance")

func measurePerformance() {
    let signpostID = OSSignpostID(log: log)
    os_signpost(.begin, log: log, name: "ML Inference", signpostID: signpostID)
    
    // ML 작업 수행
    let result = model.prediction(image: image)
    
    os_signpost(.end, log: log, name: "ML Inference", signpostID: signpostID)
}

// Instruments에서 확인 가능!

// Vision 요청 결과를 이미지에 그리기
func visualizeResults(_ observations: [VNRecognizedObjectObservation], on image: UIImage) -> UIImage {
    let imageSize = image.size
    let scale = UIScreen.main.scale
    
    UIGraphicsBeginImageContextWithOptions(imageSize, false, scale)
    image.draw(at: .zero)
    
    let context = UIGraphicsGetCurrentContext()!
    context.setStrokeColor(UIColor.red.cgColor)
    context.setLineWidth(3.0)
    
    for observation in observations {
        let boundingBox = observation.boundingBox
        
        // Vision 좌표계를 UIKit 좌표계로 변환
        let rect = VNImageRectForNormalizedRect(
            boundingBox,
            Int(imageSize.width),
            Int(imageSize.height)
        )
        
        // 박스 그리기
        context.stroke(rect)
        
        // 레이블 표시
        let label = observation.labels.first?.identifier ?? "Unknown"
        let confidence = observation.labels.first?.confidence ?? 0
        let text = "\(label) (\(String(format: "%.1f%%", confidence * 100)))"
        
        let attributes: [NSAttributedString.Key: Any] = [
            .font: UIFont.boldSystemFont(ofSize: 16),
            .foregroundColor: UIColor.red
        ]
        
        text.draw(at: CGPoint(x: rect.minX, y: rect.minY - 20), withAttributes: attributes)
    }
    
    let resultImage = UIGraphicsGetImageFromCurrentImageContext()!
    UIGraphicsEndImageContext()
    
    return resultImage
}

// 모델 암호화 (Python)
import coremltools as ct

model = ct.models.MLModel('MyModel.mlmodel')

# 암호화 키 생성
encryption_key = "your-secret-key-here"

# 암호화된 모델 저장
model.save('EncryptedModel.mlmodelc', 
          encryption_key=encryption_key)

// 동물 포즈 인식
let request = VNDetectAnimalBodyPoseRequest { request, error in
    guard let observations = request.results as? [VNAnimalBodyPoseObservation] else {
        return
    }
    
    for observation in observations {
        // 동물의 관절 위치 분석
        if let points = try? observation.recognizedPoints(.all) {
            print("감지된 관절: \(points.count)개")
        }
    }
}

let handler = VNImageRequestHandler(cgImage: image)
try? handler.perform([request])