Artikel mendalam tentang teknologi yang membentuk masa depan.

Pelajaran dari Knowledge Graph On-Device Milik Apple

Knowledge graph on-device Apple menunjukkan cara merilis ML privat dan local-first. Lima kesalahan umum praktisi dan perbaikan yang benar-benar berhasil.

Graph bercahaya berisi node dan edge abstrak melayang di atas laptop di ruangan gelap.
Personal knowledge graph ini tersusun sendiri dari sinyal yang sudah dikumpulkan perangkatmu.

Suruh Mac kamu “text adik laki-lakiku” dan ia langsung melakukannya. Tanpa spinner, tanpa pencarian yang terlihat, tanpa round-trip jaringan. Ia sudah tahu yang mana di antara ratusan orang di kontakmu yang merupakan adik laki-lakimu. Ini bisa terjadi karena setiap Mac sejak macOS Ventura diam-diam menjalankan knowledge graph on-device: sepasang daemon yang membaca Kontak, klaster wajah di Foto, peserta Kalender, metadata Mail dan Pesan, pola lokasi, dan data Screen Time, lalu menggabungkan semuanya menjadi penyimpanan yang bisa di-query tentang siapa dirimu, siapa yang kamu kenal, dan bagaimana orang-orang itu berelasi denganmu dan satu sama lain.

Peneliti keamanan baru-baru ini menyingkap seberapa dalam hal ini. Kedua daemon, knowledgeconstructiond dan intelligenceplatformd, memelihara direktori berisi 51 database SQLite di bawah ~/Library/IntelligencePlatform. Intinya, graph.db, adalah triple store yang ditulis dengan kosakata 181 kelas entitas dan 278 predikat, termasuk relasi kekerabatan hasil inferensi yang tidak pernah diketik siapa pun di kartu kontak. Perdebatan paling ramai seputar temuan ini adalah soal persetujuan (consent), dan itu debat yang wajar. Tapi saya menghabiskan bertahun-tahun mengirimkan fitur ML untuk mencari nafkah, dan ketika membaca analisis mendalamnya, reaksi pertama saya berbeda: ini salah satu contoh rekayasa ML local-first paling edukatif yang pernah dirilis dalam skala besar. Jadi alih-alih mengulas ulang soal etika, saya ingin membahas lima kesalahan yang sering dilakukan praktisi saat membangun sistem seperti ini, dan apa yang terbukti benar serta salah dilakukan insinyur Apple, supaya kamu tidak perlu belajar dengan cara yang sulit.

Kesalahan 1: Memakai Satu Model Besar Alih-alih Classifier Kecil

Insting pertama kebanyakan tim saat mendengar “OS memahami keluargamu” adalah mengira ada large language model di baliknya. Padahal tidak, dan di situlah pelajarannya. Inferensi kekerabatan yang jadi berita utama, yaitu sistem yang memutuskan kontak ini ibumu dan yang itu atasanmu, dilakukan oleh classifier kecil dan spesifik yang mengolah sinyal terstruktur: keanggotaan dan usia di Family Sharing, field nama terkait di Kontak, pola kehadiran bersama di Kalender, frekuensi dan arah komunikasi, serta kemunculan wajah bersama di Foto. Setiap classifier menjawab satu pertanyaan kecil dengan baik, lalu graph merangkai jawaban-jawaban itu.

Ini penting karena alasan yang sangat praktis: anggaran. Daemon yang berjalan terus-menerus, memakai baterai, bersamaan dengan semua proses lain di OS, tidak mampu menjalankan forward pass transformer untuk setiap event. Classifier kecil berjalan dalam hitungan mikrodetik di Neural Engine, cukup deterministik untuk diuji unit, dan ketika salah prediksi, kamu bisa melatih ulang satu classifier itu tanpa menyentuh yang lain. Saya pernah melihat tim menghabiskan berkuartal-kuartal mencoba membuat model umum melakukan hal yang bisa dilakukan lebih baik oleh gradient-boosted tree dengan tiga puluh fitur yang dipilih dengan cermat. Kami juga pernah membahas fenomena serupa di bidang visi: CNN spesialis secara rutin mengalahkan LLM frontier dalam klasifikasi gambar dengan biaya yang jauh lebih murah. Polanya berlaku di mana-mana. Fitur personalisasi hampir tidak pernah membutuhkan model umum. Yang dibutuhkan adalah skema yang baik dan segudang classifier yang membosankan tapi andal.

Manfaat lain yang kurang dihargai adalah graceful degradation. Jika pipeline pengenalan wajah tidak pernah berjalan karena pengguna tidak memakai Foto, classifier kekerabatan tetap punya Family Sharing dan Kontak untuk diolah. Model monolitik rusak secara katastrofik saat distribusi input bergeser, sedangkan ensemble classifier spesifik-sinyal hanya kehilangan satu suara. Saat kamu merancang fitur on-device berikutnya, sebutkan dulu sinyal-sinyal independennya, lalu tanyakan seperti apa model terkecil untuk tiap sinyal. Simpan LLM untuk tahap akhir interaksi bahasa alami, tempat ia benar-benar seharusnya berada.

Banyak mesin kecil spesialis bekerja berjajar sementara satu mesin raksasa diam tak terpakai di bawah terpal.
Ensemble classifier sempit mengalahkan satu model raksasa untuk inferensi yang selalu aktif dan dibatasi baterai.

Kesalahan 2: Menyimpan Fakta Tanpa Provenance atau Retraksi

Ada satu detail dalam analisis ini yang kebanyakan liputan lewatkan, dan menurut saya itulah bagian paling elegan. Sebuah edge dalam graph ini, “orang ini bekerja di organisasi ini”, bukan satu baris. Ia adalah dua baris yang berbagi relationshipId: satu baris menyebut tipe relasinya, baris lain menunjuk ke entitas terkait. Ada 46 kelas tipe relasi yang hanya ada untuk membawa indirection ini. Itu disebut reifikasi, dan alasannya adalah agar edge itu sendiri bisa membawa properti seperti skor kepercayaan, sumber, dan timestamp, serta agar bisa diretraksi nanti tanpa berpura-pura ia tidak pernah ada.

Ini kesalahan yang paling sering saya lihat pada sistem personalisasi buatan sendiri: fakta disimpan sebagai kolom datar. user.employer = "Acme". Ini berjalan baik sampai seseorang pindah kerja, bercerai, atau inferensinya memang salah. Lalu kamu harus memilih antara menimpa riwayat yang dibutuhkan untuk debugging atau membiarkan fakta usang tetap ada karena menghapusnya merusak sesuatu di hilir. Fakta personal cepat usang. Orang pindah, hubungan berakhir, perusahaan berganti. Penyimpanan yang tidak bisa menyatakan “kami percaya ini dengan keyakinan 0,7, bersumber dari peserta Kalender, diretraksi pada 3 Maret” akan diam-diam dipenuhi hantu. Skema yang menanganinya kira-kira seperti ini:

-- A reified edge: two rows share one relationship id,
-- so the edge itself can carry confidence and provenance.
CREATE TABLE triples (
subject    TEXT NOT NULL,          -- an entity id
predicate  TEXT NOT NULL,          -- e.g. 'relationshipType', 'relatedEntity'
object     TEXT NOT NULL,          -- a value or another entity id
rel_id     TEXT,                   -- groups the rows forming one edge
confidence REAL,                   -- how sure are we?
source     TEXT,                   -- which signal produced this fact
created    INTEGER NOT NULL,
retracted  INTEGER                 -- soft delete: facts decay, history stays
);
-- One edge, two rows:
-- ('person:8f2a', 'relationshipType', 'employerOf', 'rel:91', 0.82, 'calendar', ...)
-- ('person:8f2a', 'relatedEntity',    'org:acme',   'rel:91', 0.82, 'calendar', ...)

Perhatikan juga apa yang ditunjukkan pilihan implementasi ini: semuanya hidup di SQLite biasa. Tidak ada graph database eksotis, tidak ada storage engine kustom, cuma tabel yang bisa kamu query dengan database embedded paling teruji di dunia. Kalau kamu tergoda memakai graph store khusus untuk jumlah edge di kisaran jutaan pada satu perangkat, jangan. Kami sudah menulis tentang kapan embeddable graph database layak dipakai di luar SQLite, dan jawaban jujurnya adalah kebanyakan aplikasi tidak pernah sampai ke titik itu. Triple di SQLite, dengan indexing yang disiplin pada subject dan predicate, akan membawamu sangat jauh. Gunakan anggaran kompleksitasmu untuk semantik provenance dan retraksi, karena di situlah sistem seperti ini benar-benar patah.

Kesalahan 3: Menganggap Entity Resolution sebagai Detail yang Sudah Beres

Setiap design doc untuk sistem seperti ini yang pernah saya baca punya poin yang berbunyi “lalu kita satukan entitasnya”, seolah itu pekerjaan satu sore. Padahal itu bagian tersulit dari seluruh pipeline, dengan selisih yang sangat jauh. Kontakmu menulis “James Whitfield.” Foto punya klaster wajah tanpa nama. Kalender punya peserta “j.whitfield@company.com.” Pesan punya handle “+1-415-555-0142.” Nilai graph sepenuhnya bergantung pada apakah keempat observasi itu menjadi satu orang, dan apakah ia dengan benar tidak tergabung dengan James yang lain, yang dari klub lari kamu.

Arsitektur yang pragmatis adalah clustering inkremental dengan biaya error yang asimetris. Merge yang salah, yaitu memutuskan dua orang berbeda adalah satu orang, meracuni setiap inferensi di hilir dan sangat menyebalkan untuk diurai, karena fakta dari kedua orang sungguhan sekarang saling terikat di satu node. Split yang salah hanya berarti graph tahu sedikit lebih sedikit sampai bukti lebih banyak datang. Jadi kamu menetapkan threshold merge yang tinggi dan membiarkan identifier keras yang sama, misalnya nomor telepon yang muncul di dua sumber, melakukan sebagian besar pekerjaan. Sinyal lunak seperti kemiripan nama dan kemunculan bersama hanya dipakai untuk memecahkan seri. Loop intinya sengaja dibuat membosankan:

# Incremental entity resolution: precision over recall.
# A false merge corrupts everything downstream; a false split
# just means you learn slower. So merge only on strong evidence.
HARD_SIGNALS = {"phone", "email", "contact_id"}   # near-certain identity
MERGE_THRESHOLD = 0.95                             # soft-signal bar, set high
def ingest(observation, graph):
candidate = find_candidate(observation, graph)
if candidate is None:
return graph.new_entity(observation)
if shares_hard_signal(observation, candidate, HARD_SIGNALS):
return graph.merge(observation, candidate, confidence=1.0)
score = soft_match_score(observation, candidate)  # name sim, co-occurrence
if score >= MERGE_THRESHOLD:
return graph.merge(observation, candidate, confidence=score)
return graph.new_entity(observation)  # when in doubt, split

Dua aturan lanjutan yang menyelamatkanmu nanti. Pertama, setiap keputusan merge adalah fakta dengan provenance tersendiri. Catat sinyal apa yang membenarkannya, karena ketika pengguna berkata “itu bukan kakakku, itu rekan kerjaku,” kamu perlu melakukan unmerge secara presisi, bukan menghapus node. Kedua, jangan pernah biarkan output satu classifier menggabungkan entitas sendirian; wajibkan konfirmasi dari sinyal independen. Salah satu hal yang diam-diam mengesankan dari desain Apple adalah persis ini: relasi kekerabatan, pekerjaan, dan komunikasi semuanya menggantung pada entitas yang sudah di-resolve, sehingga kesalahan resolusi tertahan alih-alih diperbesar, asalkan resolusinya benar sejak awal. Sisihkan separuh timeline untuk bagian ini. Kamu akan membutuhkannya.

Kesalahan 4: Mengira “On-Device” Berarti Urusan Privasi Sudah Selesai

Sekarang bagian di mana saya berhenti memuji rekayasanya. Pembelaan standar terhadap arsitektur ini, dan itu mendominasi reaksi publik, adalah “data tidak pernah meninggalkan perangkatmu, jadi tidak apa-apa.” Itu baru separuh argumen. ML local-first memang menyelesaikan masalah residensi data: tidak ada salinan di server yang bisa bocor secara massal, tidak ada pipeline ad-tech yang menyedot social graph-mu, tidak ada target subpoena yang berisi seratus juta pengguna sekaligus. Itu kemenangan nyata dan bermakna dibanding cara perusahaan platform lain melakukan personalisasi, dan saya akan membelanya.

Tapi agregasi adalah pengali risiko tersendiri, dan penyimpanan lokal tidak berbuat apa-apa untuk itu. Setiap sumber tunggal, seperti kontakmu, kalendermu, atau metadata pesanmu, sensitif dalam batas tertentu. Graph hasil penggabungan yang tahu pekerjaanmu, silsilah keluarga beserta usia, ritme komunikasi dengan tiap orang, pola pergerakanmu, dan aktivitas harianmu secara kategoris jauh lebih berharga daripada input mana pun. Dan penyimpanan ini duduk dalam SQLite berupa plaintext, dilindungi hanya oleh Full Disk Access, tidak terdokumentasi kecuali oleh man page dua kalimat, tanpa toggle per fitur dan tanpa cara jelas untuk opt-out. Alat forensik sudah bisa membaca salinan iOS-nya. Para peneliti di balik analisis ini menjalankan eksperimen pemikiran yang jelas: berikan penyimpanan itu ke malware, atau ke pasangan yang abusif yang tahu password perangkatmu, dan kamu punya dossier siap pakai berisi siapa yang kamu ajak bicara, seberapa sering, ke mana kamu pergi, dan siapa anak-anakmu.

Local-first menyelesaikan masalah residensi data. Ia tidak berbuat apa-apa untuk masalah agregasi, dan dossier gabungan di disk tetaplah dossier.

Banyak aliran cahaya bertemu menjadi satu toples kaca bercahaya di atas pedestal.
Menggabungkan banyak sinyal terbatas menjadi satu penyimpanan menciptakan titik kegagalan tunggal yang lebih berharga daripada input mana pun.

Perbaikannya tidak eksotis, dan justru itu yang membuat ketiadaannya terasa menyakitkan. Enkripsi penyimpanan saat diam (at rest) dengan kunci yang terikat pada kehadiran pengguna. Sediakan toggle yang terlihat, bukan “Siri Intelligence” sebagai satu blok monolitik, melainkan kontrol granular atas sinyal mana yang masuk ke graph. Dokumentasikan skemanya. Dan perlakukan fakta inferensi sebagai lebih sensitif daripada fakta mentah, bukan sebaliknya. Tidak ada yang menyetujui “sistem ini menyimpulkan usia anak perempuanmu”, meskipun secara teknis mereka sudah memberi akses ke input yang memungkinkannya. Jika kamu membangun ML local-first, ucapkan kalimat ini dalam hati saat design review: fakta bahwa kita tidak bisa melihat datanya tidak berarti tidak ada yang pernah akan melihatnya. Rencanakan hari ketika perangkat dikompromikan, disita, atau dijual, karena itu akan terjadi pada sebagian kecil armadamu.

Kesalahan 5: Merilis Inferensi Tanpa Jalur Inspeksi

Pertimbangkan bagaimana kita tahu semua ini ada. Bukan dari dokumentasi, karena deskripsi resminya hanyalah man page yang singkat itu. Kita tahu karena peneliti independen melakukan reverse-engineering pada database dan membuat dashboard open-source agar pengguna bisa membaca graph miliknya sendiri, dan seorang maintainer alat forensik mengajari alatnya untuk mem-parse versi iOS. Pengguna menemukan label kekerabatan hasil inferensi tentang keluarga mereka sendiri dengan menjalankan kode pihak ketiga di mesin mereka sendiri. Itu adalah mode kegagalan, dan itu adalah jebakan yang dimasuki tim rekayasa dengan mata terbuka: sistem menghasilkan kesimpulan tentang seseorang, dan orang itu tidak punya cara first-party untuk melihat, mengoreksi, atau menghapusnya.

Ini bukan sekadar centang etika; ini juga soal operasional. Kalau kamu tidak bisa melihat graph-nya, kamu tidak bisa men-debug-nya. Ketika pengguna melapor “asisten Anda mengira mantan saya adalah istri saya,” satu-satunya cara menjawab kenapa adalah menelusuri edge itu kembali melalui provenance ke sinyal yang menghasilkannya. Tim yang membangun jalur baca sejak awal, seperti viewer internal, tombol ekspor, dan afordansi “jelaskan ini” pada setiap fakta inferensi, menghasilkan model yang lebih baik, karena inferensi yang salah berubah menjadi laporan bug yang terlihat alih-alih kekesalan diam-diam. Tim yang tidak melakukannya berakhir dengan pengguna yang mengambil screenshot dashboard hasil reverse-engineering dan membagikannya di media sosial, yang jauh lebih buruk dibanding halaman pengaturan mana pun.

Aturan praktis saya, yang saya pelajari dengan cara yang sulit: untuk fitur apa pun yang menarik kesimpulan tentang pengguna, UI inspeksi bukan fitur bagus-untuk-dimiliki yang menyusul di rilis berikutnya. Ia dikirim di rilis yang sama atau fiturnya tidak dikirim. Biayanya adalah satu panel pengaturan dan satu ekspor JSON. Imbalannya adalah kepercayaan yang tidak perlu kamu mohon-mohon lewat siaran pers. Dan secara praktis, regulator sudah mengincar celah persis ini. Sistem yang menyimpulkan atribut sensitif tentang orang wajib memberi mereka visibilitas, dan “ini on-device” tidak akan diterima sebagai pembelaan atas ketidakterlihatan.

Apa yang Bisa Dicuri untuk Fitur ML Local-First Berikutnya

Lepaskan kontroversinya, dan ini adalah arsitektur yang akan saya serahkan kepada tim mana pun yang membangun personalisasi yang tidak bisa menghubungi server. Dan jujur saja, sebagian besar personalisasi memang tidak seharusnya menghubungi server. Cetak birunya, diringkas:

  • Banyak classifier kecil di atas satu model besar. Satu per sinyal, masing-masing bisa diuji dan dilatih ulang secara independen, serta cukup murah untuk berjalan di baterai selamanya.
  • Triple store dengan edge yang direifikasi. Setiap fakta membawa confidence, sumber, dan timestamp; setiap fakta bisa diretraksi tanpa menghapus riwayat. SQLite sudah cukup.
  • Entity resolution yang disetel untuk presisi. Merge yang salah adalah error katastrofik; split yang salah hanya memperlambatmu. Konfirmasi dulu sebelum menyatukan.
  • Rekayasa privasi yang melampaui residensi. Enkripsi saat diam, persetujuan granular, batas retensi, karena agregasi menciptakan target yang tidak pernah dibuat oleh input tunggal mana pun.
  • Jalur inspeksi sejak hari pertama. Jika sistem menyimpulkan sesuatu tentang pengguna, pengguna berhak melihat, mengoreksi, dan menghapus kesimpulan itu.

Kalau kamu butuh titik awal konkret untuk sisi serving, kami sudah menulis tentang membangun fitur LLM yang berjalan penuh secara offline, dan disiplin yang sama berlaku di sini: anggap jaringan sudah hilang, anggaran dayanya kecil, dan pengguna tidak berutang apa pun padamu. Penutup yang tidak nyaman: insinyur Apple membangun sesuatu yang benar-benar patut dikagumi lalu merusaknya dengan kesunyian. Classifier-nya, skemanya, dan pengendalian diri untuk melakukan inferensi secara lokal alih-alih mengirim semuanya ke data center adalah bagian yang layak ditiru. Postur yang tidak terdokumentasi, selalu aktif, dan opt-out lewat perintah terminal itulah bagian yang layak dihindari. Bangun graph-nya. Beri tahu pengguna bahwa ia ada. Kedua bagian itu adalah rekayasa, dan bagian kedua itu tidak opsional.