Articoli approfonditi sulla tecnologia che plasma il futuro.

Lezioni dal grafo della conoscenza on-device di Apple

Il knowledge graph on-device di Apple mostra come distribuire ML privato e local-first. Cinque errori comuni e le soluzioni che funzionano davvero.

Un grafo luminoso di nodi astratti e archi sospeso sopra un laptop in una stanza buia.
Il grafo personale della conoscenza si costruisce da solo a partire dai segnali che il dispositivo raccoglie già.

Dì al tuo Mac «scrivi a mio fratello» e lo fa e basta. Nessuna rotellina di caricamento, nessuna ricerca visibile, nessun giro di rete: sa già quale delle centinaia di persone in rubrica sia tuo fratello. Funziona così perché ogni Mac da macOS Ventura in poi esegue silenziosamente un knowledge graph on-device: una coppia di daemon che leggono i Contatti, i cluster di volti in Foto, i partecipanti agli eventi del Calendario, i metadati di Mail e Messaggi, i pattern di posizione e i dati di Tempo di utilizzo, e poi fondono tutto in un archivio interrogabile su chi sei, chi conosci e come sono legate tra loro quelle persone e te.

I ricercatori di sicurezza hanno di recente mostrato quanto in profondità arrivi tutto questo. I due daemon — knowledgeconstructiond e intelligenceplatformd — mantengono una directory di 51 database SQLite sotto ~/Library/IntelligencePlatform. Il cuore del sistema, graph.db, è un triple store scritto con un vocabolario di 181 classi di entità e 278 predicati, che include relazioni di parentela dedotte che nessuno ha mai inserito in una scheda contatto. Il dibattito più acceso su questa scoperta riguarda il consenso, ed è un dibattito legittimo. Ma ho passato anni a sviluppare funzionalità di ML per lavoro, e quando ho letto l'analisi la mia prima reazione è stata diversa: è uno dei casi più istruttivi di ML local-first mai distribuiti su larga scala. Quindi, invece di rimettere in discussione l'etica, voglio passare in rassegna i cinque errori che i professionisti commettono quando costruiscono sistemi di questo tipo, e cosa hanno dimostrato di fare bene e male gli ingegneri di Apple, così non dovete impararlo a vostre spese.

Errore 1: usare un unico modello enorme invece di piccoli classificatori

Il primo istinto della maggior parte dei team, quando sente «il sistema operativo conosce la tua famiglia», è pensare che ci sia un grande modello linguistico in gioco. Non c'è, e questa è la lezione. L'inferenza sui legami di parentela che ha fatto notizia — il sistema che stabilisce che questo contatto è tua madre e quello è il tuo capo — è affidata a classificatori piccoli e specializzati che elaborano segnali strutturati: appartenenza a Condivisione in famiglia ed età, i campi dei nomi correlati nei Contatti, le co-presenze negli eventi del calendario, la frequenza e la direzionalità delle comunicazioni, la co-occorrenza dei volti in Foto. Ogni classificatore risponde bene a una piccola domanda, e il grafo mette insieme le risposte.

Questo conta per un motivo molto pratico: il budget. Un daemon che gira in continuazione, a batteria, insieme a tutto il resto che fa il sistema, non può permettersi un passaggio forward di un transformer per ogni evento. I piccoli classificatori girano in microsecondi sul Neural Engine, sono abbastanza deterministici da poter essere sottoposti a unit test e, quando uno sbaglia, puoi riaddestrare solo quello senza toccare il resto. Ho visto team bruciare trimestri interi cercando di far fare a un modello generale ciò che un gradient-boosted tree su trenta feature ben scelte fa meglio. Lo stesso fenomeno l'abbiamo già affrontato nella visione artificiale: le CNN specializzate battono regolarmente gli LLM di frontiera nella classificazione delle immagini, a una frazione del costo. Il pattern vale ovunque. Le funzionalità di personalizzazione quasi mai hanno bisogno di un modello generale: hanno bisogno di un buono schema e di un mucchio di classificatori noiosi ma eccellenti.

L'altro vantaggio, poco apprezzato, è la degradazione graduale. Se la pipeline di riconoscimento facciale non viene mai eseguita perché l'utente non usa Foto, il classificatore di parentela può comunque contare su Condivisione in famiglia e Contatti. I modelli monolitici degradano in modo catastrofico quando la distribuzione dei loro input cambia; un insieme di classificatori specifici per segnale perde semplicemente un voto. Quando progetti la prossima funzionalità on-device, elenca prima i segnali indipendenti, poi chiediti come sia il modello più piccolo possibile per ciascuno. Riserva l'LLM all'ultimo miglio dell'interazione in linguaggio naturale, dove davvero serve.

Tante piccole macchine specializzate che lavorano in fila, mentre una macchina gigante resta inutilizzata sotto un telo.
Un insieme di classificatori specifici batte un unico modello gigante per l'inferenza sempre attiva e vincolata dalla batteria.

Errore 2: memorizzare fatti senza provenienza né possibilità di ritrattazione

C'è un dettaglio nell'analisi che quasi tutti gli articoli hanno ignorato, ed è la parte che trovo più elegante. Un arco in questo grafo — «questa persona lavora in questa organizzazione» — non è una riga sola. Sono due righe che condividono un relationshipId: una riga indica il tipo di relazione, l'altra punta all'entità collegata. Ci sono 46 classi di tipi di relazione che esistono solo per portare questa indirezione. Si chiama reificazione, e la ragione per farlo è che l'arco stesso può avere proprietà — un punteggio di confidenza, una fonte, un timestamp — e può essere ritrattato in seguito senza fingere che non sia mai esistito.

Questo è l'errore che vedo più spesso nei sistemi di personalizzazione fatti in casa: fatti memorizzati come colonne piatte. user.employer = "Acme". Funziona finché qualcuno cambia lavoro, divorzia o l'inferenza era semplicemente sbagliata, e a quel punto o sovrascrivi una storia che ti serviva per il debug, oppure lasci fatti obsoleti perché cancellarli rompe qualcosa a valle. I fatti personali invecchiano in fretta. Le persone si trasferiscono, i rapporti finiscono, i datori di lavoro cambiano. Uno store che non sa esprimere «abbiamo creduto a questo con confidenza 0,7, fonte Partecipanti del calendario, ritrattato il 3 marzo» si riempirà silenziosamente di fantasmi. Lo schema che gestisce tutto questo appare più o meno così:

-- 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', ...)

Nota anche cosa ci dice la scelta implementativa: tutto questo vive in semplice SQLite. Nessun database a grafo esotico, nessun motore di storage custom — solo tabelle interrogabili con il database embedded più collaudato del pianeta. Se ti viene la tentazione di usare un archivio a grafo dedicato per un numero di archi nell'ordine dei milioni su un singolo dispositivo, non farlo. Abbiamo scritto di quando i database a grafo embeddable si giustificano oltre SQLite, e la risposta onesta è che la maggior parte delle applicazioni non arriva mai a quel punto. Triple in SQLite, con un'indicizzazione disciplinata su soggetto e predicato, ti porteranno sorprendentemente lontano. Spendi la tua complessità piuttosto su semantica di provenienza e ritrattazione — è lì che questi sistemi si rompono davvero.

Errore 3: considerare la risoluzione delle entità un dettaglio già risolto

Ogni documento di progettazione che ho letto su un sistema del genere contiene un punto elenco che dice «poi unifichiamo le entità», come se fosse il lavoro di un pomeriggio. È di gran lunga la parte più difficile dell'intera pipeline. I tuoi Contatti dicono «James Whitfield». Foto ha un cluster di volti senza nome. Il Calendario ha un partecipante «j.whitfield@company.com». Messaggi ha un identificativo «+1-415-555-0142». Il valore del grafo dipende interamente dal fatto che quelle quattro osservazioni diventino una sola persona — e dal fatto che non si fondano, correttamente, con l'altro James, quello del tuo gruppo di corsa.

L'architettura pragmatica è il clustering incrementale con costi di errore asimmetrici. Una fusione falsa — decidere che due persone diverse siano una sola — avvelena ogni inferenza a valle ed è terribile da disfare, perché i fatti di entrambe le persone reali ora sono intrecciati su un unico nodo. Una divisione falsa significa solo che il grafo sa un po' meno, finché non arriva altra evidenza. Quindi imposti una soglia di fusione alta e lasci che gli identificativi forti condivisi (un numero di telefono presente in due fonti) facciano la maggior parte del lavoro, con i segnali deboli come la somiglianza dei nomi e la co-occorrenza che servono solo a sciogliere i pareggi. Il ciclo centrale è volutamente noioso:

# 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

Due regole successive che ti salveranno più avanti. Primo, ogni decisione di fusione è essa stessa un fatto con provenienza — registra quali segnali l'hanno giustificata, perché quando un utente dice «non è mia sorella, è una collega», devi poter separare chirurgicamente, non cancellare il nodo. Secondo, non permettere mai che un singolo classificatore fonda entità da solo: richiedi una conferma da un segnale indipendente. Una delle cose silenziosamente impressionanti del design di Apple è proprio questa: i legami di parentela, di lavoro e di comunicazione dipendono tutti dall'entità risolta, quindi un errore di risoluzione viene contenuto invece di essere amplificato — a patto di aver risolto bene in partenza. Riserva metà della timeline per questo. Ti servirà.

Errore 4: pensare che «on-device» significhi che il lavoro sulla privacy è finito

Ora la parte in cui smetto di lodare l'ingegneria. La difesa standard di questa architettura — ed è quella che ha dominato la reazione pubblica — è «non lascia mai il tuo dispositivo, quindi va bene». È solo mezzo argomento. Il ML local-first risolve davvero il problema della residenza dei dati: non c'è una copia lato server da violare in massa, nessuna pipeline dell'ad-tech che risucchia il tuo grafo sociale, nessun bersaglio di un ordine di citazione per cento milioni di utenti in una volta sola. È una vittoria reale e significativa rispetto a come ogni altra azienda tecnologica fa personalizzazione, e la difendo.

Ma l'aggregazione è un moltiplicatore di rischio a sé, e lo storage locale non fa nulla per contrastarlo. Qualsiasi fonte singola — i tuoi contatti, il calendario, i metadati dei messaggi — è sensibile in modo circoscritto. Il grafo fuso, che conosce il tuo datore di lavoro, il tuo albero genealogico con le età, la cadenza delle tue comunicazioni con ciascuna persona, i tuoi spostamenti e le tue attività quotidiane, vale categoricamente più di ciascuno dei suoi input. E questo specifico archivio risiede in SQLite in chiaro, protetto solo dall'Accesso completo al disco, non documentato se non da una pagina di manuale di due frasi, senza un interruttore per funzionalità e senza un modo ovvio per disattivarlo. Gli strumenti forensi leggono già la copia iOS. I ricercatori dietro l'analisi hanno fatto l'esperimento mentale ovvio: consegna quell'archivio a un malware, o a un partner abusivo con la password del dispositivo, e hai un dossier pronto all'uso — con chi parli, con quale frequenza, dove vai, chi sono i tuoi figli.

Il local-first risolve il problema della residenza dei dati. Non fa nulla per il problema dell'aggregazione — un dossier fuso su disco resta un dossier.

Molti flussi di luce che convergono in un'unica giara di vetro luminosa su un piedistallo.
Fondere molti segnali circoscritti in un unico archivio crea un singolo punto di guasto più prezioso di qualsiasi input.

Le soluzioni non sono esotiche, ed è proprio per questo che la loro assenza fa male. Cifra l'archivio a riposo con una chiave legata alla presenza dell'utente. Offri un interruttore visibile — non un «Siri Intelligence» monolitico, ma un controllo granulare su quali segnali alimentano il grafo. Documenta lo schema. E tratta i fatti inferiti come più sensibili di quelli grezzi, non meno: nessuno ha acconsentito a «questo sistema ha dedotto l'età di tua figlia», anche se tecnicamente ha concesso l'accesso agli input che l'hanno resa possibile. Se costruisci ML local-first, ripeti questa frase in fase di design review: il fatto che non possiamo vedere i dati non significa che nessuno li vedrà mai. Pianifica il giorno in cui il dispositivo verrà compromesso, sequestrato o venduto, perché succederà a una frazione della tua flotta.

Errore 5: distribuire inferenze senza un percorso di ispezione

Pensa a come sappiamo che tutto questo esiste. Non dalla documentazione — la descrizione ufficiale è quella pagina di manuale laconica. Lo sappiamo perché ricercatori indipendenti hanno decodificato i database e hanno creato una dashboard open source con cui gli utenti possono leggere il proprio grafo, e il manutentore di uno strumento forense ha insegnato al suo tool a leggere la versione iOS. Gli utenti hanno scoperto le etichette di parentela dedotte sulle proprie famiglie eseguendo codice di terze parti sulle proprie macchine. Questo è un fallimento, ed è in cui i team di ingegneria cadono a occhi aperti: il sistema produce conclusioni su una persona, e la persona non ha alcun modo di primo livello per vederle, correggerle o cancellarle.

Non è solo una questione etica da spuntare; è anche operativa. Se non puoi vedere il grafo, non puoi fare debug. Quando un utente segnala «il tuo assistente pensa che il mio ex sia mia moglie», l'unico modo per rispondere al perché è risalire l'arco attraverso la provenienza fino al segnale che l'ha prodotto. I team che costruiscono fin dall'inizio il percorso di lettura — un viewer interno, un pulsante di esportazione, una funzione «spiega questo» su ogni fatto inferito — rilasciano modelli migliori, perché le inferenze sbagliate diventano segnalazioni di bug visibili invece di risentimento silenzioso. I team che non lo fanno finiscono con utenti che fanno screenshot di dashboard reverse-engineered e li pubblicano sui social, una figura decisamente peggiore di qualsiasi pagina delle impostazioni.

La mia regola pratica, imparata a proprie spese: per qualsiasi funzionalità che trae conclusioni su un utente, l'interfaccia di ispezione non è un «nice to have» da rimandare a una release successiva. Esce nella stessa release, oppure la funzionalità non esce. Il costo è un pannello di impostazioni e un'esportazione JSON. Il beneficio è una fiducia che non devi implorare in un comunicato stampa. E, in pratica, i regolatori stanno già girando intorno proprio a questo vuoto: i sistemi che inferiscono attributi sensibili sulle persone devono a quelle persone visibilità, e «è on-device» non sarà riconosciuto come difesa contro l'invisibilità.

Cosa copiare per la tua prossima funzionalità di ML local-first

Al netto della polemica, questa è l'architettura che consegnerei a qualsiasi team che costruisce personalizzazione senza poter chiamare casa — e francamente, la maggior parte della personalizzazione non dovrebbe chiamare casa. Il progetto, in sintesi:

  • Tanti piccoli classificatori invece di un unico modello grande. Uno per segnale, ciascuno testabile, riaddestrabile in modo indipendente e abbastanza economico da girare a batteria per sempre.
  • Un triple store con archi reificati. Ogni fatto porta confidenza, fonte e timestamp; ogni fatto può essere ritrattato senza cancellare la storia. SQLite basta.
  • Risoluzione delle entità calibrata sulla precisione. Le fusioni false sono l'errore catastrofico; le divisioni false ti rallentano soltanto. Conferma prima di unificare.
  • Ingegneria della privacy che va oltre la residenza dei dati. Cifratura a riposo, consenso granulare, limiti di conservazione — perché l'aggregazione crea un bersaglio che nessun singolo input era mai stato.
  • Un percorso di ispezione fin dal primo giorno. Se il sistema trae conclusioni sull'utente, l'utente deve poterle vedere, correggere e cancellare.

Se cerchi un punto di partenza concreto per il lato del servizio, abbiamo scritto di come costruire funzionalità LLM che funzionano completamente offline, e la stessa disciplina vale anche qui — presupponi che la rete non ci sia, che il budget energetico sia ridotto e che l'utente non ti debba nulla. La conclusione scomoda è che gli ingegneri di Apple hanno costruito qualcosa di davvero ammirevole e poi l'hanno minato con il silenzio. I classificatori, lo schema, la moderazione nel fare inferenza in locale invece di spedire tutto a un data center: questa è la parte da copiare. La postura non documentata, sempre attiva, disattivabile solo da un comando del terminale è la parte da evitare. Costruisci il grafo. Dillo all'utente che c'è. Entrambe le metà sono ingegneria, e la seconda non è opzionale.