Quoi de neuf dans BNNS Graph

Bonjour, je m’appelle Simon Gladman et je travaille pour le groupe Vector and Numerics d’Apple. Notre groupe offre des bibliothèques pour des calculs performants et économes en énergie sur le CPU. Ces bibliothèques gèrent le traitement de l’image et du signal, l’algèbre linéaire et, ce dont je vais parler aujourd’hui, l’apprentissage automatique. Basic Neural Network Subroutines, ou BNNS, est notre bibliothèque pour l’apprentissage automatique. Elle permet d’ajouter à votre app une inférence basée sur le CPU, idéale pour les cas d’utilisation en temps réel et à faible latence, comme le traitement audio. Vous pouvez l’utiliser pour implémenter des fonctionnalités afin de séparer l’audio pour isoler ou supprimer des voix, segmenter l’audio en zones selon le contenu, ou appliquer un transfert de timbre pour faire sonner un instrument comme un autre.

BNNS est aussi bien pour traiter d’autres données, comme des images. Si votre app nécessite une inférence performante, BNNS est fait pour vous.

L’an dernier, nous avons lancé BNNSGraph, une API innovante qui a rendu BNNS plus rapide, plus économe en énergie et plus facile à utiliser. Si vous vous souvenez, nous avons fait la démonstration de BNNSGraph en créant cette Audio Unit Bitcrusher pour vous montrer à quel point il est facile d’ajouter vos propres effets à Logic Pro et Garage Band.

Cette année, nous améliorons l’API de BNNSGraph pour tirer parti de Swift lors de la création de modèles d’inférence compacts et de graphes d’opérations pour le prétraitement et le post-traitement. Aujourd’hui, je vais parler de notre nouvel ajout à BNNSGraph, BNNSGraphBuilder. Je vais commencer cette séance par un bref récapitulatif de BNNSGraph. Sa définition, son rôle dans l’optimisation de l’AA et des modèles d’IA, et son adoption. Ensuite, je présenterai BNNSGraphBuilder. Je vais résumer le flux de travail nécessaire pour l’implémenter et vous montrer comment écrire un graphe simple. Après avoir présenté BNNSGraphBuilder, je vais effectuer trois démonstrations. Tout d’abord, le prétraitement d’une image avec Graph Builder. Puis, j’utilise la nouvelle API pour post-traiter les données générées par un modèle d’AA. Enfin, je mettrai à jour la démo Bitcrusher de l’an dernier pour créer le graphe des opérations dans Swift. Commençons sans plus attendre. Nous recommandons BNNSGraph pour l’audio et les cas d’utilisation sensibles à la latence, car il permet de contrôler l’allocation de mémoire et le multithreading. Ces deux éléments peuvent modifier le contexte du code noyau et empêcher l’exécution en temps réel des délais. Avant l’an dernier, vous pouviez créer des réseaux basés sur BNNS avec des couches distinctes, comme la convolution, la multiplication matricielle ou l’activation. Pour utiliser BNNS pour un modèle existant, il fallait coder chaque couche comme une primitive BNNS et écrire le code pour tous les tenseurs intermédiaires. BNNSGraph traite un graphe complet constitué de plusieurs couches et de leur flux de données, en le considérant comme un objet unique.

Vous n’avez donc pas besoin de coder chaque couche individuellement. Vous et vos utilisateurs profiterez de performances accrues et d’une meilleure efficacité énergétique.

BNNSGraph connaît l’ensemble du modèle. Il peut donc effectuer des optimisations auparavant impossibles. Ces optimisations réduisent le temps d’exécution, l’utilisation de la mémoire et les coûts énergétiques. Mieux encore, elles sont gratuites. Découvrons certaines optimisations à partir de cette section d’un modèle. L’une des optimisations est une transformation mathématique. Par exemple, réorganiser une opération de tranche afin que BNNS n’ait besoin de calculer que le sous-ensemble d’éléments de cette tranche. La fusion des couches est une autre optimisation. Par exemple, fusionner une couche de convolution et une couche d’activation en une seule opération. L’élision de copie évite de copier les données d’une tranche en faisant référence à ce sous-ensemble. BNNSGraph optimise l’utilisation de la mémoire en partageant les tenseurs autant que possible, ce qui élimine les allocations inutiles. Les optimisations de repacking des poids de BNNSGraph améliorent la localité des caches en réorganisant les poids. Pas besoin de coder pour profiter de ces optimisations. Elles se produisent automatiquement. Pour créer un graphe avec l’API basée sur des fichiers introduite l’an dernier, commencez avec un CoreML Package. Xcode compile le package dans un fichier mlmodelc, puis vous écrivez le code pour générer un graphe à partir de ce fichier. La dernière étape consiste à créer un contexte pour envelopper le graphe afin d’effectuer l’inférence. Cette approche reste le meilleur moyen d’intégrer les modèles PyTorch existants dans votre projet. Pour les petits modèles ou graphes d’opérations, un flux de travail plus immédiat est possible. Et si vous pouviez définir les différents éléments de votre graphe dans Swift ? Cette année, nous proposons une nouvelle API, BNNSGraphBuilder, pour effectuer cette opération.

La nouvelle API BNNSGraphBuilder permet d’écrire des graphes d’opérations avec le langage Swift. Vous pouvez écrire des routines de prétraitement, de post-traitement ou des modèles d’AA dans Swift. Vous créez un contexte avec ce code Swift via un appel de fonction unique, sans étapes intermédiaires. Écrire vos graphes en Swift tout en les intégrant à votre code offre des avantages immédiats. Vous utilisez un langage familier et votre graphe est vérifié lors de la compilation de votre projet Swift. Vous pouvez aussi partager entre Swift et votre graphe des valeurs connues à l’exécution, mais avant la génération du graphe. Si la forme d’un tenseur est connue à l’exécution avant d’initialiser le graphe, intégrez-la directement dans le code pour profiter des performances optimales des tailles statiques par rapport aux tailles flexibles. BNNSGraphBuilder vous permet d’interroger les tenseurs intermédiaires pour des propriétés comme la forme et le type de données afin de faciliter le débogage des graphes. Les tenseurs de type permettent à Xcode d’effectuer une saisie automatique et réduisent le risque d’erreurs d’exécution. Analysons la syntaxe, la vérification de type, les méthodes et opérateurs récents, et l’interrogation des tenseurs intermédiaires, des fonctionnalités auparavant indisponibles. Cette année, nous avons ajouté makeContext, une nouvelle méthode de type, à l’objet BNNSGraph. Elle convertit votre code Swift en un contexte réutilisable que vous utilisez pour exécuter votre graphe. Vous définissez le contexte une seule fois, généralement au démarrage de votre app. Puis, votre app exécute le contexte si nécessaire en profitant des optimisations du traitement holistique du graphe. Faisons un peu de codage pour voir makeContext en action. Cette méthode accepte une fermeture, utilisée pour définir la série d’opérations qui constituent votre graphe.

Votre graphe accepte généralement un ou plusieurs arguments. Ici, j’utilise le paramètre builder de la fermeture pour spécifier les deux arguments, x et y.

Les paramètres sont tous deux des vecteurs à huit éléments de valeurs flottantes. Dans cet exemple, le graphe effectue une multiplication élément par élément sur les deux arguments d’entrée et écrit le résultat dans l’argument de sortie nommé product. Mon graphe calcule la valeur moyenne de product et l’écrit dans un deuxième argument de sortie appelé mean, puis le code renvoie ces deux arguments de sortie.

Pour faciliter le débogage, nous pouvons imprimer les détails des tenseurs intermédiaires et de sortie générés par BNNSGraphBuilder.

Dans cet exemple, j’ai vérifié que mean a une forme de un, c’est-à-dire qu’il ne contient qu’un seul élément. Après avoir créé le contexte, vous pouvez l’interroger pour dériver les arguments et leurs positions. Ici, le code interroge les noms d’arguments du contexte et crée un array de tenseurs représentant les sorties et les entrées du graphe. BNNSGraph classe les noms d’arguments pour que les sorties précèdent les entrées.

L’API BNNSGraphBuilder offre des fonctions complètes pour initialiser des arguments à partir de différentes sources de données et pour copier ou référencer des données. Dans cet exemple, le code initialise les entrées des arrays Swift.

Après allocation des arguments d’entrée et de sortie, l’appel de la fonction execute exécute le graphe et remplit les sorties avec les résultats.

Et nous pouvons imprimer les résultats en exécutant la fonction.

Nous ne nous limitons pas à multiplier et à calculer des moyennes. Voyons rapidement BNNSGraphBuilder et découvrons d’autres opérations de la nouvelle API. Voici une sélection des primitives incluses dans BNNSGraphBuilder. Par exemple, multiplication et convolution matricielles, opérations de réduction, collecte et dispersion, ainsi que remplissage, remodelage et transposition. Notre API prend en charge de nombreuses opérations via des opérateurs Swift simples. Nous avons des opérateurs arithmétiques : multiplication, addition, soustraction et division. Nous avons aussi des opérateurs de comparaison par élément, comme l’égalité, l’infériorité et la supériorité. Et pour terminer, nous avons des opérateurs logiques élémentaires. Voilà pour cette brève présentation de l’API. Examinons deux fonctionnalités de l’API GraphBuilder, familières aux développeurs Swift, en commençant par le typage fort. Un typage fort détecte les erreurs à la compilation qui pourraient sinon survenir lors de l’exécution. L’API BNNSGraphBuilder garantit que le type de données des tenseurs est correct pour une opération donnée. Voyons cela en pratique. Dans cet exemple, le graphe affiche les résultats par élément des valeurs flottantes élevées à la puissance des exposants entiers.

Il est capable d’effectuer ce calcul en convertissant les exposants entiers en FP16. Essayer cette opération sans opération cast empêcherait la compilation de la méthode makeContext. Le graphe masque le résultat en supprimant les éléments dont les valeurs du masque 0 sont inférieures à celles du masque 1. Les éléments tensoriels générés par la comparaison étant booléens, le graphe effectue un autre cast pour multiplier les résultats par la condition. Encore une fois, sans l’opération cast, la compilation de la méthode makeContext ne sera pas exécutée. Il est préférable de détecter ce type d’erreur lors de la compilation, avant que l’app ne soit entre les mains des utilisateurs. Voilà pour le typage fort en pratique. Examinons l’approche de BNNSGraphBuilder pour le slicing, c’est-à-dire la sélection de parties avec un tenseur. Une fonctionnalité que les développeurs Swift connaissent déjà.

Un slice est en fait une fenêtre sur une partie spécifique d’un tenseur. Par exemple, un slice peut être une seule colonne ou ligne d’une matrice. L’avantage de BNNSGraph est qu’il gère les slices comme des références à des données existantes, sans copier ces données ni allouer plus de mémoire. Le slicing des tenseurs est une opération courante. Notre API GraphBuilder permet de spécifier des slices de tenseur comme des opérations source ou destination. Par exemple, vous pouvez recadrer une image sur une zone spécifique avant de la transmettre à un modèle d’AA. Voyons à quel point il est facile d’utiliser l’API GraphBuilder pour sélectionner une zone carrée au centre de cette photo d’un écureuil savourant son déjeuner. Nous allons définir deux tampons de pixels vImage. Ceux-ci stockent les données des pixels, les dimensions, la profondeur de bits et le nombre de canaux. Le premier tampon, source, contient une photo de l’écureuil. Le deuxième tampon de pixels, Destination, contient le recadrage carré. Un tampon de pixels comprend trois canaux : rouge, vert et bleu, chacun au format 32 bits à virgule flottante. Pour en savoir plus sur les tampons de pixels vImage, consultez la documentation vImage. Les marges horizontales et verticales assurent un recadrage centré de l’image source à 640 x 640. Et voici un graphe qui utilise l’opération de slice pour effectuer le recadrage. D’abord, définissons la source comme argument et spécifions la hauteur et la largeur comme tailles flexibles. Le passage d’une valeur négative, ici moins 1, indique à BNNSGraph que ces dimensions peuvent avoir une quelconque valeur. La valeur finale de la forme 3 spécifie que l’image contient trois canaux : rouge, vert et bleu. L’API BNNSGraphBuilder utilise des indices Swift pour effectuer une opération de slice. Ici, le code utilise la nouvelle structure SliceRange. Les indices de départ pour les dimensions verticales et horizontales sont les valeurs de marge correspondantes. Définir les indices de fin comme une marge négative signifie que l’index final est la dernière valeur de cette dimension moins la marge.

Ici, nous ne voulons pas rogner le long de la dimension de canal, et le code utilise fillAll pour inclure les trois canaux.

Cette année, nous introduisons une nouvelle méthode pour les tampons de pixels vImage. La méthode withBNNSTensor crée un BNNSTensor temporaire qui partage la mémoire, la taille et le nombre de canaux avec le tampon de pixels. La nouvelle méthode simplifie le transfert d’images vers et depuis votre graphe, comme le montre le code. La mémoire étant partagée, il n’y a ni copie ni allocation, ce qui offre d’excellentes performances pour le traitement d’images. Une fois la méthode de fonction d’exécution retournée, le tampon de pixels de destination contient une image coupée. Nous pouvons vérifier que notre écureuil est bien recadré en créant une image Core Graphics du résultat. En plus de la nouvelle structure de plage de slices GraphBuilder, l’API de slicing des tenseurs prend en charge tous les types de plages Swift. Peu importe vos besoins en slicing, nous avons la solution qui vous convient. Et voilà un aperçu du slicing. Nous avons examiné BNNSGraphBuilder et certaines de ses fonctionnalités. Voyons maintenant quelques cas d’utilisation. BNNSGraphBuilder est une API idéale pour créer des graphes d’opérations pour le prétraitement et le post-traitement des données échangées avec les modèles d’AA. Appliquer un seuil à une image est une technique de prétraitement qui convertit une image à tons continus en une image binaire avec seulement des pixels noirs ou blancs. Voyons comment l’implémenter avec GraphBuilder.

Avant de commencer à écrire le graphe, nous allons définir des tampons de pixels vImage. Le premier stocke l’image source, et le second est la destination qui reçoit l’image traitée. Ces deux tampons de pixels sont au format à virgule flottante 16 bits à canal unique. La première étape du graphe consiste à définir la source, qui représente l’image d’entrée. Le code utilise des valeurs négatives pour la taille de l’image pour indiquer que le graphe accepte toute taille d’image, tout en spécifiant le type de données FP16 pour les tampons de pixels. Le calcul de la valeur moyenne des pixels continus en niveaux de gris consiste simplement à appeler la méthode mean. L’opérateur remplit le tenseur à seuil avec des uns pour les pixels dont la valeur est supérieure à la moyenne des pixels et avec des zéros pour les autres pixels. Enfin, le graphe applique les uns et les zéros booléens à la profondeur de bits du tampon de pixels de destination. Nous utilisons à nouveau la méthode withBNNSTensor pour passer les deux tampons d’image au contexte et exécuter la fonction pour générer l’image traitée.

Après avoir converti cette image en niveaux de gris continus d’un couple de pélicans en vol sur le graphe, nous obtenons cette image traitée avec des pixels uniquement noirs ou blancs. Le post-traitement des résultats d’un modèle d’AA est un autre cas d’utilisation de l’API BNNSGraphBuilder.

Supposons que nous appliquions une fonction softmax suivie d’une opération topK aux résultats d’un modèle d’AA. La fonction de post-traitement génère un petit graphe instantanément. Le graphe déclare un argument d’entrée basé sur le tenseur d’entrée de la fonction. Il applique ensuite une opération softmax à l’argument d’entrée, puis calcule ses valeurs et indices topK. Notez que le paramètre k que le code transmet à la fonction topK est en fait défini en dehors de la fermeture de makeContext. Enfin, le graphe renvoie les résultats topK. Après avoir défini le graphe, la fonction déclare les tenseurs qui stockent les résultats et transmet les tenseurs de sortie et d’entrée au contexte. Enfin, la méthode makeArray convertit les valeurs topK et les index en arrays Swift et les renvoie. Nous avons là quelques exemples de données de prétraitement et de post-traitement avec l’API GraphBuilder. Regardons la démo Bitcrusher de l’an dernier et mettons à jour la section Swift pour utiliser BNNSGraphBuilder. Ce code montre comment BNNSGraph facilite l’ajout d’effets audio basés sur l’AA.

L’année dernière, nous avons fait la démonstration de BNNSGraph en l’intégrant dans une app d’extension Audio Unit. Cette app a intégré un effet Bitcrusher en temps réel à un signal audio, et la démonstration a utilisé Swift pour appliquer cet effet à une onde sinusoïdale afin d’afficher une représentation visuelle dans l’interface utilisateur. Avec cette onde sinusoïdale, le graphe peut réduire la résolution pour ajouter de la distorsion, et la représentation visuelle montre l’onde comme une série d’étapes au lieu d’une onde continue. Nous avons aussi ajouté un gain de saturation pour enrichir le son. L’an dernier, la démonstration utilisait un package CoreML basé sur PyTorch. Comparons le code de l’année dernière aux mêmes fonctionnalités dans Swift avec la nouvelle API GraphBuilder. Voici le PyTorch à gauche et le nouveau code Swift à droite. Une différence immédiate est que Swift utilise let et var pour définir les tenseurs intermédiaires. Vous pouvez donc choisir leur immuabilité ou mutabilité. Aucune importation supplémentaire n’est nécessaire pour accéder à toutes les opérations disponibles. De plus, les opérations comme tanh sont des méthodes sur tenseurs, non des fonctions libres.

Les opérateurs arithmétiques par élément sont les mêmes avec les deux approches différentes.

Une différence supplémentaire est que la fermeture makeContext peut renvoyer plusieurs tenseurs de sortie, donc vous retournez toujours un array. Swift GraphBuilder vous permet de définir des arguments d’entrée à l’intérieur de la fermeture makeContext. Si vous avez un modèle PyTorch, nous recommandons d’utiliser ce code et l’API basée sur des fichiers. Pour les nouveaux projets, notre API GraphBuilder permet d’écrire des graphes en Swift avec une structure similaire aux opérations écrites avec PyTorch, comme le montre cette comparaison. Nous pouvons aussi démontrer la prise en charge 16 bits de BNNSGraph et comment, dans cet exemple, elle est plus rapide que les opérations FP32. Voici à nouveau notre code Swift, mais cette fois en utilisant un alias de type pour spécifier la précision.

La modification de l’alias de type modifie le graphe pour utiliser FP16 plutôt que FP32. Dans cet exemple, FP16 est beaucoup plus rapide que l’équivalent du FP32. Pour conclure, BNNSGraphBuilder offre une API Swift intuitive pour créer des modèles et des graphes d’opérations efficaces et économes en énergie. Elle est idéale pour les cas d’utilisation en temps réel et sensibles à la latence, mais son interface de programmation conviviale permet un large éventail d’applications. Avant de terminer, je vous recommande de consulter notre documentation, où vous trouverez des documents de référence sur BNNSGraph et BNNSGraphBuilder. Regardez aussi notre vidéo de l’an dernier, où je discute de l’API basée sur des fichiers et de l’utilisation de BNNSGraph dans C.

Merci pour votre attention aujourd’hui.