Des articles approfondis sur les technologies qui façonnent l'avenir.

Leçons du graphe de connaissances local d'Apple

Le graphe de connaissances embarqué d'Apple montre comment livrer du ML privé et local-first. Cinq erreurs courantes et les correctifs efficaces.

Un graphe lumineux de nœuds et d'arêtes abstraits flottant au-dessus d'un ordinateur portable dans une pièce sombre.
Le graphe de connaissances personnel se construit tout seul à partir des signaux que votre appareil collecte déjà.

Dites à votre Mac « envoie un message à mon frère » et il le fait. Pas de spinner, pas de recherche visible, pas d'aller-retour réseau : il sait déjà lequel des centaines de contacts est votre frère. Cela fonctionne parce que chaque Mac depuis macOS Ventura fait discrètement tourner un graphe de connaissances embarqué : une paire de daemons qui lisent vos Contacts, les groupes de visages de Photos, les participants du Calendrier, les métadonnées de Mail et Messages, les habitudes de localisation et les données de Temps d'écran, puis fusionnent le tout dans un magasin interrogeable décrivant qui vous êtes, qui vous connaissez, et comment ces personnes sont liées à vous et entre elles.

Des chercheurs en sécurité ont récemment montré à quel point cela va loin. Les deux daemons — knowledgeconstructiond et intelligenceplatformd — maintiennent un répertoire de 51 bases SQLite sous ~/Library/IntelligencePlatform. Le cœur du dispositif, graph.db, est un triple store écrit dans un vocabulaire de 181 classes d'entités et 278 prédicats, incluant des relations de parenté déduites que personne n'a jamais saisies dans une fiche de contact. Le débat le plus bruyant autour de cette découverte porte sur le consentement, et c'est un débat légitime. Mais j'ai passé des années à livrer des fonctionnalités de ML pour gagner ma vie, et à la lecture de l'analyse, ma première réaction était différente : c'est l'une des pièces d'ingénierie ML local-first les plus instructives jamais déployées à grande échelle. Plutôt que de reprendre le débat éthique, je veux donc détailler les cinq erreurs que commettent les praticiens lorsqu'ils construisent des systèmes de ce type, ainsi que ce qu'Apple a manifestement bien fait ou mal fait, pour que vous n'ayez pas à l'apprendre à vos dépens.

Erreur 1 : Viser un grand modèle unique plutôt que de petits classifieurs

Le premier réflexe de la plupart des équipes en entendant « le système comprend ta famille » est de supposer qu'il y a un grand modèle de langage dans la boucle. Il n'y en a pas, et c'est justement la leçon. L'inférence de parenté qui a fait les gros titres — le système décidant que tel contact est votre mère, tel autre votre patron — repose sur des classifieurs étroits et spécialisés qui traitent des signaux structurés : appartenance et âges dans le Partage familial, champs de noms liés dans Contacts, co-présence dans les événements du calendrier, fréquence et direction des communications, cooccurrence de visages dans Photos. Chaque classifieur répond bien à une petite question, et le graphe assemble les réponses.

C'est crucial pour une raison très pragmatique : le budget. Un daemon qui tourne en continu, sur batterie, en plus de tout le reste que fait l'OS, ne peut pas se permettre une passe avant de transformeur par événement. De petits classifieurs s'exécutent en microsecondes sur le Neural Engine, ils sont assez déterministes pour être testés unitairement, et quand l'un d'eux se trompe, on peut le réentraîner sans toucher au reste. J'ai vu des équipes brûler des trimestres à essayer de faire faire à un modèle généraliste ce qu'un arbre de gradient boosting sur une trentaine de variables bien choisies fait mieux. Nous avons couvert le même phénomène en vision : les CNN spécialisés battent régulièrement les LLM de pointe en classification d'images pour une fraction du coût. Le schéma se vérifie partout. Les fonctionnalités de personnalisation n'ont presque jamais besoin d'un modèle généraliste : elles ont besoin d'un bon schéma et d'une pile de classifieurs ennuyeux mais excellents.

L'autre avantage sous-estimé est la dégradation gracieuse. Si le pipeline de reconnaissance faciale ne tourne jamais parce que l'utilisateur n'utilise pas Photos, le classifieur de parenté dispose toujours du Partage familial et de Contacts. Les modèles monolithiques se dégradent de façon catastrophique lorsque la distribution de leurs entrées change ; un ensemble de classifieurs spécifiques à chaque signal perd simplement une voix. Quand vous concevez une prochaine fonctionnalité on-device, listez d'abord les signaux indépendants, puis demandez-vous à quoi ressemble le plus petit modèle pour chacun. Réservez le LLM au dernier kilomètre de l'interaction en langage naturel, là où il a réellement sa place.

Plusieurs petites machines spécialisées travaillant en file pendant qu'une machine géante inutilisée repose sous une bâche.
Un ensemble de classifieurs étroits bat un modèle géant pour une inférence permanente et contrainte par la batterie.

Erreur 2 : Stocker des faits sans provenance ni possibilité de rétractation

Un détail du rapport d'analyse, que la plupart des articles ont survolé, est à mes yeux la partie la plus élégante. Une arête de ce graphe — « cette personne travaille dans cette organisation » — n'est pas une seule ligne. Ce sont deux lignes partageant un relationshipId : l'une nomme le type de relation, l'autre pointe vers l'entité liée. Il existe 46 classes de types de relation qui n'existent que pour porter cette indirection. C'est ce qu'on appelle la réification, et si on la pratique, c'est pour que l'arête puisse elle-même porter des propriétés — un score de confiance, une source, un horodatage — et puisse être rétractée plus tard sans prétendre qu'elle n'a jamais existé.

C'est l'erreur que je vois le plus souvent dans les systèmes de personnalisation maison : des faits stockés en colonnes plates. user.employer = "Acme". Ça marche jusqu'au jour où quelqu'un change de travail, divorce, ou que l'inférence était simplement fausse ; on se retrouve alors soit à écraser un historique dont on avait besoin pour déboguer, soit à garder des faits périmés parce que les supprimer casse quelque chose en aval. Les faits personnels se périment vite. Les gens déménagent, les relations se terminent, les employeurs changent. Un magasin incapable d'exprimer « nous avons cru à ceci avec une confiance de 0,7, issu des participants du calendrier, rétracté le 3 mars » finira silencieusement rempli de fantômes. Le schéma qui gère cela ressemble à peu près à ceci :

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

Ce que le choix d'implémentation révèle aussi : tout cela vit dans du SQLite classique. Pas de base de graphe exotique, pas de moteur de stockage maison — juste des tables interrogeables avec la base embarquée la plus éprouvée au monde. Si vous êtes tenté d'adopter une base de graphe dédiée pour un nombre d'arêtes de l'ordre du million sur un seul appareil, résistez. Nous avons écrit sur les cas où les bases de graphe embarquables méritent leur place au-delà de SQLite, et la réponse honnête est que la plupart des applications n'atteignent jamais ce point. Des triplets dans SQLite, avec un indexage rigoureux sur le sujet et le prédicat, vous mèneront étonnamment loin. Consacrez plutôt votre budget de complexité à la sémantique de provenance et de rétractation : c'est là que ces systèmes cassent vraiment.

Erreur 3 : Traiter la résolution d'entités comme un détail réglé

Chaque document de conception que j'ai lu pour ce type de système contient une puce disant « puis on unifie les entités », comme si c'était un travail d'après-midi. C'est de loin la partie la plus difficile de tout le pipeline. Vos contacts disent « James Whitfield ». Photos a un groupe de visages sans nom. Le calendrier a un participant « j.whitfield@company.com ». Messages a un identifiant « +1-415-555-0142 ». La valeur du graphe dépend entièrement du fait que ces quatre observations deviennent une seule personne — et qu'elles ne fusionnent pas à tort avec l'autre James, celui de votre club de course.

L'architecture pragmatique repose sur un clustering incrémental avec des coûts d'erreur asymétriques. Une fausse fusion — décider que deux personnes différentes n'en font qu'une — pollue toutes les inférences en aval et est pénible à défaire, car des faits provenant de deux vraies personnes se retrouvent emmêlés sur un même nœud. Une fausse séparation signifie simplement que le graphe en sait un peu moins jusqu'à l'arrivée de nouvelles preuves. On fixe donc un seuil de fusion élevé et on laisse les identifiants forts partagés (un numéro de téléphone présent dans deux sources) faire l'essentiel du travail, les signaux souples comme la similarité des noms ou la cooccurrence ne servant qu'à départager les égalités. La boucle centrale est volontairement ennuyeuse :

# 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

Deux règles complémentaires vous feront gagner du temps. D'abord, chaque décision de fusion est elle-même un fait avec sa provenance : enregistrez quels signaux l'ont justifiée, car lorsqu'un utilisateur dit « ce n'est pas ma sœur, c'est ma collègue », il faut défusionner chirurgicalement, sans supprimer le nœud. Ensuite, ne laissez jamais la sortie d'un seul classifieur fusionner des entités à elle seule ; exigez la corroboration d'un signal indépendant. Un des points discrètement impressionnants de la conception d'Apple est justement cela : les arêtes de parenté, d'emploi et de communication pendent toutes de l'entité résolue, donc une erreur de résolution reste contenue au lieu d'être amplifiée, à condition d'avoir bien résolu en premier lieu. Prévoyez la moitié de votre calendrier pour cette étape. Vous en aurez besoin.

Erreur 4 : Croire que « on-device » signifie que le travail sur la vie privée est terminé

Voici maintenant la partie où j'arrête de louer l'ingénierie. La défense habituelle de cette architecture — et elle a dominé la réaction publique — est « ça ne quitte jamais l'appareil, donc ça va ». C'est un demi-argument. Le ML local-first résout réellement le problème de résidence des données : il n'y a pas de copie côté serveur à pirater en masse, pas de pipeline de ciblage publicitaire qui aspire votre graphe social, pas de cible de réquisition judiciaire visant cent millions d'utilisateurs d'un coup. C'est un gain réel et significatif par rapport à la façon dont toutes les autres entreprises de plateforme font de la personnalisation, et je le défendrai.

Mais l'agrégation est un multiplicateur de risque à part entière, que le stockage local ne résout en rien. Chaque source prise isolément (vos contacts, votre calendrier, les métadonnées de vos messages) est sensible de façon limitée. Le graphe fusionné, qui connaît votre employeur, votre arbre généalogique avec les âges, votre rythme de communication avec chaque personne, vos déplacements et vos activités quotidiennes, est qualitativement plus précieux que chacune de ses entrées. Et ce magasin particulier réside en SQLite en clair, protégé uniquement par l'Accès complet au disque, non documenté à part une page de manuel de deux phrases, sans bouton de désactivation par fonctionnalité ni moyen évident de s'opt-out. Des outils forensiques lisent déjà la copie iOS. Les chercheurs à l'origine de l'analyse ont fait l'expérience de pensée évidente : remettez ce magasin à un logiciel malveillant, ou à un partenaire abusif qui connaît le mot de passe de l'appareil, et vous obtenez un dossier clé en main — qui vous contactez, à quelle fréquence, où vous allez, qui sont vos enfants.

Le local-first résout le problème de résidence des données. Il ne fait rien pour le problème d'agrégation : un dossier fusionné sur disque reste un dossier.

Plusieurs flux de lumière convergeant vers un unique bocal de verre lumineux posé sur un piédestal.
Fusionner de nombreux signaux bornés dans un seul magasin crée un point de défaillance unique plus précieux que chacune de ses entrées.

Les correctifs ne sont pas exotiques, ce qui rend leur absence d'autant plus frappante. Chiffrez le magasin au repos avec une clé liée à la présence de l'utilisateur. Proposez un interrupteur visible — pas un « Siri Intelligence » monolithique, mais un contrôle granulaire des signaux qui alimentent le graphe. Documentez le schéma. Et traitez les faits inférés comme plus sensibles que les faits bruts, pas moins : personne n'a consenti à « ce système a déduit l'âge de votre fille », même si l'on a techniquement accordé l'accès aux entrées qui l'ont rendu possible. Si vous construisez du ML local-first, répétez-vous cette phrase en revue de conception : le fait que nous ne voyions pas les données ne signifie pas que personne ne les verra jamais. Prévoyez le jour où l'appareil sera compromis, saisi ou revendu, car cela arrivera à une fraction de votre parc.

Erreur 5 : Déployer de l'inférence sans chemin d'inspection

Pensez à la façon dont nous savons que tout cela existe. Pas grâce à la documentation — la description officielle tient dans cette page de manuel laconique. Nous le savons parce que des chercheurs indépendants ont rétro-conçu les bases de données et construit un tableau de bord open source permettant aux utilisateurs de lire leur propre graphe, et qu'un responsable d'un outil forensique a appris à son outil à analyser la version iOS. Des utilisateurs ont découvert des libellés de parenté inférés sur leur propre famille en exécutant du code tiers sur leurs propres machines. C'est un mode de défaillance, et c'est un piège dans lequel les équipes d'ingénierie tombent en connaissance de cause : le système produit des conclusions sur une personne, et celle-ci n'a aucun moyen officiel de les voir, de les corriger ou de les supprimer.

Ce n'est pas seulement une case éthique, c'est aussi une question opérationnelle. Si vous ne voyez pas le graphe, vous ne pouvez pas le déboguer. Quand un utilisateur signale « votre assistant pense que mon ex est ma femme », la seule façon de répondre au pourquoi est de remonter l'arête par la provenance jusqu'au signal qui l'a produite. Les équipes qui construisent très tôt le chemin de lecture (une visionneuse interne, un bouton d'export, une fonction « expliquer » sur chaque fait inféré) livrent de meilleurs modèles, car les inférences erronées deviennent des rapports de bogue visibles au lieu de rancœurs silencieuses. Les autres finissent avec des utilisateurs qui font des captures d'écran de tableaux de bord rétro-conçus et les publient sur les réseaux sociaux, une image bien pire que n'importe quelle page de réglages n'aurait pu l'être.

Ma règle empirique, apprise à mes dépens : pour toute fonctionnalité qui tire des conclusions sur un utilisateur, l'interface d'inspection n'est pas un bonus qu'on ajoute dans une version ultérieure. Elle sort dans la même version, ou la fonctionnalité ne sort pas. Le coût se résume à un panneau de réglages et un export JSON. Le bénéfice, c'est une confiance qu'on n'a pas à quémander dans un communiqué de presse. Et concrètement, les régulateurs tournent précisément autour de cette lacune : les systèmes qui déduisent des attributs sensibles sur des personnes leur doivent de la visibilité, et « c'est sur l'appareil » ne sera pas une défense reconnue contre l'invisibilité.

Ce qu'il faut emprunter pour votre prochaine fonctionnalité ML local-first

Une fois la polémique écartée, voici l'architecture que je confierais à toute équipe qui construit de la personnalisation sans pouvoir appeler la maison mère. Et honnêtement, la plupart des personnalisations ne devraient pas appeler la maison mère. Le plan, condensé :

  • Beaucoup de petits classifieurs plutôt qu'un grand modèle. Un par signal, chacun testable et réentraînable indépendamment, et assez peu coûteux pour tourner éternellement sur batterie.
  • Un triple store avec des arêtes réifiées. Chaque fait porte une confiance, une source et des horodatages ; chaque fait peut être rétracté sans effacer l'historique. SQLite suffit.
  • Une résolution d'entités réglée pour la précision. Les fausses fusions sont l'erreur catastrophique ; les fausses séparations ne font que vous ralentir. Corroborez avant d'unifier.
  • Une ingénierie de la vie privée qui va au-delà de la résidence. Chiffrement au repos, consentement granulaire, limites de conservation, parce que l'agrégation crée une cible qu'aucune entrée isolée ne représentait.
  • Un chemin d'inspection dès le premier jour. Si le système tire des conclusions sur l'utilisateur, celui-ci doit pouvoir les voir, les corriger et les supprimer.

Si vous cherchez un point de départ concret côté service, nous avons écrit sur la construction de fonctionnalités LLM qui fonctionnent entièrement hors ligne, et la même discipline s'applique ici : partez du principe que le réseau a disparu, que le budget énergétique est faible et que l'utilisateur ne vous doit rien. La conclusion dérangeante, c'est que les ingénieurs d'Apple ont construit quelque chose de réellement admirable, puis l'ont affaibli par le silence. Les classifieurs, le schéma, la retenue qui consiste à faire l'inférence localement plutôt qu'à tout envoyer vers un centre de données : voilà la partie à copier. La posture non documentée, toujours active, désactivable seulement par une commande de terminal, c'est la partie à éviter. Construisez le graphe. Dites à l'utilisateur qu'il existe. Les deux moitiés relèvent de l'ingénierie, et la seconde n'est pas facultative.