View in English

  • Apple Developer
    • 시작하기

    시작하기 탐색

    • 개요
    • 알아보기
    • Apple Developer Program

    알림 받기

    • 최신 뉴스
    • Hello Developer
    • 플랫폼

    플랫폼 탐색

    • Apple 플랫폼
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    • App Store

    피처링

    • 디자인
    • 배포
    • 게임
    • 액세서리
    • 웹
    • 홈
    • CarPlay
    • 기술

    기술 탐색

    • 개요
    • Xcode
    • Swift
    • SwiftUI

    피처링

    • 손쉬운 사용
    • 앱 인텐트
    • Apple Intelligence
    • 게임
    • 머신 러닝 및 AI
    • 보안
    • Xcode Cloud
    • 커뮤니티

    커뮤니티 탐색

    • 개요
    • Apple과의 만남 이벤트
    • 커뮤니티 주도 이벤트
    • 개발자 포럼
    • 오픈 소스

    피처링

    • WWDC
    • Swift Student Challenge
    • 개발자 이야기
    • App Store 어워드
    • Apple 디자인 어워드
    • 문서

    문서 탐색

    • 문서 라이브러리
    • 기술 개요
    • 샘플 코드
    • 휴먼 인터페이스 가이드라인
    • 비디오

    릴리즈 노트

    • 피처링 업데이트
    • iOS
    • iPadOS
    • macOS
    • watchOS
    • visionOS
    • tvOS
    • Xcode
    • 다운로드

    다운로드 탐색

    • 모든 다운로드
    • 운영 체제
    • 애플리케이션
    • 디자인 리소스

    피처링

    • Xcode
    • TestFlight
    • 서체
    • SF Symbols
    • Icon Composer
    • 지원

    지원 탐색

    • 개요
    • 도움말
    • 개발자 포럼
    • 피드백 지원
    • 문의하기

    피처링

    • 계정 도움말
    • 앱 심사 지침
    • App Store Connect 도움말
    • 새로 추가될 요구 사항
    • 계약 및 지침
    • 시스템 상태
  • 빠른 링크

    • 이벤트
    • 뉴스
    • 포럼
    • 샘플 코드
    • 비디오
 

비디오

메뉴 열기 메뉴 닫기
  • 컬렉션
  • 전체 비디오
  • 소개

더 많은 비디오

  • 소개
  • 요약
  • 자막 전문
  • 코드
  • Core AI 만나 보기

    온디바이스 AI 모델 배포를 위한 Apple의 새로운 프레임워크인 Core AI를 알아보세요. 모델 변환, 제작 및 최적화를 위한 Python 라이브러리부터 간편한 플러그 앤 플레이 추론과 엄격한 지연 시간 및 메모리 요구 사항이 있는 고급 사용 사례를 위한 Swift API까지, 생태계를 둘러보세요. 인기 아키텍처용 바로 실행 가능한 예제가 포함된 새로운 Core AI 모델 리포지토리를 살펴보세요. 사전 모델 컴파일 등 심층적인 Xcode 통합으로 워크플로를 간소화하여 더 스마트하고 반응성이 뛰어난 앱 경험을 선사할 수 있는 방법을 알아보세요.

    챕터

    • 0:00 - Introduction
    • 0:33 - What is Core AI
    • 4:57 - Model conversion
    • 6:16 - App integration
    • 10:48 - Profiling with Instruments
    • 11:15 - Optimizing performance
    • 14:13 - Additional features
    • 15:34 - Specialization
    • 20:07 - Next steps

    리소스

    • Core AI PyTorch Extensions
    • Core AI Python
    • Core AI Optimization
    • Core AI
    • Compiling Core AI models ahead of time
    • Managing model specialization and caching
      • HD 비디오
      • SD 비디오

    관련 비디오

    WWDC26

    • Core AI 모델 제작 및 최적화 자세히 살펴보기
    • Core AI를 사용하여 앱에 온디바이스 AI 모델 통합하기
    • Metal 텐서로 맞춤형 머신 러닝 연산 최적화하기
  • 비디오 검색…

    안녕하세요, 저는 Ben이고 Core AI 팀 엔지니어입니다 오늘은 Core AI를 소개해 드리겠습니다 그리고 여러분의 앱에 지능형 기능을 추가하는 방법을 보여드릴게요 AI는 그 어느 때보다 빠르게 발전하고 있습니다 이전에는 달성하기 어려웠던 새로운 모델과 기능들이 끊임없이 등장하고 있습니다 Core AI는 그 흐름을 활용하고 그 위에서 개발할 수 있도록 구축되었습니다 Core AI는 기기 내 AI 실행의 다음 단계를 제시하며 Apple 플랫폼 전반에서 활용됩니다 최신 워크로드를 위해 처음부터 새롭게 구축되었으며 여러분에게 필요한 고성능 추론 기능을 제공하여 고급 AI 기능을 구현할 수 있게 해줍니다 Core AI는 기기 내 Apple Intelligence를 구동하는 추론 프레임워크입니다 이제 여러분도 사용할 수 있게 되었으며 그 강력한 성능을 앱의 자체 지능에 활용할 수 있습니다 Core AI는 단순한 프레임워크가 아닙니다 모델 배포 라이프사이클을 아우르는 완전한 기술 집합으로 모델 최적화 및 변환부터 디버깅과 앱 통합까지 모두 포함합니다 훌륭한 AI 기능 개발에 필요한 빠르고 반복적인 사이클을 지원하도록 설계되었습니다 Core AI를 사용하면 Apple Silicon 전체를 활용할 수 있습니다 CPU, GPU, Neural Engine 전반에서 매우 빠른 추론 성능을 제공합니다 이 프레임워크는 최신 Swift API를 제공합니다 앱이 요구하는 성능을 충족하는 표현력 있는 API로 메모리 안전성도 타협하지 않습니다

    광범위한 기술 집합은 일반적인 ML 엔지니어링 워크플로우에 자연스럽게 통합되며 익숙한 Python과 PyTorch 기반을 재사용하여 모델 작성, 최적화 및 변환을 지원합니다 Core AI는 광범위한 커스터마이징도 지원합니다 세밀한 추론 관리와 모델 특화부터 커스텀 GPU 커널까지 가능합니다 이 모든 것이 새로운 개발자 툴체인에 긴밀하게 통합되어 사전 컴파일, 전용 Core AI Instruments 그리고 강력한 시각적 디버거를 제공하며 텐서 값을 원래 Python 소스 코드까지 직접 추적할 수 있습니다 Core AI는 필요와 가용 컴퓨팅에 맞게 확장되도록 설계되었습니다 라이브 회의에서 누가 말하는지 파악하고 싶은 경우 소규모 화자 분리 모델을 사용하거나 사용자가 카메라로 무엇이든 가리키고 질문을 할 수 있게 하거나 대규모 비전 언어 모델로 즉각적인 답변을 제공하거나 복잡한 다단계 작업을 위임할 수 있게 하거나 700억 파라미터 LLM으로 구동되는 강력한 에이전트 어시스턴트를 만들 때도 Core AI로 모두 가능합니다 이 모든 것이 Apple 기기에서 로컬로 실행되며 서버도, 토큰당 비용도 없습니다 이번 세션에서는 먼저 모델을 Core AI 형식으로 변환하는 방법을 보여드리겠습니다 그런 다음 변환된 모델을 앱에 통합하는 방법을 설명하겠습니다 이어서 조금 더 깊이 들어가 모델과 앱의 성능을 최적화하는 방법을 다루겠습니다 마지막으로 유용하게 활용할 수 있는 Core AI의 추가 기능과 관련 도구들을 소개해 드리겠습니다 시작해 볼게요 훌륭한 앱 경험은 아이디어에서 시작됩니다 조금 마법 같은 느낌을 주는 무언가를 만들고 싶을 수도 있고 지능적으로 반응하는 무언가나 사람이나 하드코딩된 규칙 없이는 내릴 수 없는 결정을 하는 것을 원할 수도 있습니다 머신러닝과 AI가 바로 그런 경험을 가능하게 만들어 줍니다 아이디어가 생기면 다음 단계는 그것을 구동할 모델을 찾거나 구축하는 것입니다 아이디어 자체가 시간이 지남에 따라 발전하는 것처럼 올바른 모델을 찾는 것도 반복적인 과정입니다 여러 가지를 시도하고 요구사항에 맞게 평가하고 개선하게 됩니다 Core AI는 그 반복 과정을 지원하도록 설계되어 가능한 한 빠르고 매끄럽게 진행할 수 있도록 해줍니다 이를 구체적으로 보여드리기 위해 제가 생각한 재미있는 게임 아이디어를 구현해 보겠습니다 이 앱은 2인용 스네이크 게임으로 뱀 하나가 Core AI를 통해 실행되는 AI 모델로 구동됩니다 앱은 전통적인 스네이크 규칙을 따르며 뱀은 먹이를 먹으면 성장하고 벽, 자기 자신, 그리고 상대 뱀과의 충돌을 피해야 합니다 마지막까지 살아남은 뱀이 승리합니다 각 시간 단계마다 AI 모델은 특징 집합을 입력으로 받으며 현재 보드 상태를 나타내는 특징들이 누적되어 전체 게임 히스토리로 모델에 전달됩니다 그러면 이동할 최적의 방향을 예측합니다 스네이크는 단순한 게임이지만 이 경험을 만드는 데 사용되는 도구와 API는 동일한 기반이며 더 크고 복잡한 사용 사례까지 확장됩니다 저는 궁금했습니다 이 프로젝트에 PyTorch로 무엇을 만들 수 있을지 AI 코딩 어시스턴트의 도움을 조금 받아 간단한 스네이크 행동 예측 모델을 꽤 빠르게 스케치할 수 있었습니다 학습을 위해 간단한 시뮬레이션을 사용해 훈련 데이터를 생성했는데 단순히 게임을 실행하며 상태와 행동을 기록했습니다 아이디어는 단순하게 시작하여 앱에서 모델이 동작하게 하는 것이었습니다 다음 단계는 이 PyTorch 모델을 Core AI로 변환하는 것입니다 새로운 Core AI Torch Python 패키지를 사용하면 쉽게 변환을 수행할 수 있습니다

    먼저 SnakeTransformer 모듈의 훈련된 체크포인트를 불러오고 샘플 입력을 준비합니다 그런 다음 torch.export를 사용해 torch 프로그램을 내보내고 dynamic_shapes 인수도 사용하여 특징의 시퀀스 길이가 동적임을 지정합니다 그래야 정적 샘플 길이 5로 추적되지 않습니다 또한 변환된 프로그램에 분해를 실행하며 Core AI의 분해 테이블을 사용합니다 다음으로 Core AI의 TorchConverter를 실행하여 입력과 출력의 이름을 지정하고 마지막으로 변환된 Core AI 모델을 디스크에 저장합니다 Python 환경을 떠나기 전에 한 가지 더 할 일이 있습니다 변환된 Core AI 모델이 원래 PyTorch 모델의 수치와 일치하는지 검증하는 테스트를 실행합니다 이 작업은 Core AI 프레임워크 Python 바인딩으로 쉽게 수행할 수 있습니다 먼저 PyTorch와 Core AI 모델을 불러옵니다 그런 다음 스네이크 게임 샘플 입력을 준비합니다 그런 다음 동일한 입력을 PyTorch 모듈에 실행하고 Core AI 추론 함수에도 실행합니다 마지막으로 사용 사례에 충분히 작은 델타를 검증합니다 PyTorch와 Core AI 출력 간의 차이를요 이제 변환된 AI 모델이 준비되었으니 다음 단계는 Xcode로 이동하여 앱에 모델을 통합하는 것입니다 먼저 Xcode로 AI 모델 파일을 열면 모델에 대한 정보가 표시됩니다 모델 크기, 연산의 분포 그리고 기타 유용한 메타데이터가 포함됩니다 Functions 탭에서는 모델 내 각 고유 함수의 정확한 함수 시그니처를 확인할 수 있습니다 이 경우 모델에는 함수가 하나만 있으며 게임 보드의 특징을 입력으로 받아 로짓을 출력으로 생성합니다 이 로짓은 모델이 이동하기 가장 좋다고 생각하는 방향을 나타냅니다 또한 NDArray 값의 물음표는 해당 차원이 동적 형태를 갖는다는 것을 나타내며 동적 시퀀스 길이로 변환한 방식과 일치합니다 이제 Xcode 프로젝트에 AI 모델 파일을 포함시키고 구조를 살펴보았으니 다음 단계는 Core AI 프레임워크를 사용하여 모델을 실행하는 것입니다 Core AI 프레임워크는 새로운 Swift API 표면으로 Core AI 모델을 로드하고 실행합니다 점진적으로 공개되는 API 집합을 제공하여 간단하게 시작하고 실행할 수 있으며 더 깊은 유연성 레이어도 갖추고 있어 성능이 중요한 애플리케이션을 지원합니다 또한 non-escapable 타입과 같은 최신 Swift 언어 기능을 활용하여 성능을 희생하지 않으면서 메모리 안전 API를 제공합니다 프레임워크 내의 핵심 타입에 대해 먼저 살펴보겠습니다 AIModel은 .aimodel 파일의 URL로 초기화되며 주로 하나 이상의 추론 함수를 검사하고 로드하는 데 사용됩니다 InferenceFunction은 실행 가능한 객체로 로드된 단일 컴퓨팅 그래프를 나타냅니다 일반적인 경우 AIModel에는 하나의 메인 InferenceFunction만 있지만 여러 함수로 하나의 모델을 변환할 수도 있습니다 AIModel과 InferenceFunction은 일반적으로 앱의 AI 기능을 준비할 때 구성하는 객체입니다 예를 들어 앱 초기화 시에 구성할 수 있습니다 NDArray는 다차원 입력 및 출력 데이터를 담는 타입이며 InferenceFunction의 run 메서드를 사용하여 해당 데이터로 추론을 실행합니다 마지막으로 추론의 출력을 읽고 처리할 수 있습니다 스네이크 게임 구현을 위해 먼저 ModelPlayer 타입을 만들겠습니다 앱 초기화 시에 사용할 AI 모델 파일의 URL로 초기화됩니다 그런 다음 AIModel을 초기화하고 메인 추론 함수를 로드합니다 다음은 모델 플레이어가 결정을 내리는 로직입니다 앱에서 정의한 SnakePlayer 프로토콜을 준수합니다 주요 프로토콜 요구사항은 chooseAction 함수로 게임의 히스토리를 전달받아 뱀이 취할 다음 행동을 반환합니다 먼저 NDArray를 생성하여 입력 특징을 채웁니다 이 추론 함수에서 NDArray의 예상 구조는 float32 데이터의 2차원 배열로 형태의 첫 번째 차원은 현재 시퀀스 길이이고 두 번째는 고정된 히든 차원 크기입니다 그런 다음 NDArray에 특징을 기록합니다 writeFeatures 헬퍼 함수를 사용하여 게임과 NDArray의 변경 가능한 뷰를 인수로 전달합니다 NDArray.MutableView 타입은 non-escapable 타입으로 NDArray의 백킹 스토리지에 안전하고 효율적으로 접근을 제공합니다 입력을 준비한 후 추론을 실행하고 예상되는 출력 로짓 ndarray를 추출합니다 마지막 단계는 출력 로짓을 샘플링하여 뱀이 이동할 다음 방향을 선택하는 것으로 ndarray 뷰를 헬퍼 함수에 전달하여 값을 읽고 가장 큰 로짓에 해당하는 방향을 선택합니다 writeFeatures 함수는 입력 특징을 채우는 역할을 합니다 이 특징들이 무엇을 포함하는지 간단히 살펴보겠습니다

    AI 뱀의 머리에서 모든 벽까지의 정규화된 거리 가장 가까운 음식까지의 정규화된 상대적 X 및 Y 거리

    현재 방향을 인코딩하는 네 가지 요소 상대 뱀까지의 정규화된 거리 그리고 마지막으로 상대방의 방향 이제 이것을 모두 합쳐 테스트 실행을 해보겠습니다 두 뱀 모두 AI 모델로 구동하여 어떻게 되는지 보겠습니다

    실행해보니 모델이 작동하고 있습니다 그런데 게임이 진행될수록 점점 느려지는 것을 볼 수 있습니다 Core AI 프레임워크와 함께 Xcode에 새로운 Instrument가 있어 앱에서 실행되는 Core AI 모델을 프로파일링하는 데 도움이 됩니다 이 경우 Instruments로 앱을 실행했고 시간이 지남에 따라 추론 간격이 눈에 띄게 커지는 것을 볼 수 있는데 이는 추론 호출의 지연 시간이 증가하고 있다는 의미입니다 트랜스포머 모델은 시퀀스 길이에 대해 이차 시간 복잡도를 가지기 때문에 이는 자연스러운 결과입니다 우리 게임에서는 시퀀스 길이가 모델이 이동할 때마다 증가합니다 이 경우 다음 단계는 모델 사용 성능을 최적화하는 것입니다 입력 시퀀스가 증가할 때마다 트랜스포머 모델은 내부 키 그리고 시퀀스의 모든 요소에 대한 값 임베딩을 재계산합니다 트랜스포머를 사용할 때 이런 디코딩 루프의 성능을 개선하기 위해 일반적으로 사용되는 전략은 키와 값을 캐시하는 것으로 시퀀스의 각 요소에 대해 계산된 값을 추론마다 처음부터 재계산하지 않고 캐시합니다 이는 Core AI에서 상태를 사용하여 달성할 수 있습니다

    상태는 모델의 입력으로 읽히면서 추론 중에 인플레이스로 업데이트됩니다 키 및 값 캐시를 모델의 상태로 도입함으로써 각 추론마다 재계산하는 것을 피할 수 있고 전체 게임 히스토리를 입력으로 제공할 필요도 없어집니다 이전 단계에서 필요한 데이터가 상태에 저장되기 때문입니다 따라서 첫 번째 입력 이후 이후의 각 단계는 히스토리에 캐시를 사용하며 최신 보드 상태의 새로운 특징만 받습니다 키/값 캐싱을 구현하기 위해 원래 작성 코드로 돌아가 키 및 값 캐시를 추가하는 몇 가지 변경을 하겠습니다 먼저 torch 모듈을 업데이트하여 키 및 값 캐시 텐서를 torch register_buffer API를 사용하여 트랜스포머 모듈 내 버퍼로 추가합니다 이렇게 하면 나중에 이 텐서들이 내보낸 torch 프로그램에서 변경 가능한 버퍼가 되며 Core AI가 이를 상태로 변환합니다 그런 다음 모듈의 forward 함수에서 캐시를 실제로 사용하는 로직을 추가합니다 이는 캐시에서 이전 특징의 키와 값을 읽는 것을 포함합니다 그런 다음 새 특징에 대한 계산된 키와 값을 캐시에 다시 씁니다 마지막으로 이전과 동일한 코드를 재실행하여 모델을 다시 변환하되 이번에는 변환 호출에 state_names 인수를 추가하여 새로운 상태 인수의 이름을 지정합니다 새 함수 시그니처로 모델을 다시 변환했으니 앱 코드를 업데이트하겠습니다 먼저 ModelPlayer를 업데이트하여 키 및 값 캐시 NDArray를 저장합니다 이것들이 각 추론에 전달되는 상태 인수가 됩니다 트랜스포머에 맞는 예상 형태로 초기화합니다 이 경우 모델이 키와 값 캐시를 항상 최대 가능한 컨텍스트 길이에 맞는 고정 크기로 기대하도록 변환했습니다 그런 다음 추론을 실행할 시간이 되면 MutableView의 컬렉션을 구성하여 키 및 값 캐시의 뷰를 포함시킵니다 그런 다음 InferenceFunction.run 메서드의 states 인수로 제공합니다 이제 각 추론 중에 캐시가 읽히고 인플레이스로 업데이트됩니다 업데이트된 모델로 앱을 다시 실행해 보겠습니다 이번에는 일정한 속도를 유지하며 더 이상 시간이 지나도 느려지지 않습니다 Instruments에서 업데이트된 앱을 추적하면 추론 지연 시간이 훨씬 느린 속도로 증가하는 것을 확인할 수 있습니다 마무리하기 전에 스네이크 게임을 만들 때 사용하지 않았지만 자체 앱을 개발할 때 유용할 수 있는 기능들을 소개하겠습니다 스네이크 게임 모델을 변환할 때 coreai-torch 패키지를 사용하여 PyTorch 모듈을 직접 변환했습니다 이 방식은 간단하고 많은 사용 사례에서 잘 작동하지만 때로는 모델 작성 방법에 대해 더 많은 제어가 필요할 수 있으며 잠재적으로 모델 내 연산이 실행되는 방식까지도요 Core AI Python 패키지가 제공하는 것들을 아직 표면만 다뤘습니다 Core AI API를 사용하여 모델을 직접 작성하는 것도 지원하며 Apple Silicon에 맞게 모델을 최적화하고 Metal 4로 커스텀 커널 구현을 정의하는 것도 가능합니다 이러한 고급 모델 작성 방식에 대해 자세히 알아보려면 "Dive into Core AI model authoring and optimization" 세션을 참고하세요 성능 디버깅 외에도 변환된 모델의 수치를 디버깅하는 것도 중요합니다 이를 위해 Core AI Debugger를 사용할 수 있으며 변환된 모델을 시각화하고 중간 텐서 값을 쉽게 검사하며 변환된 모델의 연산을 해당 연산을 도입한 Python 소스 코드까지 역추적할 수 있습니다 편리한 Core AI 디버그 게이지도 있어 Xcode에서 앱이 실행되는 동안 스트리밍 Core AI 활동을 보여줍니다 Instruments로 넘어가기 전에 성능 문제를 발견하기에 좋은 곳입니다 스네이크 게임 구현에서 간략히 다룬 한 가지는 모델 특화 과정입니다

    앱과 함께 AI 모델을 배포할 때 그것은 모델의 소스 표현으로 모든 Apple 기기에서 실행할 수 있습니다 그러나 앱 내에서 모델을 실제로 로드하고 실행하려면 앱이 실행되는 기기에 맞게 특화되어야 합니다 모델이 로드될 때 확인하여 이미 특화되어 캐시되었는지 확인합니다 특화 과정은 매우 큰 모델의 경우 상당한 시간이 걸릴 수 있습니다 이후 로드는 캐시에서 빠르게 되지만 처음 한 번은 계획이 필요할 수 있습니다 사용자 인터랙티브 플로우 내에서 모델 특화가 발생하지 않도록 피하는 것을 권장합니다 Core AI가 이를 도울 수 있습니다 먼저 Core AI는 앱의 기본 모델 캐시에 프로그래밍 방식으로 접근할 수 있게 해줍니다 앱의 기본 모델 캐시에 접근할 수 있습니다 캐시에서 직접 모델을 로드하도록 요청할 수 있습니다 nil이 반환되면 캐시에 없으며 특화가 필요합니다 이를 사용하여 기능을 제한하거나 사용자에게 알릴 수 있습니다 앱이 모델을 준비하는 동안 잠시 기다려야 할 수 있다고요 둘째로, 앱에서 모델 특화를 명시적으로 요청할 수 있으며 로드와 독립적으로 수행할 수 있습니다 에셋을 다운로드한 후나 사용자가 기능을 선택했을 때 할 수 있어 모델이 미리 준비됩니다 더 많은 제어도 가능합니다 SpecializationOptions는 모델이 추론에 최적화되는 방식을 구성하는 데 도움이 됩니다 AIModelCache로 더 이상 필요 없는 항목을 삭제하고 항목의 지속 기간 정책을 제어할 수도 있습니다 동일한 앱 그룹의 여러 앱 간에 캐시를 공유할 수도 있습니다 "Managing model specialization and caching" 문서를 developer.apple.com에서 참고하세요

    특화가 언제 발생하든 간에 시간이 걸립니다 내부를 간단히 살펴보겠습니다 특화 중에 모델은 두 가지 주요 변환을 거칩니다 첫째로, 핵심 컴파일 단계를 거치며 컴퓨팅을 분할, 계획 및 최적화합니다 둘째로, 사용된 컴퓨팅 유닛에 대한 실행 가능한 아티팩트가 생성됩니다 이 아티팩트는 생성된 기기와 OS 버전에 연결됩니다 이 두 단계 중 컴파일이 대부분의 지연 시간을 차지합니다 Core AI 툴체인은 그 시간을 줄이는 데 도움을 줄 수 있습니다 개발 머신에서 일부 컴파일을 미리 수행하도록 허용함으로써 컴파일된 버전의 모델을 생성합니다 컴파일된 모델도 특정 사용자 기기에 맞게 특화되어야 하지만 해야 할 작업이 훨씬 적어 상당히 빠르게 완료됩니다 이 옵션에 대해 자세히 알아보려면 "Compiling Core AI models ahead of time" 문서를 developer.apple.com에서 자세히 확인 하세요. 특화가 언제, 어디서, 어떻게 이루어지는지 제어하는 것은 사용자 경험을 최적화하는 한 가지 방법입니다 최적화하고 싶은 또 다른 영역은 모델을 사용하는 밀접한 추론 루프에서 오버헤드를 제거하는 것입니다 Core AI 프레임워크에는 이를 위한 여러 API가 있습니다 동적으로 확인할 수 있으며 NDArray 인수의 최적 메모리 레이아웃을 확인하고 해당 구조로 할당하여 추론 시 레이아웃 변환을 피할 수 있습니다

    또한 프레임워크가 쓸 출력 값을 미리 할당할 수 있어 추론 중 새로운 출력 값 할당을 피할 수 있습니다

    비동기 값을 사용하여 여러 추론 함수의 실행을 효율적으로 파이프라이닝할 수도 있습니다 여러 추론 함수를 함께 파이프라이닝할 수 있습니다 대부분의 사용 사례에서 상위 레벨 추론 API가 필요한 곳에 정확히 도달하게 해줍니다 그러나 밀접한 추론 루프를 최적화하거나 모델을 복잡한 컴퓨팅 파이프라인에 통합할 때 이런 하위 레벨 API가 필요할 때 사용할 수 있습니다 막 시작하는 분이든 깊이 파고드는 분이든 Core AI Models 저장소는 필요한 것을 찾기에 좋은 곳입니다 인기 모델 컬렉션이 있으며 각각 단 하나의 명령어로 앱에 맞게 변환 및 최적화할 수 있습니다 Core AI 모델 작성을 전문으로 하는 AI 스킬과 최적화 및 변환 스킬도 있습니다

    특정 모델 계열을 위한 라이브러리가 담긴 Swift 패키지도 제공되며 이미 많은 하위 레벨 추론 최적화가 내장된 상위 레벨 API를 제공합니다 또한 Core AI 언어 모델을 만들기 위한 API도 제공하며 Foundation Models 프레임워크에 바로 연결됩니다 커스텀 모델과 토큰 샘플링 전략을 직접 가져올 수 있습니다 마무리하자면 Core AI는 모든 Apple Silicon에서 사용할 수 있어 모든 Apple 플랫폼에서 최첨단 AI 경험을 구축하는 데 도움을 드립니다 기존 Python 도구와 이미 친숙한 도구들과 긴밀하게 통합되어 있으며 앱 내에서 모델을 효율적으로 실행하기 위한 최신 Swift 프레임워크와 최첨단 디버깅 도구를 제공하여 Apple 기기에서 모델이 어떻게 실행되는지 이해할 수 있게 해줍니다 여러분이 어떤 경험을 만들어낼지 기대됩니다

    • 5:08 - Convert a PyTorch model to Core AI

      import torch
      import coreai_torch
      # Load trained snake model and sample input for tracing
      pt_model = SnakeTransformer().load_checkpoint("snake.pt")
      example  = torch.randn(1, 5, 16)
      
      # Export the torch program including dynamic shape for input sequence
      seq_len  = torch.export.Dim("seq_len", min=1, max=256)
      exported = torch.export.export(
          pt_model, args=(example,), 
          dynamic_shapes={"features": {1: seq_len}},
      )
      exported = exported.run_decompositions(coreai_torch.get_decomp_table())
      
      # Convert torch graph → Core AI graph
      ai_program = coreai_torch.TorchConverter().add_exported_program(
          exported, input_names=["features"], output_names=["logits"],
      ).to_coreai()
      
      # Save as a .aimodel asset the runtime can load
      ai_program.save_asset("SnakeTransformer.aimodel")
    • 5:44 - Verify converted model numerics

      import torch
      import numpy as np
      from coreai. runtime import AIModel, NDArray
      # Load models
      pt_model = SnakeTransformer().load_checkpoint("snake.pt")
      ai_model = await AIModel.load("SnakeTransformer.aimodel")
      function = ai_model.load_function("main")
      # Assemble input sample - 10 frames of 16-dim game features, shape (1, 10, 16)
      features = np.array(lextract_features(game) for - in range (10)],
      dtype=np.float32)[np.newaxis]
      # PyTorch reference
      with torch.no_grad():
      	pytorch_logits = pt_model(torch.from_numpy(features)) . numpy )[0, -1]
      # Core AI inference
      result = await function({ "features": NDArray(data=features)} )
      coreai_logits = result["logits"]. numpy()[0, -1]
      # Validate
      max_diff = np.max(np.abs(pytorch_logits - coreai_logits))
      	assert max_diff < 0.01
    • 7:41 - Core AI framework core types

      // Core types within Core AI
      import CoreAI
      
      // Load the '.aimodel' file
      let model = try await AIModel(contentsOf: modelURL)
      
      // Load the main inference function
      let mainFunction: InferenceFunction = try model.loadFunction(named: "main")!
      
      // Construct the n-dimensional input data
      let inputNDArray: NDArray = nextInput()
      
      // Run inference
      var outputs = try await mainFunction.run(inputs: ["input": inputNDArray])
      
      guard let outputNDArray = outputs.remove("output")?.ndArray else {
        // Handle unexpected missing output
      }
    • 8:33 - Initialize ModelPlayer with AIModel

      // Initialize the player by loading the AIModel and InferenceFunction
      struct ModelPlayer {
        let nextActionFunction: InferenceFunction
      
        init(modelURL: URL) async throws {
          let model = try await AIModel(contentsOf: modelURL)
          self.nextActionFunction = try model.loadFunction(named: "main")!
        }
      }
    • 8:49 - Run inference with NDArray inputs

      extension ModelPlayer: SnakePlayer {
      
        mutating func chooseAction(game: SnakeGame) async throws -> Direction {
      
          // Create an NDArray for the next input and write board features into it
          var inputFeatures = NDArray(shape: [game.stepCount, hiddenDim], scalarType: .float32)
          writeFeatures(of: game, into: inputFeatures.mutableView())
      
          // Run inference and extract the expected logits output NDArray
          var outputs = try await nextActionFunction.run(inputs: ["features": inputFeatures])
          guard let logits = outputs.remove("logits")?.ndArray else {
            throw ModelError.missingOutput
          }
      
          return predictedDirection(from: logits.view())
        }
      
        func writeFeatures(of game: SnakeGame, into view: consuming NDArray.MutableView<Float>) { … }
        func predictedDirection(from logits: NDArray.View<Float>) -> Direction { … }
      }
    • 10:10 - Input features for the snake model

      // Features at each time step
      var features = [Float]()
      
      // Distance to wall in all directions, normalized between [0, 1]
      features += [dWallUp, dWallDown, dWallLeft, dWallRight]
      
      // Distance to nearest food, normalized between [-1, 1]
      features += [dFoodX, dFoodY]
      
      // Direction encoded as one-hot: [1,0,0,0]=up, [0,1,0,0]=down, etc.
      features += dir.oneHotEncoding
      
      // Distance to the other snake, normalized to [-1, 1]
      features += [dUserX, dUserY]
      
      // Direction of the opponent snake
      features += dirU.oneHotEncoding
    • 12:18 - Add KV cache buffers to PyTorch module

      # Update torch module to include key and value caches
      # Use register_buffer to later make the exported torch program treat them as mutable
      
      class SnakeTransformerStateful(nn.Module):
          def __init__(self, ...):
              super().__init__()
              self.register_buffer(
                  "k_cache", torch.zeros(N_LAYERS, 1, MAX_SEQ_LEN, D_MODEL))
              self.register_buffer(
                  "v_cache", torch.zeros(N_LAYERS, 1, MAX_SEQ_LEN, D_MODEL))
              # …
    • 12:50 - Update forward pass to read/write KV caches

      # During forward pass, read/write KV caches
      
      class SnakeTransformerStateful(nn.Module):
      
          def forward(self, features, position_ids):
              new_k, new_v = [], []
              for i, block in enumerate(self.blocks):
                  # read previous keys/values from caches
                  k_prev = self.k_cache[i]
                  v_prev = self.v_cache[i]
                  # ... compute q/k/v for the new token, attend over valid prefix ...
                  new_k.append(k_updated)
                  new_v.append(v_updated)
      
              # Update key/value caches
              self.k_cache.copy_(torch.stack(new_k))
              self.v_cache.copy_(torch.stack(new_v))
      
              return self.action_head(self.ln_final(x))
    • 12:59 - Re-convert model with state names

      # Updated coreai-torch conversion code using key/value cache states
      import torch
      import coreai_torch
      
      exported = torch.export.export(
          stateful_model,
          args=(example_features, example_position_ids),
          dynamic_shapes={"position_ids": {1: seq_len}},
      )
      exported = exported.run_decompositions(coreai_torch.get_decomp_table())
      
      ai_program = coreai_torch.TorchConverter().add_exported_program(
          exported,
          input_names=["features", "position_ids"],
          state_names=["keyCache", "valueCache"],
          output_names=["logits"],
      ).to_coreai()
      
      ai_program.save_asset("SnakeTransformer.aimodel")
    • 13:17 - Store KV cache NDArrays in ModelPlayer

      // Add stored properties for the key and value caches
      struct ModelPlayer {
          let nextActionFunction: InferenceFunction
      
          var keyCache: NDArray
          var valueCache: NDArray
      
          init(modelURL: URL) async throws {
              let model = try await AIModel(contentsOf: modelURL)
              self.nextActionFunction = try model.loadFunction(named: "main")!
      
              self.keyCache = NDArray(shape: [layers, maxContext, hiddenDim], scalarType: .float32)
              self.valueCache = NDArray(shape: [layers, maxContext, hiddenDim], scalarType: .float32)
          }
      }
    • 13:45 - Pass state views to inference function

      extension ModelPlayer: SnakePlayer {
          mutating func chooseAction(game: SnakeGame, snakeID: Int) async throws -> Direction {
              // …
      
              var stateViews = InferenceFunction.MutableViews()
              stateViews.insert(&keyCache, for: "keyCache")
              stateViews.insert(&valueCache, for: "valueCache")
      
              // Run inference and extract the expected logits output NDArray
              var outputs = try await nextActionFunction.run(
                  inputs: ["features": inputFeatures],
                  states: stateViews)
              // …
          }
      }
    • 16:22 - Check model cache before loading

      // Check if your model can be loaded from the cache
      let cache = AIModelCache.default
      
      guard let model = try cache.model(for: modelURL, options: .default) else {
          Task { @MainActor in
              informUser("Preparing AI features. This may take a while…")
          }
      }
    • 16:42 - Request model specialization

      // Explicitly request specialization
      try await AIModel.specialize(contentsOf: modelURL)
    • 0:00 - Introduction
    • Introduction to Core AI and an overview of what the session covers: model conversion, app integration, performance optimization, and additional features.

    • 0:33 - What is Core AI
    • Core AI is the inference framework powering on-device Apple Intelligence, now available to developers. It covers the full model deployment lifecycle, leverages all of Apple Silicon (CPU, GPU, ANE), and comes with a modern Swift API, Python tooling, and a dedicated developer toolchain.

    • 4:57 - Model conversion
    • How to convert a PyTorch model to the Core AI format using the coreai-torch Python package — including exporting with torch.export, specifying dynamic shapes, running the converter, and verifying numerical correctness of the converted model.

    • 6:16 - App integration
    • How to load and run a Core AI model in your app using the CoreAI Swift framework — inspecting the model in Xcode's model viewer, initializing an AIModel, preparing inputs as NDArrays, running inference, and extracting outputs.

    • 10:48 - Profiling with Instruments
    • How to use the new Core AI instrument in Xcode to profile model latency and identify performance bottlenecks, such as growing inference times caused by quadratic complexity in transformer models.

    • 11:15 - Optimizing performance
    • How to eliminate inference slowdowns by adding a key-value cache as a stateful input to your model — authoring the cache in PyTorch, re-converting with state_names, and updating your app to pass MutableViews of the cache buffers at inference time.

    • 14:13 - Additional features
    • A tour of Core AI tools not used in the demo: the rich Python authoring experience, the Core AI Debugger for numeric debugging of converted models, and the Core AI debug gauge in Xcode for streaming activity monitoring.

    • 15:34 - Specialization
    • How Core AI specializes models for the target device — what happens during specialization, how to manage it with programmatic cache access and SpecializationOptions, and how ahead-of-time (AOT) compilation can shift work off the user's device.

    • 20:07 - Next steps
    • Summary of Core AI's capabilities: on-device inference across all Apple Silicon, Python tooling integration, and debugging tools — with an invitation to explore the Core AI Models repository.

Developer Footer

  • 비디오
  • WWDC26
  • Core AI 만나 보기
  • 메뉴 열기 메뉴 닫기
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    메뉴 열기 메뉴 닫기
    • Swift
    • SwiftUI
    • Swift Playground
    • TestFlight
    • Xcode
    • Xcode Cloud
    • SF Symbols
    메뉴 열기 메뉴 닫기
    • 손쉬운 사용
    • 액세서리
    • Apple Intelligence
    • 앱 확장 프로그램
    • App Store
    • 오디오 및 비디오(영문)
    • 증강 현실
    • 디자인
    • 배포
    • 교육
    • 서체(영문)
    • 게임
    • 건강 및 피트니스
    • 앱 내 구입
    • 현지화
    • 지도 및 위치
    • 머신 러닝 및 AI
    • 오픈 소스(영문)
    • 보안
    • Safari 및 웹(영문)
    메뉴 열기 메뉴 닫기
    • 문서(영문)
    • 튜토리얼
    • 다운로드
    • 포럼(영문)
    • 비디오
    메뉴 열기 메뉴 닫기
    • 지원 문서
    • 문의하기
    • 버그 보고
    • 시스템 상태(영문)
    메뉴 열기 메뉴 닫기
    • Apple Developer
    • App Store Connect
    • 인증서, 식별자 및 프로파일(영문)
    • 피드백 지원
    메뉴 열기 메뉴 닫기
    • Apple Developer Program
    • Apple Developer Enterprise Program
    • App Store Small Business Program
    • MFi Program(영문)
    • Mini Apps Partner Program
    • News Partner Program(영문)
    • Video Partner Program(영문)
    • Security Bounty Program(영문)
    • Security Research Device Program(영문)
    메뉴 열기 메뉴 닫기
    • Apple과의 만남
    • Apple Developer Center
    • App Store 어워드(영문)
    • Apple 디자인 어워드
    • Apple Developer Academy(영문)
    • WWDC
    최신 뉴스 읽기.
    Apple Developer 앱 받기.
    Copyright © 2026 Apple Inc. 모든 권리 보유.
    약관 개인정보 처리방침 계약 및 지침