Par : Sarry Zheng et Howard Swerdfeger, École de la fonction publique du Canada

La vie quotidienne des Canadiens est de plus en plus façonnée par de nouvelles technologies et de nouveaux services qui sont fondés sur les données. En utilisant ces technologies et ces services, le gouvernement du Canada est en mesure d'accéder à des données provenant de sources multiples afin de mieux répondre aux besoins des citoyens et d'éclairer la prise de décisions.

L'Environnement de fichiers couplables de Statistique Canada est l'un des moyens permettant d'améliorer l'analyse. Il s'agit d'un environnement au niveau des entreprises qui permet de coupler les données administratives aux renseignements sur les entreprises et les particuliers dans l'ensemble du Canada. Cet outil permet d'accéder à des renseignements plus précis et à des analyses plus complètes. Il permet également de réduire le fardeau d'enquête et de réponse des ministères et des industries privées.

Qu'entend-on par données couplées?

Les données couplées découlent d'un processus par lequel les enregistrements de différentes sources de données sont réunis en un seul fichier à l'aide d'identificateurs comme le nom, la date de naissance, l'adresse et d'autres caractéristiques. Ce processus est également connu sous le nom de couplage d'enregistrements, d'appariement de données et de résolution d'entités, entre autres termes. L'idée initiale du couplage de données remonte aux années 1950. Cette technique est utilisée dans de nombreux domaines tels que l'entreposage de données, les renseignements organisationnels et la recherche médicale.

Types de couplage

Il existe deux types de couplage : l'appariement statistique et l'appariement exact.

1. L'appariement statistique permet de créer un fichier qui reflète la répartition de la population sous-jacente. Les enregistrements qui sont combinés ne correspondent pas nécessairement à la même entité, comme une personne ou une entreprise. On suppose que la relation des variables dans la population sera semblable à la relation dans le fichier. Cette méthode est fréquemment utilisée dans les études de marché.
2. L'appariement exact consiste à coupler les renseignements relatifs à un enregistrement particulier dans un fichier aux renseignements d'un autre fichier afin de créer un seul fichier contenant les renseignements exacts pour chaque enregistrement. Il en existe deux sous-types : le couplage d'enregistrements déterministe et le couplage d'enregistrements probabiliste.^{Note de bas de page 1}
   • Le couplage d'enregistrements déterministe permet de coupler des enregistrements à partir d'identificateurs communs entre les sources de données.
   • Le couplage d'enregistrements probabiliste permet de coupler des enregistrements lorsque leurs colonnes ne sont pas toutes identiques, selon la probabilité que les enregistrements correspondent.

Couplage d'enregistrements probabiliste

Le couplage d'enregistrements probabiliste est une méthode pouvant servir à coupler des fichiers de données et à créer un ensemble de paires potentielles lorsqu'un ensemble de données ne contient pas d'identificateur unique, qu'il est incomplet ou qu'il comporte des erreurs. Comme nous pouvons le voir à la figure 1, les premiers enregistrements sont identiques, tandis que les deuxièmes et les troisièmes enregistrements correspondent, mais ne sont pas identiques. L'objectif de tout algorithme de couplage d'enregistrements probabiliste est de reproduire la capacité d'un être humain d'affirmer avec une grande certitude que ces entités sont les mêmes.

Pratiques normalisées

L'un des outils que Statistique Canada utilise pour effectuer des couplages d'enregistrements probabilistes est le logiciel SAS appelé G-Coup. Ce logiciel représente une mise en œuvre directe de l'algorithme de couplage d'enregistrements de Fellegi-Sunter, qui est offert comme application Windows.

À mesure que la puissance de calcul s'accroît, ce qui permet de coupler de plus grands ensembles de données en moins de temps et de les rendre accessibles sur des ordinateurs de bureau, la mise au point de nouveaux modèles théoriques et l'amélioration des méthodologies et des logiciels existants sont de plus en plus répandues. Par exemple, la trousse d'outils de couplage d'enregistrements dans Python (anglais seulement) et l'outil reclin (anglais seulement) dans R sont deux exemples de logiciels ouverts faciles à utiliser qui s'intègrent bien à la méthode de couplage d'enregistrements de Fellegi-Sunter.

Algorithme de Fellegi-Sunter

Depuis sa publication, l'algorithme de Fellegi-Sunter (1969)^{Note de bas de page 2} est devenu l'approche utilisée de facto pour faire le couplage d'enregistrements probabiliste. Ce modèle consiste à estimer les poids d'appariement pour chaque colonne individuelle et à combiner ces poids d'appariement en une probabilité d'appariement globale. En supposant que les variables doivent être indépendantes étant donné l'état de l'appariement, on peut combiner le modèle avec le théorème de Bayes et le quantifier à l'aide de deux paramètres clés pour chaque colonne, soit les probabilités $m$ et $u$, où :

• $m$ est la probabilité que les valeurs d'une colonne donnée ne correspondent pas, mais que les enregistrements soient les mêmes.
• $u$ est la probabilité que les valeurs d'une colonne donnée soient les mêmes, mais pas les enregistrements.

Selon le théorème de Bayes

$P\left(R|D\right)=\frac{P\left(D|R\right)*P\left(R\right)}{P\left(D\right)}$

où :

• $P\left(R\right)$ est la probabilité d'un appariement d'enregistrements.
• $P\left(D\right)$ est la probabilité d'appariement de certains éléments d'information.

En développant le dénominateur,

$P\left(R|D\right)=\frac{P\left(D|R\right)*P\left(R\right)}{P\left(D|R\right)*P\left(D\right)+P\left(D|\overline{R}\right)*P\left(\overline{R}\right)}$

où :

• $P\left(\overline{R}\right)$ est la probabilité que deux enregistrements ne correspondent pas, ou $1-P\left(R\right)$.

Comme nous avons plusieurs colonnes ou plusieurs lignes de données disponibles, nous pourrions utiliser $m_i$ et $u_i$ pour calculer les probabilités $m$ et $u$ de la $i$^e colonne.

$P\left(R|D\right)=\frac{\prod _{i=1}^{N_{\mathrm{col}}}{m}_i*P\left(R\right)}{\prod _{i=1}^{N_{\mathrm{col}}}{m}_i*P\left(R\right)+\prod _{i=1}^{N_{\mathrm{col}}}{u}_i*\left(1-P\left(R\right)\right)}$

M. Yvan P. Fellegi a été statisticien en chef de Statistique Canada de 1985 à 2008. Au cours de son mandat, il a mis en application de nouvelles méthodes de collecte et de compilation de statistiques nationales. Il a aussi défendu haut et fort l'indépendance de l'organisme par rapport à la politique. En juin 2008, à la retraite de M. Fellegi, le Gouvernement canadien l'a nommé statisticien en chef émérite.

Comparaisons de chaînes

L'algorithme de Fellegi-Sunter a au moins un désavantage qui se règle habituellement lors des applications pratiques. Dans la pratique, pour de nombreuses colonnes, les probabilités $m$ et $u$ ne sont souvent pas fondées sur la probabilité que deux colonnes soient identiques, mais plutôt sur l'utilisation d'une fonction de distance appropriée pour mesurer la similarité entre deux colonnes, puis pour calculer le seuil. Les probabilités $m$ et $u$ seraient alors fondées sur ces seuils.

Pour les chaînes, il existe plusieurs fonctions de distance courantes, chacune pouvant être utile pour combiner des données et tenir compte des différences prévues (fautes d'orthographe) dans l'ensemble de données. Certaines de ces fonctions sont résumées ci-dessous :

Couplage d'unités lexicales

Bien que la combinaison de l'algorithme de Fellegi-Sunter et de mesures traditionnelles de la distance des chaînes soit très utile, elle présente plusieurs lacunes possibles :

• Pour les colonnes qui comportent des niveaux catégoriques et qui ne sont pas réparties uniformément, seul le taux d'appariement moyen est pris en compte pour le paramètre u. Il faut penser à apparier la colonne de la ville avec la valeur « Williamstown », ce qui est bien plus porteur de renseignements que l'appariement de la valeur « Toronto ».
• La plupart des algorithmes de distance des chaînes fonctionnent sur le plan des caractères. Ils partent du principe que les distances sémantiques sont des fonctions des caractères qui composent une chaîne, tandis que, en français comme en anglais, l'information est transmise aux lecteurs par les mots.

L'algorithme de couplage d'unités lexicales et le progiciel R permettent de corriger ces problèmes. L'algorithme peut aider à relever les enregistrements où plusieurs niveaux catégoriques sont présents. Il permet également d'indiquer les colonnes comportant plusieurs mots à la fois, comme le nom ou l'adresse d'une entreprise.

L'algorithme de base consiste à accomplir les étapes suivantes :

1. Segmentez en unités lexicales les mots dans la colonne et comptez les occurrences de chaque unité lexicale dans l'ensemble de données.

   

2. Répétez la procédure de segmentation en unités lexicales et de dénombrement pour un autre ensemble de données.
3. Créez une jointure externe complète pour les unités lexicales à deux mots.

   Jointure externe complète pour les unités lexicales

   Unité lexicale	N_a	N_b	U_prob
   Springfield	24	7 500	3,7%
   Evergreen	12	2	0,0005%
   Terrace	12	500	0,12%
   Plympton	6	1	0,00013%
   Industrial	4	8	0,00067%

4. Utilisez cette option pour estimer la probabilité $U$ pour chaque unité lexicale, où $n_{\mathrm{ta}}$ et $n_{\mathrm{tb}}$ représentent le nombre d'occurrences de l'unité lexicale t dans l'ensemble de données a ou b, et $N_a$ et $N_b$ représentent le nombre d'enregistrements dans l'ensemble de données a et b.
   $U_t=\frac{n_{\mathrm{ta}}*n_{\mathrm{tb}}}{N_a*N_b}$
5. Estimez la probabilité m dans son ensemble ou indépendamment pour chaque unité lexicale.
6. Joignez le fichier fusionné des unités lexicales dénombrées aux deux ensembles de données originaux, en calculant la probabilité $P\left(R|T_{i-1\dots N_t}\right)$ que deux enregistrements soient identiques étant donné qu'ils ont une unité lexicale en commun.
   $P\left(R|T_{i-1\dots N_t}\right)=\frac{\prod _{t=1}^{N_t}{m}_t*P\left(R\right)}{\prod _{t=1}^{N_t}{m}_t*P\left(R\right)+\prod _{t=1}^{N_t}{u}_t*\left(1-P\left(R\right)\right)}$

Voici quelques-unes des limites de la technique de couplage d'unités lexicales :

• Comme toutes les méthodes liées à l'algorithme de Fellegi-Sunter, cette technique présuppose que les éléments d'information sont indépendants. Le couplage d'unités lexicales part du principe que les mots sont indépendants. Par exemple, alors que les mots « recherche et développement » apparaissent souvent ensemble et ne devraient pas être traités indépendamment, cet algorithme traiterait ces mots comme des unités indépendantes et distinctes.
• Cet algorithme ne tient pas compte de l'ordre des mots. Ainsi, la combinaison « Bill et Ted » serait considérée comme identique à « Ted et Bill ».
• L'algorithme a de la difficulté à trouver des correspondances si une simple faute d'orthographe se trouve dans un mot d'identification important. Par exemple, cet algorithme pourrait avoir plus de difficulté à trouver la paire d'enregistrements « café Starbucks » et « Café Starbacks » que la paire d'enregistrements « café Starbucks coffee » et « Cofé Starbucks ».

Pour en savoir plus sur cette technique, consultez TokenLink sur GitHub (en anglais).

Pour commencer

L'Environnement de fichiers couplables (EFC) de Statistique Canada offre un soutien aux utilisateurs et aux partenaires pour leurs recherches et leurs rapports selon le principe du recouvrement des coûts. Pour en savoir plus sur ce service offert, communiquez avec l'équipe de l'EFC.

Les ministères qui souhaitent extraire de la valeur des données sur leurs parties réglementées en utilisant des données couplées doivent tenir compte de trois choses.

Identificateurs uniques

Songez à recueillir des identificateurs uniques, comme le numéro d'entreprise, auprès de vos parties réglementées. Bien qu'il soit possible de coupler des données sans identificateurs uniques au moyen de caractéristiques comme le nom ou l'adresse de l'entreprise, cela peut entraîner des erreurs dans le processus de couplage. Le taux d'erreur est souvent lié à la qualité des données et au mécanisme de collecte des données.

Statistiques sommaires

Déterminez quelle mesure sommaire demander. S'il existe un risque d'erreur dans le processus de couplage, certaines mesures sommaires sont plus efficaces que d'autres pour prévenir les valeurs aberrantes. Comme mesures de la tendance centrale et de la variation, pensez à demander la médiane et l'intervalle interquartile plutôt que la moyenne arithmétique et l'écart-type, car les deux premières mesures sont plus efficaces que les deux dernières pour prévenir les valeurs aberrantes.

Granularité et taille des données

Tenez compte des éventuelles suppressions de données. Si un ministère demande que les données soient résumées à un niveau très détaillé et qu'il n'y a pas un grand nombre de parties réglementées, il se pourrait qu'on supprime les cellules d'un tableau sommaire pour protéger la confidentialité des entités et se conformer à la Loi sur la statistique. En général, plus les ensembles de données sont grands, plus le niveau d'agrégation des données peut être affiné.

Remerciements

L'Environnement de fichiers couplables de Statistique Canada; Zhuo (Sarah) Zhang, Robert Dorling, Ministre des pêches et océans Canada

Si vous avez des questions à propos de mon article ou si vous souhaitez en discuter davantage, je vous invite à une Rencontre avec le scientifique des données, un événement au cours duquel les auteurs rencontrent les lecteurs, présentent leur sujet et discutent de leurs résultats.

Jeudi, le 17 novembre
14 h 00 à 15 h 00 HNE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

Par Loïc Muhirwa, Statistique Canada

Introduction

Étant donné que de nombreuses applications nécessitent l'identification des substructures des images numériques, la segmentation est une procédure fondamentale de prétraitement. La segmentation binaire entre l'avant-plan et l'arrière-plan d'une image, d'application très large, est un exemple canonique de segmentation d'image. En imagerie médicale, il peut être nécessaire de segmenter des images de résonance magnétique (RM) ou de tomodensitométrie (TDM) d'un organe en structures anatomiques distinctes ou de segmenter différents types de tissus. Dans le domaine de la neuroimagerie particulièrement, il est possible de segmenter le cerveau humain selon le tissu principal (matière blanche et grise) ou selon l'état de santé d'un tissu, c'est-à-dire sain ou avec lésion.

Pour mettre en forme ces idées, il nous faut une représentation mathématique d'une image. Il existe plusieurs manières de représenter les images, selon les applications; certaines sont plus pratiques que d'autres. Comme le décrit l'article, en raison de la multiplicité des méthodes de segmentation d'image, il est difficile de trouver une représentation mathématique unique d'une image. Malgré cela, nous adopterons une représentation primaire, de laquelle nous pourrons nous écarter aux fins de simplification de la notation ou pour régler les cas dans lesquels une image est un objet discret, par opposition à un objet continu. Formellement, une image peut être représentée comme une table de pixels d'un domaine d'image à un domaine d'intensité, comme suit :

$I: \Omega \to \mathrm{R}$

où le domaine d'image $\Omega$ est un espace compact et un sous-ensemble simplement connexe de $R^d\mathrm{for}d\in \left\{2, 3\right\}$ pour des images en 2D ou 3D, également appelé volumes (voir : la définition de simplement connexe – le contenu de cette page est en anglais). Par ailleurs, sans perte de généralité, l'article étudie seulement les images aux valeurs d'intensité unidimensionnelles, telles que les images en niveaux de gris. Il s'agit d'une définition implicite étant donné que l'image est mise en correspondance avec $\mathrm{R}$. Dans cette représentation d'image, nous pouvons définir conceptuellement une segmentation Z de l'image I comme étant la carte suivante :

$Z:\Omega \to \left\{0,...,K-1\right\},$

où $K$ est le nombre de segments d'image distincts.

Figure 1 : Segmentation d'une coupe axiale du cerveau. Le rouge, le vert et le bleu correspondent respectivement à la matière blanche, à la matière grise et au liquide céphalorachidien. (Source de l'image : A review of medical image segmentation: methods and available software.^{Footnote 21})

En gros, la segmentation des images numériques peut être classée en deux catégories : la segmentation manuelle et la segmentation automatique. Dans la segmentation manuelle, un être humain annote manuellement les différents segments dans une image numérique, tandis que dans la segmentation automatique, un algorithme automatisé segmente l'image. La segmentation manuelle présente plusieurs difficultés, notamment en matière de coût, de temps et d'uniformité. Premièrement, dans de nombreuses applications, la personne qui annote les images doit être spécialiste du domaine, ce qui rend la segmentation manuelle difficile et coûteuse sur le plan opérationnel.

Si l'on prend l'exemple de la neuroimagerie médicale, certains des types de segmentation les plus courants consistent en une segmentation selon le type de tissu, qui classe le tissu cérébral en trois grands types : matière blanche, matière grise et liquide céphalorachidien (voir la figure 1). L'annotation manuelle du volume d'images neurologiques d'un seul patient nécessite beaucoup de temps et des connaissances de radiologue. Deuxièmement, le traitement d'image peut nécessiter l'annotation de centaines d'images, ce qui est ingérable en cas de traitement manuel. Troisièmement, les segmentations manuelles varient considérablement d'une personne à l'autre, y compris quand elles sont réalisées par des spécialistes^{Footnote 1}. Certains tomodensitomètres peuvent produire des images facilement segmentables par un procédé automatique. À titre d'exemple, comme une image neurologique de tomodensitométrie a des intensités ayant une correspondance physique fixe, la segmentation automatisée ne pose pas de difficulté. Pour ces raisons et bien d'autres, il faut privilégier la segmentation automatique.

Dans les sections suivantes, nous classerons les méthodes de segmentation automatique en deux catégories : les méthodes fondées sur un modèle génératif et les méthodes d'apprentissage profond.

Segmentation automatique – Méthodes fondées sur un modèle génératif

Dans les méthodes fondées sur un modèle génératif, la segmentation d'une image est modélisée comme un problème d'inférence statistique. Plus précisément, on spécifie un modèle génératif de l'image, dans lequel la segmentation est une variable latente et la segmentation d'une image correspond à l'inférence de cette variable.

Modèles univariés

Pour ce qui est des points, la méthode univariée modélise les intensités d'image de différents segments en tant que sous-populations à partir d'un modèle par mélanges finis (MMF) avec des distributions d'intensité différentes décrivant les processus de génération de données de différents segments. Dans le cadre de cette modélisation, les intensités d'image appartenant à des segments donnés sont tirées de mélanges distincts. Un des cas particuliers de MMF souvent utilisé dans la segmentation d'image est un modèle de mélange gaussien (MMG) dans lequel les distributions de mélange sont gaussiennes.^{Footnote 2Footnote 3Footnote 4} Au moyen d'un MMG, nous montrerons comment un modèle génératif peut servir à segmenter une image. L'image est représentée par une variable aléatoire $I$qui est un ensemble de variables aléatoires indépendantes $I\left(x\right)$ avec un support $\mathrm{R}$ et l'on suppose que $Z\left(x\right)$ est une variable aléatoire avec un support ${\left\{0,1\right\}}^k$ représentant la valeur d'intensité et l'affectation de mélange pour un élément de domaine d'image $x\in \Omega$ respectivement. Soit $\pi$ un vecteur de variable aléatoire avec un support $[0,1{]}^k$ comme probabilités de mélange, où la $k^e$ entrée ${\pi }_k$ indique la probabilité d'appartenance au $k^e$ segment d'image. En supposant une configuration bayésienne, $Z\left(x\right)| \pi ~ Categorical(\pi )$ est une variable latente telle que cet événement $Z(x{)}_k=1$ indique que $x$ appartient au $k^e$ segment d'image et qu'il existe une loi a priori de Dirichlet sur les probabilités de mélange, à savoir $\pi ~ Dirichlet\left(\beta \right)$ La fonction de densité conjointe de probabilité d'affectation de segment et d'intensité à une valeur $x\in \Omega$ donnée a la forme suivante :

$\mathrm{\mathbb{P}}\left(I\left(x\right)=x,Z\left(x\right)=z|\pi ,\mu ,\sigma \right) \propto \prod _{k=1}^KƝ{(\mu ,{\sigma }^2)}^{zk}\prod _{k=1}^K{{\pi }_k}^{zk}\frac{\Gamma \left(K\beta \right)}{\Gamma \left(\beta \right)}\prod _{k=1}^K{{\pi }_k}^{\beta -1}$

où $\mu$ et $\sigma$ sont des ensembles de paramètres de moyenne et de variance, respectivement, pour chaque mélange et $\beta$ représente des paramètres de parcimonie de Dirichlet.

Modèles multivariés

Contrairement aux méthodes univariées, les méthodes multivariées modélisent la distribution d'intensité sur l'ensemble d'un domaine d'image, tout en tenant compte des dépendances à long terme entre pixels. Les champs aléatoires de Markov (CAM) sont une classe de modèles qui spécifient une distribution dans le domaine de l'image en commençant par discrétiser le domaine de manière à ce que

$\Omega ={\left\{1,...,M\right\}}^d$

pour certains $M\in N$ and $d\in \left\{2,3\right\}.$ Après cette discrétisation, la segmentation et les intensités sont indexées par les sommets d'un graphe non orienté et par les sommets adjacents correspondant aux pixels adjacents.^{Footnote 5} Supposons d'abord que les estimations d'intensité moyenne pour chaque classe de segments sont données, puis soit ${\mu }_k$ et ${{\sigma }^2}_k$ be the mean and variance intensity estimate for the $k^e$ segment d'image. Nous pouvons alors définir une fonctionnelle qui correspond à la probabilité $\log$ négative du modèle et qui a la forme suivante :

$H\left[Z\right]=\sum _{k=1}^K\sum _{x \in \Omega }\mathbb{l}\left(Z\left(x\right)=k\right){\left[\frac{I\left(x\right)-{\mu }_k}{{\sigma }_{{}_k}}\right]}^2+\lambda \sum _{x \in \Omega }\mathbb{l}\sum _{y \in N\left(x\right)}\mathbb{l}{\delta }_Z\left(x,y\right)$

où $N\left(x\right)$ est l'ensemble de sommets adjacents à $x, l(\cdot )$ est une fonction indicatrice et ${\delta }_Z(x,y)$ est un terme de pénalité qui pénalise les emplacements voisins dans le domaine d'image qui n'ont pas en commun les étiquettes de segment. En pratique ${\mu }_k$ ${{\sigma }^2}_k$ sont généralement obtenus par un étiquetage partiel (semi-supervisé) effectué par un spécialiste du domaine. Dans l'équation précédente, la première double sommation pénalise un $Z(\cdot )$ qui étiquette les pixels dont les intensités s'écartent considérablement de l'intensité moyenne dans cette classe de segments. Pour la classe de segments, la distance par rapport à la moyenne est normalisée par l'écart-type afin que la proximité de la moyenne entre classes de segments soit comparable. La deuxième sommation double favorise un $Z$ qui donne aux pixels voisins la même étiquette, et $\lambda$ est un paramètre qui équilibre les deux sommations doubles.

Inférence et apprentissage

Comme cela a été dit plus haut, dans le contexte des modèles génératifs, la segmentation d'image est un problème statistique dans lequel la segmentation est inférée et les paramètres qui régissent le modèle génératif sont appris. Dans cette sous-section, nous donnons des exemples de problèmes d'inférence qui se posent couramment dans la segmentation d'image.

Maximum de vraisemblance et estimation du maximum a posteriori

Si nous avons accès à une distribution a posteriori ou une vraisemblance soluble, cette inférence est réalisable au moyen d'une estimation par la méthode du maximum de vraisemblance (EMV) ou d'une estimation du maximum a posteriori (MAP) de l'affectation des segments. De façon plus formelle, dans l'hypothèse d'un contexte bayésien, supposons que nous avons accès à une distribution a posteriori soluble et au comportement raisonnable $p\left(Z\right|I)$ où $Z$ et $I$ sont respectivement le MAP de la segmentation et l'image. L'estimation par le MAP du MAP de la segmentation aurait la forme suivante :

$Z_{MAP}=argma{x}_{z}p\left(Z\right|I).$

Il n'est pas toujours facile de tirer un échantillon en cas de distribution a posteriori d'une segmentation; cela est particulièrement vrai pour les CAM. Dans ces scénarios, on utilise généralement des méthodes Monte Carlo par chaînes de Markov (MCMC) fondées sur des graphes. Plus précisément, un échantillonnage de Gibbs est généralement utilisé pour les CAM^{Footnote 6} puisqu'il s'agit d'un cas particulier de champ aléatoire conditionnel (CAC), ce qui permet de relativement facilement spécifier chaque affectation de segment comme une probabilité conditionnelle.

Inférence variationnelle

Plutôt que d'échantillonner une distribution a posteriori insoluble, on peut utiliser une méthode dite d'inférence variationnelle (IV) pour estimer la distribution a posteriori au moyen d'une distribution issue d'une famille de distributions solubles. Cette famille de distributions solubles est celle des distributions variationnelles, d'après le calcul des variations ou calcul variationnel. Après spécification de la famille de distributions, on peut estimer la distribution a posteriori en trouvant la distribution variationnelle qui optimise certaines mesures entre la distribution a posteriori vraie et elle-même. L'indicateur le plus couramment utilisé pour mesurer la similarité entre deux distributions est la divergence Kullback-Leibler (KL), définie comme suit :

$KL\left(q\left|\right|p\right)=E_z\left[log\frac{q\left(z\right)}{p\left(z\right|x)}\right]$

où $q(\cdot )$ est une densité approximative et $p(\cdot )$ est une densité vraie sur le même support. L'inférence de la segmentation latente au moyen de cette approximation de distribution peut être formulée comme un problème d'inférence d'espérance-maximisation bayésienne variationnelle (EMBV).^{Footnote 7} Une analyse plus approfondie de l'inférence variationnelle peut se trouver dans la section 4 de Variational Inference.^{Footnote 8}

Méthodes d'apprentissage profond

Depuis quelques années, les méthodes d'apprentissage profond (AP) ont été appliquées avec succès à de nombreuses tâches d'apprentissage. Il a été démontré qu'elles surpassent des techniques antérieures d'apprentissage automatique de pointe, en particulier dans le domaine de la vision par ordinateur.^{Footnote 9} Vaguement inspirées des modèles informatiques d'apprentissage biologique, les méthodes d'AP donnent des modèles informatiques efficaces et extrêmement parallélisables de couches de traitement multiples qui apprennent implicitement des représentations de données.^{Footnote 10} Les configurations structurelles de ces couches de traitement sont connues sous le nom d'architectures. Certaines des architectures prédominantes dans la vision par ordinateur comprennent les réseaux antagonistes génératifs (ou GAN pour l'anglais)^{Footnote 11} les réseaux de neurones récurrents (ou RNN en anglais)^{Footnote 12} et les réseaux neuronaux convolutifs ^{Footnote 13} ces derniers affichant des performances particulièrement bonnes en segmentation d'image. Un réseau neuronal convolutif en 3D appliqué à la segmentation des lésions cérébrales^{Footnote 14} a permis d'améliorer le modèle précédent pour obtenir les meilleures performances des ensembles de données de référence publics BRATS 2015^{Footnote 15} et ISLES 2015^{Footnote 16} (ensembles de données publics utilisés dans les défis sur la segmentation des lésions cérébrales).

Réseaux neuronaux convolutifs

Figure 2 : Processus typique de segmentation par apprentissage profond avec un réseau neuronal convolutif. Source de l'image : Going Deep in Medical Image Analysis: Concepts, Methods, Challenges and Future Directions^{Footnote 17}

À l'heure actuelle, les réseaux neuronaux convolutifs sont considérés comme les réseaux les plus à la pointe de la technologie pour les problèmes de segmentation d'image par AP supervisé.^{Footnote 18} Leur architecture s'inspire d'un modèle de champ récepteur hiérarchique du cortex visuel et comprend généralement la composition de trois types de couches :

1. couches de convolution, où un noyau (filtre) est convolué sur des entrées pour extraire une hiérarchie de caractéristiques;
2. couches non linéaires, qui permettent de mapper les entrées aux espaces de caractéristiques;
3. couches de regroupement, qui réduisent la résolution spatiale en agrégeant les informations locales.

Chaque couche est constituée d'unités de traitement connectées localement. Ces connexions locales sont appelées champs récepteurs. Les couches sont généralement composées pour former une pyramide multirésolution dans laquelle les couches de niveau supérieur apprennent les caractéristiques de champs récepteurs plus larges. Les paramètres du modèle sont généralement appris au moyen d'une version stochastique de l'algorithme de rétropropagation^{Footnote 19} qui est une routine d'optimisation par gradient propageant efficacement le gradient du résidu à travers le réseau.

Méthodes d'évaluation

En général, les méthodes d'évaluation de la segmentation supervisée tentent de quantifier le degré de chevauchement entre une segmentation estimée et la segmentation réelle sur le terrain. En utilisant la notation cartographique d'une segmentation de l'expression (2), nous pouvons comprendre de façon équivalente la segmentation comme un ensemble avec l'image de sa carte, c'est-à-dire $Z\left(\Omega \right).$

Le coefficient de Dice (D) est l'une des méthodes d'évaluation de la segmentation les plus populaires et les plus faciles à comprendre sur le plan conceptuel. Pour deux segmentations $A$ et $B$, le coefficient de Dice est calculé comme suit

$D\left(A,B\right)= \frac{2|A\cap B|}{\left|A\right| + \left|B\right|}$

Le coefficient de Jaccard (J) — une autre méthode d'évaluation de la segmentation — est lié au coefficient de Dice par l'expression suivante

$D= \frac{2J}{1+J}$

$D$ est connu pour produire des valeurs plus grandes pour des volumes plus élevés. Une autre méthode d'évaluation de la segmentation est la distance de Hausdorff moyenne, qui est particulièrement recommandée pour les tâches de segmentation présentant des limites complexes et de petits segments minces. Comparativement au coefficient de Dice, la distance de Hausdorff moyenne a l'avantage de tenir compte de la localisation quand on considère les performances de la segmentation^{Footnote 20} Pour deux segmentations $A$ et $B$, qui sont des sous-ensembles non vides d'un espace métrique $(S,d)$, la distance de Hausdorff moyenne est calculée comme suit :

$H\left(A,B\right)=\frac{1}{2}\left(\frac{1}{\left|A\right|}\sum _{x\in A}\underset{y\in B}{mind}\left(x,y\right)+\frac{1}{\left|B\right|}\sum _{x\in A}\underset{y\in B}{mind}\left(x,y\right)\right).$

Pour connaître d'autres méthodes d'évaluation, se reporter à Metrics for evaluating 3D medical image segmentation^{Footnote 22}

Conclusion

En conclusion, la segmentation d'image est une technique cruciale dans le traitement d'image en général et en imagerie médicale en particulier. Ce processus est une partie essentielle d'un pipeline de traitement d'image qui nécessite des analyses d'images en aval, dans lesquelles sont identifiées les sous-structures sémantiques d'une image. L'apprentissage automatique nous permet d'automatiser cette procédure et de conserver la qualité d'exécution d'une annotation par un spécialiste, pour un coût nettement moindre.

Si vous avez des questions à propos de mon article ou si vous souhaitez en discuter davantage, je vous invite à une Rencontre avec le scientifique des données, un événement au cours duquel les auteurs rencontrent les lecteurs, présentent leur sujet et discutent de leurs résultats.

Jeudi, le 17 novembre
14 h 00 à 15 h 00 HNE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

Par : Mihir Gajjar, Statistique Canada
Collaborateurs : Reginald Maltais, Allie Maclsaac, Claudia Mokbel et Jeremy Solomon, Statistique Canada

MLflow (le contenu de cette page est en anglais) est une plateforme en source ouverte qui permet de gérer le cycle de vie d'apprentissage automatique, notamment l'expérimentation, la reproductibilité, le déploiement et un registre de modèles central. MLflow propose quatre composantes :

• MLflow Tracking : enregistrement et interrogation d'essais : code, données, paramètres de configuration et résultats.
• MLflow Projects : assemblage de code de science des données en un format permettant de reproduire les passages sur n'importe quelle plateforme.
• MLflow Models : déploiement de modèles d'apprentissage automatique dans divers environnements d'utilisation.
• Model Registry : stockage, annotation, découverte et gestion de modèles au sein d'un répertoire central.

Cet article se concentre sur MLflow Tracking. Le site Web de MLflow détaille les trois autres composantes.

Avantages de MLFlow

MLflow Tracking offre une solution pouvant être adaptée de votre machine locale à l'entreprise entière. Cela permet aux scientifiques des données de commencer sur leur machine locale, alors que les organisations peuvent mettre en œuvre une solution veillant à la maintenabilité à long terme et à la transparence au sein d'un répertoire central.

MLflow Tracking fournit des capacités de suivi cohérentes et transparentes en :

• effectuant le suivi programmatique des paramètres et des résultats correspondants pour les essais de modélisation et en les comparant à l'aide d'une interface utilisateur;
• récupérant le modèle présentant les meilleurs résultats ainsi que son code correspondant, pour diverses mesures d'intérêt pour tous les essais de différents projets;
• regardant temporellement en arrière, afin de relever des essais effectués avec certaines valeurs de paramètres;
• permettant aux membres de l'équipe de procéder à des essais et de faire part des résultats en collaboration;
• exposant à l'intention de la direction l'état d'avancement de plusieurs projets au sein d'une seule interface ainsi que tous les détails (paramètres, tracé des résultats, mesures, etc.);
• permettant le suivi pour tous les passages et paramètres au moyen d'un simple carnet; ce qui réduit le temps passé à gérer du code et diverses versions de carnet;
• fournissant une interface permettant le suivi d'essais basés sur Python et R.

Comment passer d'un essai à un autre avec MLflow?

Cet article se concentre sur l'utilisation de MLflow avec Python. Le document QuickStart (le contenu de cette page est en anglais) relatif à MLflow présente des exemples de son utilisation avec R pour une installation locale sur une seule machine. Les organisations souhaitant déployer MLflow entre des équipes peuvent également se reporter à ce document QuickStart.

Le présent article explore un exemple d'utilisation de MLflow avec Python; toutefois, pour bien comprendre le fonctionnement de MLFlow, il est utile d'effectuer chaque étape sur votre machine.

Installation de MLflow

MLflow peut s'installer comme progiciel Python standard en entrant la commande suivante dans une fenêtre de terminal :

$ pip install mlflow

Une fois l'exécution de la commande terminée, vous pouvez entrer mlflow sur votre terminal et explorer les options disponibles. Vous pouvez essayer, par exemple : mlflow –version , pour vérifier la version installée.

Lancement du serveur MLflow

Il est recommandé de disposer d'un serveur MLflow centralisé pour une personne, une équipe ou une organisation, afin que les passages pour différents projets puissent être journalisés à un emplacement central, en les isolant par essai (différents essais pour différents projets). Nous discutons plus en détail de ces questions plus loin dans le présent article. Pour commencer rapidement à utiliser l'outil, vous pouvez ignorer le lancement du serveur et journaliser tout de même les passages. Ce faisant, les passages sont enregistrés dans un répertoire intitulé « MLruns », dans le même répertoire que le code. Vous pouvez plus tard ouvrir l'interface utilisateur de MLflow en suivant le même chemin d'accès et visualiser les passages journalisés.

Les passages peuvent être journalisés sur un serveur MLflow exécuté localement ou à distance en configurant l'adresse URI (identifiant uniforme de ressource) adéquate de suivi. La configuration de l'emplacement de journalisation adéquat est expliquée plus bas.

Si vous préférez toutefois lancer le serveur immédiatement, vous pouvez le faire en entrant la commande suivante :

$ mlflow server

Le terminal affichera des renseignements similaires à ceux présentés ci-dessous, qui montrent que le serveur écoute au port de serveur local 5000. Cette adresse est utile pour accéder à l'interface utilisateur (IU) de MLflow. N'hésitez pas à explorer la différence subtile entre l'IU de MLflow et le serveur de MLflow dans les documents relatifs à MLflow Tracking (le contenu de cette page est en anglais).

[2021-07-09 16:17:11 –0400] [58373] [INFO] Starting gunicorn 20.1.0
[2021-07-09 16:17:11 –0400] [58373] [INFO] Listening at: http://127.0.0.1:5000 (58373)
[2021-07-09 16:17:11 –0400] [58373] [INFO] Using worker: sync
[2021-07-09 16:17:11 –0400] [58374] [INFO] Booting worker with pid: 58374
[2021-07-09 16:17:11 –0400] [58375] [INFO] Booting worker with pid: 58375
[2021-07-09 16:17:11 –0400] [58376] [INFO] Booting worker with pid: 58376
[2021-07-09 16:17:11 –0400] [58377] [INFO] Booting worker with pid: 58377

Journalisation des données dans MLflow

Deux principaux concepts sous-tendent le suivi avec MLflow : les essais et les passages. Les données journalisées au cours d'un essai sont enregistrées sous forme de passage dans MLflow. Ces passages peuvent être organisés en essai; ce qui regroupe les passages pour une tâche particulière. On peut alors visualiser, rechercher, comparer et télécharger les artéfacts et métadonnées de passages pour les passages journalisés dans le cadre d'un essai MLflow.

Les données d'un essai peuvent être journalisées comme passage dans MLflow à l'aide de progiciels MLflow Python, R ou Java ou au moyen de l'IPA (interface de programmation d'applications) REST.

Le présent article fait la démonstration de la modélisation d'un des concours de mise en route de TLN (traitement du langage naturel) sur Kaggle intitulé « Natural Language Processing with Disaster Tweets (le contenu de cette page est en anglais) ». On utilise un carnet Jupyter et l'IPA Python de MLflow pour journaliser des données dans MLflow. Nous mettrons l'accent sur la démonstration de la façon de journaliser des données dans MLflow au cours de la modélisation, plutôt que sur l'obtention des meilleurs résultats de modélisation.

Tout d'abord, commençons par le processus de modélisation habituel, qui inclut des importations, la lecture de données, le prétraitement de texte, les caractéristiques de pondération rtf-idf (term frequency-inverse document frequency) et le modèle de machine à vecteurs de support (SVM). À la fin, une section sera intitulée « Journalisation dans MLflow ».

Importation des bibliothèques

Commencez par importer toutes les bibliothèques requises par l'exemple :

# To create unique run name.
import time
# To load data in pandas dataframe.
import pandas as pd

# NLP libraries

# To perform lemmatization
from nltk import WordNetLemmatizer
# To split text into words
from nltk. tokenize import word_tokenize
# To remove the stopwords
from nltk.corpus import stopwords

# Scikit-learn libraries

# To use the SVC model
from sklearn.svm import SVC
# To evaluate model performance
from sklearn.model_selection import cross_validate, StratifiedkFold
# To perform Tf-idf vectorization
from sklearn.feature_extraction.text import TfidfVectorizer
# To get the performance metrics
from sklearn.metrics import f1_score, make_scorer
# For logging and tracking experiments
import mlflow

Création d'un nom de passage unique

MLflow permet de suivre plusieurs passages d'un essai grâce à un paramètre de nom de passage. Le nom du passage peut être défini comme toute valeur, mais devrait être unique, afin de pouvoir être identifié ensuite parmi les différents passages. Ci-dessous, un horodatage est utilisé comme nom unique.

run_name = str(int(time.time()))
print('Run name: ', run_name)

On obtient :

Nom de passage : 1625604741 

Lecture des données

Chargez la formation et les données de test à partir des fichiers CSV fournis pour l'exemple.

# Kaggle competition data download link: https://www.kaggle.com/c/nlp-getting-started/data
train_data = pd.read_csv("./data/train.csv")
test_data = pd.read_csv("./data/test.csv")

En exécutant la portion de code suivant dans une cellule :

train_data

La figure 1 présente un exemple de données de formation venant d'être chargées.

Figure 1 : Aperçu des données de formation chargées

Les données de formation représentent environ 70 % des données totales.

print('The length of the training data is %d' % len(train_data))
print('The length of the test data is %d' % len(test_data))

Produit :

The length of the training data is 7613
The length of the test data is 3263

Prétraitement de texte

Selon la tâche à réaliser, différents types d'étapes de prétraitement peuvent être nécessaires pour que le modèle d'apprentissage automatique apprenne de meilleures caractéristiques. Le prétraitement peut normaliser les intrants, supprimer certains mots courants, le cas échéant, de sorte que le modèle ne les apprenne pas comme des caractéristiques, et apporter des modifications logiques et utiles pouvant mener à une amélioration du rendement et de la généralisation du modèle. La section suivante montre comment des étapes de prétraitement peuvent aider le modèle à capturer les caractéristiques pertinentes au cours de l'apprentissage.

def clean_text(text):
    # split into words
    tokens = word_tokenize(text)
    # remove all tokens that are not alphanumeric. Can also use .isalpha() here if do not want to keep numbers.
    words = [word for word in tokens if word.isalnum()]
    # remove stopwords
    stop_words = stopwords.words('english')
    words = [word for word in words if word not in stop_words]
    # performing lemmatization
    wordnet_lemmatizer = WordNetLemmatizer()
    words = [wordnet_lemmatizer.lemmatize(word) for word in words]
    # Converting list of words to string
    words = ' '.join(words)
    return words

train_data['cleaned_text'] = train_data['text'].apply(clean_text) 

Lors de la comparaison du texte d'origine et du texte nettoyé, les pseudo-mots ont été supprimés :

train_data['text'].iloc[100]

'.@NorwayMFA #Bahrain police had previously died in a road accident they were not killed by explosion https://t.co/gFJfgTodad (en anglais seulement)'

train_data['cleaned_text'].iloc[100]rain_data['text'].iloc[100]

'NorwayMFA Bahrain police previously died road accident killed explosion http'

À la lecture du texte ci-dessus, on peut dire qu'il contient des renseignements sur une catastrophe et devrait donc être classé comme tel. Pour confirmer cela avec les données, imprimez l'étiquette présente dans le fichier CSV relatif à ce tweet :

train_data['target'].iloc[100]

Produit :

1

Caractéristiques Tf-idf

Ensuite, nous convertissons une collection de documents bruts vers une matrice de caractéristiques TF-IDF en vue d'alimenter le modèle. Pour de plus amples détails sur tf-idf, reportez-vous aux documents TF–IDF - Wikipédia and scikit-learn sklearn.feature_extraction.text (le contenu de cette page est en anglais).

ngram_range=(1,1)
max_features=100
norm='l2'

tfidf_vectorizer = TfidfVectorizer(ngram_range=ngram_range, max_features=max_features, norm=norm)

train_data_tfidf = tfidf_vectorizer.fit_transform(train_data['cleaned_text'])
train_data_tfidf

Produit :

<7613x100 sparse matrix of type '<class 'numpy.float64'>'
with 15838 stored elements in Compressed Sparse Row format>

tfidf_vectorizer.get_feature_names()[:10]

Produit :

['accident',
'amp',
'and',
'as',
'attack',
'back',
'best',
'body',
'bomb',
'building']

Modèle SVC

L'étape suivante de la modélisation est d'ajuster un modèle et d'évaluer son rendement.

On utilise un programme de validation croisée K-Folds stratifié pour évaluer le modèle. Voir scikit learn sklearn.model_selection (le contenu de cette page est en anglais) pour de plus amples détails.

strat_k_fold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

Faire fonctionner un programme de calcul de résultat à l'aide de la mesure f1-score pour l'utiliser comme paramètre dans le modèle SVC.

scoring_function_f1 = make_scorer(f1_score, pos_label=1, average='binary')

Vient ensuite une étape importante pour adapter le modèle aux données. Dans cet exemple, le classificateur SVC est utilisé. Voir scikit learn sklearn.svm.svc (le contenu de cette page est en anglais) pour de plus amples détails.

C = 1.0
kernel='poly'
max_iter=-1
random_state=42

svc = SVC(C=C, kernel=kernel, max_iter=max_iter, random_state=random_state) 
cv_results = cross_validate(estimator=svc, X=train_data_tfidf, y=train_data['target'], scoring=scoring_function_f1, cv=strat_k_fold, n_jobs=-1, return_train_score=True)
cv_results

Produit :

{'fit_time': array([0.99043322, 0.99829006, 0.94024873, 0.97373009, 0.96771407]),
'score_time': array([0.13656974, 0.1343472 , 0.13345313, 0.13198996, 0.13271189]),
'test_score': array([0.60486891, 0.65035517, 0.5557656 , 0.5426945 , 0.63071895]),
'train_score': array([0.71281362, 0.76168757, 0.71334394, 0.7291713 , 0.75554698])}

def mean_sd_cv_results(cv_results, metric='F1'):
    print(f"{metric} Train CV results: {cv_results['train_score'].mean().round(3)} +- {cv_results['train_score'].std().round(3)}")
    print(f"{metric} Val CV results: {cv_results['test_score'].mean().round(3)} +- {cv_results['test_score'].std().round(3)}")

mean_sd_cv_results(cv_results)

F1 Train CV results: 0.735 +- 0.021
F1 Val CV results: 0.597 +- 0.042

! Jupyter nbconvert --to html mlflow-example-real-or-not-disaster-tweets-modeling-SVC.ipynb

[NbConvertApp] Converting notebook mlflow-example-real-or-not-disaster-tweets-modeling-SVC.ipynb to html
[NbConvertApp] Writing 610630 bytes to mlflow-example-real-or-not-disaster-tweets-modeling-SVC.html

Journalisation dans MLflow

Tout d'abord, configurez le serveur URI. Le serveur s'exécutant localement, définissez l'URI de suivi comme port de serveur local 5000. L'URI de suivi peut être configurée pour un serveur distant également (voir : Where Runs are Recorded [le contenu de cette page est en anglais]).

server_uri = 'http://127.0.0.1:5000'
mlflow.set_tracking_uri(server_uri)

Pour organiser les passages, un essai a été créé et défini à l'emplacement où les passages seront journalisés. La méthode « set_experiment » créera un nouveau passage avec le nom de chaîne fourni et le définira comme l'essai en cours pour lequel les passages seront journalisés.

mlflow.set_experiment('nlp_with_disaster_tweets')

Enfin, lancez un passage et journalisez les données dans MLflow.

# MLflow logging.
with mlflow.start_run(run_name=run_name) as run:

    # Logging tags
    # run_name.
    mlflow.set_tag(key='Run name', value=run_name)
    # Goal.
    mlflow.set_tag(key='Goal', value='Check model performance and decide whether we require further pre-processing/hyper-parameter tuning.')
    # Modeling exp.
    mlflow.set_tag(key='Modeling technique', value='SVC')

    # Logging parameters
    mlflow.log_param(key='ngram_range', value=ngram_range)
    mlflow.log_param(key='max_features', value=max_features)
    mlflow.log_param(key='norm', value=norm)
    mlflow.log_param(key='C', value=C)
    mlflow.log_param(key='kernel', value=kernel)
    mlflow.log_param(key='max_iter', value=max_iter)
    mlflow.log_param(key='random_state', value=random_state)

    # Logging the SVC model.
    mlflow.sklearn.log_model(sk_model=svc, artifact_path='svc_model')
   
    # Logging metrics.
    # mean F1-score - train.
    mlflow.log_metric(key='mean F1-score - train', value=cv_results['train_score'].mean().round(3))
    # mean F1-score - val.
    mlflow.log_metric(key='mean F1-score - val', value=cv_results['test_score'].mean().round(3))
    # std F1-score - train.
    mlflow.log_metric(key='std F1-score - train', value=cv_results['train_score'].std().round(3))
    # std F1-score - val.
    mlflow.log_metric(key='std F1-score - val', value=cv_results['test_score'].std().round(3))
   
    # Logging the notebook.
    # Nb.
    mlflow.log_artifact(local_path='real-or-not-disaster-tweets-modeling-SVC.ipynb', artifact_path='Notebook')
    # Nb in HTML.
    mlflow.log_artifact(local_path='real-or-not-disaster-tweets-modeling-SVC.html', artifact_path='Notebook')

Selon le code ci-dessus, vous commencez un passage avec un nom de passage (run_name), puis journalisez ce qui suit :

1. Balises : paire clé-valeur. La clé et la valeur sont toutes deux des chaînes; par exemple, cela peut servir à journaliser l'objectif du passage pour lequel la clé serait « Goal: » et la valeur peut être « To try out the performance of Random Forest Classifier with default parameters » (mettre à l'essai le rendement d'un classificateur de forêt aléatoire avec des paramètres par défaut).
2. Paramètres : également une paire clé-valeur pouvant servir à journaliser les paramètres du modèle.
3. Modèle : peut servir à journaliser le modèle. Vous journalisez ici un modèle scikit-learn comme artéfact MLflow, mais nous pouvons également journaliser un modèle pour d'autres bibliothèques d'apprentissage automatique pris en charge à l'aide du module MLflow correspondant.
4. Mesures : paire clé-valeur. Le type de données de clé est « string » (chaîne) et peut avoir le nom de la mesure. Le paramètre de valeur est de type de données « float ». Le troisième paramètre facultatif est « step » qui est un nombre entier représentant toute mesure de progression de la formation : nombre d'itération de formation, nombre d'époques, etc.
5. Artéfacts : un fichier ou répertoire local peut être journalisé comme artéfact pour le passage en cours. Dans cet exemple, nous journalisons à l'aide du carnet, de sorte que ces informations sont accessibles pour des passages futurs. Ce faisant, il est possible d'enregistrer un tracé comme « courbe de perte » ou « courbe de précision » dans le code et le journaliser comme artéfact dans MLflow.

Voilà, vous avez journalisé avec succès les données pour un passage dans MLflow! L'étape suivante est de visualiser les données journalisées.

IU de MLflow

Si vous retournez à la figure 1, vous vous souviendrez que vous avez lancé le serveur et qu'il écoutait au port de serveur local 5000. Ouvrez cette adresse dans votre navigateur préféré pour accéder à l'IU de MLflow. Une fois l'IU de Mlflow visible, vous pouvez utiliser l'interface pour consulter les données d'essai journalisées. Les essais créés s'affichent dans la barre latérale de l'IU et les balises, paramètres, modèle et mesures journalisés figurent dans les colonnes.

Figure 2 : IU de MLflow

Pour explorer un passage particulier plus en détail, cliquez sur le passage pertinent dans la colonne Heure de début. Cela permet d'explorer un passage journalisé en détail. Le nom du passage s'affiche et vous pouvez ajouter des notes relatives au passage, comme les paramètres, mesures, balises et artéfacts journalisés. Les données journalisées à l'aide de l'API Python pour ce passage figurent ici.

Les fichiers journalisés comme artéfacts peuvent être téléchargés; ce qui peut être utile si vous souhaitez extraire le code ultérieurement. Puisque le code ayant généré des résultats pour chaque passage est enregistré, vous n'avez pas à créer plusieurs copies du même code et pouvez expérimenter avec un seul carnet-cadre en changeant le code entre les passages.

Le modèle formé journalisé peut être chargé dans un essai futur à l'aide de l'IPA Python pour le passage journalisé.

Figure 3: Exploration des artéfacts journalisés dans un passage

Pour démontrer la fonctionnalité de comparaison de passages, d'autres essais de modélisation ont été effectués et journalisés dans MLflow en changeant quelques paramètres dans le même carnet jupyter. N'hésitez pas à modifier certains paramètres et à journaliser davantage de passages dans MLflow.

La figure 4 présente les différents passages journalisés. Vous pouvez appliquer un filtre, conserver les colonnes souhaitées et comparer les paramètres ou les mesures entre les différents passages. Pour procéder à une comparaison détaillée, vous pouvez sélectionner les passages que vous souhaitez comparer et cliquer sur le bouton « Comparer » encerclé dans la figure ci-dessous.

Figure 4 : Personnalisation et comparaison de différents passages à l'aide de l'IU de MLflow

Après avoir cliqué sur le bouton « Comparer », une comparaison sous forme de tableau entre différents passages est générée (comme le présente la figure 5), permettant de facilement comparer les données journalisées pour différents passages. Les paramètres qui diffèrent entre les passages sont surlignés en jaune. Cela fournit à l'utilisateur une idée de la façon dont le rendement du modèle a varié au fil du temps en fonction des paramètres modifiés.

Figure 5 : Comparaison détaillée de passages journalisés dans l'IU de MLflow

Des changements dans les paramètres et dans les mesures pour différents passages peuvent également être présentés dans un diagramme de dispersion. Les valeurs des axes des x et des y peuvent être définies comme tout paramètre ou toute mesure permettant à l'utilisateur d'analyser les changements. Dans la figure 6, le lecteur peut analyser la variation de la validation; dans ce cas, le F1-score moyen pour différentes valeurs du paramètre « max_features ». Si vous passez le curseur sur un point de donnée, les détails relatifs à ce passage s'affichent.

Figure 6 : Configuration du diagramme de dispersion pour visualiser les effets des différentes configurations de paramètres dans les passages journalisés

Le diagramme à coordonnées parallèles est également utile, car il présente à l'utilisateur d'un seul coup d'œil l'effet de certains paramètres sur les mesures souhaitées.

Figure 7 : Configuration du diagramme à coordonnées parallèles pour visualiser les effets de différents paramètres sur les mesures d'intérêt

Autres aspects intéressants du suivi avec MLflow Tracking

Autres éléments importants à noter relativement à MLflow Tracking :

• Les passages peuvent être directement exportés dans un fichier CSV à l'aide de l'IU de MLflow.
• Il est possible d'accéder à l'aide d'un programme à toutes les fonctions de l'IU de suivi; vous pouvez interroger et comparer les passages avec du code, charger des artéfacts de passages journalisés ou exécuter une recherche automatisée de paramètre en appliquant une requête sur les mesures de passages journalisés pour décider des nouveaux paramètres. Vous pouvez également journaliser de nouvelles données sur un passage déjà journalisé dans un essai après l'avoir chargé à l'aide d'un programme (consultez Querying Runs Programmatically pour de plus amples détails - le contenu de cette page est en anglais).
• En utilisant l'IU de MLflow, les utilisateurs peuvent rechercher des passages présentant des valeurs de données particulières à partir de la barre de recherche. Un exemple de cela serait d'utiliser metrics.rmse < 1 et params.model='tree'. Cela est très utile lorsque vous avez besoin de trouver un passage à paramètres particuliers exécuté par le passé.
• Le carnet Jupyter utilisé comme exemple dans ce billet de blogue est accessible sur GitHub (le contenu de cette page est en anglais).

N'hésitez pas à communiquer avec nous à l'adresse statcan.dsnfps-rsdfpf.statcan@statcan.gc.ca pour nous faire part d'autres fonctionnalités intéressantes ou cas d'utilisation que vous aimez utiliser qui auraient pu être mentionnés selon vous. Nous vous offrirons également l'occasion de rencontrer le scientifique des données pour discuter de MLFlow plus en détail. Trouvez de plus amples détails ci-dessous.

Si vous avez des questions à propos de cet article ou si vous souhaitez en discuter, nous vous invitons à notre nouvelle série de présentations Rencontre avec le scientifique des données où le(s) auteur(s) présenteront ce sujet aux lecteurs et aux membres du RSD.

Mardi, le 18 octobre
14 h 00 à 15 h 00 HAE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

Par Dominic Demers et Jessica Lachance, Commission de la fonction publique du Canada

Introduction

La Commission de la fonction publique (CFP) est un organisme indépendant dont le mandat est de promouvoir et de protéger une fonction publique impartiale, fondée sur le mérite et représentative de tous les Canadiens. Parmi ses nombreuses responsabilités, la CFP supervise également plus de 50 000 activités d'embauche qui relèvent de la Loi sur l'emploi dans la fonction publique (LEFP), chaque année.

Ce riche environnement de données comprend plus d'un million de curriculum vitæ et 8 000 offres d'emploi par an. Certaines données sont structurées, comme le nom de l'organisation ou le groupe et le niveau du poste. Cependant, la plupart des données sur les ressources humaines (RH) recueillies par la CFP ne sont pas structurées. Les données non structurées, comme les offres d'emploi ou les questions de présélection, peuvent être utilisées à des fins d'analyse.

La Direction des services de données et de l'analyse de la CFP est responsable des demandes de données, des études statistiques, des enquêtes, des modèles de prévision et des outils de visualisation des données pour les activités de dotation et de recrutement qui relèvent de la LEFP.

Le présent article donne un aperçu de deux techniques de traitement du langage naturel (TLN) utilisées par notre équipe pour extraire des renseignements précieux de deux zones de texte ouvertes, à savoir les variables Exigences en matière d'études et Zone de sélection. Nous expliquons également comment nous les avons utilisées par la suite pour alimenter l'Outil de prévision de candidatures, un outil de visualisation des données qui fait état d'offres d'emploi.

Outil de prévision de candidatures

En 2019, la CFP a élaboré l'Outil de prévision de candidatures pour aider les gestionnaires et les conseillers en RH du gouvernement du Canada à se préparer aux processus de sélection. Les utilisateurs peuvent sélectionner les caractéristiques d'une offre d'emploi et obtenir une estimation du nombre de candidats, en fonction d'emplois similaires qui ont déjà été annoncés.

La première version de l'outil ne fonctionnait qu'avec les données structurées des offres d'emploi. Cependant, la CFP a reçu des commentaires au sujet de deux zones de texte ouvertes que les utilisateurs souhaitaient exploiter pour obtenir une meilleure estimation du nombre de candidats pour leur processus de sélection. Ces zones comprenaient le niveau d'études dans les qualifications essentielles et, pour les processus internes, des détails sur la zone de sélection, comme le ministère, l'emplacement ou la classification.

Par conséquent, la CFP a utilisé des techniques de classification de texte pour les zones relatives aux études et à la zone de sélection afin de structurer les renseignements en catégories qui alimentent l'Outil de prévision de candidatures. Ces algorithmes ont permis à la CFP de produire des rapports plus précis et utiles.

Classification de texte

La classification de texte est un sous-ensemble de problèmes du TLN. L'objectif de la classification de texte est de prendre les zones de texte ouvertes et d'attribuer à chaque texte une étiquette à partir d'un ensemble limité d'options.

Dans notre cas, nous avons étudié deux modèles différents pour atteindre notre objectif. Pour la variable d'exigences en matière d'études, nous avons utilisé une approche fondée sur des règles employant des expressions courantes. Pour la variable de zone de sélection, nous avons utilisé une approche fondée sur l'apprentissage automatique appelée « Reconnaissance de l'entité désignée ».

Bien que la classification de texte à l'aide d'un modèle quelconque puisse produire de bons résultats, la capacité de l'algorithme à extraire des renseignements du texte n'est pas toujours fiable. Par conséquent, nous avons dû évaluer l'efficacité avec laquelle l'algorithme extrait les renseignements pertinents. Nous avons évalué le modèle à l'aide d'un ensemble de données d'essai et examiné les paramètres pour déterminer la performance du classificateur.

Évaluation des modèles de classification de texte

Pour évaluer la performance de nos algorithmes de classification de texte, nous avons utilisé une matrice de confusion. Il s'agit d'un tableau qui décrit la performance du modèle de classification pour un ensemble de données d'essai pour lesquelles les valeurs « vraies » sont connues.

Le nombre de prévisions exactes et inexactes est résumé dans un tableau et comprend des valeurs de comptage. Le tableau résume également le nombre d'erreurs commises par notre classificateur et, surtout, le type d'erreur.

La matrice de confusion comprend quatre types de combinaisons de valeurs prédites et vraies. Dans notre contexte de classification de texte, l'algorithme fournira une valeur « vraie » (ou « positive ») en cas de prédiction du texte dans le cadre de la classification. Par exemple, si le texte est classé comme « diplôme d'études secondaires », l'algorithme renverra une valeur « vraie » (ou « positive ») pour cette classification.

Les quatre catégories sont décrites ci-dessous.

Figure 1 : Matrice de confusion

Combinaison Vrai positif (VP) : On prédit que la classification est vraie et cela est exact.
Combinaison Vrai négatif (VN) : On prédit que la classification est fausse et cela est exact.
Combinaison Faux positif (FP) ou erreur de type 1 : On prédit que la classification est vraie, mais cela est inexact.
Combinaison Faux négatif (FN) ou erreur de type 2 : On prédit que la classification est fausse, mais cela est inexact.

À partir de ces combinaisons, nous avons obtenu les mesures de performance suivantes :

• Exactitude : Pourcentage de textes qui ont été catégorisés avec la classification exacte. Sert à déterminer le nombre de classifications que le modèle a prédit correctement.
• Precision $\left(\frac{TP}{TP+FP}\right)$: The percentage of texts correctly classified out of the total number of texts classified as positive. Used to determine the proportion of positive identification that were correct.
• Recall $\left(\frac{TP}{TP+FN}\right)$: The percentage of actual positive values that are predicted correctly. Used to determine the proportion of actual positives that were correctly identified.
• Score F1 : Moyenne harmonique entre précision et rappel.

Dans le contexte du présent article, ces statistiques seront utilisées pour évaluer le rendement en matière de classification de deux variables, à savoir les variables Exigences en matière d'études et Zone de sélection.

Zone « Exigences en matière d'études »

Conformément à la LEFP, le Secrétariat du Conseil du Trésor a établi des normes de qualification par groupe professionnel ou classification pour l'administration publique centrale. Les normes de qualification définissent les exigences en matière d'études minimales pour chaque groupe professionnel. Les offres d'emploi pour les postes visés par la LEFP doivent inclure ces critères de mérite.

En règle générale, les gestionnaires utilisent la norme de qualification comme leur exigence essentielle. Mais ils peuvent établir des exigences en matière d'études supérieures au besoin. Par exemple, un gestionnaire d'embauche peut exiger qu'un analyste principal des politiques de niveau EC-06 ait une maîtrise, même si l'exigence minimale est un baccalauréat.

On pourrait s'attendre à ce que moins de candidats disposent d'une maîtrise que d'un baccalauréat. L'analyse du niveau d'études nous permettrait de fournir aux utilisateurs de l'Outil de prévision de candidatures des estimations et d'anciennes offres d'emploi plus pertinentes.

Méthode

Il y a un peu plus de 100 normes de qualification pour l'ensemble des groupes professionnels, lesquelles sont également rédigées en langage naturel. Nous avons déterminé que ces normes pouvaient être résumées comme appartenant à l'un des huit niveaux d'études suivants :

• Études secondaires partielles
• Études secondaires
• Études postsecondaires partielles
• Études postsecondaires
• Diplôme professionnel (p. ex. diplôme en droit, en médecine)
• Maîtrise
• Doctorat ou grade supérieur
• Niveau d'études inconnu/hors catégorie

Pour étiqueter les offres d'emploi en fonction du niveau d'études, nous avons utilisé des expressions courantes afin de trouver des phrases clés, que nous avons ensuite étiquetées. Les expressions courantes sont une séquence de caractères qui indiquent une tendance dans le texte. Pour analyser le niveau d'études, nous avons :

• trouvé des phrases clés, à l'aide d'expressions courantes, qui indiquent un type d'études;
• associé ces phrases à un niveau commun d'études;
• étiqueté du texte concernant les exigences en matière d'études avec l'un de ces niveaux communs.

Au total, nous avons utilisé 30 règles différentes pour établir une correspondance entre les descriptions de poste et les huit niveaux d'études. Ces règles ont été créées manuellement, à l'aide d'un processus itératif. Nous avons commencé par des expressions courantes qui saisissent la structure des phrases et les phrases clés utilisées dans de nombreuses normes de qualification. Nous avons ensuite ajouté des règles supplémentaires pour saisir les cas qui ne respectaient pas les normes de qualification.

Voici une représentation visuelle du processus :

Dans cette image, la première section représente nos données. Le segment mis en évidence en vert indique la partie pertinente du texte liée aux exigences en matière d'études. « Avoir terminé deux années de formation dans un programme acceptable d'études postsecondaires en informatique, en technologie de l'information, en gestion de l'information ou dans une autre spécialité connexe au poste à doter ».

La deuxième section représente la règle qui a été appliquée au texte à l'aide d'expressions courantes. Le texte a été signalé comme contenant l'expression « … années d'études… postsecondaires ».

En raison de cet indicateur et de l'absence d'un indicateur d'une qualification supérieure (p. ex. « grade » ou « doctorat »), cette offre d'emploi a été étiquetée comme exigeant le niveau d'études « Études postsecondaires partielles ».

Évaluation du modèle

Pour évaluer le modèle, nous avons extrait un échantillon de 1 000 offres d'emploi de l'exercice 2019-2020 et avons étiqueté manuellement le niveau d'études correspondant à chaque offre. Le tableau ci-dessous présente la précision, le rappel et le score F1 de notre algorithme fondé sur des règles, pour chacun des huit niveaux d'études.

Résultats

Nous avons appliqué l'algorithme à un total de 18 055 offres d'emploi entre le 1er avril 2016 et le 31 mars 2019. Le tableau suivant présente une répartition des offres d'emploi pour des postes EX-01, par niveau d'études tiré de l'algorithme. Comme l'indiquent les résultats ci-dessous, la grande majorité exigent des études secondaires ou postsecondaires.

À l'aide de cette méthodologie, lorsqu'ils accèdent à l'Outil de prévision de candidatures pour estimer le nombre de demandes d'emploi, les utilisateurs peuvent filtrer les résultats dans ce nouveau champ lié aux études. Par exemple, depuis le 1er avril 2015, 921 postes EX-01 ont été annoncés et ont suscité l'intérêt d'un nombre médian de 30 candidats. Sur ces offres, 806 exigeaient un diplôme d'études postsecondaires et ont suscité l'intérêt d'un nombre médian de 32 candidats.

Zone « Zone de sélection »

Contexte

Conformément au paragraphe 34(1) de la LEFP, en vue de l'admissibilité à tout processus de nomination, une organisation peut limiter la zone de sélection pour les processus d'emploi internes en fixant des critères géographiques, organisationnels ou professionnels. Cette restriction est inscrite dans le champ « Qui est admissible » d'une offre d'emploi.

Une zone de sélection restreinte réduira le bassin de candidats potentiels. Les utilisateurs de l'Outil de prévision de candidatures souhaitaient connaître le nombre de candidats auquel ils pourraient s'attendre s'ils limitaient leur zone de sélection aux employés du niveau mentionné de leur ministère uniquement, par opposition à tous les fonctionnaires au Canada.

Méthode

Notre objectif était d'analyser le contenu de la zone de texte ouverte « Zone de sélection » pour en extraire le ou les ministères, emplacements et niveaux mentionnés en utilisant une technique appelée « reconnaissance de l'entité désignée ». Un modèle de reconnaissance de l'entité désignée est une technique de TLN qui désigne les « entités » dans un bloc de texte, comme les noms propres (nom d'une personne, pays) ou une catégorie de choses (animaux, véhicules).

Dans notre cas, les entités extraites sont les suivantes :

• des organisations (p. ex. « Transports Canada », « la fonction publique fédérale »);
• des emplacements (p. ex. « Canada », « région de l'Atlantique », « dans un rayon de 40 km de Winnipeg [Manitoba] »);
• les classifications des professions (p. ex. « EC-04 », « EX-01 »).

Pour appliquer le modèle de reconnaissance de l'entité désignée, nous avons utilisé spaCy (le contenu de cette page est en anglais seulement), une bibliothèque libre gratuite destinée au traitement avancé du langage naturel dans Python.

L'algorithme de reconnaissance de l'entité désignée de spaCy comprend les entités « ORG » (organisation), « LOC » (localisation) et « GPE » (géopolitique).

Pour réduire la quantité de marquage manuel, nous avons adopté une approche itérative afin de créer notre ensemble de données d'entraînement. Tout d'abord, nous avons utilisé l'algorithme par défaut de spaCy pour marquer un échantillon aléatoire de 1 000 zones de sélection. Nous avons ensuite apporté les changements suivants :

1. Fusion des balises « LOC » et « GPE » en une seule balise « LOC »;
2. Ajout d'une balise « LEVEL » qui indique les classifications professionnelles;
3. Correction de tout autre problème lié aux balises « ORG » et « LOC ».

À partir de là, nous avons créé 200 autres exemples de données d'entraînement, qui ont été ciblés pour inclure des exemples supplémentaires de la balise « LEVEL » et d'autres cas que l'algorithme initial a systématiquement omis de repérer.

Une fois l'ensemble des données d'entraînement mis en place, l'algorithme de reconnaissance de l'entité désignée de spaCy effectue les tâches suivantes :

1. Créer un modèle de prédiction en utilisant une partie des données d'entraînement étiquetées.
2. Envoyer une version sans étiquette d'une autre partie des données d'entraînement au modèle et prédire les entités.
3. Comparer les étiquettes prédites et les étiquettes vraies.
4. Mettre à jour le modèle pour représenter les étiquettes inexactes. Le volume de changements entre les modèles est appelé « gradient ».
5. Répéter jusqu'à ce que le gradient soit réduit et que les prédictions du modèle changent très peu entre les itérations.

Ce processus a engendré un modèle final qui peut déterminer les différents critères d'une zone de sélection. L'image ci-après illustre un exemple de marquage du modèle effectué.

Figure 3 : Classification de la zone de sélection

En haut de l'image s'affiche le texte complet de la zone de sélection. En bas de l'image, nos trois « entités » sont mis en évidence. « la fonction publique » est marquée par la balise ORG, « PM-04 » par la balise LEVEL et « dans un rayon de 40 km d'Edmonton (Alberta) » par la balise LOC.

Évaluation du modèle

Nous avons évalué le modèle à l'aide d'un échantillon aléatoire de 465 énoncés de la zone de sélection, que nous avons étiquetés manuellement. Le tableau suivant montre les scores de précision et de rappel pour chaque type d'entité.^{Footnote 1}

Résultats

À l'aide des résultats du modèle, nous avons produit l'analyse exploratoire suivante. Cette analyse est fondée sur 13 362 offres d'emploi internes entre le 1er avril 2016 et le 31 mars 2019.

Figure 4: Diagramme de Venn de la zone de texte ouverte « Zone de sélection », par organisation, groupe professionnel et géographie

Ce que nous avons constaté, c'est que la plupart des offres d'emploi internes utilisent au moins l'un des filtres décrits dans la LEFP et que la plupart des zones de sélection comportant un filtre géographique étaient pour les « personnes employées dans la fonction publique qui occupent un poste dans la région de la capitale nationale (RCN) ».

Cependant, nous avons constaté que certaines zones de sélection sont plus difficiles à analyser. En voici quelques exemples :

1) Employés de Transports Canada qui occupent un poste à Calgary, Edmonton, Saskatoon, Winnipeg, Whitehorse, Yellowknife ou Churchill.

2) En cas de nombre insuffisant de candidats, les personnes employées dans la fonction publique qui occupent un poste à moins de 40 km de Winnipeg (Manitoba) ou à moins de 40 km d'Edmonton ou de Calgary (Alberta) pourraient être prises en compte sans que le poste soit annoncé de nouveau. Par conséquent, les candidats dans cette zone de sélection élargie sont encouragés à poser leur candidature.

Notre modèle a donné de bons résultats, mais en raison de critères multiples, nous avons décidé d'utiliser notre analyse avec un ensemble plus vaste de catégories. Auparavant, dans l'Outil de prévision de candidatures, les utilisateurs pouvaient seulement choisir une « offre d'emploi interne » ou une « offre d'emploi externe ». Maintenant, les offres d'emploi internes que les utilisateurs peuvent choisir sont plus précises. Ils ont le choix entre les offres d'emploi suivantes:

• Offres d'emploi internes, ouvertes à tous les fonctionnaires
• Offres d'emploi internes, ouvertes aux fonctionnaires de la RCN
• Offres d'emploi internes (autres zones de sélection)

En ajoutant ces fonctionnalités à notre modèle, nous l'avons amélioré, de sorte qu'il permette aux utilisateurs de rechercher un ensemble plus restreint d'offres d'emploi pour trouver celles qui correspondent à leur processus de sélection prévu.

Conclusion

Les zones de texte ouvertes sont un excellent moyen de recueillir des renseignements et ne devraient pas être exclues des formulaires ou des enquêtes. Elles servent à recueillir des réponses fourre-tout lorsque les questions ne permettent pas aux utilisateurs de fournir des renseignements dans un ensemble de choix prédéfini.

Mais cette souplesse se fait au détriment de l'exactitude des classifications. Les systèmes de classification peuvent générer les bonnes prédictions (valeurs vraies positives et vraies négatives), mais peuvent aussi produire les mauvaises (valeurs fausses positives et fausses négatives). La validation croisée du rendement de votre algorithme sera essentielle afin de déterminer si les classifications sont suffisamment précises à des fins de production de rapports.

Le présent article a exposé des méthodes qui visent à structurer les renseignements tirés des zones de texte ouvertes aux fins de production de rapports dans l'Outil de prévision de candidatures. Les catégories provenant des zones « Zone de sélection » et « Exigences en matière d'études » ont été utilisées pour remplir des menus déroulants permettant aux utilisateurs d'améliorer leurs résultats de recherche.

Nous vous encourageons à consulter l'Outil de prévision de candidatures ou nos autres outils de visualisation des données dans le Centre de visualisations des données de la CFP.

Si vous avez des questions à propos de cet article ou si vous souhaitez en discuter, nous vous invitons à notre nouvelle série de présentations Rencontre avec le scientifique des données où le(s) auteur(s) présenteront ce sujet aux lecteurs et aux membres du RSD.

mardi, le 18 octobre
14 h 00 à 15 h 00 p.m. HAE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

Par : Kenneth Chu, Statistique Canada

La Division de la science des données de Statistique Canada a récemment terminé un certain nombre de projets de recherche visant à évaluer l’efficacité d’une technique statistique appelée analyse en composantes principales fonctionnelles (ACPF) comme méthode d’ingénierie des caractéristiques afin d’extraire les tendances temporelles des données des séries chronologiques de satellites radar à synthèse d’ouverture (RSO).

Ces projets ont été réalisés en collaboration avec la Division de l’agriculture et la Division de la statistique de l’énergie et de l’environnement de Statistique Canada, ainsi qu’avec le Centre national de recherche faunique (CNRF) d’Environnement et Changement climatique Canada. Ces projets ont utilisé les données de Sentinel-1. Sentinel-1 est une constellation de satellites radar du programme Copernicus de l’Agence spatiale européenne. Elle recueille des données d’imagerie RSO qui capturent des renseignements sur les structures de la surface terrestre de la zone imagée. Sentinel-1 assure une couverture mondiale tout au long de l’année et dans toutes les conditions météorologiques de la zone imagée. Les données ne sont pas influencées par l’alternance du jour et de la nuit, ont une haute résolution spatiale (environ 10 m x 10 m) et une fréquence fixe de capture des données tous les 12 jours pour chaque zone imagée. Par conséquent, les données de Sentinel-1 conviennent parfaitement aux études scientifiques, car les structures de la surface de la Terre contiennent des renseignements importants.

Nos résultats suggèrent que l’ACPF pourrait être un outil très efficace pour extraire numériquement les tendances temporelles saisonnières saisies dans une série chronologique d’images de Sentinel-1 à grande échelle et de manière très granulaire. Le présent article présente un sommaire de la méthode fondée sur l’ACPF et de ses résultats d’extraction des caractéristiques à partir des séries chronologiques saisonnières de Sentinel-1.

Motivation

Je vais me concentrer sur l’une des zones d’étude de la recherche, à savoir la région de la baie de Quinte en Ontario, située près de Belleville. L’objectif de ce projet est de donner une classification plus précise des zones humides. Ce qui suit est une image satellitaire optique (plutôt qu’une image satellitaire radar) de la région de la baie de Quinte, téléchargée depuis Google Maps.

Figure 1: Image satellitaire optimale de la baie de Quinte, Ontario. Téléchargée depuis Google Maps.

Dans la Figure 1, notez la grande étendue d’eau au centre supérieur de l’image et les champs agricoles rectangulaires. Notez également l’île près du centre supérieur et la voie d’eau qui la sépare du continent.

Examinez ensuite la Figure 2, qui est une carte de la couverture terrestre de la région de la baie de Quinte.

Figure 2: Carte de la couverture terrestre de la baie de Quinte, ON. Cette image est créée à partir de données des séries chronologiques saisonnières de 2019 du RADARSAT-2 (Banks et al., 2019). Les couleurs indiquent les différents types de couverture terrestre : Le bleu indique l’eau, le rose indique les eaux peu profondes, le cyan montre les marais, le rouge indique les forêts, le vert correspond aux marécages et le marron indique des terres agricoles.

La figure 3 est un rendu rouge, vert, bleu (RVB) des trois premiers scores des composantes principales fonctionnelles (CPF) calculés à partir des données des séries chronologiques de Sentinel-1 de 2019 pour la région de la baie de Quinte. Notez la remarquable granularité et le haut degré de concordance avec la carte de couverture terrestre de la Figure 2.

Figure 3: Rendu RVB des trois premiers scores de CPF calculés à partir des données des séries chronologiques de Sentinel-1 de 2019 pour la région de la baie de Quinte.

La carte de la couverture terrestre de la figure 2 a été créée à partir des données des séries chronologiques de 2019 de RADARSAT-2 (l’un des satellites d’observation de la Terre RSO de l’Agence spatiale canadienne), à l’aide de la méthodologie décrite dans Banks et al. (2019). Elle est bien corroborée par la réalité du terrain recueillie par des observations sur le terrain. Une observation notable ici est que la voie d’eau qui sépare l’île au centre supérieur de l’image et le continent contient en fait deux types de zones humides – les marais en cyan et les eaux peu profondes en rose. Ces deux types de zones humides ne sont pas faciles à distinguer sur la figure 1. L’article rapporte que les données des séries chronologiques saisonnières du RSO contiennent suffisamment de renseignements pour la classification des terres humides, mais la méthodologie décrite comporte un haut degré de prise de décision manuelle informée par des connaissances d’experts (p. ex. les saisies de données pour quelles dates ou statistiques à utiliser, etc.).Cette méthode demandait beaucoup de travail et la façon d’automatiser cette méthodologie et de l’appliquer à l’échelle régionale, provinciale ou pancanadienne n’était pas claire.

Le projet de la baie de Quinte a été motivé par la recherche d’une méthodologie automatisable et efficace pour extraire numériquement les tendances temporelles des séries chronologiques saisonnières RSO afin de faciliter les tâches de classification de la couverture terrestre en aval.

Principaux résultats : Visualisation des caractéristiques extraites par ACPF

L’ACPF peut être une méthodologie puissante pour extraire les tendances dominantes d’une collecte de séries chronologiques (Wang et al. 2016). Nous avons donc réalisé une étude de faisabilité sur l’utilisation de l’ACPF comme technique d’extraction de caractéristiques pour les séries chronologiques saisonnières RSO au niveau du pixel. Les caractéristiques qui en résultent sont des scores CPF au niveau du pixel. Nos résultats préliminaires suggèrent que la méthodologie fondée sur l’ACPF pourrait être remarquablement efficace. La figure 3 est le rendu RVB des trois premiers scores CPF (le premier score CPF est le canal rouge, le deuxième score CPF est le vert, le troisième score CPF est le bleu (Wikipédia 2022)); calculés à partir des données des séries chronologiques de Sentinel-1 de 2019 pour la baie de Quinte. Notez la remarquable granularité de la figure 3 et son niveau élevé de concordance avec la figure 2. Cela suggère fortement que les caractéristiques extraites fondées sur l’ACPF peuvent faciliter de manière importante les tâches de classification de la couverture terrestre en aval. La suite du présent article expliquera comment la figure 3 a été générée à partir des données des séries chronologiques de Sentinel-1.

Aperçu de la procédure d’extraction des caractéristiques fondée sur l’ACPF

Voici un aperçu de la procédure :

• Un sous-ensemble d’emplacements/pixels a été soigneusement et stratégiquement sélectionné dans la zone d’étude de la baie de Quinte.
• Leurs séries chronologiques de Sentinel-1 respectives ont été utilisées pour éduquer un moteur d’extraction des caractéristiques fondées sur l’ACPF.
• Le moteur d’extraction des caractéristiques fondé sur l’ACPF a ensuite été appliqué aux séries temporelles de Sentinel-1 de chaque emplacement/pixel de toute la zone de la baie de Quinte. La sortie de chaque série temporelle est une séquence ordonnée de nombres appelés scores CPF pour l’emplacement/pixel correspondant. Ces scores sont en ordre décroissant de la variabilité expliquée par leur CPF correspondante.
• La figure 3 ci-dessus est le rendu RVB des trois premiers scores CPF des données des séries chronologiques de 2019 de Sentinel-1.

Les données de formation

La collecte de données de formation (à partir des emplacements/pixels de la région de la baie de Quinte) a été soigneusement et stratégiquement choisie pour contenir des propriétés précises.

• Les emplacements de la formation étaient répartis dans toute la zone d’étude de la baie de Quinte.
• Les types de couverture terrestre étaient connus sur la base d’observations antérieures sur le terrain.
• Six types de couverture terrestre étaient représentés dans la collecte de formation : eau, eau peu profonde, marais, marécage, forêt et terres agricoles.
• La collecte de formation était bien équilibrée entre les types de couverture terrestre, car chaque type de couverture terrestre contenait exactement 1000 emplacements/pixels (à l’exception des eaux peu profondes, qui en comptaient 518).
• Les six types de couverture terrestre représentés dans la collecte de formation sont complets, car chaque emplacement/pixel de la zone d’étude de la baie de Quinte est couvert par l’un de ces six types de couverture terrestre.

Les données de Sentinel-1 ont deux polarisations – transmission verticale et réception verticale (VV), et transmission verticale et réception horizontale (VH). Ces deux polarisations peuvent être considérées comme deux variables observées mesurées par les satellites de Sentinel-1.

Les différentes structures de la surface de la Terre sont détectées avec des sensibilités différentes en polarisations. Par exemple, la diffusion des surfaces rugueuses, comme celles causées par un sol nu ou l’eau, est plus facilement détectée dans la polarisation VV. D’autre part, la diffusion volumique, généralement causée par les feuilles et les branches d’un couvert forestier, est plus facilement détectée dans les polarisations VH et HV. Enfin, un type de diffusion appelé à double réflexion, couramment causée par les bâtiments, les troncs d’arbres ou la végétation inondée, est plus facilement détecté dans la polarisation HH (NASA, 2022). Pour la suite de cet article, nous nous concentrerons sur la polarisation VV.

Figure 4: Données des séries chronologiques VV de Sentinel-1 pour les sites de formation et les diagrammes en ruban correspondants pour une visualisation facile des tendances temporelles. (a) : Données de 2017. Groupe du panneau gauche : Tracés linéaires des données des séries chronologiques VV de Sentinel-1 regroupés par type de couverture terrestre connu. Groupe du panneau droit : Graphiques en ruban correspondants, la courbe noire de chaque panneau indiquant la courbe moyenne particulière au panneau, et le ruban indiquant un écart-type au-dessus et au-dessous de la courbe moyenne particulière au panneau. (b), (c) : Données de 2018 et 2019, respectivement.

Analyse en composantes principales fonctionnelles

Nous donnons une explication conceptuelle de l’ACPF en la comparant à l’analyse en composantes principales ordinaires (ACPO).

L’ACPO est :

• Supposons un ensemble fini $\mathcal{D}=\{ {\mathbf{x}}_1,{\mathbf{x}}_2,\dots ,{\mathbf{x}}_n \}\subset {\mathrm{ℝ}}^d$(des points de données) est donné.
• Trouver des directions orthogonales $\mathcal{d}$ , plus précisément, des sous-espaces unidimensionnels dans ${\mathrm{ℝ}}^d$ le long desquels $\mathcal{D}$ présente la plus grande variabilité, la deuxième plus grande, la troisième plus grande, et ainsi de suite. Ici, l’orthogonalité est définie par le produit interne standard (produit scalaire) sur ${\mathrm{ℝ}}^d$. Pour chaque sous-espace orthogonal unidimensionnel, choisir un vecteur unitaire dans ce sous-espace. Les vecteurs unitaires mutuellement orthogonaux résultants $\mathcal{d}$ sont les composantes principales ordinaires et elles forment une base orthonormale pour ${\mathrm{ℝ}}^d$.
• Réécrire chaque ${\mathbf{x}}_i, i=1,2,\dots ,n$, en matière de composantes principales ordinaires. Les coefficients de cette combinaison linéaire sont les scores des composantes principales ordinaires de ${\mathbf{x}}_i$ par rapport aux composantes principales ordinaires.

En quoi l’ACPF (plus précisément, la version particulière de l’ACPF que nous avons utilisée) diffère-t-elle de l’ACPO?

• L’espace vectoriel de dimension finie ${\mathrm{ℝ}}^d$ est remplacé par un sous-espace $\mathcal{F}$ (éventuellement de dimension infinie) des fonctions intégrables en $L^2$définies sur un certain intervalle (de temps) $[a,b]$.
• Le produit interne standard sur ${\mathrm{ℝ}}^d$ est remplacé par le produit interne $L^2$ inner product $⟨ · , · ⟩$ sur F, c.-à-d. pour $\mathcal{f},g\in \mathcal{F}\subset L^2[a,b]$, $⟨ f , g ⟩ := {\int }_a^{b}f\left(z\right) g\left(z\right) dz$

Pourquoi l’ACPF peut-elle saisir des tendances temporelles?

• La raison en est que la « géométrie » de l’intervalle $[a,b]$ est intégrée dans la définition même du produit interne $L^2$ . Plus concrètement, le processus d’intégration des fonctions sur $[a,b]$ intègre des renseignements sur l’ordre et la distance entre chaque paire de points temporels.
• Cette « conscience » de la géométrie de l’intervalle $[a,b]$ permet à son tour au produit interne $L^2$ de saisir des renseignements sur les tendances temporelles.

Procédure générale pour appliquer l’ACPF à des données de séries chronologiques

• Supposons qu’un ensemble fini $\mathcal{D}$ de $\mathcal{n}$ séries chronologiques observées soit défini sur un ensemble commun de points temporels dans un certain intervalle de temps $[a,b]$ p. ex. dans la saison de croissance d’une certaine année civile), où $\mathcal{a}$ et $\mathcal{b}$ sont respectivement le point temporel commun initial et final.
• Interpoler chaque série temporelle donnée dans $\mathcal{D}$ pour obtenir une fonction définie sur $[a,b]$. On obtient un ensemble fini $\mathcal{B}\left(\mathcal{D}\right)$ de $\mathcal{n}$ fonctions définies sur l’intervalle commun $[a,b]$, dont chacune est une interpolation d’une des séries chronologiques observées originales dans $\mathcal{D}$.
  Remarque : Les B-splines sont un choix courant de techniques d’interpolation à cette fin (Schumaker, 2022).
• Calculer la fonction moyenne globale et une séquence ordonnée de composantes principales fonctionnelles pour la collecte $\mathcal{B}\left(\mathcal{D}\right)$ de fonctions (interpolations de séries chronologiques dans $\mathcal{D}$ dans son ensemble. Notez que chaque CPF est elle-même une fonction définie sur $[a,b]$ (Wang et al. 2016).

Ensuite, pour chaque fonction dans $\mathcal{B}\left(\mathcal{D}\right)$, exprimez-la comme une combinaison linéaire des CPF. Les coefficients de cette combinaison linéaire sont les scores des CPF de la fonction donnée par rapport aux CPF.

Par conséquent, les fonctions dans $\mathcal{B}\left(\mathcal{D}\right)$, le CPF et les scores CPF peuvent être organisées comme suit :

$\begin{array}{ccccccccccccc}{\left(\begin{array}{c}\text{interpolation}\\ \text{d'une série}\\ \text{chronologique}\end{array}\right)}_1& \approx & \left(\begin{array}{c}\text{fonction de}\\ \text{moyenne}\\ \text{globale}\end{array}\right)& +& {\mathrm{score}}_{11}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionelle}\end{array}\right)}_1& +& {\mathrm{score}}_{12}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionelle}\end{array}\right)}_2& +& \cdots \\ {\left(\begin{array}{c}\text{interpolation}\\ \text{d'une série}\\ \text{chronologique}\end{array}\right)}_2& \approx & \left(\begin{array}{c}\text{fonction de}\\ \text{moyenne}\\ \text{globale}\end{array}\right)& +& {\mathrm{score}}_{21}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionelle}\end{array}\right)}_1& +& {\mathrm{score}}_{22}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionelle}\end{array}\right)}_2& +& \cdots \\ ⋮& ⋮& ⋮& & & & ⋮& & & & ⋮& & \\ {\left(\begin{array}{c}\text{interpolation}\\ \text{d'une série}\\ \text{chronologique}\end{array}\right)}_n& \approx & \left(\begin{array}{c}\text{fonction de}\\ \text{moyenne}\\ \text{globale}\end{array}\right)& +& {\mathrm{score}}_{n1}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionelle}\end{array}\right)}_1& +& {\mathrm{score}}_{n2}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionelle}\end{array}\right)}_2& +& \cdots \end{array}$

Plus le nombre de CPF est important, plus les approximations ci-dessus devraient être précises.

• Nous considérons que la fonction moyenne globale et la séquence ordonnée de CPF sont ce qui a été appris des fonctions en $\mathcal{B}\left(\mathcal{D}\right)$ utilisant le mécanisme de l’ACPF.
• Enfin, notons qu’une fois que la fonction moyenne globale et les CPF de $\mathcal{B}\left(\mathcal{D}\right)$ ont été calculés (ou « apprises »), elles peuvent être utilisées pour calculer les scores de nouvelles fonctions définies sur $[a,b]$, en particulier pour les interpolations de nouvelles séries chronologiques. C’est cette observation qui permet d’utiliser le mécanisme de l’ACPF comme une technique d’ingénierie des caractéristiques.

Déroulement des opérations d’extraction de caractéristiques fondées sur l’ACPF

Nous expliquons comment les scores des CPF qui sous-tendent la figure 3 ont été calculés dans le projet de la baie de Quinte.

• Comme décrit précédemment, une collecte $\mathcal{T}$ d’emplacements/pixels « de formation » de la zone d’étude de la baie de Quinte a été méticuleusement choisie, comme décrit précédemment.
• Les données des séries chronologiques de Sentinel-1 pour 2017, 2018 et 2019 ont été extraites pour chaque emplacement/pixel de formation dans $\mathcal{T}$. Nous désignons la collecte des séries chronologiques résultantes par $\mathcal{D}$.
• Chaque série temporelle dans $\mathcal{D}$ a été interpolée à l’aide de B-splines. Nous désignons la collecte de fonctions résultante par $\mathcal{B}\left(\mathcal{D}\right)$.
• La fonction moyenne globale et l’ensemble des composantes principales fonctionnelles ont été calculés (« appris ») à partir de $\mathcal{B}\left(\mathcal{D}\right)$ en utilisant le mécanisme de l’ACPF. Ce mécanisme de l’ACPF a été mis en œuvre sous la forme de l’ensemble R fpcFeatures (actuellement, uniquement pour un usage interne au CNRF et à Statistique Canada).
• La série temporelle de Sentinel-1 de 2017 pour chacun des emplacements/pixels hors formation de la zone d’étude de la baie de Quinte a été interpolée avec des B-splines. Pour chacune des interpolations des B-spline résultantes, les scores CPF par rapport aux composantes principales fonctionnelles apprises ont été calculés. Cela s’applique également aux séries chronologiques Sentinel-1 hors formation de 2018 et 2019.
• Les scores CPF résultants sont considérés comme les caractéristiques extraites pour chaque emplacement/pixel. Ces caractéristiques extraites peuvent être utilisées pour des tâches d’analyse ou de traitement en aval, comme la visualisation (p. ex. le rendu RVB), la classification de la couverture terrestre, la détection des changements d’utilisation du sol, etc.

Ce déroulement des opérations d’extraction de caractéristiques fondées sur l’ACPF est illustré à la figure 5.

Figure 5: Schéma du déroulement des opérations d’extraction de caractéristiques fondée sur

Les composantes principales fonctionnelles calculées

Si vous vous souvenez, le soi-disant « moteur d’extraction de caractéristiques fondé sur l’ACPF entraîné » n’est en fait que la fonction de moyenne globale et la séquence ordonnée de CPF (fonctions définies sur un intervalle de temps commun) calculées à partir des données de formation. La figure 6 présente les sept premières CPF calculées à partir des données des séries chronologiques de Sentinel-1 VV de formation pour 2017, 2018 et 2019 de la zone d’étude de la baie de Quinte.

Figure 6: Représentations graphiques des sept premières composantes principales fonctionnelles comme fonctions du temps.

Ce sont des représentations graphiques des sept premières CPF en fonction du temps. Le panneau ${\mathcal{k}}^e$ (en comptant à partir du haut) visualise la CPF${\mathcal{k}}^e$. Rappelons que chaque CPF est, avant tout, une fonction (continue) du temps, considérée comme un vecteur $u_{\mathcal{k}} \in \mathcal{F}$ dans un certain espace vectoriel des fonctions $\mathcal{F}$ de (intégrable en $L^2$) définies sur un certain intervalle de temps.

Dans chaque panneau, la courbe grise indique la courbe moyenne des interpolations splines de toutes les séries chronologiques VV (sur tous les lieux de la formation et pour les années 2017, 2018 et 2019). Les CPF s’avèrent être des vecteurs propres d’une certaine carte linéaire (liée à la « variance » de l’ensemble de données d’apprentissage) de $\mathcal{F}$ à elle-même (Wang et al. 2016). Dans chaque panneau, la courbe orange représente la fonction obtenue en ajoutant à la courbe moyenne (en gris) le multiple scalaire $\surd {\lambda }_k · {\mathit{u}}_k$ de la ${\mathcal{k}}^{th}$ composante principale fonctionnelle ${\mathit{u}}_k$, où ${\lambda }_k \ge 0$ est la valeur propre correspondant à ${\mathit{u}}_k$. La courbe bleue est obtenue en soustrayant le même multiple de ${\mathit{u}}_k$ de la courbe moyenne. Notez également que la première composante principale explique environ 85,04 % de la variabilité des données de formation (série chronologique VV), la deuxième composante explique environ 7,18 %, et ainsi de suite.

Ensuite, notez que la première composante principale fonctionnelle ressemble à une ligne horizontale (courbe orange dans le panneau supérieur); elle capture la caractéristique la plus dominante dans les séries chronologiques de formation, qui se révèle être la grande différence quasi constante dans les valeurs VV entre les séries chronologiques de l’eau/eau peu profonde et celles du reste des types de couverture terrestre (autre que l’eau). Cette grande différence quasi constante est clairement observable dans les tracés en ligne et en ruban des figures 4, 5 et 6.

Enfin, il faut noter que la deuxième composante principale fonctionnelle (courbe orange dans le deuxième panneau) présente un creux en début de saison et un pointe en fin de saison, ce qui permet de saisir la tendance des eaux peu profondes, comme on peut l’observer dans les diagrammes en ruban des eaux peu profondes des figures 4, 5 et 6.

Les deux premiers scores CPF des données de formation

Nous montrons ici les nuages de points du premier score CPF par rapport au second pour les données de formation. Observez la bonne séparation des emplacements de formation de l’eau et de l’eau peu profonde de ceux des autres types de couverture terrestre, et observez également la cohérence de cette séparation d’une année à l’autre.

Figure 7: Scores CPF de 2017 – formation

Contrôle d’intégrité : approximation de la série temporelle de formation originale par l’ACPF.

Étant donné que l’ACPF repose sur l’approximation de séries chronologiques de données de formation individuelles en tant que combinaisons linéaires d’une séquence de CPF (elles-mêmes des fonctions) qui sont apprises à partir des séries chronologiques des données de formation en tant que groupe :

$\begin{array}{ccccccccccccc}{\left(\begin{array}{c}\text{interpolation}\\ \text{d'une série}\\ \text{chronologique}\end{array}\right)}_i& \approx & \left(\begin{array}{c}\text{fonction de}\\ \text{moyenne}\\ \text{globale}\end{array}\right)& +& {\mathrm{score}}_{i1}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionnelle}\end{array}\right)}_1& +& {\mathrm{score}}_{i2}& ·& {\left(\begin{array}{c}\text{composantes}\\ \text{principales}\\ \text{fonctionnelle}\end{array}\right)}_2& +& \cdots \end{array}$

Pour évaluer l’adéquation de l’ACPF à un ensemble particulier de données des séries chronologiques, il est prudent d’examiner dans quelle mesure les approximations fondées sur l’ACPF peuvent réellement se rapprocher des données des séries chronologiques originales.

La figure 12 montre six séries chronologiques de données de formation de Sentinel-1 choisies au hasard et leurs approximations par l’ACPF pour donner une impression de la qualité de l’ajustement des approximations de l’ACPF.

Figure 8: Approximations par l’ACPF de six séries chronologiques de données de formation.

Travaux à venir

• Cet article présente la technique d’ingénierie des caractéristiques fondée sur l’ACPF pour les données saisonnières des séries chronologiques de Sentinel-1. Rappelons toutefois que le but ultime est la classification des zones humides. La recherche de suivi immédiat consiste à appliquer certaines techniques de classification « de base » (p. ex. une forêt aléatoire) aux caractéristiques extraites fondées sur l’ACPF (c.-à-d. les scores CPF) et à examiner les précisions qui en résultent.
• La plupart des techniques de classification de base, comme la forêt aléatoire, ignorent les relations spatiales entre les emplacements/pixels. Si les techniques de base se révèlent insuffisamment précises, vous pouvez envisager des techniques de classification plus sophistiquées qui tentent de prendre en compte les relations spatiales, p. ex. en imposant des contraintes qui favorisent les emplacements/pixels proches pour avoir le même type de couverture terrestre prédit. L’une de ces techniques est le champ aléatoire de Markov caché, qui traite la tâche de classification de la couverture terrestre comme un problème de segmentation d’image non supervisée.
• Il a fallu environ 45 minutes pour générer la figure 3, en l’exécutant dans 16 fils parallèles sur un seul ordinateur virtuel x86 64-conda-linux-gnu (64 bits), sur un nuage informatique commercial, avec 28 Go de mémoire, en utilisant le système d’exploitation Ubuntu 20.04.2 LTS et R version 4.0.3 (2020– 10-10). Toutefois, la figure 3 ne couvre que la zone d’étude de la baie de Quinte, qui est une zone minuscule comparée à la province de l’Ontario ou à l’ensemble du Canada. L’utilisation des mêmes ressources informatiques que celles mentionnées ci-dessus pour exécuter le flux de travail d’extraction de caractéristiques fondées sur l’ACPF nécessiterait environ trois semaines pour l’Ontario et plusieurs mois pour l’ensemble du Canada. Plusieurs années de données de Sentinel– 1 pour l’ensemble du Canada auront une empreinte de stockage de plusieurs douzaines de téraoctets. D’un autre côté, on aimerait bien, à terme, mettre en place un système de classification pancanadien des terres humides (presque entièrement) automatisé. L’informatique répartie (informatique en nuage ou grappes de calcul à haute performance) sera nécessaire pour déployer un tel déroulement des opérations capable de traiter de tels volumes de données dans un délai raisonnable. Une étude de suivi est en cours pour déployer ce déroulement des opérations sur la plate-forme nuagique de Google (Google Cloud Platform (GCP)) pour l’ensemble de la Colombie-Britannique. Nous prévoyons que le temps d’exécution du déploiement du GCP pour l’ensemble de la Colombie-Britannique, divisé en centaines de tâches de calcul simultanées, sera inférieur à 3 heures. En outre, nous mentionnons que, en raison de la nature vectorielle des calculs de l’ACPF, une mise en œuvre du GPU devrait en théorie être possible, ce qui pourrait accélérer encore davantage les calculs de manière spectaculaire. Un article scientifique sur les résultats et les méthodologies de cette série de projets est en préparation et sera bientôt publié dans une revue à comité de lecture.
• Comme nous l’avons mentionné, les changements saisonniers des structures de la surface de la Terre, saisis sous forme de tendances temporelles dans les données des séries chronologiques de Sentinel-1, sont des variables prédictives utiles pour la classification des zones humides. Toutefois, pour pouvoir utiliser les données correctement et à grande échelle, il faut être conscient d’un certain nombre de problèmes potentiels. Par exemple, les utilisateurs de données doivent être bien informés des artefacts de mesure qui peuvent être présents dans de telles données, de la façon de détecter leur présence et de la façon de les corriger, si nécessaire. Nous prévoyons également que les tendances temporelles varieront (p. ex. en raison des variations naturelles, des cycles climatiques, du changement climatique), tant d’une année à l’autre que dans l’espace. La question de savoir comment tenir compte des variations spatiotemporelles des tendances temporelles de Sentinel-1 lors de la conception et de la mise en œuvre d’un déroulement des opérations pancanadien.
• Rappelons que nous nous sommes concentrés exclusivement sur la polarisation VV dans les données de Sentinel-1, bien que nous ayons déjà mentionné que les données de Sentinel-1 présentent une polarisation supplémentaire, à savoir VH. Les différentes polarisations sont sensibles aux différents types de structures au niveau du sol (NASA, 2022). En outre, Sentinel-1 est une constellation de satellites RSO en bande C (c.-à-d. avec une fréquence de signal radar d’environ 5,4 GHz), ce qui signifie notamment que Sentinel-1 mesure, très approximativement, des structures au niveau du sol d’une taille d’environ 5,5 cm. Toutefois, il existe d’autres satellites RSO qui ont des fréquences de signal différentes qui ciblent donc des structures au niveau du sol de tailles différentes (NASA, 2022). Il sera très intéressant de voir si les données RSO avec des fréquences de signal différentes, et mesurées dans des polarisations différentes, pourront être combinées afin d’améliorer de manière importante l’utilité de ces données.

Références

1. BANKS, S., WHITE, L., BEHNAMIAN, A., CHEN, Z., MONTPETIT, B., BRISCO, B., PASHER, J., AND DUFFE, J. Wetland classification with multi-angle/temporal sar using random forests. Remote Sensing 11, 6 (2019).
2. EUROPEAN SPACE AGENCY. Sentinel-1 Polarimetry. https://sentinel.esa.int/web/sentinel/user-guides/sentinel-1-sar/product-overview/polarimetry (le contenu de cette page est en anglais). Accédé : 2022-02-10.
3. NASA. What is Synthetic Aperture Radar? https://earthdata.nasa.gov/learn/ backgrounders/what-is-sar (le contenu de cette page est en anglais).  Accédé : 2022-02-10.
4. SCHUMAKER, L. Spline Functions: Basic Theory, third ed. Cambridge Mathematical Library. Cambridge Mathematical Library, 2007.
5. WANG, J.-L., CHIOU, J.-M., AND MU¨LLER, H.-G. Functional data analysis. Annual Review of Statistics and Its Application 3, 1 (2016), 257–295.
6. WIKIPEDIA. RGB color model. https://en.wikipedia.org/wiki/RGB_color_model (le contenu de cette page est en anglais). Accédé : 2022-02-10.

Si vous avez des questions à propos de cet article ou si vous souhaitez en discuter, nous vous invitons à notre nouvelle série de présentations Rencontre avec le scientifique des données où le(s) auteur(s) présenteront ce sujet aux lecteurs et aux membres du RSD.

mercredi, le 14 septembre
14 h 00 à 15 h 00 p.m. HAE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

par: Reginald Maltais, Statistique Canada

Introduction

L'un des premiers enjeux soulevés par le Réseau de la science des données (RSD) lors de sa mise en place, a été la difficulté d'attirer et de retenir les talents en science des données au sein du gouvernement du Canada. Il n'existait aucun instrument commun pour l'évaluation équitable des candidatures à l'échelle gouvernement, et il n'y avait pas non plus de manière de déterminer les compétences requises pour permettre l'avancement professionnel des scientifiques des données déjà à l'emploi du gouvernement.

Les profils de compétences offrent une manière de consigner le niveau minimum de compétences requises dans diverses disciplines pour un poste donné au sein du gouvernement fédéral. En avril 2021, le Réseau de la science des données a mis sur pied le Groupe de Travail (GT) sur les compétences en science des données pour déterminer : 1) les postes que les scientifiques des données pourraient occuper au gouvernement fédéral et 2) les compétences requises pour ces postes.

Le GT a lancé ses travaux dans le cadre d'un atelier donné à la Conférence sur les données de 2021, lors duquel la décision a été prise de mettre l'accent sur les postes en science des données suivants :

• analyste en science des données
• ingénieur/ingénieure en science des données
• spécialiste de la visualisation en science des données
• gestionnaire en science des données

Figure 1 : Schéma en étoile du profil de compétences

Justification des profils de compétences

Des profils de compétences ne sont pas le type d’instrument de ressources humaines auquel les gens pensent immédiatement lorsqu’ils créent l’annonce d’un poste ou présentent leur candidature à un poste. Compte tenu du fait que les rôles sont habituellement définis selon la description des fonctions, et qu’au sein du gouvernement, l’énoncé des critères de mérite est utilisé pour dresser la liste des compétences requises pour un poste aux fins d’embauche, quelle valeur un profil des compétences peut-il apporter?

Les profils de compétences comblent une importante lacune et peuvent être utilisés à tous les échelons à de multiples fins — les gestionnaires peuvent les utiliser pour préparer la description de poste qui accompagnera une nouvelle annonce dans la banque Emplois GC. Les spécialistes en ressources humaines peuvent aussi les utiliser pour rédiger des énoncés de critères de mérite propres à un poste, permettant ainsi de créer des annonces pour différents niveaux d'expertise tout en assurant un certain niveau de cohérence à l'échelle du gouvernement. Les profils de compétences offrent aussi l'avantage de ne pas être liés à une classification ou à un niveau en particulier, contrairement aux descriptions de poste.

Par exemple, un analyste de politiques qui souhaite devenir un analyste en science des données pourrait utiliser un profil de compétences pour connaître les compétences qui sont requises pour assumer un tel rôle. Il peut ensuite intégrer ces compétences dans le plan d’apprentissage de son poste actuel. Cela peut l’aider à tirer parti des données avec lesquelles il travaille actuellement et le guider pendant qu’il développe les aptitudes requises pour devenir un analyste en science des données.

Les talents en technologie sont rares. Il y a une très forte concurrence interne pour les rares talents qui ne sont pas toujours affectés à des initiatives prioritaires.

Le fait de ne pas être lié à une classification ou à un niveau existants offre une grande souplesse professionnelle et a permis au Groupe de travail de réellement envisager ce que cela signifie d’être un scientifique des données au gouvernement du Canada, sans se limiter aux définitions prévues dans les cadres existants. Bien entendu, quand une personne est embauchée pour un poste, elle doit être correctement classifiée; c’est pourquoi les profils de compétences sont utilisés comme intrants pour le Groupe de Travail des ressources humaines sur les fonctions liées à l’information et aux données. Ce groupe a pour but de normaliser les descriptions de poste, de dresser un parcours montrant comment une carrière peut progresser, et d’aider à accroître la visibilité des talents qui sont disponibles dans l’ensemble du gouvernement.

Comment les utiliser aujourd’hui

Le gouvernement du Canada dote toutes sortes de postes dont les titulaires travaillent et analysent les données. Ce n’est pas tout le monde qui souhaite ou doit être un scientifique des données, mais le fait d’offrir aux employés le moyen de s’établir un plan pour améliorer leurs aptitudes analytiques et la diversité de leurs compétences contribuera à renforcer le gouvernement dans son ensemble.

Les chercheurs qui souhaitent incorporer la science des données dans leur travail ne veulent pas nécessairement renoncer à leurs postes de recherche. Les profils des compétences peuvent les aider à déterminer les capacités requises pour s’assurer qu’une science des données de grande qualité peut être intégrée à leurs travaux. Les gestionnaires qui désirent bâtir des équipes robustes peuvent utiliser les profils en complément avec le Cadre des compétences en données du gouvernement du Canada, élaboré par le Groupe de travail sur les personnes et la culture de la Communauté de pratique sur les données ministérielles pour créer des équipes comportant un large éventail de compétences et déjà prêtes à répondre aux besoins de leurs ministères ou organismes respectifs.

Appuyer diverses structures d’équipe

Il y a de multiples angles à la science des données, ce qui signifie qu’il y a de multiples façons d’intégrer la science des données dans les équipes. Certaines organisations ont des besoins tellement prononcés qu’elles ont formé des divisions entières pour fournir une expertise en science des données en tant que service, alors que d’autres tentent d’intégrer les scientifiques des données dans de nouveaux secteurs d’activité ou dans ceux qui sont déjà en place. Chaque approche s’accompagne d’enjeux particuliers liés au recrutement, à la rétention et à la progression de carrière.

Les compétences qui ont été définies fournissent des renseignements en lien avec les personnes et les organisations quant aux compétences minimales requises pour différents niveaux de poste. Ainsi, les gestionnaires d’embauche peuvent cibler les compétences et les niveaux du poste à doter, et cela permet aux candidats de voir le perfectionnement des compétences requis pour obtenir un poste de niveau plus élevé en science des données.

Les fondements d’une chaîne de valeur en RH améliorée

La gestion des talents est un dossier complexe. Comme on l'a souligné dans le Processus opérationnel commun en matière de ressources humaines, les profils de compétences ne représentent qu'une portion d'un plus vaste ensemble. En tirant profit des compétences développées par la communauté, les gestionnaires d'embauche collaborent maintenant à l'élaboration de descriptions de poste normalisées interministérielles, dans le cadre du Groupe de travail des ressources humaines sur les fonctions liées à l'information et aux données. Les compétences pourront être appliquées à des classifications précises au sein du gouvernement du Canada, faisant avancer davantage les éléments réutilisables qui rendront l'embauche plus facile.

Les ressources pour développer vos capacités techniques en tant que scientifique des données ne manquent pas. Le Réseau de la science des données pour la fonction publique fédérale diffuse régulièrement des occasions d’apprentissage. Cependant, les capacités techniques ne sont pas les seules qualités requises d’un fonctionnaire, et les profils de compétences offrent un cadre que les personnes peuvent utiliser pour compléter leur plan d’apprentissage. Qu’il s’agisse de renseigner sur l’importance de l’éthique, de la protection des renseignements personnels ou de la communication narrative, les profils de compétences donnent aux scientifiques des données un aperçu des domaines où ils peuvent s’améliorer et leur servir de référence pour l’élaboration de leur plan d’apprentissage.

Un avenir qui s’annonce prometteur

La science des données est encore relativement nouvelle au sein de la fonction publique. Bien qu'elle soit déjà présente dans de nombreux aspects de la vie des Canadiennes et des Canadiens, la capacité d'exploiter la science des données pour mieux servir la population n'est qu'à ses débuts. De la Comparaison des outils de reconnaissance optique de caractères pour les documents à forte densité de texte et les textes provenant de scènes, à l'amélioration des temps de service en automatisant l'ingestion des données à partir de documents écrits (voir la page Intelligence documentaire), en passant par l'utilisation responsable des systèmes décisionnels automatisés du gouvernement fédéral, la science des données est déjà utilisée et porte ses fruits. Le gouvernement fournit un grand nombre de services, et la science des données peut être utilisée de bien des manières. Les analystes qui travaillent déjà à la prestation de ces services disposent maintenant d'une nouvelle ressource pour les aider à déterminer comment améliorer leurs propres compétences pour commencer à utiliser la science des données, et les gestionnaires disposent de nouveaux outils qu'ils peuvent utiliser pour évaluer les scientifiques des données lorsqu'ils tentent l'intégrer dans leurs secteurs de programme. Visitez la page GCWiki pour le Réseau de la science des données de la fonction publique fédérale pour voir les profils de compétences pour les postes suivants :

• Analyste en science des données
• Ingénieur/ingénieure en science des données
• Spécialiste de la visualisation en science des données
• Gestionnaire en science des données

Si vous avez des questions à propos de cet article ou si vous souhaitez en discuter, nous vous invitons à notre nouvelle série de présentations Rencontre avec le scientifique des données où le(s) auteur(s) présenteront ce sujet aux lecteurs et aux membres du RSD.

mercredi, le 14 septembre
14 h 00 à 15 h 00 p.m. HAE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

par : Ekramul Hoque, Statistique Canada

Que sont les métadonnées?

Les métadonnées sont des données qui fournissent des renseignements sur d'autres données. En d'autres termes, il s'agit de « données sur des données ». Il s'agit de l'une des composantes essentielles de la gouvernance des données, car elle impose des règles de gestion en matière de collecte et de contrôle des données. Les scientifiques de données consacrent un temps considérable à rassembler et à comprendre les données. Nous pouvons générer des aperçus plus rapides lorsque nous avons accès aux métadonnées sous-jacentes.

Pourquoi une organisation a-t-elle besoin d'un système de gestion des métadonnées?

Lorsqu'une organisation dispose d'un système de gestion des métadonnées, cela signifie que ses employés peuvent ajouter des métadonnées dans leurs référentiels de manière rapide et précise sans aucune incidence sur l'accès aux données au sein de leurs systèmes. Cela permet d'accroître la créativité des flux de travail et de renforcer les processus opérationnels. Par exemple, l'une des activités principales de Statistique Canada consiste à effectuer une analyse statistique d'un large éventail de types et de quantités de données. Pour y parvenir efficacement, les analystes doivent être en mesure d'identifier rapidement les données les plus utiles pour en déterminer la structure et la sémantique.

Parmi les principaux avantages de la gestion des métadonnées, notons les suivants :

• Optimisation de l'utilisation des données pertinentes et accroissement de leur qualité
• Plateforme commune permettant à divers groupes d'utilisateurs des données de discuter et de gérer efficacement leur travail. Par exemple, les ingénieurs de données, qui travaillent avec des métadonnées techniques et des normes de type de données, peuvent fournir une assistance pour la génération et la consommation de métadonnées
• Délais de livraison de projets plus courts grâce à une meilleure intégration des données sur diverses plateformes

Naturellement, une analyse de données réussie repose sur une gestion solide des métadonnées. Une bonne gestion des métadonnées peut également améliorer la capacité en matière de découverte des données. Elle résume l'information fondamentale de base sur les données, ce qui facilite la recherche et le suivi.

L'automatisation des métadonnées est une tendance récente de l'industrie qui remplace le processus de plus en plus fastidieux de la mise en correspondance manuelle des données pendant la gestion des métadonnées. Parmi les principaux avantages de l'automatisation, citons l'assurance de la qualité des données et le raccourcissement des délais de réalisation des projets grâce à une meilleure intégration des données sur diverses plateformes. La gestion des métadonnées garantit la conformité à la réglementation grâce à la normalisation des données. Elle améliore également la productivité et réduit les coûts. La gestion des métadonnées permet de connaître les données existantes et leur valeur potentielle, favorisant ainsi la transformation numérique; celle-ci permet aux organisations de connaître les données dont elles disposent et leur valeur potentielle.^{Note de bas de page 1}

Normalisation des données

Lorsque les données sont fournies par des partenaires externes, il est probable que leur système ou application ait été créé indépendamment. La normalisation des données établit une compréhension mutuelle de la signification et de la sémantique des données, ce qui permet aux utilisateurs de les interpréter et de les utiliser de manière appropriée.^{Note de bas de page 2}

Dans le cadre du Collectif canadien de normalisation en matière de gouvernance des données, Statistique Canada a adopté les recommandations de l'initiative d'échange de données et de métadonnées statistiques^{Note de bas de page 3} (SDMX), un projet international qui vise à normaliser et à moderniser les mécanismes et les processus d'échange de données et de métadonnées. Les règles SDMX sont maintenant diffusées sous l'égide de l'Organisation internationale de normalisation et sont approuvées à titre de norme officielle à Statistique Canada.

SDMX est un cadre qui permet de normaliser à la fois les données et les métadonnées. Bien qu'il soit bien implanté dans le Système des comptes nationaux de Statistique Canada, il est encore en phase initiale d'introduction dans d'autres secteurs de l'organisation. Cette méthode d'interopérabilité des données devrait permettre :

• de réduire les doublons;
• de mieux comprendre les concepts;
• de cerner les lacunes statistiques;
• de faciliter le rapprochement des données;
• d'approfondir les analyses.

La norme SDMX pourrait être exploitée, par harmonisation, dans un format « normatif léger et souple » permettant l'utilisation d'outils pour produire rapidement des couches d'infrastructure et d'interopérabilité, ce qui faciliterait l'échange rapide de l'information.

Catalogage des données

Le catalogage des données est un autre élément clé de la gestion des métadonnées. Cette expression est communément définie comme la découverte de données utiles à partir d'ensembles de données participants. Elle a pour objectif principal d'employer des méthodes cohérentes pour trouver les données et les renseignements qui leur sont associés. La figure 1 illustre comment les processus d'analyse changent lorsque les analystes utilisent un catalogue de données.

Figure 1 : Processus avec et sans catalogue de données. Graphique tiré d' Alation - Data Intelligence + Human Brilliance (le contenu de cette page est en anglais)

Sans catalogue de données, les analystes recherchent des renseignements en étudiant la documentation antérieure, en collaborant avec des associés et en ayant recours à d'autres ensembles de données reconnaissables. Ce cycle exige une expérimentation et la nécessité « d'étendre et d'améliorer » les données. L'analyste doit ensuite consulter des ensembles de données déjà connus.

Le catalogue de données permet à l'analyste de rechercher des ensembles de données disponibles, d'évaluer les données et de prendre des décisions éclairées quant aux renseignements à utiliser. Il peut ensuite examiner et planifier l'information de manière efficace et avec plus de certitude.^{Note de bas de page 4} Le réseau de stockage et de distribution de données CKAN (le nom est derivé d'acronym du « Comprehensive Knowledge Archive Network ») a été créé pour soutenir ce processus.

Qu'est-ce que le CKAN?

CKAN - The world's leading open source data management system (le contenu de cette page est en anglais) est un système de gestion de données à code source ouvert destiné aux éditeurs de données nationaux et régionaux, aux gouvernements et aux organisations qui souhaitent publier des données, les faire connaître et les rendre ouvertes et accessibles à l'utilisation.

Pourquoi utiliser CKAN?

• Il s'agit d'un logiciel libre et gratuit, ce qui signifie que les utilisateurs conservent tous les droits sur les données et les métadonnées qu'ils stockent dans le logiciel.
• Le logiciel est encodé avec Python et JavaScript. Le code JavaScript, dans CKAN, est décomposé en modules, c'est-à-dire en petites unités indépendantes de code JavaScript. Dans les thèmes CKAN, on peut ajouter des fonctionnalités JavaScript en y intégrant ses propres modules. De cette façon, le code demeure simple et facile à tester, à déboguer et à maintenir, puisqu'il est décomposé en petits modules indépendants. Les développeurs sont autorisés à ajouter des extensions, c'est‑à‑dire des paquets en Python qui modifient ou étendent CKAN. Chaque extension contient un ou plusieurs modules d'extension qui doivent être ajoutés au fichier de configuration CKAN de l'utilisateur pour activer les fonctionnalités de l'extension.
• La gestion des utilisateurs et des données est ainsi assurée.
• De cette façon, on peut développer des extensions personnalisées.
• On y trouve également un point de terminaison de l'interface de programmation d'application (IPA), qui sert à stocker, à modifier, à extraire et à analyser les données.

Cas d'utilisation des métadonnées

À la fin de 2019, l'équipe Opérationnalisation de la science des données de Statistique Canada a commencé à utiliser le Programme intégré de la statistique des entreprises (PISE) de l'organisme. Le PISE est le système commun de traitement des données utilisé pour la plupart des enquêtes économiques de Statistique Canada.

L'objectif du projet est de vaincre les limites de l'espace analytique actuel. Une nouvelle solution permettra :

• de répondre au besoin d'une solution analytique en libre-service;
• d'accroître la capacité de connexion aux outils d'analyse;
• d'accroître la capacité de recherche et de découverte dans des ensembles de données;
• d'éviter la duplication des données;
• d'avoir moins recours à des modes d'accès uniformisés;
• d'utiliser l'analyse horizontale à partir de données extérieures au PISE.

Le PISE et la Division de la science des données se sont associés à l'infrastructure de données FAIR (IDF) pour déterminer si un prototype pouvait être créé à l'aide d'outils à code source ouvert.

L'IDF vise à produire un écosystème collaboratif de données et de métadonnées pour tous les fournisseurs et utilisateurs de données. Au cœur de cet espace figurent un catalogue de données, de même que des outils de gestion des données et des métadonnées.

Transfert de connaissances des analystes à l'administrateur avant la mise en place d'un système infonuagique

Le PISE dispose d'analystes qui souhaitent accéder aux enquêtes. Ces enquêtes sont gérées et mises à jour par un administrateur de l'équipe du PISE; cependant, le processus de mise à jour et de création d'accès entraîne des duplications et des redondances de données. De plus, les analystes ont du mal à faire des recherches parmi ces données et les métadonnées correspondantes, car elles sont disponibles dans des répertoires partagés.

Figure 2 : Goulot d'étranglement dans la validation de concept du PISE

Transfert de connaissances des analystes à l'administrateur après la mise en place d'un système infonuagique

L'équipe a proposé une solution en trois points pour remédier au goulot d'étranglement :

• Le service de recherche de l'IDF : L'équipe de l'IDF a facilité l'enregistrement et la découverte des métadonnées grâce à une couche de virtualisation des données^{Note de bas de page 5} Le moteur de recherche figure au-dessus d'Elastic Search et il y a des points de terminaison IPA qui permettent aux utilisateurs externes et internes de gérer leur actif en données.
• CKAN
• Le locataire de la plateforme Azure

Le PISE télécharge les données et les métadonnées dans CKAN et le service de recherche de l'IDF. Cela permet aux analystes de rechercher les données et les métadonnées et d'y avoir accès. Les deux systèmes sont synchronisés avec le locataire de la plateforme Azure pour gérer l'authentification des utilisateurs et le stockage des données.

Figure 3 : Solution présentée pour la validation de concept du PISE

Une solution de gestion des métadonnées

Pour être réussie, la mise en œuvre d'une solution de gestion des métadonnées doit comprendre : une stratégie en matière de métadonnées; l'intégration et la publication des métadonnées; la saisie et le stockage des métadonnées; ainsi que la gouvernance et la gestion des métadonnées. La stratégie de métadonnées garantit la cohérence de l'ensemble de l'écosystème de données d'une organisation. Elle explique pourquoi l'entreprise assure le suivi des métadonnées et recherche toutes les sources de métadonnées, de même que les méthodes qu'elle utilise. Une telle stratégie peut se révéler très complexe sur le plan du volume et des variations des données, de même que sur le plan des capacités technologiques de l'entreprise qui l'appuient. Le graphique ci-dessous donne un aperçu très général de la manière dont une telle stratégie peut être mise en œuvre.

Figure 4 : Infrastructure de métadonnées

Toute organisation dispose d'une liste de sources de données qui se présentent sous diverses formes, telles que des données structurées, des formats de fichiers plats ou des IPA Web. Ces données sont utilisées par les analystes aux fins de visualisation et d'établissement de rapports, de création d'analyses ou de prestation de services cognitifs. Une stratégie de gestion des métadonnées est essentielle pour garantir que les données sont bien interprétées et sont susceptibles de favoriser l'obtention de résultats.

La première étape de cette gestion est l'absorption des données; en général, cela nécessite un ensemble de transformations et de classifications. En cette matière, l'adoption d'une normalisation des données est un processus clé, car elle permettra d'établir une manière commune de structurer et de comprendre les données, en plus d'inclure les principes et les questions de mise en œuvre pour leur utilisation. L'objectif opérationnel de ce processus permettra également de procéder à une analyse et à un échange collaboratifs avec des partenaires externes.

Grâce à la normalisation, les administrateurs de données devraient être en mesure d'enregistrer l'actif en données et les métadonnées. Ils devraient avoir la possibilité d'absorber et d'enregistrer leurs métadonnées, ce qui rendra leur actif en données découvrable et leur permettra de continuer à gérer leurs données par l'intermédiaire d'une couche de virtualisation. Cela peut être réalisé en introduisant un outil de catalogage des données qui facilitera la mise en place d'une méthode cohérente de repérage des données et des renseignements disponibles pour les partenaires internes et externes de l'organisation.

Grâce à l'emploi de technologies à code source ouvert et d'une infrastructure infonuagique moderne, il est possible de créer une plateforme où ces partenaires peuvent importer des données brutes provenant de diverses sources vers un espace de stockage sécurisé (c'est-à-dire un lac de données ou un stockage en Blob). Plutôt que d'avoir une base de données « sur site » pour l'outil de catalogage des données ou d'enregistrement des métadonnées, comme Postgres ou autre, le stockage dans le nuage est un moyen plus évolutif et plus solide pour appuyer de tels systèmes. Il permettra non seulement de mettre à jour les données, de les synchroniser et de les partager facilement, mais aussi de gérer le contrôle d'accès aux éléments sensibles.

Les services de recherche peuvent être mis en œuvre à la dernière couche de cette stratégie, afin de rendre les données et les métadonnées accessibles aux utilisateurs finaux. Lorsqu'il y a une lacune au chapitre des données, les utilisateurs devraient être autorisés à la signaler, de sorte que les responsables puissent savoir quelles données sont nécessaires pour la combler. Toute la communication entre les composants du graphique peut se faire par l'intermédiaire d'IPA ou de SSH, pour permettre un système d'intégration modulaire.

Enfin, une organisation a besoin d'une structure de gouvernance des métadonnées, qui comprend une évaluation de la responsabilité, des cycles de vie et des statistiques des métadonnées, de même que de leur intégration dans les divers processus opérationnels.

Si vous avez des questions à propos de cet article ou si vous souhaitez en discuter, nous vous invitons à notre nouvelle série de présentations Rencontre avec le scientifique des données où le(s) auteur(s) présenteront ce sujet aux lecteurs et aux membres du RSD.

Mardi, le 21 juin
14h00 à 15h00 p.m. HAE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

par : Marie-Pier Schinck, Eunbee (Andrea) Jang et Julien-Charles Lévesque, Emploi et Développement social Canada

Introduction et objectif de l'étude

Ces dernières années, le ministère de l'Emploi et Développement social Canada (EDSC) a utilisé le traitement du langage naturel (TLN) dans de nombreux projets et a repéré des défis associés au travail lorsque la proportion de données de chaque langue officielle est débalancée. Les récents progrès réalisés dans le domaine du TLN sont principalement axés sur la langue anglaise, et les ressources consacrées aux langues autres que l'anglais sont limitées. Ainsi, lorsqu'ils travaillent sur des solutions de TLN appliquées pour EDSC, les scientifiques des données doivent prendre des décisions concernant le traitement de la langue française, tout en faisant face à des ressources limitées et à des priorités concurrentes.

Les auteurs de cette étude ont initialement soulevé des préoccupations concernant le traitement de la langue française en se fondant principalement sur leur expérience en tant que scientifiques des données travaillant avec des ensembles de données bilingues à EDSC (voir : Langues officielles et traitement du langage naturel). En réponse, les auteurs ont consulté divers scientifiques des données fédéraux et des chercheurs en TLN. Ils ont alors constaté que ces défis ne se limitaient pas à EDSC et étaient, en fait, communs à divers ministères et organismes.

L'objectif principal du projet est d'explorer cette question et d'acquérir des connaissances transférables que les scientifiques des données peuvent utiliser pour améliorer l'équité des solutions fournies par EDSC.

Comme point de départ, nous mesurons l'ampleur du biais linguistique dans quatre projets d'EDSC où des systèmes de classification multilingue ont été mis en œuvre. Nous mettons également à l'essai des stratégies de rééquilibrage afin de mieux comprendre la représentation idéale de la langue minoritaire. Nous comparons les rendements des modèles dans plusieurs scénarios, à savoir des modèles multilingues, des modèles unilingues séparés, ou une approche interlinguistique fondée sur une traduction du français vers l'anglais permettant un entraînement unilingue à partir d'un modèle unilingue anglais. Nous pouvons ainsi observer la mesure dans laquelle les rendements des modèles s'améliorent ou se détériorent en fonction de chaque langue.

2 – Mise en place de l'étude

Les quatre ensembles de données utilisés dans le cadre de cette étude portent sur des problèmes de classification supervisée de projets antérieurs et en cours à EDSC. Le champ d'application a été limité à des problèmes de classification supervisée afin de représenter le temps et les ressources disponibles pour ce projet, en raison de la facilité d'accès aux données et parce qu'il s'agit de la tâche de TLN la plus communément traitée par notre équipe.

2.1 – Vectorisation et architecture du modèle

Pour notre expérience, nous avons entraîné des modèles pour chaque ensemble de données et pour plusieurs méthodes de vectorisation, architectures de modèles et configurations d'hyperparamètres (voir tableau 2). Les méthodes de vectorisation et les modèles choisis couvrent certains des outils les plus courants utilisés pour les problèmes de classification de TLN. Les méthodes de vectorisation comprennent une méthode de sélection des caractéristiques appliquée aux sacs de mots reposant sur la distribution khi carré (Chi2BOW), des vectorisations FastText (FT) et des vectorisations contextuelles provenant d'un algorithme multilingue BERT (Devlin et al., 2018b).

Pour la configuration du modèle, nous disposons de deux grands ensembles d'architectures de classification, que nous appelons les méthodes d'apprentissage contextuelles et non contextuelles. On entend par « non contextuel » les systèmes d'apprentissage qui traitent des représentations agrégées de phrases et rejettent les renseignements relatifs à l'ordre des mots. Il s'agit notamment de la régression logistique (LR), du perceptron multicouche (MLP) et de XGBoost (XGB; Chen et Guestrin, 2016). En revanche, les approches contextuelles prennent en compte les renseignements relatifs à l'ordre des mots dans l'apprentissage et la prédiction. Nous avons mis en œuvre deux architectures de modèles contextuelles, un réseau de neurones récurrents à mémoire court et long terme (LSTM, Hochreiter et Schmidhuber, 1997) et un modèle populaire basé sur l'attention appelé BERT (Devlin et al., 2018a). Les détails de la recherche des hyperparamètres sont inadmissibles pour le présent article, mais les principaux résultats sont fournis à la lumière d'une méthodologie de recherche exhaustive. Nous avons également évalué les méthodes de LR, de MLP et de XGB avec une simple vectorisation de sac de mots (sans sélection de caractéristiques du khi carré), bien qu'elle soit omise dans cet article pour simplifier la présentation. N'hésitez pas à communiquer avec les auteurs pour obtenir le rapport dans son intégralité.

3 – Présence de biais

Dans la présente étude, nous nous intéresserons au biais linguistique en examinant la disparité dans la précision des tests entre les deux langues officielles. La présence de biais sera évaluée dans plusieurs contextes différents, et ceux-ci seront abordés plus en détail ci-dessous.

Disparité des rendements des modèles multilingues

Notre première expérience consistait à entraîner des modèles multilingues (c.-à-d. un entraînement simultané des deux langues avec un seul modèle), avec les méthodes abordées dans la section précédente, en utilisant la représentation linguistique trouvée dans les ensembles de données originaux (sans rééquilibrage). Pour évaluer la présence d'un biais linguistique, nous avons ensuite comparé le rendement obtenu pour la partie française des données avec celui obtenu pour la partie anglaise^{Note de bas de page 1}. La figure 1 montre la précision des tests par langue pour la meilleure configuration des hyperparamètres de chaque méthode testée.

Figure 1 : Précision du test par rapport à la langue du texte.

Un examen de la figure 1 nous permet d'abord de conclure qu'aucune tendance dominante ne se perpétue dans les quatre ensembles de données. Par exemple, l'ensemble de données du projet des RE montre que les résultats obtenus pour la partie anglaise des données surpassent systématiquement ceux de la partie française des données. En revanche, pour l'ensemble de données du projet T4, la tendance inverse se dégage; en effet, la plupart des méthodes produisent pour la partie française un rendement supérieur à celui de la partie anglaise. Cela peut s'expliquer par le fait que l'ensemble de données du projet T4 contient la plus grande proportion de données françaises ainsi que par le contenu des données en soi, où le contexte commercial appuie l'hypothèse d'une distribution sous-jacente différente pour chaque langue, de sorte que le problème de classification est plus facile à résoudre en français qu'en anglais. Les ensembles de données des projets de la DGAPRI et des RH affichent des tendances moins claires : le rendement du français surpasse légèrement celui de l'anglais pour la DGAPRI, tandis qu'on observe l'inverse pour les RH.

Pour obtenir une image plus détaillée, nous avons compilé les différences de rendement de ces expériences et les avons normalisées en calculant leurs écarts réduits (des scores plus élevés indiquant un meilleur rendement relatif en anglais). Cet exercice a révélé qu'en moyenne, les modèles multilingues entraînés pour cette étude ont obtenu des résultats légèrement supérieurs en anglais qu'en français, par un facteur de 0,13 écart-type sur la mesure de rendement. Les tendances sur les ensembles de données individuels sont légèrement plus fortes, avec une différence moyenne de 0,56 et 0,41 écart-type respectivement pour les ensembles de données des projets des RE et des RH, et de -0,33 pour le projet T4. Malgré ce léger biais général en faveur de l'anglais, la principale conclusion de ces résultats est l'importance d'une analyse de rendement minutieuse propre à la langue dans l'utilisation de modèles multilingues, car la présence de biais variera en fonction des propriétés de l'ensemble de données et du contexte commercial qui sous-tend la collecte des données.

Influence de la distribution des langues dans les systèmes multilingues

Dans la présente section, nous explorons l'incidence de la proportion linguistique (c.-à.d. le rapport entre les données françaises et anglaises) dans les systèmes multilingues. Nous évaluons deux méthodes qui sont couramment utilisées pour les tâches de classification du TLN et qui ont donné des résultats satisfaisants sur nos repères : BOW+XGBoost et BERT. Pour notre évaluation, nous utiliserons l'ensemble de données du projet des RE en raison de sa taille plus importante.

Dans l'expérience, le sous-échantillonnage est appliqué à l'une des langues afin d'obtenir un rapport cible entre les données françaises et les données anglaises de l'ordre de 10:90 à 90:10. Les données d'essai restent intactes avec un rapport entre le français et l'anglais de 28:72, afin d'effectuer chaque fois une évaluation en fonction des mêmes échantillons.

Figure 2 : Expérience de rapport linguistique sur des données du projet des RE. À gauche : Sacs de mots avec un classificateur XGBoost. À droite : Moyenne du modèle BERT sur trois répétitions par rapport.

La figure 2 illustre les rendements de ces deux modèles avec les répartitions des rapports de données décrites ci-dessus. Comme prévu, l'expérience montre qu'une diminution de la proportion de données dans une langue donnée tend à réduire le rendement dans cette langue dans tous les cas; la tendance inverse est observée lorsque la proportion d'une langue augmente, bien que le rendement reste parfois stable pour divers rapports. La courbe de précision générale est systématiquement plus proche de la courbe de précision de l'anglais, car elle est calculée sur un ensemble de tests utilisant le rapport linguistique fixe (fr:ang) que l'on trouve dans l'ensemble de données original (28:72).

Les expériences montrent également que les rapports linguistiques optimaux varient en fonction des diverses méthodes d'apprentissage. Plus précisément, pour BOW + XGBoost, les scores de précision du français et de l'anglais présentent l'écart le plus faible avec un rapport de 50:50 (fr:ang). Avec la méthode BERT, les deux langues présentent le plus faible écart de précision aux rapports 30:70 et 40:60. Ceci est particulièrement intéressant étant donné que le rapport optimal est différent du rapport original dans l'ensemble de données, dans ce cas 28:72.

Cette expérience indique que la manipulation artificielle de la proportion linguistique peut intensifier ou améliorer les biais. Il est conseillé d'avoir une proportion de langues quelque peu équilibrée à l'entraînement afin de réduire la disparité entre le rendement des deux langues. Cependant, il faut faire un compromis entre la précision générale (précision pour l'ensemble des échantillons) et la précision pour les textes français et anglais : le point de rendement optimal peut ne pas être le même pour les deux critères.

Compromis entre la modélisation multilingue et unilingue

Dans la présente section, nous présentons une analyse de la disparité des rendements pour chaque langue dans l'entraînement d'un modèle dans les deux langues, ce qu'on appelle le contexte multilingue (multi), et dans l'entraînement de deux modèles (un par langue), soit le contexte unilingue (uni). Les résultats sont présentés séparément pour chaque langue; la section en langue française comprend également le rendement d'un système unilingue anglais entraîné avec des données françaises traduites vers anglais (trad_uni). Il convient de souligner que le modèle n'a été entraîné qu'avec des données françaises traduites, plutôt qu'avec l'ensemble des données comprenant les données originales anglaises et les données françaises traduites, principalement en raison de contraintes en termes de ressources informatiques. Cette expérience vise à comprendre la mesure dans laquelle le signal nécessaire à la classification demeure intact après la traduction de documents. Pour la traduction, nous utilisons le modèle de traduction automatique neuronal Marian.^{Note de bas de page 2}

Anglais

Le diagramme à barres de la figure 3 montre le meilleur rendement de chaque méthode pour la partie anglaise des données. Deux barres sont associées à chaque méthode : la barre de gauche montre le contexte multilingue et la barre de droite, le contexte unilingue.

En termes d'architecture de modèle, on constate que le modèle BERT est le plus performant sur tous les ensembles de données. En revanche, la méthode de perceptron multicouche avec vectorisation du sac de mots au khi carré (C2BOW + MLP) est l'une des configurations les moins performantes parmis tous les ensembles de données.

Figure 3 : Comparaison du rendement en anglais (précision du test) dans deux contextes – multilingue et unilingue

Pour les ensembles de données des projets T4, des RH et de la DGAPRI, le rendement du modèle BERT est plus élevé dans le contexte multilingue, tandis que le contexte unilingue surpasse légèrement le contexte multilingue pour l'ensemble de données du projet des RE, qui, fait intéressant, est le plus grand ensemble de données. Bien que l'entraînement multilingue semble donner de meilleurs résultats pour les modèles reposant sur BERT, les méthodes multilingues affichent, dans leur ensemble, un rendement légèrement inférieur à celui des modèles unilingues, en moyenne de 0,56 %. Nous considérons cela comme une preuve que la méthode d'entraînement (multilingue ou unilingue) n'a pas d'incidence considérable sur la catégorie de langue dominante, l'anglais.

Français

La figure 4 présente la comparaison générale des trois approches avec la modélisation française. Plus précisément, nous comparons le rendement de la partie française des données dans le contexte multilingue (multi) avec des approches unilingues, l'une avec des modèles entraînés avec des données françaises originales (uni) et l'autre avec les données françaises traduites en anglais à introduire dans un système unilingue anglais (trad_uni). Pour trad_uni, nous utilisons uniquement la partie française des données pour l'entraînement, et laissons de côté les données originales en anglais, afin d'observer directement l'incidence de l'approche axée sur la traduction sur la langue minoritaire.

Figure 4 : Comparaison du rendement du français pour trois approches – multilingue, unilingue, traduit unilingue.

En ce qui concerne l'architecture des modèles, à l'instar de ce qui a été observé pour l'anglais, les meilleures méthodes ont tendance à varier en fonction de l'ensemble de données, BERT étant la méthode la plus performante dans l'ensemble. La méthode BERT est la meilleure pour les données du projet des RH, des RE et de la DGAPRI; le contexte unilingue surpasse les deux autres contextes dans les deux premiers cas (RH et RE) et le contexte multilingue obtient les meilleurs résultats pour la DGAPRI. Il est intéressant de noter que la méthode Chi2BOW + MLP offre un résultat supérieur à toutes les autres méthodes pour l'ensemble de données du projet T4, alors qu'elle obtient les plus mauvais résultats pour les trois autres ensembles de données.

En ce qui concerne les systèmes d'entraînement, nous remarquons tout d'abord que trad_uni semble être le contexte le moins performant en général pour les ensembles de données des projets T4, des RE et de la DGAPRI. En ce qui concerne le projet des RH, trad_uni n'est pas toujours la pire approche, mais ce n'est pas non plus le meilleur modèle. Il semble que les erreurs de deux modèles en cascade, le modèle neuronal de traduction automatique utilisé et le classificateur principal, sont potentiellement propagées lorsqu'ils sont utilisés l'un après l'autre. Cela prouve que la traduction n'est peut-être pas une option idéale pour atténuer le problème du déséquilibre des données. Toutefois, il convient de noter que la portée de notre expérience sur l'approche fondée sur la traduction est limitée à la partie française des données et que le résultat peut varier si l'intégralité des données (soit les données anglaises et les données françaises traduites en anglais) est utilisée dans un système unilingue anglais.

Les modèles unilingues français semblent offrir des résultats supérieurs à ceux des modèles multilingues équivalents pour trois des quatre ensembles de données, soit les RH, les RE et la DGAPRI. Pour l'ensemble de données du projet T4, nous observons que les modèles multilingues surpassent la version unilingue pour la majorité des méthodes. Enfin, une évaluation des différences de scores de précision pour la partie française des données entre les modèles unilingues et multilingues nous permet de constater que les modèles unilingues surpassent en moyenne les modèles multilingues de 2,22 points de pourcentage de précision. Cette différence est beaucoup plus prononcée que ce qui a été observé pour la langue anglaise. Cela indique que le choix d'utiliser un modèle multilingue, par opposition à deux modèles unilingues, entraînera en moyenne une baisse plus importante du rendement dans la partie française des données, par rapport à la partie anglaise.

4 – Conclusion

La prise de décisions concernant le traitement de données textuelles bilingues est monnaie courante pour de nombreux spécialistes des données travaillant en tant que fonctionnaires fédéraux. Bien que le statut des langues officielles prescrit qu'il ne devrait pas y avoir de différence dans le traitement de chaque langue, cela peut être particulièrement difficile lorsque les outils de TLN sont plus nombreux et de qualité supérieure en anglais qu'en français. Cette initiative visait à acquérir des connaissances appliquées et transférables afin d'aider les spécialistes des données du gouvernement du Canada à prendre des décisions plus éclairées dans l'élaboration de solutions de TLN pour des ensembles de données bilingues.

Nos résultats ont d'abord indiqué qu'aucune tendance ne s'applique à tous les ensembles de données lorsqu'on examine le biais dans les modèles multilingues. Par exemple, l'ensemble de données du projet des RE a montré un léger biais où le rendement des commentaires en anglais est systématiquement plus élevé que celui des commentaires en français, tandis que l'analyse des données du projet T4 a révélé une tendance inverse avec un biais favorisant le français. En résumé, bien qu'il n'y ait pas de règle définitive concernant l'apparition de biais dans les modèles multilingues dans tous les ensembles de données, certains modèles ont tendance à être moins performants dans l'une des langues officielles, ce qui fait ressortir la nécessité d'une évaluation adaptée à la langue pour éviter les risques de traitement biaisé ou de répercussion disparate. Les expériences sur les proportions de langues dans le contexte multilingue ont montré que l'objectif d'une représentation de 30 % à 50 % du français par sous-échantillonnage de la langue majoritaire donne les meilleurs résultats. Plus précisément, elle permet de réduire la disparité du rendement entre les deux langues officielles, sans nuire au rendement général.

L'exploration du contexte multilingue par rapport au contexte unilingue a révélé que l'incidence sur le rendement de la partie anglaise des données était négligeable, car les deux contextes donnent des résultats semblables, bien que le rendement soit légèrement supérieur dans le contexte unilingue. D'autre part, on constate avec la partie française des données une diminution plus importante du rendement dans le contexte multilingue, par rapport au contexte unilingue. Cela signifie que, lorsqu'une identification linguistique de bonne qualité est disponible, les praticiens de la science des données dans l'ensemble du gouvernement du Canada devraient sérieusement envisager l'utilisation de deux modèles unilingues, car cela tend à donner de meilleures performances en moyenne, par opposition à l'utilisation d'un seul modèle multilingue. Enfin, la traduction du français pour l'utilisation d'un modèle unilingue anglais s'est avérée le moins prometteur des trois contextes pour tous les ensembles de données. Puisque, selon notre expérience, il comporte un plus grand risque de biais sur la langue minoritaire, nous recommandons d'effectuer une analyse complète de son incidence lorsque l'on tente de déployer un modèle unilingue unique reposant sur la traduction de la langue minoritaire.

Si vous avez des questions à propos de cet article ou si vous souhaitez en discuter, nous vous invitons à notre nouvelle série de présentations Rencontre avec le scientifique des données où le(s) auteur(s) présenteront ce sujet aux lecteurs et aux membres du RSD.

Mardi, le 21 juin
14h00 à 15h00 p.m. HAE
MS Teams – le lien sera fourni aux participants par courriel

Inscrivez-vous à la présentation Rencontre avec le scientifique des données. À bientôt !

References

Chen, T., et C. Guestrin. 2016. « Xgboost: A scalable tree boosting system », Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, p. 785 à 794.

Devlin, J., M.W. Chang, K. Lee et K. Toutanova. 2018a. « BERT: Pre-training of deep bidirectional transformers for language understanding », arXiv, prépublication arXiv:1810.04805.

Devlin, J., M.W. Chang, K. Lee et K. Toutanova. 2018b. Multilingual BERT, GitHub: google-research / bert (le contenu de cette page est en anglais)

Hochreiter, S., et J. Schmidhuber. 1997. « Long short-term memory », Neural Computation, vol. 9, no 8, p. 1735 à 1780.

Par : Scott Syms, Services partagés Canada

L'étendue de l'écosystème Python revêt une importance inestimable pour la communauté de la science des données. La sélection d'outils Python permet à ses utilisateurs d'accéder à des environnements expressifs pour étudier les données, former des modèles d'apprentissage automatique et afficher les résultats dans un format autodocumenté. Il a même été suggéré que les carnets Jupyter, un environnement d'exploration de données Python populaire, remplacent le traditionnel article scientifique.^{Note de bas de page 1}

Cependant, Python a des lacunes. Les éléments mêmes qui le rendent accessible et utilisable, tels que le typage dynamique, le comptage des références et le verrouillage global de l'interpréteur, peuvent empêcher les programmes d'utiliser pleinement les ressources informatiques disponibles. Cela est particulièrement évident lors du traitement de grands ensembles de données ou de charges de travail à forte intensité de calcul.

En règle générale, il y a deux approches à adopter pour les charges de travail à forte intensité de calcul en Python.

Pour les scientifiques des données qui utilisent des mégadonnées ou des charges de travail à forte intensité de calcul, Python propose des solutions de rechange. Les accélérateurs de calcul, tels que Numba,^{Note de bas de page 2} PyPy^{Note de bas de page 3} et Pyston^{Note de bas de page 4} utilisent des optimisations de codage pour accélérer les environnements de développement sur une seule machine. Combinées à la prise en charge du traitement simultané par Python,^{Note de bas de page 5} ces bibliothèques peuvent accroître la capacité de traitement d'une seule machine.

Une autre approche fait appel à des bibliothèques, telles que Dask^{Footnote 6} et PySpark^{Note de bas de page 7} pour répartir le traitement sur plusieurs machines. Rien ne vous empêche de faire les deux – optimiser sur place et répartir la charge.

En définitive, les outils que vous utilisez sont définis par des contraintes en matière de mise en œuvre. Pour les scientifiques des données qui ont accès à des environnements en nuage gérés, la possibilité de créer des centaines de machines pour analyser rapidement les données est un moyen évident de résoudre le problème du calcul. Pour les utilisateurs disposant de ressources plus modestes, cependant, les options d'évolutivité peuvent être limitées. L'intelligence artificielle à la périphérie du réseau peut ne pas disposer de la même capacité de calcul que dans les environnements en nuage.

Vers la fin de l'année 2020, la publication scientifique Nature a suggéré une solution de rechange à certaines des approches traditionnelles à l'égard du calcul des données scientifiques.^{Note de bas de page 8} L'auteur a proposé de développer des logiciels scientifiques en Rust, un nouveau langage émergent et très performant.

Le langage de programmation Rust a été lancé en 2009 en tant que projet parallèle du programmeur de Mozilla, Graydon Hoare. Il offre un rendement similaire à celui de C++, mais fournit de meilleures mesures de sécurité concernant l'utilisation de la mémoire et du traitement simultané. Comme C++ et Python, il peut être utilisé sur toute une série de plateformes, de la programmation de microcontrôleurs aux applications Web asynchrones à haute capacité. Les applications Rust peuvent être compilées en WebAssembly,^{Note de bas de page 9} ce qui leur permet de s'exécuter dans le navigateur à des vitesses quasi natives.

La combinaison de la vitesse, de la sécurité et de l'interopérabilité est un mélange idéal de caractéristiques lorsqu'il s'agit de traiter un problème d'ingénierie de mégadonnées provenant de l'analyse de données de position des navires à l'échelle mondiale.

Système d'identification automatique

Aux termes d'un accord international, les navires océaniques doivent transmettre des messages de données de voyage à l'aide du système d'identification automatique (AIS).^{Note de bas de page 10} Ces messages peuvent être collectés depuis l'espace, regroupés en une image générale des activités de navigation et vendus à des organismes commerciaux et gouvernementaux. L'article Building a Maritime Picture in the Era of Big Data : The Development of the Geospatial Communication Interface+ décrit les défis que pose la collecte de données sur la position des navires pour la surveillance mondiale.^{Note de bas de page 11}

L'Agence spatiale canadienne (ASC) gère les marchés du gouvernement du Canada visant l'obtention de données de suivi maritime mondial depuis l'espace. Chaque jour, elle distribue des millions de messages de positionnement aux partenaires maritimes à l'échelle du gouvernement. Au cours de la dernière décennie, l'ASC a recueilli plus de 50 milliards de messages.

La National Marine Electronics Association (NMEA) met à jour la norme de l'AIS mondiale. Vous trouverez ci-dessous un échantillon de données de l'AIS.

1569890647\s:VENDOR,q:u,c:1569890555*5F\!AIVDM,1,1,,A,13KG9?10031jQUNRI72jM5?40>@<,0*5C
1569890647\s:VENDOR,q:u,c:1569890555*5F\!AIVDM,1,1,,B,13aEPIPP00PE33dMdJNaegw4R>@<,0*77
1569890647\g:1-2-6056,s:VENDOR,c:1569890555*3A\!AIVDM,2,1,6,A,56:GTg0!03408aHj221<QDr1UD4r3?F22222221A:`>966PW0:TBC`6R3mH8,0*0E
1569890647\g:2-2-6056*58\!AIVDM,2,2,6,A,88888888880,2*22

Chaque phrase ci-dessus contient des métadonnées sur le rapport de position. Elles comprennent les éléments suivants :

• Heure à laquelle l'observation a été réalisée par le capteur
• Source de la détection
• Moment où le rapport a été transmis du satellite à une station au sol
• Si la phrase constitue ou non une partie d'un groupe de messages

Bien qu'une partie du message soit lisible par l'homme, les données importantes concernant l'identité et le déplacement du navire sont enveloppées dans une charge utile ASCII à six bits vers la fin de la phrase. Le site Web d'Eric Raymond sur le décodage du protocole AIVDM/AIVDO^{Note de bas de page 12} présente un guide détaillé sur la façon dont les données du navire sont placées dans la chaîne.

Décodage de l'AIS avec une application Rust

L'objectif fixé pour cette application Rust est de convertir une archive de données brutes de l'AIS en un équivalent JSON qui peut être utilisé pour l'analyse des données. Le résultat devrait permettre la préservation des données d'origine pour un nouveau traitement, si nécessaire. Le reformatage des données au format JSON est une étape importante dans le pipeline d'ingénierie des données, car il permet de charger les données dans un cadre de données ou une base de données ou encore de les convertir dans un format optimisé pour la lecture, comme Apache Parquet.

Voici le résultat souhaité lorsque l'on utilise JSON pour mettre en paquets les données et préserver les données d'origine parallèlement aux éléments dérivés.

{
"sentence":"1569888002\\s:VENDOR,q:u,c:1569884202*4F\\!AIVDM,1,1,,B,1:kJS6001UJgA`mV1sFrGHAP0@L;,0*56",
"landfall_time":"1569888002",
"group":"",
"satellite_acquisition_time":"1569884202",
"source":"VENDOR",
"channel":"B",
"raw_payload":"1:kJS6001UJgA`mV1sFrGHAP0@L;",
"message_type":1,
"message_class":"singleline",
"mmsi":"725000984",
"latitude":-45.385661666666664,
"longitude":-73.55857,
"call_sign":"CQ4F3",
"destination":"HALIFAX",
"name":"SS MINNOW",
"ship_type":"23",
"eta":"",
"draught":"",
"imo":"",
"course_over_ground":"86950448",
"position_accuracy":"0",
"speed_over_ground":"101",
"navigation_status":"0"
}

Présentation du programme RUST

Pour extraire des renseignements de données de l'AIS, chaque caractère de la charge utile doit être converti de l'ASCII à six bits en son équivalent binaire. La phrase entière est également fusionnée en une longue chaîne binaire. Les morceaux de chaîne sont reconvertis en chiffres et en texte lisibles par l'homme.

Figure 1 : L'extraction des données de la charge utile nécessite leur conversion en format binaire.

Pour aider à tirer tout le potentiel de calcul possible de la machine hôte, Rust assure un « traitement simultané audacieux ». La charge de travail peut être facilement répartie sur tous les cœurs d'ordinateur disponibles grâce à des canaux de passage de messages transmettant les données entre les fils d'exécution (ou simplement, entre les fils).

Le processus est divisé en trois groupes. Le premier est un processus à un seul fil qui lit un fichier source de données de l'AIS, en insérant chaque ligne dans un champ struct, et transmet ce dernier à un groupe de fils qui effectue l'analyse syntaxique initiale par le biais d'un canal.

Le fil de réception analyse les messages de position de ligne unique et transmet les résultats à un rédacteur de fichiers sous forme de paquet JSON. Les phrases multilignes sont transmises à un second groupe de fils qui met en cache et réassemble les parties de phrases. Là encore, ces résultats sont transmis au rédacteur de fichiers sous forme de chaîne JSON.

Étant donné que le traitement est confié à des fils concomitants, il n'y a aucune garantie d'ordre en sortie. En raison des délais d'attente et des différences quant au temps de traitement, il est possible que l'ordre de sortie de chaque rapport ne soit pas identique à l'ordre d'entrée.

Faits saillants du programme

Figure 2 : Processus du programme

Une expression ordinaire peut être utilisée pour extraire les données lisibles par l'homme dans la phrase de l'AIS, mais un travail supplémentaire doit être effectué pour convertir les données de la charge utile à six bits en une chaîne binaire, prendre des parties du résultat et reconvertir ces parties en texte, en nombres flottants et entiers.

Épinglage Cargo et épinglage de la version

Rust utilise un système de construction bien pensé où les dépendances des paquets et les directives de construction peuvent être indiquées dans un fichier de définition.

[package]
name = "rustaise"
version = "0.1.0"
edition = "2021"

[dependencies]
crossbeam-channel = "0.5.2"
threadpool = "1.8.1"
num_cpus  = "1.13.1"
hashbrown = "0.12.0"
clap = "3.0.7"
regex = "1.5.4"
bitvec = "1.0.0"
serde = { version = "1.0.136", features = ["derive"] }
serde_json = "1.0.78"

[profile.release]
lto = true

Les dépendances appelées « boîtes » peuvent être énumérées avec une version donnée. La mise à niveau vers une version différente de la boîte doit être réalisée explicitement, ce qui réduit les erreurs imputables au passage à des versions différentes de la bibliothèque.

Contrôle étroit de la portée des variables

L'une des méthodes utilisées par Rust pour assurer la sécurité de la mémoire consiste à contrôler étroitement la portée des variables.

// Attribuons 21 à X
let x = 21;
	{
	// Attribuons maintenant 12 à X
	let x =12;
	}
// Puisque le champ d'application a pris fin pour l'affectation précédente
// la valeur de X est toujours 21
println!("{}", x);

L'extrait de code ci-dessus imprimerait le nombre « 21 », car l'affectation « x = 12 » n'est valable qu'entre les accolades.

Bien qu'il s'agisse d'un moyen efficace de garder votre mémoire en ordre, il peut être contre-intuitif. Par exemple, ce qui suit ne fonctionne pas, car la variable -x est tronquée à la fin de la paire d'accolades de blocs jf.

if y == 1 {
    let x = 21;
} else {
    let x = 0;
}
println!("{}", x);

}

Une façon de résoudre ce problème consiste à créer une fonction anonyme dont la sortie est affectée à la variable. Des affectations de variables avec des évaluations imbriquées « if » sont utilisées dans l'ensemble du programme.

let y = 1;
let x = 21;
let x: i8 ={
    if y == 1 {
     67
    }
    else {
    0
    }
};

println!("{}", x);

Le contrôle rigide des durées de vie et de la propriété des variables modifie la façon dont vous structurez votre programme.

Il est inutile de résister

Le compilateur est très bavard et refusera de compiler du code qui transgresse les garde-fous de Rust.

error[E0308]: mismatched types
 --> src/main.rs:8:10
  |
8 |  67.0
  |  ^^^^ expected `i8`, found floating-point number

For more information about this error, try `rustc --explain E0308`.
error: could not compile `playground` due to previous error

Bien que parfois frustrants, les messages du compilateur sont utiles pour déterminer la cause de l'erreur. On voit souvent le mantra « travaillez en collaboration avec le compilateur » dans les commentaires en ligne.

Le logiciel commence par définir une structure qui contiendra les phrases brutes et les données extraites lors des phases de traitement.

#[derive(Serialize, Default, Clone, Debug)]
struct PositionReport {
    pub sentence: String,
    pub landfall_time: String,
    pub group: String,
    pub satellite_acquisition_time: String,
    pub source: String,
    pub channel: String,
    pub raw_payload: String,
    pub message_type: u64,
    pub message_class: String,
    pub mmsi: String,
    pub latitude: f64,
    pub longitude: f64,
    pub call_sign: String,
    pub destination: String,
    pub name: String,
    pub ship_type: String,
    pub eta: String,
    pub draught: String,
    pub imo: String,
    pub course_over_ground: String,
    pub position_accuracy: String,
    pub speed_over_ground: String,
    pub navigation_status: String,
} // fin de struct PositionReport

Notez le mot-clé #Derive qui précède la définition de la structure. Bien que Rust ne soit pas un langage orienté objet comme Java, il permet d'échanger des méthodes entre les structures à l'aide d'une fonctionnalité appelée Traits d'une manière qui « émule » l'héritage.

Dans la déclaration ci-dessus, les traits Serialize, Default, Clone et Debug sont ajoutés à la structure.

Groupes de fils

La définition des groupes de fils est assez simple en Rust. Le programme trouve le nombre de cœurs disponibles et déclare le nombre de processeurs au traval pour chaque fil.

Les boucles for sont utilisées pour lancer des fils individuels.

    // Les travailleurs sont les nombres de processeurs
    let n_workers = num_cpus::get();

    let reading_thread = ThreadPool::new(1);
    let extraction_pool = ThreadPool::new(n_workers);
    let multiline_assembly_thread = ThreadPool::new(n_workers);

    for _a..n_workers: {
    multiline_assembly.execute(move || {
    // Faire des choses
    }
    }

    for _b..n_workers: {
    extraction_pool.execute(move || {
    // Faire des choses
    }
    }

    reading_thread.execute(move || {
    // Faire des choses
    }

Les boucles for contrôlent le nombre de fils lancés, tandis que le mot-clé move transmet les variables actuelles au fil.

Définitions des canaux et contrôle du flux

Les canaux de relais entre les fils sont définis avec une limite pour éviter que les fils producteurs ne surchargent le canal et n'épuisent la mémoire. Par défaut, le programme fixe la borne supérieure à 500 000 éléments, mais elle peut être modifiée depuis la ligne de commande pour s'adapter au mieux à la mémoire disponible.

Chaque déclaration définit un canal d'envoi et de réception, de même que les types de données qui circuleront sur le bus de messages.

let (raw_file_tx, raw_file_rx): (Sender<PositionReport>, Receiver<PositionReport>) = bounded(flow_limit);
let (multiline_handling_tx, multiline_handling_rx): ( Sender<PositionReport>, Receiver<PositionReport>) = bounded(flow_limit);
let (ready_for_output_tx, ready_for_output_rx): (Sender<String>, Receiver<String>) =
bounded(flow_limit);

En raison des règles de Rust sur la réutilisation des variables, le type de données du canal doit être cloné dans chaque fil, mais chaque clone fait en réalité référence à l'instance d'origine du bus de messages.

 extraction_pool.execute(move || {
    let raw_file_rx = raw_file_rx.clone().clone();
    let extract_ready_for_output_tx = extract_ready_for_output_tx.clone();
    let multiline_handling_tx = multiline_handling_tx.clone();
 }

Correspondance des messages

Les types de messages de l'AIS déterminent la manière dont les renseignements relatifs au navire sont stockés dans la charge utile à six bits, de sorte que toute tâche d'analyse syntaxique doit commencer par déterminer le type de la phrase actuelle et l'introduire comme un INT non signé dans le champ struct approprié.

line.message_type = pick_u64(&payload, 0, 6);

À partir de là, le type de message peut être comparé aux modèles d'analyse syntaxique et aux autres champs dans la structure remplie.

match line.message_type {
1 | 2 | 3 => {
// Si le message est de classe A cinétique
line.mmsi = format!("{}", pick_u64(&payload, 8, 30));
line.latitude = pick_i64(&payload, 89, 27) as f64 / 600_000.0;
line.longitude = pick_i64(&payload, 61, 28) as f64 / 600_000.0;
...
}
5 => {
// Si le message est de classe A statique
line.mmsi = format!("{}", pick_u64(&payload, 8, 30));
line.call_sign = pick_string(&payload, 70, 42);
line.name = pick_string(&payload, 112, 120);
...
}

Arc, Mutex et cartes de hachage

L'assemblage de messages multilignes dans des fils multiples nécessite la mise en cache de parties de phrases pour pouvoir les transmettre. Ce programme utilise une carte de hachage commune enveloppée dans un mutex pour contenir des parties de phrases.

// Initialiser les cartes de hachage pour les messages AIS multi-phrases
// Ceux-ci sont développés par des ARC et des Mutex pour une utilisation en filetage multiple
let mut payload_cache: Arc<Mutex<HashMap<String, String>>> =
Arc::new(Mutex::new(HashMap::new()));
let mut source_cache: Arc<Mutex<HashMap<String, String>>> =
Arc::new(Mutex::new(HashMap::new()));
let mut sat_time_cache: Arc<Mutex<HashMap<String, String>>> =
Arc::new(Mutex::new(HashMap::new()));

À l'instar des canaux interprocessus, les cartes de hachage doivent être clonées dans chaque instance de fil.

// Initialiser les cartes de hachage pour les messages AIS multi-phrases
let payload_cache = Arc::clone(&mut payload_cache);
let source_cache = Arc::clone(&mut source_cache);
let sat_time_cache = Arc::clone(&mut sat_time_cache);

Chaque carte de hachage doit disposer d'un verrou défini dans chaque fil pour harmoniser les lectures et effectuer des suppressions à partir de plusieurs fils.

    let mut payload_lock = payload_cache.lock().unwrap();
    let mut source_lock = source_cache.lock().unwrap();
    let mut sat_time_lock = sat_time_cache.lock().unwrap();

    // insérer dans le cache temporel si le champ struct n'est pas vide
    if line.satellite_acquisition_time.len() > 0 {
    sat_time_lock.insert(line.group.clone(), line.satellite_acquisition_time);
    }

Sérialisation JSON

Le cadre SERDE permet de sérialiser une structure en une chaîne JSON. À la fin du cycle d'analyse syntaxique, chaque fil convertit la structure remplie en une chaîne JSON pour l'écrire dans un fichier.

ready_for_output_tx.send(serde_json::to_string(&line).unwrap());

Le résultat du programme peut être chargé dans le logiciel Pandas avec la commande suivante :

import pandas as pd
df=pd.read_json("output.json", lines=True)

Il peut également être converti en un fichier Parquet compressé en utilisant le programme json2parquet de Dominik Moritz.

json2parquet -c brotli norway.json norway.parquet

Exécution du programme

L'exécution du programme sans paramètres produira le résultat suivant :

error: The following required arguments were not provided:
		<INPUT>
		<OUTPUT>

    USAGE:
		rustaise <INPUT> <OUTPUT> [FLOW_LIMIT]
	For more information try --help
	With the --help flag.

    AIS parsing program 1.0
	Scott Syms <ezrapound1967@gmail.com>
	Does selective parsing of a raw AIS stream

	USAGE:
	rustaise <INPUT> <OUTPUT> [ARGS]
	ARGS:
		<INPUT>    Sets the input file to use
		<OUTPUT>   Sets a custom output file
		<FLOW_LIMIT>   Sets a limit on the number of objects in memory at one time (default: 500000)
		<PARSE_THREADS>    Sets the number of threads to use for parsing (default: number of CPUs)
		<MULTILINE_THREADS>    Sets the number of threads to use for multiline parsing (default: number of CPUs)
  	OPTIONS:
		-h, --help   Print help information
		-V, --version    Print version information

En décompressant le programme norway.7z et en exécutant ce qui suit, on obtient un fichier JSON dont le contenu est analysé syntaxiquement.

rustaise norway.nmea norway.json

Le paramètre FLOW LIMIT vous permet de limiter les données contenues dans les canaux de messages. Dans certains systèmes soumis à des contraintes de mémoire, le plafonnement des messages en cours permet d'éviter les problèmes de mémoire insuffisante. Les paramètres PARSE_THREADS et MULTILINE_THREADS sont des paramètres facultatifs qui permettent de contrôler le nombre de fils créés pour les fils d'analyse syntaxique à une ou plusieurs lignes.

Vitesse d'exécution

Rust est à la hauteur de sa réputation en tant que langage incroyablement rapide.

Les résultats d'exécution dans le tableau de temps ci-dessous sont obtenus à partir d'un MacBook doté d'un processeur 8 cœurs Intel Core i9 à 2,3 GHz avec 32 Go de mémoire. La rangée du tableau indique le nombre de lignes du fichier d'entrée. La première colonne indique le temps nécessaire pour traiter l'échantillon, et la dernière colonne annonce le volume de données pouvant être traitées en une journée au taux d'échantillonnage.

D'après ces chiffres, le logiciel serait capable de traiter une archive de l'AIS de 50 milliards de lignes en un peu moins de deux jours, sur un seul ordinateur portatif.

Dernières réflexions

Il s'agit de ma première tentative de programmation sérieuse en Rust et, même du point de vue d'un novice, il est possible de faire mieux.

• D'abord, comme j'ai une connaissance imparfaite du langage, la solution peut ne pas être idiomatique (c.-à-d. faire un usage optimum de ce que Rust offre pour résoudre le problème).
• Le programme ignore largement le cadre de gestion des erreurs de Rust. L'initialisation de la structure avec des valeurs par défaut peut consommer inutilement de la mémoire. L'utilisation des méthodes struct et des traits personnalisés peut présenter certains avantages.
• La refactorisation du code dans le format de bibliothèque et de module de Rust permettrait de rendre le code plus lisible.
• Enfin, Rust offre un cadre de test unitaire qui simplifierait la mise à jour du code.

Le « jeu en vaut généralement la chandelle » ici. Même avec les inconvénients du code, Rust fonctionne comme annoncé, et il vaut la peine d'apprendre le langage dans les situations où le code sera réutilisé ou lorsque le temps d'exécution posera problème.

Par ailleurs, les développeurs qui souhaitent tirer parti du rendement de Rust tout en demeurant dans l'écosystème Python pourraient utiliser le projet PyO3^{Note de bas de page 13} pour créer des extensions Python natives en Rust.

Obtenir le code

Tout le code est disponible à Github - ScottSyms/RustAISe (le contenu de cette page est en anglais).

N'hésitez pas à utiliser ce site Web. Merci de bien vouloir me faire part de vos commentaires.

Licences

Le logiciel est distribué sous une licence Apache 2.0.

L'archive comprend un échantillon compressé en sept fichiers .zip de données de l'AIS provenant du gouvernement norvégien. Il est distribué sous la licence Norwegian License for Open Government Data (NLOD) 2.0.^{Note de bas de page 14}

Une partie du code de manipulation bitvec est tirée du paquet nmea-parser de Timo Saarinen,^{Note de bas de page 15} qui est fourni sous une licence Apache 2.0.

Scott Syms est conseiller technique en matière de science des données et d'intelligence artificielle, et relève de la Direction générale du dirigeant principal de la technologie de SPC.

Par : Nicholas Denis, Statistique Canada

Les sujets du mois :

• Générer des images réalistes à partir de textes
• Fait de la place pour la réduction des dimensions
• Les machines apprennent à coder !

Générer des images réalistes à partir de textes

Les chercheurs génèrent des images photo réalistes à partir de textes provenant d'utilisateurs à l'aide d'un modèle de 3,5 milliards de paramètres.

Quoi de neuf? : OpenAI a tiré parti du succès récent de son modèle populaire CLIP (Contrastive Language-Image Pre-training) pour entraîner un modèle de diffusion gaussien capable de générer des images réalistes et nuancées à partir d'un texte décrivant l'image à générer. Le modèle GLIDE (Guided Language to Image Diffusion for generation and Editing), est accessible via Google CoLab.

Comment ça fonctionne : À partir d'une entrée de texte et d'un vecteur de bruit initialement échantillonné de façon aléatoire, $x0$, le modèle est capable de « dé-bruiter » séquentiellement l'échantillon à l'étape $t \left(xt\right)$, conditionné par le texte en entrée et l'échantillon dé-bruité à l'étape précédente $(xt-1)$. L'image finale dé-bruitée, $xT$, est l'image générée finale qui tente de capturer la sémantique du texte fourni par l'utilisateur.

Pourquoi cela fonctionne-t-il ? : Les modèles de diffusion gaussiens sont des processus de bruit additif qui commencent avec une image et produisent une chaîne de Markov d'images de plus en plus bruyantes, où l'image au temps t,

$q\left(x_t\right|x_{t-1})=\aleph (xt; \surd {\alpha }_t{x}_{t-1},(1-{\alpha }_t)I)$

c'est-à-dire que la distribution des images suivantes, conditionnellement à l'image précédente, est normalement distribuée, où ${\alpha }_t$ est un paramètre de bruit. Le résultat final est une image totalement aléatoire. Sous des conditions modérées, la postérieure $q\left(x_{t-1}\right| x_t)$ est bien définie, et peut donc être approximée avec des réseaux de neurones profonds. Brièvement,

• Le processus inverse représente une manière de supprimer séquentiellement le bruit d'une image, pour arriver à une image photo réaliste et naturelle.
• En partant d'une image naturelle et en y ajoutant un bruit gaussien, ils sont capables d'entraîner un modèle pour estimer le bruit ajouté.
• Les auteurs utilisent d'autres techniques et astuces provenant de diffusion guidée en utilisant la sémantique du texte d'un modèle CLIP.

Résultats : L'évaluation quantitative des modèles génératifs est difficile et reste un problème ouvert. Cependant, la recherche inclut des mesures de performance de pointe. Sur le plan qualitatif, le modèle est capable de produire des images incroyablement nuancées et spécifiques, comme "un dessin au crayon d'un ascenseur spatial" et "un vitrail d'un panda mangeant du bambou". En outre, les auteurs ont demandé à des évaluateurs humains d'examiner les images générées par GLIDE et par d'autres modèles génératifs de pointe. Les humains ont jugé que les images produites par GLIDE étaient plus réalistes que les autres modèles dans 66% à 91% des cas.

Mais... : Il est courant dans les publications sur les modèles génératifs que les auteurs sélectionnent les meilleures données générées à présenter, mais il est également fréquent que les auteurs incluent aussi un échantillon suffisamment grand d'instances sélectionnées au hasard. Cet article aurait pu inclure une galerie beaucoup plus grande d'images sélectionnées au hasard à partager. De plus, le modèle compte 3,5 milliards de paramètres et nécessite un temps considérable (20 secondes) pour générer une seule image, ce qui rend cette approche peu susceptible d'être déployée à grande échelle.

Notre avis : Les modèles génératifs sont de plus en plus puissants et produisent des images de haute qualité qui trompent les humains quant à leur authenticité, et leur qualité ne fera qu'augmenter avec le temps. Voyez si vous pouvez voir la différence ici : which face is real (le contenu de cette page est en anglais). Avec des techniques telles que GLIDE qui peuvent prendre des données et des instructions spécifiques de l'humain pour produire des images arbitraires de haute qualité (et bientôt des vidéos), les questions juridiques, éthiques et de nature probatoire devront être abordées immédiatement.

Tasse-toi l'analyse en composantes principales, fait de la place pour l'apprentissage de la réduction des dimensions

TLDR (Twin Learning for Dimensionality Reduction (le contenu de cette page est en anglais)) bat l'analyse en composantes principales (ACP) dans les cas de dimensions de petites et moyennes tailles (8 à 128 dimensions).

Quoi de neuf : Naver Labs a publié TLDR, une technique générale qui utilise un codeur de réduction de dimensionnalité linéaire d'une manière qui pousse les voisins les plus proches dans l'espace d'entrée à être similaires dans l'espace plus petit de représentation.

Comment ça fonctionne ?:

• Pendant l'entraînement, une instance de données particulière dans un des espaces d'entrée de haute dimension est échantillonné et on calcule quels sont ses k voisins les plus proches.
• Une matrice de représentation linéaire fait correspondre l'instance de données et ses voisins à l'espace de dimension inférieure par le biais de la matrice de représentation.
• Les représentations de dimension inférieure sont projetées (via un réseau de projecteurs) dans un espace de dimension beaucoup plus élevée où leur matrice de corrélation croisée est calculée.
• La fonction de perte Barlow Twins récemment proposée est utilisée, ce qui pousse la matrice de corrélation croisée à devenir la matrice d'identité.
• Après l'entraînement, le réseau de projecteurs est éliminé et l'encodeur linéaire est utilisé pour réduire la dimensionnalité.

Pourquoi cela fonctionne-t-il?

• La fonction de perte de Barlow Twins est minimisée lorsque la matrice de corrélation croisée entre les vecteurs est la matrice d'identité. Cela équivaut à une représentation factorisée, où chaque dimension des données est complètement indépendante.
• En minimisant la corrélation croisée entre les dimensions, l'information redondante codée est minimisée, ce qui est une propriété souhaitable pour la réduction de la dimensionnalité.
• En calculant cette perte sur des paires d'entrées qui sont des voisins proches dans l'espace d'entrée, la fonction de représentation linéaire apprend quelque chose de similaire à l'apprentissage des manifolds (voir: Manifold Learning – le contenu de cette page est seulement en anglais), où les points localement proches sont invariants (similaires) dans l'espace de représentation de dimension inférieure.

Résultats : Les auteurs se concentrent sur les tâches de récupération. Étant donné une image ou un document texte en entrée, la tâche de récupération essaie de trouver l'instance ou les instances les plus similaires au texte d'entrée dans un ensemble de données particulier. Notez que pour les images, TLDR a été appliqué aux sorties produites par un modèle de vision pré-entraîné, et pour le texte, TLDR a été appliqué aux sorties produites par un modèle de langage BERT pré-entraîné.

• Sur les ensembles de données de récupération d'images, TLDR a amélioré l'ACP en termes de précision moyenne de 6 à 10%, à travers différentes dimensions de sortie.
• Sur des tâches de récupération test, TLDR a amélioré l'ACP en termes de score de rappel jusqu'à 27%, avec une amélioration de plus en plus spectaculaire à mesure que la taille de la dimension de sortie diminue.
• Comparé à d'autres techniques de réduction de la dimensionnalité, y compris les techniques basées sur les collecteurs, TLDR a constamment surpassé toutes les autres approches pour les dimensions de sortie de huit et plus, mais a été moins performant pour les dimensions de tailles deux et quatre.

Notre avis : Les techniques de réduction de la dimensionnalité sont généralement discutées dans le contexte des ensembles de données tabulaires et pour l'utilisation des techniques classiques d'apprentissage automatique, mais elles ne sont souvent pas utiles pour les données à très haute dimension, comme les images et le texte. TLDR est une technique générale de réduction linéaire de la dimensionnalité qui peut être appliquée à des données tabulaires ou complexes. Cette technique pourrait être utile pour des tâches telles que :

• Tâches de récupération
• Stratégies de sélection d'étiquettes dans l'apprentissage actif
• Exploration des groupements (clustering) et des données
• Utilisation pour des modèles d'apprentissage automatique explicables

Aidez-nous ! Les machines apprennent à coder !

Google DeepMind présente AlphaCode, qui obtient des résultats supérieurs au 50e percentile dans les compétitions de codage.

Quoi de neuf : DeepMind a construit un nouveau jeu de données de programmation compétitive utilisé pour entraîner un modèle de 41 milliards de paramètres qui peut prendre une description textuelle en langage naturel d'un défi de codage (voir figure ci-dessus) et produire un code fonctionnel pour résoudre le défi. C'est de la folie !

Comment ça fonctionne : Les compétitions de codage sont assez courantes. DeepMind a construit plusieurs ensembles de données pour former de manière itérative un réseau neuronal profond capable de prendre un texte en langage naturel décrivant un défi de programmation, comme illustré ci-dessus, et de produire du code, caractère par caractère. Pour ce faire, ils ont d'abord échantillonné un grand nombre de solutions potentielles, puis ils ont procédé à un filtrage et à un regroupement pour éliminer les solutions candidates faibles. Enfin, 10 solutions diverses ont été soumises à un concours réel. Nous détaillons ci-dessous quelques étapes importantes :

• Ils ont construit un ensemble de données de pré-entraînement basé sur un instantané public des dépôts GitHub utilisant le code de 12 langages de programmation populaires, ce qui représente 715 Go de données.
• Ils utilisent un modèle de transformateurs à 41 milliards de paramètres avec une architecture d'encodeur et de décodeur, qui, étant donné une séquence de texte, produira une séquence de texte.
• Le pré-entraînement du modèle consiste à prédire le prochain token (caractère/mot dans le code) en fonction de l'entrée et de la sortie produites jusqu'à présent.
• Une perte standard de modèle de langage masqué (comme dans BERT) a été utilisée, où, étant donné une séquence d'entrées (description du problème en langage naturel), 15% du texte est effacé de manière aléatoire et le modèle doit déduire le texte manquant.
• Le modèle pré-entraîné est affiné sur leur ensemble de données de programmation compétitive. Des objectifs d'entraînement similaires à ceux du pré-entraînement sont utilisés ici.
• Leur modèle est capable d'échantillonner des millions de solutions possibles pour chaque défi soumis en entrée.
• L'apprentissage par renforcement a été utilisé pour augmenter la diversité des solutions échantillonnées par le modèle.
• Étant donné que seules 10 solutions peuvent être soumises par défi, les auteurs filtrent leurs millions de solutions potentielles à travers un certain nombre de tests, fournis dans chaque défi, puis regroupent leurs solutions en fonction du comportement du programme. Une solution parmi les 10 plus grandes grappes a été échantillonnée et soumise comme solution au défi.

Résultats : Le modèle a été appliqué à 10 défis de codage distincts.

• Les auteurs ont constaté que lorsqu'ils échantillonnent 1 million de solutions possibles et soumettent les 10 (estimées comme étant les) meilleures, le code résout avec succès le défi de codage dans plus de 30 % des cas. De plus, le taux de réussite évolue positivement en fonction du nombre de solutions échantillonnées produites ainsi que de la taille du modèle. De plus, les performances en fonction du temps d'entraînement du modèle sont linéaires et aucun plateau n'a été observé, ce qui signifie que si l'entraînement était plus long, le modèle serait plus performant.
• Les auteurs estiment que le modèle, en moyenne, s'est classé dans le 54e percentile supérieur des solutions aux problèmes à coder, juste au-dessus du programmeur médian.

Quel est le contexte? : Bien que cette tâche soit incroyablement difficile et qu'il soit tout simplement stupéfiant qu'un modèle puisse résoudre ne serait-ce qu'une seule tâche, ces résultats ne devraient pas être une surprise. Copilot de Github peut suggérer automatiquement des lignes ou même des fonctions complètes de code. Copilot est construit par OpenAI, qui réalise de nombreux travaux similaires à ceux de cet article. Tout le monde peut utiliser ce service, dès aujourd'hui.

Tout comme certains craignent que la science des données et l'apprentissage automatique n'entraînent l'automatisation des emplois, le code généré automatiquement et l'AutoML pourraient faire craindre aux scientifiques des données eux-mêmes d'être éliminés par l'automatisation !

Notre avis : Il semble que ce n'était qu'hier que le monde s'émerveillait de la capacité des modèles d'AA à déduire la présence d'objets tels que des chats et des chiens dans une image donnée. Aujourd'hui, nous assistons à l'avancée continue de modèles d'AA capables d'extraire et d'abstraire un contenu sémantique incroyablement complexe de longs blocs de texte décrivant des tâches compliquées, puis de produire une syntaxe longue et spécifiquement structurée qui est un code de programmation fonctionnel résolvant la tâche donnée.

Bien que les résultats soient prometteurs et puissent encore être améliorés, ce domaine n'en est qu'à ses débuts et on peut certainement s'attendre à ce que les résultats s'améliorent. Les préoccupations éthiques entrent alors en jeu à différents niveaux. D'une part, quelle est la responsabilité d'un développeur, qui utilise cette technologie pour écrire un code qu'il est incapable de construire lui-même ? Un tel développeur peut-il être en mesure de déboguer ou de s'assurer que le code fait bien ce qu'il est censé faire ?

1	1=int(input( ) )
2	for i in range(t):
3		s=input( )
4		t=input( )
5		a=[ ]
6		b=[ ]
7		for j in s:
8			a.append(j)
9		for j in t:
10			b.append(j)
11		a.reverse( )
12		b.reverse( )
13		c=[ ]
14		while len(b) !=0 and len(a) !=0
15			if a [0]==b[0]:
16				c.append(b.pop(0))
17				a.pop(0)
18		elif a[0] !=b[0] and len (a) !=1:
19			a.pop(0)
20			a.pop(0)
21		elif a[0] !=b[0] and len(a) ==1:
22			a.pop(0)
23		if len (b) ==0:
24			print ("YES")
25		else:
26			print ("NO")