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")
 

Par : Nikhil Widhani, Statistique Canada

Du fait des progrès technologiques considérables, de nombreux outils et techniques utilisés au sein de la communauté de la science des données effectuent une lente transition vers la source ouverte. Les outils en source ouverte sont des solutions sans frais dont le code base peut être modifié pour l'adapter aux besoins de l'utilisateur, lui fournissant ainsi souplesse et réduction des coûts. Des outils exclusifs permettent généralement de faire le travail de façon efficace, mais ils peuvent être coûteux et doivent toujours être adaptés aux besoins de l'organisation. Les outils exclusifs manquent souvent d'options de personnalisation et ne résolvent parfois qu'une partie d'un problème. Dans le cas d'enjeux plus complexes, comme créer une collection de microservices relatifs à diverses tâches, il peut être nécessaire d'utiliser simultanément plusieurs outils exclusifs.

Les outils en source ouverte, donnant à l'utilisateur un contrôle total du code base, permettent aux organisations d'appliquer des correctifs de sécurité en cas de nouvelles menaces et de maintenir la protection des renseignements personnels et la confidentialité des données. De nombreux projets en source ouverte peuvent être combinés pour former une solution centrale répondant à une exigence plus vaste.

Prenons l'exemple d'un projet permettant de créer un pipeline sécurisé pour l'ingestion de données. Des modules séparés de ce processus pourraient inclure d'extraire régulièrement de nouvelles données obtenues de manière éthique, d'exécuter des algorithmes d'apprentissage automatique responsables aux moments opportuns et de créer un tableau de bord permettant la visualisation des données. Dans le présent article, je vais expliquer le processus d'utilisation d'un cadre de travail Web Django, afin de créer une application Web tout-en-un prête pour la production fournissant de l'information, tout en protégeant les renseignements personnels et la confidentialité des données qu'elle utilise. Cette solution particulière a recours à un tableau de bord pour les clients et à une interface utilisateur graphique (IUG) pour les développeurs. L'IUG d'administration peut servir à exécuter régulièrement des tâches planifiées afin d'extraire de nouvelles données et d'exécuter un pipeline d'un clic de bouton.

Django est un cadre de travail Web en source ouverte fondé sur le langage de programmation Python et est utilisé par des firmes multinationales. Sa conception de base offre souplesse, sécurité^{Note de bas de page 1} et évolutivité. Les applications développées avec Django peuvent être réutilisées pour d'autres projets sans devoir récrire le code. Parfois, il suffit de copier le code d'un projet à un autre. Pour créer ce type d'application Web, nous allons utiliser la trousse à outils Django et des modules externes, afin de développer une architecture souple, tout en gardant l'évolutivité à l'esprit. L'architecture proposée est représentée à la figure 1.

Figure 1 : Architecture proposée pour créer une application Web tout-en-un.

Composantes

Les composantes de l'architecture et ses fonctions sont la base de données, l'application dorsale, le pipeline, le planificateur de tâches et l'interface de programmation REST. Je vais détailler chacune de ces composantes.

Base de données

Une base de données recueille et stocke des données. Il s'agit de la composante principale d'un projet, puisque toutes les parties d'un projet sont liées aux données. Les bases de données peuvent être classées comme étant relationnelles et non relationnelles. Les bases de données relationnelles peuvent stocker des données de façon structurée dans des tableaux et permettre des relations avec d'autres tableaux. Par défaut, Django prend en charge des bases de données relationnelles, comme PostgreSQL (langage de requête structuré), SQLite et MySQL. Le choix dépend du type de projet; PostgreSQL pouvant être plus adapté à des projets de plus grande envergure, alors que SQLite peut être plus adapté à des projets moins importants, comme ceux comprenant moins de 100 000 lignes. MySQL est généralement utilisé lorsque les capacités de PostgreSQL, comme le soutien pour des données géospatiales ou des types de données avancées, ne sont pas nécessaires. Les bases de données non relationnelles n'utilisent pas le format d'un schéma tabulaire pour stocker les données. Elles ont plutôt recours à des modèles d'objets propres au type de données stockées. Elastic Search consiste en une base de données moderne axée sur les documents couramment utilisée pour effectuer des recherches rapides dans des millions de documents. Elastic Search pourrait être utilisée lorsque l'utilisateur doit stocker un volume important de données et de requêtes devant être exécutées en temps réel. Dans le présent projet, je vais utiliser SQLite qui est adaptée à la taille de la tâche.

Application dorsale

L'application dorsale effectue la majorité du travail. Utiliser Django comme cadre d'application dorsale facilite le travail en bénéficiant des améliorations apportées au cours des 15 ans de développement constant depuis sa parution le 21 juillet 2005.^{Note de bas de page 2} Les utilisateurs de Django peuvent également tirer profit d'une vaste communauté en ligne. De nombreux progiciels tiers sont en outre disponibles pour répondre à une variété de tâches. Dans les sections suivantes, je vais présenter les progiciels et trousses d'outils utilisés pour créer une application Web tout-en-un pour la science des données.

Pipeline

Dans le domaine de la science des données, un pipeline est un ensemble de codes ou de processus qui convertit des données brutes en données utilisables. Les pipelines peuvent parfois servir à extraire et à structurer des données à partir d'un format brut, alors que dans d'autres cas, ils peuvent utiliser des modèles d'apprentissage automatique afin d'extraire de l'information précieuse à partir des données. Il existe de nombreux cas d'utilisation de pipelines, mais la sélection d'un pipeline dépend des exigences du projet. Souvent, les projets de science des données font intervenir un ensemble de codes Python pouvant être exécutés pour effectuer certaines des opérations.

Planificateur de tâches

Un planificateur de tâches sert à effectuer des tâches asynchrones exécutées en arrière-plan sans interrompre d'autres processus de l'application. Pour des tâches chronophages comme le traitement de pipeline de données, on préfère souvent gérer ces tâches en arrière-plan grâce à des fils d'exécution, sans bloquer le flux normal de requêtes-réponses.^{Note de bas de page 3} Si votre application Web nécessite, par exemple, que vous téléversiez un document PDF numérisé à prétraiter avant d'invoquer un module d'extraction, l'utilisateur verra une page de chargement jusqu'à ce que le fichier soit traité. Parfois, la page de chargement peut s'afficher plus longtemps que prévu; un message d'erreur de dépassement de délai d'inactivité est alors reçu. Cette erreur se produit, car les navigateurs et les requêtes Web ne sont pas conçus pour attendre interminablement qu'une page se charge. Cela peut être résolu en prétraitant les données du PDF en arrière-plan et en envoyant un avis à l'utilisateur une fois le traitement terminé. Les planificateurs de tâches sont une manière pratique de résoudre ce comportement.

Par défaut, Django ne prend pas en charge la planification de tâches; toutefois, des applications Django tierces, comme Django-Celery,^{Note de bas de page 4} peuvent intégrer des files d'attente de tâches asynchrones. Ce progiciel peut être installé avec une commande pip install Django-Celery. Une documentation complète est disponible pour la bibliothèque et peut être consultée en cas de besoin. Un serveur d'agents comme Redis est nécessaire pour faciliter la communication entre le planificateur de tâches et l'application dorsale. Redis stocke les messages que produit l'application de file d'attente de tâches Celery décrivant le travail à faire. Redis sert également à stocker les résultats des listes d'attente de Celery, qui peuvent alors être extraits du système frontal pour présenter l'état de la progression à l'utilisateur. Django-Celery peut prendre en charge certains des cas d'utilisation suivants :

• exécuter des tâches cron d'extraction de données planifiées, afin de mettre ces nouvelles données à jour dans la base de données (p. ex. extraction de nouvelles données tous les jours à 4h00);
• nettoyage et restructuration des données;
• exécution de modèles d'apprentissage automatique dès que de nouvelles données sont ingérées;
• mise à jour de la base de données et application des modifications au tableau de bord.

Figure 2: Déroulement du processus d'un planificateur de taches.

Figure 3 : Interface utilisateur du planificateur de tâches

Exécuter ainsi un pipeline permet une meilleure utilisation des ressources; l'exécution des tâches de pipeline pouvant être planifiées la nuit, lorsqu'un moins grand nombre d'utilisateurs utilisent l'application. Séparer les tâches de production et les tâches de développement permet également un développement plus efficace. Toutes les parties distinctes du projet peuvent être combinées en une seule application prête pour la production. Enfin, exécuter le pipeline peut fournir aux utilisateurs un contrôle supplémentaire sur le produit, puisqu'ils peuvent facilement exécuter le pipeline comme ils le souhaitent.

Interfaces de programmation REST

Les interfaces de programmation (IPA) sont des microservices simplifiant le développement de logiciels. Elles sont souvent utilisées pour séparer des fonctions distinctes d'une application en services Web de moindre envergure. Lors de la recherche d'une adresse à l'aide d'un code postal, par exemple, une IPA REST de recherche d'adresses retournera toutes les adresses de voirie au sein de la zone du code postal. La réponse est souvent fournie au format JSON (notation d'objet JavaScript), une norme de l'industrie comprise par de nombreuses applications et de nombreux langages de programmation. Une IPA REST prend en charge de multiples méthodes; les plus courantes étant GET, POST, DELETE et UPDATE. Chaque méthode sépare la logique et permet de structurer le code. Ces méthodes s'expliquent d'elles-mêmes et sont respectivement responsables d'obtenir, d'ajouter ou de publier de nouvelles données, de supprimer et de mettre à jour des données. Utiliser des IPA REST dans des applications Web agit comme un intergiciel entre une base de données et un système frontal, protégeant la base de données de vulnérabilités en matière de sécurité.

Dans Django, il est possible de créer des IPA avec une simple réponse HTTP JSON. Toutefois, une trousse d'outils en source ouverte dédiée appelée Django-rest-framework permet de créer des IPA.^{Note de bas de page 5} Les avantages d'utiliser le cadre Django REST incluent, entre autres, les suivants :

• une IPA prête à utiliser pouvant être recherchée en ligne;
• des politiques intégrées d'authentification en matière de sécurité des données;
• des convertisseurs préconçus pouvant facilement convertir un objet Python en objet JSON;
• une documentation complète, personnalisable et prise en charge par divers autres modules Django externes.

Pour des cas d'utilisation similaires à ce qui est présenté dans cet article, le cadre Django REST peut être utilisé pour créer des IPA de données et d'extraction de tâches et de progression de pipeline lors d'une exécution en arrière-plan. Ces données peuvent être intégrées au système frontal pour indiquer la progression comme l'illustre la figure 4.

Figure 4 : Traitement des fichiers PDF

Sécurité

Il conviendrait de toujours considérer la sécurité lors de l'examen des options de cadre de travail. Dans le présent article, je mentionne le cadre Python de Django et certains de ses progiciels. Django est un cadre présentant de nombreuses fonctionnalités de sécurité. Il prend en charge le déploiement derrière des sites https et chiffrés à l'aide de SSL (couche de sockets sécurisée). Django ORM (mise en correspondance relationnelle d'objets) protège également contre des requêtes SQL de type injection, avec lesquelles des utilisateurs peuvent exécuter du code SQL indésirable dans la base de données. Il authentifie également des adresses Web au moyen d'une valeur « ALLOWED_HOSTS » (hôtes autorisés) dans le fichier de paramètres, qui comprend le nom d'hôte de la page Web. Ce paramètre évite des attaques « cross-site scripting » (injection de contenu) avec lesquelles des noms d'hôte fictifs peuvent être utilisés.

À Statistique Canada, bon nombre des applications Web Python sont déployées dans l'Espace de travail d'analyse avancée qui respecte les lignes directrices de StatCan en matière de sécurité, de protection des renseignements personnels et de confidentialité. Des éléments standard de protection de réseau, comme des pare-feu, la gestion du trafic, des droits d'utilisateur réduits pour le code de l'application et la séparation des préoccupations, servent tous à réduire la surface d'attaque générale pour tout vecteur potentiel. De plus, RBAC (contrôle de l'accès fondé sur le rôle) sert à limiter l'accès au tableau de bord, évitant que des utilisateurs indésirables accèdent aux applications. Diverses méthodes d'analyse et de détection des vulnérabilités permettent également de veiller au maintien de l'activité des applications sécurisées.

Conclusion

Dans le présent article, nous avons traité d'une possibilité de création d'application Web pouvant servir à exécuter automatiquement un pipeline, ainsi que de la composante de tableau de bord pour les clients. Nous avons également discuté de techniques et d'outils modernes pouvant être utilisés avec la programmation Python pour atteindre des résultats.

La composante frontale peut être créée à l'aide de Django et d'une combinaison de langages, tels que HTML (langage de balisage hypertexte), JavaScript et CSS (feuilles de style en cascade). D'autres cadres, comme React, peuvent également être utilisés. Ce type de système dorsal peut également être intégré à Microsoft PowerBI, à l'aide d'une IPA. Même si la création du système frontal est hautement subjective, utiliser des modèles Django pour le système frontal est utile, car il peut servir à créer une application Web tout-en-un. Dans ce cadre de travail, les possibilités sont infinies. L'architecture aide principalement à réduire le codage, les ressources et la maintenance, et facilite la création d'applications réutilisables pour des projets similaires. Elle consiste en de nombreuses composantes non isolées pouvant être réutilisées pour d'autres applications à l'aide d'une architecture de microservices.

L'article du Réseau de la science des données intitulé Déploiement de votre projet d'apprentissage automatique en tant que service développe plus en détail les pratiques mentionnées propres au développement de projets. Les techniques et concepts décrits dans le présent article sont également utiles aux diverses étapes du développement de projet et pourraient être intégrés lors du déploiement d'applications. Des liens vers la plupart des ressources figurent dans les références.

Pour de plus amples renseignements, veuillez communiquer avec nous à l'adresse statcan.datascience-sciencedesdonnees.statcan@statcan.gc.ca.

Répondez à notre bref sondage de 2 minutes

Nous avons besoin de votre aide pour améliorer le Réseau de la science des données. Merci de consacrer 2 minutes à répondre à quelques questions rapides. Vos commentaires sont bienvenus et précieux. C'est votre dernière chance de répondre au Sondage sur le bulletin d'information du Réseau de la science des données. Nous remercions ceux et celles qui y ont déjà répondu!

Par : Sayema Mashhadi, Statistique Canada

La reconnaissance optique de caractères (ROC) est utilisée pour saisir du texte à partir de photos contenant certains renseignements textuels, ainsi qu'à partir de documents numérisés, tels que des formulaires, des factures ou des rapports. Le texte peut être composé de toute combinaison de caractères imprimés ou manuscrits et peut comprendre des symboles, des chiffres, des signes de ponctuation, etc. Il existe de nombreux outils de ROC de source libre dans divers langages de programmation qui peuvent être utilisés sans aucune formation préalable en données ou en apprentissage automatique. Cet article compare deux outils de ROC de source libre couramment utilisés pour reconnaître les textes imprimés dans les projets d'extraction d'information de la Division de la science des données de Statistique Canada : Tesseract, le moteur de ROC de Google (le contenu de cette page est en anglais), et CRAFT, l'outil de ROC de Clova AI (le contenu de cette page est en anglais). Tesseract a été développé par Hewlett-Packard (HP) dans les années 1980 en tant que logiciel propriétaire, puis rendu ouvert en 2005. Depuis, Google a continué à le développer et publie des versions améliorées gratuites à quelques années d'intervalles. Grâce aux mises à jour régulières et majeures du code source, Tesseract est très populaire dans la communauté de source libre. CRAFT est un outil de ROC de pointe destiné à la détection de texte de scène (images avec des zones de texte à différents angles dans un arrière-plan complexe) avec le score le plus élevé de moyenne harmonique (le contenu de cette page est en anglais) sur de multiples ensembles de données publiques par rapport à d'autres outils de source libre de ROC utilisés pour la détection de texte de scène. Pour voir d'autres scores de moyenne harmonique, visitez le site Character Region Awareness for Text Detection (le contenu de cette page est en anglais).

Motivation

L'extraction d'information est le processus qui consiste à extraire des informations structurées utiles à partir de données non structurées sous forme de fichiers texte, d'images, de vidéos, de clips audio, etc. L'information extraite est utilisée pour préparer les données à une analyse. Habituellement, l'information provenant de données non structurées est obtenue en la parcourant manuellement, ce qui prend du temps et est susceptible d'entraîner des erreurs. Les outils d'extraction d'information permettent de réduire les efforts manuels, de gagner du temps et de réduire le risque d'erreurs humaines.

Les outils de ROC sont nécessaires pour l'extraction d'information lorsqu'on traite des images ou des documents numérisés. Dans le cadre de projets antérieurs, nous avons travaillé avec des images numérisées de produits de santé naturels, des formulaires numérisés et des états financiers numérisés qui nécessitent, entre autres, la détection et la reconnaissance de texte dans le but de convertir des données non structurées en données structurées utilisables. Pour en savoir plus sur l'un de nos projets concernant l'intelligence documentaire, consultez notre récent article du Réseau de la science des données Intelligence documentaire : L'art de l'extraction d'information à partir des PDF.

Qualité de l'image

La performance de la ROC, quel que soit l'algorithme ou la technologie exploitée, dépend fortement de la qualité de l'image. Si la qualité de l'image est nette et claire pour l'œil humain, un outil de ROC a plus de chances de convertir l'image en une chaîne de texte avec une grande précision. D'autre part, des images de mauvaise qualité peuvent rapidement dégrader la performance des outils de ROC. Certaines techniques de prétraitement des images peuvent être appliquées pour améliorer la visibilité de l'information textuelle dans les images ou les données numérisées. Ces techniques peuvent inclure la binarisation, la suppression du bruit et l'augmentation du contraste et de la netteté afin d'améliorer la visibilité du texte. Les documents numérisés peuvent également contenir des problèmes d'alignement qui doivent être corrigés par le rajustement de l'image et la correction de la perspective ou de la courbure. Apprenez-en plus sur les techniques typiques de prétraitement des images utilisées avant la ROC (le contenu de cette page est en anglais).

Détection et reconnaissance de texte

La reconnaissance n'est qu'une partie de la solution. Bien qu'elle soit souvent appelée simplement ROC, la ROC comporte deux parties : la détection et la reconnaissance. L'outil doit d'abord détecter où se trouve le texte dans l'image, puis reconnaître ce texte ou le convertir en une chaîne de caractères simple. Une image peut contenir des espaces vides, des objets, des figures, des dessins, des graphiques et d'autres éléments qui ne peuvent pas être convertis en une chaîne de caractères simple. Par conséquent, un modèle de détection identifie et isole d'abord les zones de texte, puis les transmet au modèle de reconnaissance pour la conversion.

Il existe de nombreux outils de ROC disponibles pour des types spécifiques d’image. Les deux plus populaires sont la détection/reconnaissance de texte de scène et la détection/reconnaissance de documents. Les outils de ROC entraînés sur des images de scène sont plus aptes à détecter les zones de texte sur des fonds complexes et reconnaissent mieux les textes courbes que les outils de ROC entraînés sur des documents numérisés contenant du texte sur des fonds unis. Il est important de choisir des modèles qui ont été formés pour les tâches similaires à notre cas d'utilisation. En outre, nous avons observé que l'utilisation d'un modèle de détection d'un outil et d'un modèle de reconnaissance d'un autre outil peut également aboutir à une amélioration de la performance.

Cas d'utilisation : documents à forte densité de texte

Les documents sont généralement denses en zones de texte, et l'outil de ROC choisi doit être entraîné sur des données similaires : texte foncé sur fond clair, paragraphes, polices de tailles différentes, souvent avec des espaces blancs, ou figures, tableaux, graphiques et diagrammes occupant une partie de la page.

En comparant les performances de Tesseract et de CRAFT, on peut voir que Tesseract reconnaît mieux le texte complet dans un image alors que CRAFT fait quelques erreurs. Nos expériences nous ont également permis de constater que Tesseract est plus performant pour la reconnaissance des caractères alphabétiques et de la ponctuation. Cependant, CRAFT est meilleur que Tesseract pour reconnaître les chiffres et les codes (une combinaison de chiffres et de lettres), y compris dans les documents à forte densité de texte. Au cours de nos tests, nous avons observé que CRAFT confond le caractère « O » avec le chiffre zéro. Cela indique que le modèle CRAFT n'est pas biaisé pour la prédiction des caractères alphabétiques lorsqu'il traite des paragraphes de texte.

Cas d'utilisation : texte de scène

Le texte de scène est une image avec des zones de texte à différents angles sur un fond complexe. Les images d'un marché animé, d'une rue avec des panneaux de signalisation ou de produits commerciaux peuvent entrer dans cette catégorie. Dans l'exemple ci-dessous, un produit de santé naturel est illustré. Il peut être assez difficile de détecter du texte dans différents alignements, polices et couleurs, et aucun des deux outils de ROC n'a atteint une précision parfaite. On peut toutefois noter que CRAFT a détecté plus de zones de texte que Tesseract. Cela s'explique surtout par le fait que CRAFT est un modèle de détection et de reconnaissance de texte de scène et qu'il est entraîné à repérer avec précision une variété de zones de texte sur des fonds complexes. Nos expériences ont permis de constater que CRAFT est plus performant pour détecter même les plus petites zones de texte sur une image et qu'il surpasse les autres modèles de détection de texte de scène disponibles.

Image

---

Résultat Tesseract

Utilisé par les
parents depuis
des générations
| Recommandé
NON PA
£
130 g

---

Résultat CRAFT

Recommandé
Utilisé par
par les médecins
No
parents depuis
des générations

Outil de ROC personnalisé

En plus de la variété des outils disponibles selon le cas d'utilisation, il est possible de créer un outil ROC unique en utilisant le modèle de détection de texte d'un outil et le modèle de reconnaissance d'un autre outil. Cette méthode a été employée avec succès dans l'un de nos projets d'extraction d'information portant sur des formulaires numérisés, où CRAFT a été utilisé pour la détection et Tesseract pour la reconnaissance. La combinaison a bien fonctionné, car CRAFT est plus performant pour détecter toutes les zones de texte (tailles de police beaucoup plus petites pour les titres des champs de formulaire) et Tesseract est plus performant pour convertir les zones de texte individuelles détectées en chaînes de caractères simples.

Conclusion

Les outils de ROC de source libre sont un excellent moyen d'extraire des informations à partir d'images ou de documents numérisés. De nombreux outils de ROC de pointe sont entraînés pour un cas d'utilisation spécifique et peuvent être utilisés sans aucune formation préalable. La performance dépend fortement de la qualité de l'image, mais certaines techniques de prétraitement de l'image peuvent être mises à profit pour améliorer les résultats. Dans nos tests, Tesseract, le moteur de ROC de Google, a produit de meilleurs résultats sur les documents à forte densité de texte, et CRAFT, de Clova AI, a produit de meilleurs résultats sur les données de textes de scène. Une fois les outils combinés, nous avons pu utiliser les points forts des deux outils pour effectuer une extraction d'information plus précise à partir d'ensembles plus complexes d'images contenant une variété de textes.

Veuillez s'il vous plaît prendre 2 minutes pour répondre à notre sondage

Nous sollicitons votre aide afin d'améliorer le Réseau de la science des données. Veuillez s'il vous plaît prendre 2 minutes pour répondre à quelques questions rapides. Nous sommes impatients de recevoir vos commentaires et les apprécions. C'est votre dernière chance de compléter le Sondage sur le bulletin d'information du Réseau de la science des données. Merci à tous ceux qui l'ont déjà rempli !

Par : Nicholas Denis, Statistique Canada

Les sujets du mois :

• Une approche novatrice de pré-entraînement : Le Contrastive Language-Image Pre-training (CLIP)
• Un réseau neuronal formé grâce à des paramètres de normalisation par lots
• Mesurer des instances de données difficiles à apprendre et voir de quelle façon en tirer parti pour former un réseau neuronal

Révolution : Une nouvelle approche de pré-entraînement d'apprentissage par transfert voit le jour!

Figure 1: Contrastive Language-Image Pre-training (CLIP)

L'entreprise OpenAI présente une nouvelle approche de pré-entraînement produisant des modèles pré-entraînés de pointe pour la vision par ordinateur

La nouveauté : L'approche CLIP utilise à la fois des entrées sous forme de textes et d'images pour entraîner des modèles de vision par ordinateur, sans aucune étiquette, qui peuvent exécuter une grande variété de tâches à des niveaux de performance de pointe (ou presque) sur 30 ensembles de données différents. Quelques exemples de tâches comprennent la reconnaissance d'objets, la reconnaissance optique de caractères, la reconnaissance d'actions à partir de vidéos, la géolocalisation et la classification d'objets finement détaillés. OpenAI, l'entreprise qui a créé cette nouvelle approche, a mis les modèles à code source libre à la disposition du public.

Comment ça fonctionne : OpenAI a construit un ensemble de données extraites du Web contenant 400 millions d'images associées à des descriptions textuelles. L'entreprise a mis en place l'approche CLIP (Contrastive Language-Image Pre-training), une approche qui prend l'entrée d'une image et la description textuelle de l'image et apprend à intégrer les représentations de l'image et du texte sur la surface d'une (hyper) sphère aussi précisément que possible. C'est tout!

Pourquoi cela fonctionne-t-il? Imaginez que vous puissiez déterminer les descriptions textuelles associées à 400 millions d'images différentes? Il serait juste de dire que vous avez appris la sémantique des objets dans les images, et que vous avez correctement découvert un grand nombre de catégories et de concepts. C'est exactement ce qui se passe avec CLIP. Cette approche présente un nouveau mécanisme d'inférence utilisant des invites textuelles :

• puisque CLIP est entraîné sans aucune étiquette, il n'y a pas de couche de classification;
• pour une image d'entrée donnée, CLIP produit une représentation de l'image;
• pour un ensemble donné de classes pour une application donnée, des invites textuelles entrent dans le modèle sous la forme d'« Une photo d'une <CLASSE> », où CLASSE est remplacé par les classes d'intérêt (p. ex. chat, chien);
• CLIP produit une représentation du texte pour chaque invite, et la classe la plus proche de la représentation de l'image est sélectionnée comme classe inférée.

Résultats : Après avoir pré-entraîné un modèle avec un énorme corpus de données image-texte provenant du Web, les auteurs utilisent plus de 30 ensembles de données de référence en vision par ordinateur et étudient les performances de CLIP sur un grand nombre de tâches de vision par ordinateur. Les auteurs testent les performances du modèle sur l'apprentissage par transfert à zéro coup (aucun apprentissage supplémentaire), ainsi que sur l'évaluation linéaire et la mise au point.

• L'approche CLIP utilisant l'apprentissage à zéro coup (où, au moment de l'inférence, un algorithme d'apprentissage doit effectuer une classification sur des catégories de classes non observées pendant l'entraînement) dépasse un classificateur linéaire entièrement supervisé ajusté aux caractéristiques ResNet-50 sur 16 des 27 ensembles de données, y compris ImageNet.
• L'ajustement d'un classificateur linéaire sur les caractéristiques de CLIP dépasse l'utilisation du Noisy Student EfficientNet-L2 (apprentissage par transfert de pointe à partir de l'ensemble de données ImageNet) sur 21 des 27 ensembles de données (jusqu'à 23,6 % d'amélioration de la précision).
• La performance de CLIP zéro coup était incroyablement résistante aux changements de distribution, y compris les attaques adverses, les images stylisées, l'utilisation de bruit synthétique et l'utilisation d'images synthétiques fournies.

Quel est le contexte? L'entreprise OpenAI a contribué à ouvrir la voie au pré-entraînement des modèles de langage avec la famille de modèles de langage GPT (Generative Pre-trained Transformer) qui sont couramment utilisés. Il est clair que son expertise dans ce domaine l'a aidée à produire cette approche novatrice. Depuis la diffusion de la publication au sujet de cette approche au début de l'année 2021, plusieurs dizaines de travaux ont été menés, ont été analysés et ont utilisé CLIP, ce qui en fait l'ouvrage phare de l'année 2021. Les modèles et le code sont disponibles gratuitement en ligne: openAI/CLIP GitHub (le contenu de cette page est en anglais). Comme indiqué sur leur site web, OpenAI est une enterprise de recherche et de déploiement de l'IA. Sa mission est de faire en sorte que l'intelligence artificielle générale profite à l'ensemble de l'humanité. (le contenu de cette page est en anglais) - des systèmes très autonomes qui surpassent les humains dans la plupart des travaux à valeur économique - qui profite à l'ensemble de l'humanité. Ils tentent de construire directement des IAG sûres et bénéfiques, de mettre leur travail à la disposition d'autres personnes visant le même résultat, et sont régis par le conseil d'administration à but non lucratif d'OpenAI.

Et puis? CLIP a été utilisé pour la recherche d'images et de vidéos à l'aide de texte, de segmentation et de sous-titrage d'images. Bien que CLIP ait d'autres utilités comme faire la mise au point du modèle, les approches traditionnelles d'apprentissage par transfert (qui impliquent de geler le modèle CLIP) ou l'utilisation de ses caractéristiques comme entrées d'un nouveau modèle de réseau neuronal plus petit, l'aspect très important de CLIP réside dans sa capacité de transfert à zéro coup.

Lorsque l'approche a été évaluée sur ImageNet (un ensemble de données d'un million d'images comprenant 1 000 classes), CLIP a atteint une précision de 76,2 %, sans aucune supervision au niveau des classes. CLIP peut agir comme un classificateur à jeu ouvert (open-set) en utilisant les invites textuelles. Plutôt que d'avoir un modèle paramétrique produisant une distribution sur un nombre fixe de classes, au moment de l'inférence, l'approche CLIP est capable d'interroger le modèle avec un nombre quelconque de classes en utilisant la conception novatrice de l'invite, ce qui la rend incroyablement polyvalente et générale.

Une recherche distincte utilisant l'approche CLIP pour la segmentation montre que lorsque l'on fournit une image de zèbres buvant le long de la rivière, l'invite textuelle se lit comme suit : « Le zèbre devant les autres zèbres », ce qui permet au modèle CLIP de segmenter correctement le zèbre qui lui est demandé. De quoi changer la donne!

Notre avis : La littérature parle d'elle-même. Le nombre d'articles de recherche utilisant l'approche CLIP montre le côté novateur et la puissance de cette dernière. CLIP est utile pour un large éventail de tâches de vision par ordinateur. Nous pensons que les approches d'apprentissage profond qui utilisent de multiples modalités de données (c.-à-d. image/texte/audio, etc.) deviendront de plus en plus courantes. Cependant, comme on l'a vu avec le pré-entraînement des modèles de langage, tels que GPT-3 d'OpenAI, il est probable que la taille de ces modèles augmentera. À mesure que les paramètres de ces modèles augmenteront, seules les plus grandes entreprises technologiques seront en mesure d'assumer les coûts pour l'apprentissage de ces modèles, ce qui rendra peu probable leur utilisation par le public et la possibilité de les rendre à code source libre.

La normalisation par lots (BatchNorm) est tout ce dont vous avez besoin

Figure 2 : Relation entre le nombre de paramètres de normalisation par lots et l'exactitude lors de la mise à l'échelle de la profondeur et de la largeur des ResNets; dans CIFAR-10.

Figure 3: La distribution de y pour ResNet-110 et ResNet-101 agrégé à partir de cinq (CIFAR-10).

Des chercheurs du Massachusetts Institute of Technology et de Facebook Research obtiennent une précision de 83 % pour l'apprentissage de CIFAR10 en utilisant uniquement des paramètres de normalisation par lots.

La nouveauté : La normalisation par lots est une technique omniprésente dans l'apprentissage profond. Les auteurs étudient le pouvoir expressif des paramètres de normalisation par lots en entraînant des réseaux de neurones, fournissant la preuve que la normalisation par lots est extrêmement puissante dans l'apprentissage profond, capable d'apprendre à partir de caractéristiques aléatoires.

Comment ça fonctionne : L'écart réduit est une technique courante de prétraitement des données, qui vise à transformer les entrées pour qu'elles soient approximativement normales (0,1). Cependant, dans l'apprentissage profond, lorsque chaque lot de données passe dans le réseau, les données sont transformées à chaque couche et ne suivent plus cette distribution. La normalisation par lots est similaire à l'écart réduit, cependant elle ne vise pas à transformer les données pour qu'elles soient normales (0,1), mais plutôt normales $(\beta ,\gamma )$ où $\beta$ et $\gamma$ sont des paramètres assimilables. Les auteurs forment des réseaux neuronaux où tous les paramètres de poids sont fixes et ne sont pas mis à jour, tandis que les paramètres de la normalisation par lots sont les seuls paramètres mis à jour par apprentissage.

Résultats :

• Les auteurs démontrent d'abord que pour différentes architectures de réseaux neuronaux, l'utilisation de la normalisation par lots est toujours avantageuse et améliore les performances du modèle.
• Lors de l'utilisation d'un ResNet-110 sur CIFAR10, avec l'ensemble des 1,7 million de paramètres assimilables, le modèle atteint une précision de test de 93,3 %, mais lorsqu'il utilise uniquement les 8 300 paramètres de normalisation par lots, le modèle est capable d'atteindre une précision de test de 69,7 %. De plus, un ResNet-866 avec 65 000 paramètres atteint une précision de test de 83 %.
• En utilisant uniquement les paramètres de normalisation par lots pour l'apprentissage, les auteurs ont trouvé une corrélation de Pearson presque parfaite entre les paramètres de normalisation par lots (couches d'un réseau) et la précision du test.
• Une analyse des paramètres appris a montré que le modèle apprend à désactiver efficacement entre un tiers et un quart de toutes les caractéristiques, en élaguant implicitement le réseau.

Quel est le contexte? La normalisation par lots a fait l'objet de nombreuses études visant à faire la lumière sur le pourquoi et le comment de son fonctionnement. Bien qu'aucun praticien de l'apprentissage profond n'ait besoin de plus de preuves pour utiliser la normalisation par lots dans ses modèles, le fait qu'un modèle puisse avoir de bonnes performances en utilisant uniquement la normalisation par lots est assez impressionnant et révélateur. Étant donné que tous les autres paramètres sont initialisés et fixés de manière aléatoire, cela signifie en réalité que les caractéristiques produites à partir des données d'entrée sont aléatoires, et que les paramètres de la normalisation par lots sont capables de transformer de manière itérative les caractéristiques aléatoires en caractéristiques discriminantes pour la classification en aval.

Mais... Bien que le résultat soit très intéressant et puisse donner lieu à d'autres recherches, les auteurs ne suggèrent pas aux praticiens de former uniquement des réseaux à normalisation par lots.

Et puis? Les implications de ce travail fournissent un soutien supplémentaire pour la puissance et l'importance de l'utilisation de la normalisation par lots dans l'apprentissage profond. Un ResNet de 866 couches avec seulement 65 000 paramètres est capable d'obtenir de très bons résultats, alors qu'un réseau à une seule couche avec ce nombre de paramètres échouerait probablement complètement à la même tâche. Ce résultat pourrait très bien ouvrir la voie à de nouvelles conceptions architecturales et à des recherches centrées sur des réseaux plus profonds, mais plus étroits (moins de paramètres par couche).

Notre avis : Cette recherche est intéressante en soi, et est importante pour l'avancement de la recherche sur la normalisation par lots. Comme les poids de chaque couche des réseaux sont initialisés de façon aléatoire, chaque couche agit comme une transformation aléatoire sur les données, produisant des caractéristiques aléatoires. Étant donné que la normalisation par lots apprend uniquement à rééchelonner et à décaler ces caractéristiques aléatoires, ce travail fournit la preuve que cette approche peut être efficace pour les tâches d'apprentissage par transfert utilisant des modèles pré-entraînés. De plus, étant donné qu'une grande partie des paramètres appris ont effectivement élagué ou désactivé des caractéristiques, il pourrait y avoir une certaine pollinisation croisée avec la communauté sur l'élagage des réseaux (le contenu de cette page est en anglais). Pour nos lecteurs, le message à retenir est simple : utilisez la normalisation par lots.

Mesurer des instances de données difficiles à apprendre

Figure 4:Fréquence de sélection humaine par opposition à la dureté visuelle angulaire

Les chercheurs ont établi une mesure de la « difficulté » d'une instance de données à être correctement classée, qui présente une corrélation négative avec la fréquence à laquelle les annotateurs humains sélectionnent les instances comme exemples d'une classe donnée.

La nouveauté : Des chercheurs de l'Université de Toronto, de l'Université Rice, du California Institute of Technology, du Georgia Institute of Technology, de NVIDIA Corporation et du Vector Institute établissent une mesure de la difficulté d'un exemple par rapport à la capacité d'un modèle à classer correctement une instance de données, et forment le modèle en utilisant un programme basé sur cette mesure.

Comment ça fonctionne : La dureté visuelle angulaire calcule l'angle que fait une représentation avec chacun des centres de classe et produit un score où, en gros, les valeurs les plus grandes correspondent aux représentations qui ont des angles plus grands par rapport aux classes de leurs étiquettes identifiant la vérité (et qui sont donc plus éloignées). Ensuite, à l'aide de la dureté visuelle angulaire, l'ensemble de données peut être classé en matière de difficulté des instances, et un sous-ensemble peut être utilisé pour entraîner un modèle à l'aide d'instances d'un niveau de difficulté approprié (apprentissage par programme).

Résultats :

• Les chercheurs ont constaté que la dureté visuelle angulaire présente une forte corrélation (négative) avec la fréquence de sélection humaine, soit la fréquence à laquelle les annotateurs humains sélectionneraient une instance comme exemple d'une classe donnée. Par conséquent, plus l'exemple est facile, plus il est probable qu'un humain le sélectionnera et le reconnaîtra comme un exemple d'une classe donnée.
• Les chercheurs utilisent la dureté visuelle angulaire pour l'auto-formation semi-supervisée dans le cadre de l'adaptation au domaine. En bref, cela implique deux ensembles de données complètement différents, générés à partir de distributions complètement différentes, mais avec les mêmes classes. Avec des étiquettes sur l'ensemble de données « source » et aucune étiquette d'entraînement dans l'ensemble de données « cible », l'objectif est de généraliser à des instances non vues de l'ensemble de données « cible ». Les modèles ont d'abord été formés sur l'ensemble de données « source », puis la dureté visuelle angulaire a été appliquée à l'ensemble de données « cible ». Les instances inférieures à un seuil (instances plus faciles) ont été sélectionnées pour produire des pseudo-étiquettes par les modèles précédemment formés (voir voir Pseudo-Labeling to deal with small datasets - le contenu de cette page est en anglais). Ces instances pseudo-étiquetées ont été ajoutées à l'ensemble de données et le modèle a été entraîné de nouveau. Cette approche a donné de meilleurs résultats que les précédentes approches de pointe d'adaptation au domaine sur différents ensembles de données.

Quel est le contexte? L'apprentissage par programmes est un domaine largement étudié en apprentissage automatique. Les techniques d'extraction d'échantillons durs et semi-durs sont cruciales pour de nombreuses techniques d'apprentissage métrique profond et d'apprentissage auto-supervisé.

Et puis? De l'apprentissage métrique profond à l'apprentissage par programmes, la mesure de la difficulté des instances d'un ensemble de données est de plus en plus importante pour une grande variété de techniques d'apprentissage automatique. De nombreux ensembles de données concrètes comportent des étiquettes approximatives (lisez : incorrectes) et il est probable (lisez : avec un peu de chance) que le modèle ne classifie jamais « correctement » ces instances. Le domaine de l'identification des instances mal étiquetées utilise des exemples difficiles à ajuster, à réétiqueter ou à supprimer de l'ensemble de données afin d'améliorer les performances du modèle. L'apprentissage par programmes bénéficie de la production d'instances correctement séquencées pour que le modèle puisse apprendre, en trouvant un niveau de difficulté « idéal ». Les instances trop faciles sont un gaspillage de puissance informatique et ne produisent pas de gradients utiles pour les mises à jour de l'apprentissage, tandis que les exemples trop difficiles peuvent être aberrants, mal étiquetés ou simplement peu susceptibles d'être classés correctement. Dans un cas comme dans l'autre, les deux peuvent nuire au modèle et représenter un gaspillage de puissance informatique.

Mais... Bien que la dureté visuelle angulaire soit nouvelle dans sa formulation exacte, l'utilisation de l'angle entre une représentation et son centre de classe véritable, ou des variantes de celui-ci, a déjà existé auparavant. Cependant, c'est le premier travail (à notre connaissance) qui montre une corrélation entre une mesure de dureté et la façon dont les humains peuvent juger une instance comme étant facile ou difficile.

Notre avis : Bien qu'il soit peu probable que la dureté visuelle angulaire soit adoptée comme mesure ultime de la dureté des instances, le but du présent article était de souligner le fait qu'il existe un large corpus de littérature visant à mesurer la difficulté des instances d'apprentissage, et d'utiliser ces renseignements pour éclairer l'apprentissage sous la forme de fonctions de perte, de pseudo-étiquetage, de détection d'anomalies et d'apprentissage par programmes.

Par : Soufiane Fadel, Statistique Canada

Les modèles d'apprentissage automatique sont souvent considérés comme une boîte noire opaque. Ils regroupent des caractéristiques à utiliser comme données d'entrée et génèrent des prédictions. Après la phase d'entraînement, quelques questions courantes se posent. Comment les différentes caractéristiques influent-elles sur les résultats de la prédiction? Quelles sont les variables les plus importantes qui influent sur les résultats de la prédiction? Dois-je croire les conclusions, bien que les indicateurs de rendement du modèle semblent être excellents? Par conséquent, l'explicabilité du modèle s'avère importante dans l'apprentissage automatique. Les renseignements obtenus à partir de ces méthodes d'intelligibilité sont utiles pour effectuer le débogage, guider l'ingénierie des caractéristiques, orienter les futures collectes des données, éclairer la prise de décision humaine et instaurer la confiance.

Pour être plus précis, distinguons deux idées essentielles dans l'apprentissage automatique : l'intelligibilité et l'explicabilité. L'intelligibilité désigne le degré avec lequel un modèle d'apprentissage automatique peut lier avec précision une cause (données d'entrée) à un résultat (données de sortie). L'explicabilité fait référence au degré avec lequel le fonctionnement interne d'une machine ou d'un système d'apprentissage profond peut être articulé avec des mots humains. En d'autres termes, c'est la capacité d'expliquer ce qui se passe.

Dans le présent article, nous nous penchons également sur les valeurs de Shapley, qui constituent l'une des méthodes d'explicabilité des modèles les plus utilisées. Nous donnons un aperçu technique des détails sous-jacents à l'analyse de la valeur de Shapley et décrivons les bases du calcul des valeurs de Shapley en formalisant mathématiquement le concept et en donnant également un exemple pour illustrer l'analyse de la valeur de Shapley dans un problème d'apprentissage automatique.

Quelles sont les valeurs explications additives de Shapley (SHAP)?

Si vous recherchez l'expression anglaise « SHAP analysis » (analyse SHAP), vous découvrirez qu'elle provient d'un article de 2017 de Lundberg et Lee, intitulé « A Unified Approach to Interpreting Model Predictions » (le contenu de cette page est en anglais), qui introduit l'idée de « Shapley Additive exPlanations » (explications additives de Shapley, également appelée SHAP). SHAP permet de fournir une explication pour la prédiction d'un modèle d'apprentissage automatique en calculant la contribution de chaque caractéristique à la prédiction. L'explication technique du concept de SHAP repose sur le calcul des valeurs Shapley à partir de la théorie des jeux de coalition. Les valeurs de Shapley ont été nommées en l'honneur de Lloyd Shapley, qui a introduit le concept en 1951 et a ensuite remporté le Prix de la Banque de Suède en sciences économiques en mémoire d'Alfred Nobel en 2012. Concrètement, les valeurs de Shapley s'apparentent à une méthode permettant de montrer l'impact relatif de chaque caractéristique (ou variable) que nous mesurons sur les données de sortie finales du modèle d'apprentissage automatique en comparant l'effet relatif des données d'entrée à la moyenne.

Théorie des jeux et théorie des jeux coopératifs

Tout d'abord, expliquons la théorie des jeux afin de comprendre comment elle est utilisée pour analyser les modèles d'apprentissage automatique. La théorie des jeux constitue un cadre théorique pour les interactions sociales avec des acteurs en concurrence. C'est l'étude de la prise de décision optimale par des agents indépendants et concurrents dans un contexte stratégique. Un « jeu » s'entend d'un scénario comportant de nombreux décideurs, chacun d'entre eux cherchant à maximiser ses résultats. Le choix optimal sera influencé par les décisions des autres. Le jeu détermine les identités, les préférences et les tactiques possibles des participants, ainsi que la manière dont ces stratégies influent sur le résultat. Dans le même contexte, la théorie des jeux coopératifs (une branche de la théorie des jeux) postule que les coalitions de joueurs constituent les principales unités de prise de décision et peuvent contraindre à une conduite coopérative. Par conséquent, au sein des jeux coopératifs, la compétition s'opère davantage entre une coalition de joueurs qu'entre des joueurs individuels. L'objectif vise à mettre au point une « formule » pour mesurer la contribution au jeu de chaque joueur, cette formule est la valeur de Shapley.

Valeurs de Shapley : intuition

Le scénario s'entend comme suit : une coalition de joueurs collabore afin d'obtenir un bénéfice total particulier grâce à leur collaboration. Étant donné que certains joueurs peuvent contribuer davantage à la coalition que d'autres et que divers joueurs peuvent présenter divers degrés d'influence ou d'efficacité, quelle devrait être la répartition finale des bénéfices entre les joueurs dans un jeu donné? En d'autres termes, nous voulons connaître l'importance de la collaboration de chaque participant et le type de gain qu'il peut escompter en conséquence. Une solution potentielle à ce problème est fournie par les valeurs du coefficient de Shapley. Ainsi, dans le contexte de l'apprentissage automatique, les valeurs des caractéristiques d'une instance de données servent de membres de la coalition. Les valeurs de Shapley nous indiquent alors comment répartir le « gain » entre les caractéristiques de manière équitable, ce qui constitue la prédiction. Un joueur peut être une valeur de caractéristique unique, comme dans les données tabulaires. Un joueur peut également être défini comme un ensemble de valeurs des caractéristiques.

Valeurs de Shapley : formalisme

Il est important de comprendre la base mathématique et les propriétés qui soutiennent le cadre de la valeur de Shapley. Ce point est abordé plus en détail dans cette section.

Formule de la valeur de Shapley

La valeur de Shapley est définie comme la contribution marginale de la valeur de la variable à la prédiction parmi toutes les « coalitions » concevables ou sous-ensembles de caractéristiques. En d'autres termes, il s'agit d'une approche visant à redistribuer les bénéfices globaux entre les joueurs, étant donné qu'ils coopèrent tous. Le montant que chaque « joueur » (ou caractéristique) obtient après une partie est défini comme suit :

${\varphi }_i\left(x\right)=\sum _{S\subset F\left\{i\right\}} \frac{\left|S\right|!\left(\left|F\right|-\left|S\right|-1\right)!}{\left|F\right|!}\left[f_{S\cup \left\{i\right\}}\left(x_{S\cup \left\{i\right\}}\right)-f_S\left(x_S\right)\right]$

Où :

• $x$ : données d'entrée observées
• ${\varphi }_i\left(x\right)$ : valeur de Shapley pour la caractéristique $i$ des données d'entrée $x$ pour le jeu/modèle $f$.
• $F$ : ensemble de toutes les caractéristiques
• $f_S$ : modèle formé sur le sous-ensemble de caractéristiques $S$.
• $f_{S\cup \left\{i\right\}}$  : modèle formé sur le sous-ensemble de caractéristiques $S$ et $\left\{i\right\}$.
• $x_S$ : données d'entrée restreintes de $x$ étant donné le sous-ensemble de caractéristiques $S$.
• $x_{S\cup \left\{i\right\}}$: données d’entrée restreintes de $x$ étant donné le sous-ensemble de caractéristiques $S$ et $\left\{i\right\}$.

Cela pourrait être reformulé et exprimé comme suit :

${\varphi }_i\left(x\right)=\underset{\text{Moyenne} }{\underbrace{\frac{1}{\left|F\right|}\sum _{S\subset F\left\{i\right\}}}}\underset{\text{poids combinatoires}}{\underbrace{{\left(\begin{array}{c}\left|F\right|-1\\ \left|S\right|\end{array}\right)}^{-1}}}\underset{\text{contribution marginale}}{\underbrace{\left[f_{S\cup \left\{i\right\}}\left(x_{S\cup \left\{i\right\}}\right)-f_S\left(x_S\right)\right]}}$

Le concept des valeurs de Shapley peut être divisé en trois composantes : contribution marginale, pondération combinatoire et moyenne. Il est préférable de lire de droite à gauche tout en développant son intuition.

• La contribution marginale s'entend de la mesure dans laquelle le modèle change lorsqu'une nouvelle caractéristique $i$ est ajoutée. Étant donné un ensemble de caractéristiques $S$, nous désignons $fs$ comme le modèle formé avec les caractéristiques $S$ présentes. $f_{S\cup \left\{i\right\}}$ est le modèle formé avec une caractéristique supplémentaire $i$. Lorsque ces deux modèles présentent des prédictions différentes, la quantité entre crochets indique exactement de combien ils diffèrent l'un de l'autre.
• La pondération combinatoire s'entend de la pondération à donner à chacun des différents sous-ensembles de caractéristiques de taille $\left|S\right|$ (en excluant la caractéristique $i$).
• Enfin, la moyenne déterminera la moyenne de toutes les contributions marginales de toutes les tailles de sous-ensembles imaginables allant de $0$ à $\left|F\right|- 1$. Nous devons omettre la seule caractéristique pour laquelle nous souhaitons évaluer l'importance.

Propriétés théoriques

Les valeurs de Shapley présentent un certain nombre de caractéristiques souhaitables; de telles valeurs satisfont aux quatre propriétés suivantes : efficacité, symétrie, joueur nul et linéarité. Ces aspects peuvent être considérés comme une définition d'une pondération équitable lorsqu'ils sont pris ensemble.

Considérez le scénario suivant : vous avez entraîné un modèle de forêt aléatoire, ce qui implique que la prédiction est basée sur une moyenne de plusieurs arbres de décision différents. Vous pouvez calculer la valeur de Shapley pour chaque arbre indépendamment, en faire la moyenne, et utiliser la valeur de Shapley résultante pour calculer la valeur de la caractéristique dans une forêt aléatoire. Cela est garanti par la propriété de linéarité.

Exemple d'application d'apprentissage automatique : intelligibilité

Les qualités théoriques des valeurs de Shapley sont toutes intéressantes et souhaitables, mais en pratique, il se peut que nous ne soyons pas en mesure de déterminer la valeur de Shapley précise en raison de contraintes pratiques. L'obtention de la formulation précise de la valeur de Shapley nécessite un temps de traitement important. Lorsqu'il s'agit de situations réelles, la réponse approximative est souvent la plus pratique, car il existe $2^{\left|F\right|}$ coalitions potentielles des valeurs des caractéristiques. Le calcul de la valeur exacte de Shapley est trop coûteux d'un point de vue informatique. Heureusement, nous pouvons appliquer certaines approches d'approximation; la qualité de ces techniques influe sur la robustesse des caractéristiques théoriques. Plusieurs tests en recherche ont été menés (en anglais seulement) pour démontrer que les résultats de l'approximation SHAP sont plus cohérents par rapport aux valeurs produites par d'autres algorithmes couramment utilisés.

La figure suivante fournit un exemple de la façon d'examiner les contributions des caractéristiques pour étudier les prédictions d'un modèle « Xgboost » qui estime le prix de vente des maisons à l'aide de 237 variables explicatives, décrivant presque tous les aspects des maisons résidentielles à Ames, dans l'lowa. L'ensemble des données liées à cette analyse est accessible au public sur Kaggle - House Prices - Advanced Regression Techniques (le contenu de cette page est en anglais).

Figure 1

En bas du graphique est indiquée la valeur prévue des données de sortie du modèle (182 000 $). Chaque ligne au-dessus montre comment la contribution positive (en rouge) ou négative (en bleu) de chaque caractéristique fait évoluer la valeur en la faisant passer des données de sortie prévues du modèle aux données de sortie du modèle pour cette prédiction (242 000 $). Les informations en gris devant les noms des caractéristiques indiquent la valeur de chaque caractéristique pour cet échantillon. À partir de ce graphique, nous pouvons conclure que 228 caractéristiques ajoutent un total de 7 397,47 $ à la valeur prédite, et que chacune des variables énumérées ci-dessus a un impact supérieur à 5 000 $. Le prix prévu de cette maison particulière grimpe à plus de 18 000 $ avec une surface habitable au sol de 7 500 pieds carrés. Le prix est réduit de 7 660,98 $ en raison de la taille du terrain de 7 050 pieds carrés.

Conclusion

Comme nous l'avons vu, les valeurs de Shapley comportent des propriétés théoriques mathématiquement satisfaisantes en tant que solution aux problèmes de la théorie des jeux. Le cadre fournit des explications contrastives, ce qui signifie qu'au lieu de comparer une prédiction à la prédiction moyenne de l'ensemble des données, il est possible de la comparer à un sous-ensemble ou même à un seul point des données. Il explique qu'une prédiction est un jeu joué par les valeurs des caractéristiques.

En outre, cette méthodologie constitue l'une des rares méthodes explicatives fondées sur une théorie solide, puisque les axiomes mathématiques (efficacité, symétrie, joueur nul, linéarité) fournissent une base raisonnable pour l'explication.

Enfin, il convient de préciser que cette stratégie figure parmi les nombreuses solutions possibles. Cependant, la valeur de Shapley est souvent préférable, car elle est basée sur une théorie solide, répartit équitablement les effets et fournit une explication complète.

Références

Bosa, K. (2021). Utilisation responsable de l'apprentissage automatique à Statistique Canada.

Cock, D. D. (2011). Ames, Iowa: Alternative aux données sur le logement à Boston.  Journal of Statistics Education.

Molnar, C. (2021). Apprentissage automatique interprétable : Un guide pour rendre les modèles de la boîte noire explicables.

Scott Lundberg, S.-I. L. (2017). Une approche unifiée de l'interprétation des prédictions des modèles.

Yadvinder Bhuller, H. C., & O'Rourke, K. (n.d.). De l'exploration à l'élaboration de modèles d'apprentissage automatique interprétables et précis pour la prise de décision : privilégiez la simplicité et non la complexité.

La Communauté de pratique (CdP) de l'apprentissage automatique appliqué à l'analyse de textes est un groupe interministériel d'employés du gouvernement du Canada qui font part et discutent de solutions d'apprentissage automatique (AA) de haute qualité concernant les données textuelles. Le groupe a été créé en 2018 sous la forme d'un petit groupe de spécialistes de la science des données de Statistique Canada et s'est rapidement élargi pour devenir une CdP interministérielle composée de représentants de plus de 15 ministères et organismes fédéraux qui se réunissent virtuellement tous les mois.

La CdP a pour principal objectif d'accroître la capacité de l'AA dans de multiples disciplines au sein de la fonction publique. Aucune expérience préalable de l'AA n'est requise pour participer à ces réunions. Les personnes de toutes les disciplines et de tous les ministères et organismes sont invitées à participer aux réunions et à prendre part aux discussions.

La CdP atteint son objectif en:

• Collaborant par le biais de discussions sur divers aspects de l'analyse de textes
• Partageant des présentations et d'autres documents concernant l'analyse de textes
• Fournissant des mises à jour sur les questions et les problèmes rencontrés lors de l'application de l'apprentissage automatique sur des données textuelles (utilisation de Gitlab, de certains packages, etc.)
• Établissant des pratiques exemplaires fondées sur diverses expertises au sein du gouvernement.

Au cours de l'année 2021, la CdP a organisé 13 présentations de différents ministères et organismes. Chaque présentation permettait d'illustrer une solution concrète d'AA appliquée aux données textuelles ou un exemple de cas qui nécessitait le développement d'une application d'AA au texte.

Présentations de 2021

Vous trouverez ci-dessous une description de chacune des présentations qui ont eu lieu l'année dernière. Si vous souhaitez accéder aux présentations ou obtenir plus de renseignements à leur sujet, veuillez communiquer avec la CdP de l'apprentissage automatique appliqué à l'analyse de textes : statcan.appliedmltextcop-cdpaaappliquetexte.statcan@statcan.gc.ca.

Classification des commentaires sur le Recensement de 2021 à Statistique Canada

Dans le but d'améliorer l'analyse des commentaires sur le Recensement de la population de 2021, la division de la science des données de Statistique Canada a travaillé en collaboration avec le Secrétariat des domaines spécialisés du recensement pour créer une preuve de concept sur l'utilisation des techniques d'apprentissage automatique pour classer rapidement et en toute objectivité les commentaires formulés dans le cadre du recensement. En plus de classer les commentaires par domaine spécialisé, le modèle visait aussi à classer les commentaires sur des problèmes techniques et des préoccupations en matière de protection de la vie privée.

Tirer profit des données pour solidifier son savoir d'affaires: Utiliser la rétroaction des clients pour nourrir l'innovation et la prise de décision à Immigration, Réfugiés et Citoyenneté Canada (IRCC)

Depuis 2014, IRCC récolte de la rétroaction sur ses services de la part de sa clientèle. La Direction générale de l'expérience client a prévu de lancer un projet d'apprentissage automatique pour analyser les commentaires de manière plus approfondie. Cette analyse plus poussée de ces données lui permettrait d'avoir une meilleure compréhension des attentes et opinions de cette dernière et d'aligner ses projets d'innovation et son processus de prise de décision. Le présentateur a discuté avec les membres de la CdP des approches de projet appropriées pour démontrer la valeur ajoutée des projets d'apprentissage automatisé à la haute gestion.

Analyse des données pour les services d'assurance et de consultation à l'Agence du revenu du Canada (ARC)

La section de l'analyse des données au sein de la Direction générale de la vérification, de l'évaluation et des risques de l'ARC a créé un musée des données en 2016. Le musée des données a permis :

1. la fourniture d'analyses de données descriptives et diagnostiques pour de multiples activités d'assurance et de consultation,
2. l'utilisation de l'apprentissage automatique pour une meilleure reconnaissance des patrons, une meilleure classification et une meilleure détection des valeurs aberrantes, et
3. l'élaboration de procédures opérationnelles standardisées pour la confidentialité et la protection des données.

La section de l'analyse des données a constaté de visu que les méthodes et techniques de traitement du langage naturel (TLN) sont sous-utilisées dans le secteur de l'audit interne, et a saisi l'occasion d'appliquer le TLN à diverses étapes du processus d'audit interne. Par exemple, le TLN a aidé les équipes d'audit interne à :

1. analyser de grands volumes de données textuelles non structurées, telles que des notes d'entrevue, des rapports de 400 pages de l'Office Gouvernemental des Comptes, et des pages Web lors de la génération automatique de résumés de risques à partir de l'environnement socio-économique,
2. visualiser l'interconnectivité des risques,
3. mesurer le ton des rapports en utilisant l'analyse des sentiments, et
4. exploiter un moteur de recherche de questions et réponses en langage naturel.

Ingénierie des données avec R, R Markdown, Shiny et les algorithmes

Cette présentation a présenté les défis et les solutions liés à l'ingénierie des données, et le domaine qui traite de l'automatisation et de la transformation des données. Le présentateur a discuté de la taxonomie des tâches d'ingénierie des données et des outils pour y répondre. Il a décrit les efforts pour créer la trousse des outils d'ingénierie des données et la Communauté de pratique. Des applications Shiny pour la fusion/déduplication de données floues et l'analyse TLN de la base de données ouvertes du Canada des demandes d'accès à l'information complétées ont été présentées.

La Modélisation thématique dynamique à Statistique Canada

Cette présentation a fourni un aperçu technique de la méthodologie sous-jacente à la modélisation thématique, expliquant la base de l'allocation de Dirichlet latente et introduisant une dimension temporelle dans l'analyse de modélisation thématique. Cela a été fait dans le contexte de la détection d'événements à l'aide des données de la Base canadienne de données des coroners et des médecins légistes (BCDCML).

Analyse des événements à l'aide des structures du centre de situation à Transports Canada

La Direction des préparatifs d'urgence envoi des notifications sur les événements (incidents, accidents, etc.) qui touchent l'infrastructure de transport du Canada (maritime, aérien et de surface), 24 heures sur 24 et 7 jours sur 7, aux abonnés par courriel. L'équipe du présentateur a conçu ces notifications bilingues pour produire des ensembles de données analytiques afin d'extraire des renseignements, de permettre l'analyse de texte et de détecter des modèles pour des événements similaires.

L'analyse des médias sociaux en temps réel à Transports Canada

Cette application Web de validation de concept a exploité les données des médias sociaux en temps réel et a fourni des informations géospatiales et des analyses de texte à l'aide du traitement du langage naturel. L'objectif de l'application était d'aider les analystes à déterminer dans quelle mesure des événements reliés à la sûreté et à la sécurité pouvaient être extraits des médias sociaux. En outre, un composant attribuant des scores aux sentiments a été ajouté pour permettre une analyse des sentiments basée sur des sujets ou des organisations clés. Bien qu'elle n'ait jamais été mise en œuvre, la preuve de concept a permis une analyse rapide des problèmes émergents pour une sous-population d'utilisateurs de médias sociaux, y compris des particuliers, des fournisseurs d'informations et la police nationale.

L'apprentissage automatique quantique appliqué à la classification de texte par Statistique Canada, l'Institut quantique de l'Université de Sherbrooke et la Banque du Canada

Les technologies découlant de l'informatique quantique ont le potentiel de révolutionner plusieurs domaines de l'apprentissage automatique, incluant la classification de texte. Durant cet exposé, les présentateurs ont exploré trois approches distinctes d'apprentissage automatique quantique à l'époque des ordinateurs quantiques d'échelle intermédiaire bruitées, dans le but de présenter ces méthodes aux chercheurs et aux scientifiques de données existants dans le domaine.

De la guérison du cancer à la saisie des gazouillis : Le TLN appliqué pour les sciences de la santé à l'Agence de la santé publique du Canada (ASPC)

Le présentateur a partagé son bref voyage à travers l'application pratique du TLN aux problèmes de la recherche en sciences de la santé. Il s'agit notamment de l'utilisation du TLN basé sur des règles pour extraire les interactions médicament-maladie des résumés de recherche médicale, jusqu'à l'utilisation de l'apprentissage automatique visant les gazouillis sur la vaccination afin de prédire les épidémies. Les leçons apprises et les erreurs qui ont été faites ont été discutées.

Vers l'automatisation des examens systématiques sur la vaccination à ASPC

L'ASPC (avec Xtract AI, Vancouver, BC) envisage l'automatisation de différentes étapes de synthèse des données visant à accroître les gains d'efficacité. Le présentateur a partagé le résumé d'une version préliminaire d'un nouveau système d'apprentissage automatique fondé sur des avancements récents quant au TLN, comme BioBERT, où d'autres optimisations seront réalisées par l'entremise d'une nouvelle base de données de documents portant sur la vaccination. Le modèle de TLN optimisé obtenu et qui est au cœur de ce système a pu déceler et extraire les champs relatifs aux principes de la Population, l'Intervention, les Comparateurs, les Résultats (PICR) des publications sur la vaccination avec une exactitude moyenne s'élevant à 88% dans cinq classes de texte.

Création de Tableaux de Bord de Visualisation de Données à l'aide de Cadres Python de source ouverte à Statistique Canada

La construction de tableaux de bord s'est avérée utile dans le domaine de la science des données. Avec les progrès actuels dans ce domaine, on assiste à l'émergence d'outils de source libre puissants, hautement personnalisables et gratuits. Le présentateur a parlé de certains des meilleurs outils python adaptés à la construction de tableaux de bord, a montré des exemples de travaux pertinents réalisés par la Division de la sciences des données et a présenté un bref aperçu de la façon de s’initier à deux outils des plus populaires, Dash et Django.

Automatisation de l'extraction d'informations à partir d'états financiers dans le système SEDAR à l'aide de techniques basées sur la disposition spatiale à Statistique Canada

Le format PDF (Portable Document Format) est le plus couramment utilisé par les entreprises à des fins d'information financière. L'absence de moyens efficaces pour extraire les données de ces fichiers PDF hautement non structurés d'une manière tenant compte de la mise en page représente un défi majeur pour les analystes financiers pour analyser et traiter efficacement les informations en temps opportun. «Spatial Layout based Information and Content Extraction» (SLICE) - un algorithme de vision par ordinateur unique utilise simultanément des informations textuelles, visuelles et de mise en page pour segmenter plusieurs points de données en une structure tabulaire. Cette solution proposée, réduit considérablement les heures de travaux manuelles consacrées à l'identification et à la capture des informations requises en automatisant le processus d'extraction des variables financières pour près de 70 000 PDF par an en temps quasi réel. Il comprend également le développement d'un système de gestion des métadonnées robuste qui indexe près de 150 variables pour chaque document financier ainsi qu'une application web qui permet aux utilisateurs d'interagir avec les données extraites. Consultez le récent article du Réseau de la science des données sur Intelligence documentaire : l'art de l'extraction d'information à partir des PDF.

Assistant d'affaires, agent conversationnel d'Innovation, Sciences et Développement économique Canada (ISDE)

ISDE a commencé à mettre en œuvre la technologie de l'assistant virtuel en 2019 avec un produit appelé agent Conversationnel. L'assistant virtuel est un canal de communication que les Canadiens peuvent actuellement exploiter lorsqu'ils atterrissent sur les pages web et l'application mobile de l'ISDE. L'Office de la propriété intellectuelle du Canada (OPIC), Corporations Canada (CC) et le Secteur des Communications Stratégiques et du Marketing (SCSM) et l'appli Entreprises Canada utilisent un agent conversationnel sur le web et sur les plate-formes mobiles pour aider à réduire les appels vers les centres d'appels et offrir un service amélioré lorsqu'ils fournissent des informations aux Canadiens qui visitent leurs sites web ou leurs applications. L'agent actuel est construit sur une architecture Microsoft tirant parti de Microsoft Azure et de l'IA de compréhension du langage de Microsoft, LUIS. Une présentation similaire a été faite lors de l'atelier sur les agents conversationnels organisé par le Réseau de la science des données. Les présentateurs y expliquaient le contexte et l'objet de leur technologie d'assistant virtuel. Voir Conversation sur les agents conversationnels – Compte rendu de l'atelier sur les agents conversationnels.

Conclusion

Tout au long de l'année 2021, des personnes de différents ministères et organismes du gouvernement du Canada ont présenté diverses applications de techniques d'apprentissage automatique (AA) aux données textuelles. Nous avons couvert différentes étapes du pipeline des données, allant du prétraitement à la visualisation. Nos membres tirent profit de chacune des expériences et des leçons apprises par les autres et peuvent ensuite créer plus efficacement des produits d'AA.

En 2022, la Communauté de pratique (CdP) continuera d'être un centre qui permet aux fonctionnaires de faire connaître leur passion pour l'application des techniques d'AA dans le but de répondre à des problèmes opérationnels concrets. La CdP est menée par Statistique Canada et bénéficie de la participation active de tous les ministères de la fonction publique fédérale. Nous encourageons les présentations de tous les ministères et nous espérons continuer à couvrir le nombre croissant d'applications du TLN dans les ministères.

Pour obtenir plus de renseignements sur la CdP ou pour en devenir membre, veuillez communiquer avec la Communauté de pratique de l'apprentissage automatique appliqué à l'analyse de textes : statcan.appliedmltextcop-cdpaaappliquetexte.statcan@statcan.gc.ca. Les employés du gouvernement du Canada peuvent également faire partie de notre groupe GCExchange sur la Communauté de pratique (CdP) sur l'apprentissage automatique appliqué : Analyse de texte.

Par Claudia Mokbel et Kathleen Carson, Statistique Canada

Le Réseau de la science des données (RSD) a été créé il y a plus d'un an dans le but d'instaurer un espace dynamique de collaboration pour les spécialistes de la science des données et les passionnés du domaine. Pour reprendre le pédagogue Steven Anderson : « Seuls, nous sommes intelligents. Ensemble, nous sommes géniaux. » Cet énoncé décrit parfaitement le principe sur lequel repose le RSD, car cela témoigne de la nécessité de collaborer au sein de la communauté de la science des données afin de repousser constamment les limites.

C'est dans cette optique que le RSD a organisé l'atelier sur les agents conversationnels et a invité les participants à discuter de tous les aspects liés à la mise en œuvre d'agents conversationnels, y compris des participants qui songeaient à se doter d'un tel agent, mais qui ne savaient pas trop par où commencer. L'atelier a entre autres servi à exposer les différentes étapes du processus de mise en œuvre des agents conversationnels et a permis aux participants d'établir des contacts en prévision du moment où ils seront prêts à amorcer le processus de mise en œuvre d'agents conversationnels.

« La science des données est en quelque sorte un sport d'équipe, et je me plais à penser que le Réseau de la science des données constitue le stade où les gens peuvent mettre en commun l'expérience acquise dans le cadre de l'élaboration d'outils opérationnels qui permettent de résoudre des problèmes organisationnels concrets », a mentionné Eric Rancourt, directeur général de la Direction des méthodes statistiques modernes et de la science des données à Statistique Canada. « À titre de chef de file de confiance en matière de science des données, Statistique Canada est fier d'animer de tels événements afin qu'il soit possible de mettre à profit les connaissances collectives portant sur les initiatives nouvelles et novatrices en matière de science des données. »

« C'est l'un des principaux objectifs du Réseau de la science des données : créer un espace dynamique qui nous permet d'établir des liens et de collaborer avec des pairs », ajoute Sevgui Erman, directrice de la Division de la science des données à Statistique Canada. « De cette manière, nous pouvons apprendre et acquérir ensemble des connaissances et des compétences qui aident notre communauté à s'épanouir. L'atelier sur les agents conversationnels a constitué un excellent outil pour continuer de progresser en vue de l'atteinte de cet objectif. »

Au cas où vous l'auriez manqué…

L'atelier sur les agents conversationnels, qui s'est tenu le 6 décembre 2021, a porté notamment sur différents projets axés sur des avancées technologiques en matière d'intelligence artificielle (IA) pour aider les utilisateurs à interagir avec des services ou des applications Web. En tout, 255 personnes ont participé à l'événement, dont des représentants du secteur privé, du secteur public et du milieu universitaire; il y avait même des participants qui venaient d'Europe.

L'atelier a débuté par un mot de bienvenue de Sevgui Erman et d'Eric Rancourt. Le maître de cérémonie était Jeremy Solomon, chef du Réseau et de la stratégie de la science des données à Statistique Canada, qui est également responsable du bulletin mensuel du Réseau de la science des données Méli-mélo de la science des données.

Vous trouverez les présentations sur les agents conversationnels faites par les six ministères et organismes fédéraux participants, dans les deux langues officielles, en visitant la page des présentations de l'atelier les agents conversationnels de GCWiki.

Dans la première présentation, John Nephin, de Services partagés Canada (SPC), propose une démonstration des services d'agent conversationnel Azure de son organisme et de l'architecture sous-jacente. Également, il décrit le cadre et les services entourant la logique des agents numériques, l'expérience utilisateur, l'aspect de la cognition, l'ingestion de données, et plus encore.

La deuxième présentation a été faite par Charith Gunasekara, ingénieur agréé travaillant au ministère de la Défense nationale. Cette présentation était axée sur la création, à partir de technologies de sources ouvertes, d'un agent conversationnel apte à répondre aux questions.

Mary Griffin et Fraydon Karimi d'Innovation, Sciences et Développement économique Canada ont présenté l'assise technologique de l'assistant virtuel de leur ministère. Ils ont exposé le contexte et l'objectif entourant la mise en œuvre de leur agent conversationnel et ont donné un aperçu de l'architecture sur laquelle il repose.

Après une courte pause, la quatrième présentation, faite par Alexandre Istrate, de la Division de la science des données à Statistique Canada, a porté sur les progrès réalisés par sa division en vue d'élaborer une solution robuste d'agent conversationnel à temps pour l'essai comportemental du recensement prévu en 2024, ce qui aidera aussi Statistique Canada à se préparer pour le Recensement de 2026.

Alexei Lapouchnian, gestionnaire de l'Accélérateur numérique de Ressources naturelles Canada, a traité de l'incorporation des systèmes d'IA aux concepts organisationnels axés sur les assistants intelligents. Ce projet était fondé sur les résultats de recherches menées à l'Université de Toronto en partenariat avec une grande entreprise technologique. Le but du projet consistait à découvrir comment intégrer l'IA aux processus opérationnels (PO) d'entreprise et à augmenter le nombre de décisions prises dans le cadre de ces PO assistés par l'IA. La présentation décrit les problèmes actuels liés à l'adoption de l'IA dans les entreprises et propose des solutions envisageables.

Gias Uddin, du Bureau du surintendant des institutions financières, a fait la dernière présentation. Celle-ci portait sur la conception de trousses d'outils de traitement du langage naturel au sein de l'industrie et dans le domaine de la recherche, incluant les leçons apprises et les messages à retenir.

Prochaines étapes

Le RSD a pris de l'expansion au cours de la dernière année; il constitue désormais un carrefour central où convergent les praticiens de la science des données, les gestionnaires et toutes les personnes qui ont un intérêt pour le domaine, qu'ils viennent du secteur privé, du secteur public, du milieu universitaire ou d'ailleurs. Le plan est de continuer à bâtir le Réseau en fonction des besoins de ses membres. Consultez l'article Le bulletin d'information du Réseau de la science des données a un an pour en savoir plus.

Considérant les bons commentaires reçus au sujet de l'atelier sur les agents conversationnels, le RSD a déjà entamé des travaux pour organiser d'autres événements du même genre. L'équipe se consacre actuellement à la mise sur pied d'un atelier sur les carrefours de données, qui devrait avoir lieu au début de mars. Si vous souhaitez faire une présentation dans le cadre de cet atelier, communiquez avec nous : statcan.dsnfps-rsdfpf.statcan@statcan.gc.ca.

À titre de chef de file de confiance en matière de science des données, Statistique Canada continuera d'appuyer l'essor d'un robuste écosystème de la science des données grâce à des événements et à des ateliers ayant pour but d'établir des liens avec d'autres praticiens et gestionnaires de la science des données. Le RSD vous tiendra au courant des initiatives de collaboration, des projets et des ateliers futurs.

Auteur : Anurag Bejju, Statistique Canada

Les documents PDF (Portable Document Format) sont l'un des formats de fichier les plus populaires et les plus utilisés. Tandis que le monde évolue rapidement vers une économie numérique, les PDF sont devenus une solution écologique au papier, permettant aux créateurs de diffuser, d'imprimer et de visualiser facilement un fichier dans sa mise en page prévue sur de multiples plateformes. Ils contiennent une foule de renseignements importants pour les organisations, les entreprises et les institutions, dans un format qui reflète le papier qu'ils ont remplacé.

Bien que les PDF constituent un moyen fiable de formater et de stocker des données, il n'est pas toujours facile d'en extraire les données. Statistique Canada a tiré parti de la puissance des technologies d'intelligence artificielle responsables et de l'application de solutions de science des données pour rechercher et élaborer des solutions permettant d'extraire de précieux renseignements de sources non structurées comme les PDF et les images numérisées. L'application de ces solutions permet de réduire les coûts et garantit que les renseignements sont fournis aux Canadiens de manière plus opportune, plus précise et plus sécurisée. En obtenant, puis en extrayant des données à partir de documents PDF, nous pouvons concevoir des moyens de générer des statistiques significatives de haute qualité en temps opportun. Cela permet de gagner un temps considérable dans la saisie des données et permet aux chercheurs de consacrer leur temps à des analyses plus importantes.

Qu'est-ce que l'intelligence documentaire?

Travailler avec des documents non structurés est complexe et peut entraîner un gaspillage de ressources précieuses. De nombreux services financiers, organismes gouvernementaux et autres grandes entreprises travaillent avec des documents imprimés et électroniques qui doivent être transformés et stockés dans un format de données consultable et interrogeable (p. ex. JSON ou CSV). Le processus d'extraction et de transformation des données à partir des PDF est souvent effectué manuellement et peut demander beaucoup de ressources, car les membres doivent copier des parties de renseignements pertinents et les formater dans une structure tabulaire. Ce processus peut être lourd, entraîner des erreurs et provoquer des retards. Même avec de multiples ressources pour la récupération des données, il faut parfois des jours ou des semaines pour obtenir des renseignements concrets.

En réponse à ces défis, les entreprises technologiques créent des outils d'automatisation qui permettent de saisir, d'extraire et de traiter les données à partir de divers formats de documents. Les technologies d'intelligence artificielle, telles que le traitement automatique du langage naturel, la vision par ordinateur, l'apprentissage profond et l'apprentissage automatique, créent des solutions en libre accès qui transforment les renseignements non structurés et semi-structurés en données exploitables. Ces technologies d'intelligence documentaire sont appelées traitement intelligent des documents.

Quels sont les avantages du traitement intelligent des documents?

Le traitement intelligent des documents présente six avantages essentiels :

1. Temps : Il faut moins de temps pour traiter et créer des sources de données structurées.
2. Argent : Il permet de réaliser des économies en réduisant le travail d'extraction manuelle.
3. Efficacité : Il supprime les tâches répétitives en milieu de travail et accroît la productivité.
4. Fiabilité : Il augmente la précision des renseignements extraits et réduit les erreurs humaines.
5. Évolutivité : Il offre la possibilité de faire évoluer un grand volume de documents à un coût relativement faible.
6. Polyvalence : Il traite les documents structurés, semi-structurés et non structurés dans la plupart des formats.

Types de documents PDF

Les trois types de documents PDF les plus courants sont les suivants :

1. PDF structurés : La mise en page et la structure sous-jacentes de ces documents restent fixes dans l'ensemble des données. En créant des segments, puis en leur apposant des étiquettes appropriées, on construit des pipelines d'automatisation pour extraire et structurer les valeurs dans un format tabulaire. Ces modèles peuvent être reproduits pour des formulaires présentant des dispositions similaires.
2. PDF textuels non structurés : Si vous pouvez cliquer et glisser pour sélectionner du texte dans une visionneuse PDF, votre document PDF est un document textuel. Extraire du texte libre de ces documents peut être assez simple, mais le faire en tenant compte de la mise en page ou du contexte peut être extrêmement difficile. La base de données Système électronique de données, d'analyse et de recherche (SEDAR) utilisée par Statistique Canada (qui sera expliquée plus en détail plus bas dans l'article) contient des millions de PDF textuels non structurés qui nécessitent des techniques avancées de traitement intelligent des documents afin de créer des ensembles de données structurés.
3. PDF non structurés numérisés : Les documents PDF numérisés contiennent des renseignements de formes et de tailles multiples. Des étapes supplémentaires permettent de localiser les composants du texte et d'effectuer une reconnaissance optique des caractères pour extraire le texte. Une fois que le PDF est converti en texte et que l'emplacement du texte est spécifié, vous pouvez déployer des méthodes semblables à celles utilisées pour les PDF textuels pour extraire des renseignements. Les dernières recherches dans ce domaine seront abordées dans les prochains articles de cette série.

Bibliothèques de source libre disponibles pour l'extraction de PDF

Progiciel 1 : PyPDF2

PyPDF2 (le contenu de cette page est en anglais) est une boîte à outils PDF entièrement en langage Python provenant du projet PyPDF. Elle peut extraire des données de fichiers PDF ou manipuler des fichiers PDF existants pour produire un nouveau fichier. Cela permet au développeur de recueillir, diviser, transformer et fusionner des PDF ainsi que d'extraire les métadonnées associées au PDF. Comme le montre l'image, la précision de l'extraction du texte est inférieure à celle des autres logiciels, et vous ne pouvez pas extraire d'images, de cadres de délimitation, de graphiques ou d'autres supports de ces documents. Il s'agit d'un bon outil si le seul objectif est d'extraire du texte libre indépendamment de sa mise en page.

Extrait de code

import PyPDF2

with open(pdf_path, "rb") as f:
    reader = PyPDF2.PdfFileReader(f)
    page = reader.getPage(1)
    output = page.extractText()
	

Exemple de PDF

Sorties

Progiciel 2 : PyMuPDF

PyMuPDF (le contenu de cette page est en anglais) est une liaison Python pour MuPDF, soit une visionneuse, un moteur de rendu et une boîte à outils légers pour les documents PDF, les fichiers XPS et les livres numériques, qui est développée et mise à jour par Artifex Software inc. Il permet au développeur d'obtenir des fonctionnalités beaucoup plus avancées basées sur la mise en page, avec une capacité de rendu et une vitesse de traitement élevée. Les programmeurs ont accès à de nombreuses fonctions importantes de MuPDF à partir d'un environnement Python. Comme PDFMiner (décrit sous Progiciel 3), ce progiciel ne fournit que des renseignements sur la mise en page, et le développeur doit construire des processus pour les structurer et les formater.

Extrait de code

import fitz
import pandas as pd

doc = fitz.open(good_pdf_path)
page = doc[4]
_, _, p_width, p_height = page.MediaBox
text = page.getText("blocks")
output = pd.DataFrame(text, columns=["block_xMin", "block_yMin", "block_xMax", "block_yMax", "block_text", "block_id", "page" ])

Exemple de PDF

Sorties

Progiciel 3 : PDFMiner

Le progiciel PDFMiner (le contenu de cette page est en anglais) vous permet d'analyser tous les objets d'un document PDF en objets Python et d'analyser, de regrouper et d'extraire du texte ou des images de manière lisible par un humain. Il prend également en charge des langues comme le chinois, le japonais et le coréen ainsi que l'écriture verticale. Comme le montre l'image, vous pouvez obtenir des renseignements tels que le cadre de délimitation exact de chaque élément de texte sous forme de chaîne, ainsi que d'autres renseignements sur la mise en page (polices, etc.). Bien que ce progiciel puisse être excellent pour localiser des éléments dans le document, le développeur doit construire des processus pour le structurer et le formater.

Extrait de code

from pdfminer.pdfdocument import PDFDocument
from pdfminer.pdfpage import PDFPage
from pdfminer.pdfparser import PDFParser
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.converter import PDFPageAggregator
from pdfminer.layout import LAParams, LTTextBox, LTTextLine, LTFigure
import pandas as pd
output = []
def parse_layout(layout):
    """Function to recursively parse the layout tree."""

    for lt_obj in layout:

        if isinstance(lt_obj, LTTextBox) or isinstance(lt_obj, LTTextLine):
            output.append([lt_obj.__class__.__name__, lt_obj.bbox, lt_obj.get_text()])
        elif isinstance(lt_obj, LTFigure):
            parse_layout(lt_obj)  # Recursive

with open(pdf_path, "rb") as f:
    parser = PDFParser(f)
    doc = PDFDocument(parser)
    page = list(PDFPage.create_pages(doc))[1]  # Page Number
    rsrcmgr = PDFResourceManager()
    device = PDFPageAggregator(rsrcmgr, laparams=LAParams())
    interpreter = PDFPageInterpreter(rsrcmgr, device)
    interpreter.process_page(page)
    layout = device.get_result()
    _, _, width, height = page.mediabox
    parse_layout(layout)

output = pd.DataFrame(output, columns=["bbox_type", "coords", "token"])
output[["word_xMin", "word_yMin", "word_xMax", "word_yMax"]] =  output["coords"].to_list()

Exemple de PDF

Sorties

Progiciel 4 : Tabula-py

Tabula-py (le contenu de cette page est en anglais) est une simple enveloppe Python de tabula-java, qui peut lire un tableau à partir de PDF et le convertir en format DataFrame de pandas. Il vous permet également de le convertir en fichier CSV, TSV et JSON et d'utiliser des fonctionnalités avancées comme la grille, qui fonctionne bien pour les lignes séparant les cellules du tableau. Il peut être difficile d'extraire et de détecter correctement le contenu des tableaux pour les PDF plus complexes.

Extrait de code

import tabula
import pandas as pd

output = tabula.read_pdf(pdf_path, lattice=False, pages=4)[0]

Exemple de PDF

Sorties

Progiciel 5 : Camelot

Tout comme Tabula-py, Camelot (le contenu de cette page est en anglais) est également une bibliothèque Python qui peut vous aider à extraire les tableaux des documents PDF. Il s'agit du progiciel le plus efficace et le plus avancé, qui vous permet de contrôler le processus d'extraction des tableaux. Il fournit également des mesures de précision et d'espacement des blancs pour le contrôle de la qualité, ainsi que des méthodes de segmentation des pages pour améliorer l'extraction.

Extrait de code

import camelot
tables = camelot.read_pdf(good_pdf_path)
output = tables[0].df

Exemple de PDF

Sorties

Utilisation du traitement intelligent des documents dans le projet SEDAR

Statistique Canada a acquis l'ensemble de données historiques du système de classement SEDAR. Les spécialistes des données disposent ainsi d'une source de données de rechange qui leur permet d'obtenir des renseignements précieux et de fournir des renseignements en temps opportun. SEDAR est un système utilisé par les sociétés canadiennes cotées en bourse pour déposer des documents relatifs aux valeurs mobilières (tels que des états financiers, des rapports annuels et des notices annuelles) auprès de diverses commissions canadiennes des valeurs mobilières. Les employés de Statistique Canada utilisent la base de données SEDAR pour la recherche, la confrontation des données, la validation, le processus de mise à jour de la base de sondage, et plus encore. Toutefois, l'extraction de données à partir des documents relatifs aux titres publics se fait manuellement et prend beaucoup de temps.

Pour gagner en efficacité, l'équipe des sciences des données a mis au point un pipeline d'intelligence documentaire basé sur l'intelligence artificielle qui détermine et extrait correctement les variables financières clés des bons tableaux d'un document PDF. Cela a permis de transformer une grande quantité de documents publics non structurés provenant de SEDAR en ensembles de données structurées. Cette transformation permet l'automatisation et l'extraction de renseignements économiques relatifs aux entreprises canadiennes.

La première partie du processus d'automatisation consiste à déterminer les pages requises dans le document PDF, ce qui est fait à l'aide d'une méthodologie élaborée à Statistique Canada. Une sous-section du document comprenant une forte densité de tableaux est d'abord établie. Cette sous-section de pages est ensuite traitée afin d'extraire les caractéristiques principales, qui sont utilisées par un modèle de classification par apprentissage automatique formé pour déterminer les bonnes pages. La deuxième partie du processus d'automatisation porte sur l'extraction des tableaux. Les pages déterminées à la première étape servent d'entrée pour un algorithme d'extraction de tableaux élaboré à l'interne appelé algorithme Spatial Layout based Information and Content Extraction (SLICE)(le contenu de cette page est en anglais), qui extrait tous les renseignements dans un tableau en format numérique. Les données sont présentées dans une application Web interactive et peuvent être téléchargées en format CSV.

Ce processus robuste automatise le processus d'extraction des variables financières pour un maximum de 70 000 PDF par an en quasi temps réel. Cela permet de réduire considérablement le nombre d'heures passées à déceler et à saisir manuellement les renseignements requis et de réduire la redondance des données.

Souhaitez-vous en savoir plus sur l'intelligence documentaire?

Les outils à code source ouvert fonctionnent pour les processus simples d'extraction de PDF, mais ne sont pas adaptés aux sources complexes, non structurées et variables de documents PDF. Dans les prochains articles, nous aborderons les dernières recherches en matière d'apprentissage automatique et d'intelligence artificielle dans le domaine de l'intelligence documentaire. Nous parlerons encore également de SLICE, le nouvel algorithme de vision par ordinateur conçu et développé par Statistique Canada que nous avons mentionné auparavant. Cet algorithme a la capacité d'utiliser simultanément des renseignements textuels, visuels et de mise en page pour segmenter plusieurs points de données dans une structure tabulaire. Cette solution modulaire fonctionne avec des tableaux non structurés et effectue l'extraction de variables financières à partir d'une variété de documents PDF.

Par : Alden Chen, Statistique Canada

Introduction

La visualisation des données est un élément clé de nombreux projets de science des données. Pour certains intervenants, notamment les spécialistes du domaine et les cadres qui ne sont pas nécessairement des experts techniques, il s'agit de la principale voie par laquelle ils voient, comprennent et interagissent avec les projets de données. Par conséquent, il est important que les visualisations communiquent des renseignements aussi clairement que possible. Trop souvent, les visualisations sont entravées par certains défauts courants qui les rendent difficiles à interpréter ou, pire encore, sont trompeuses. Cet article passe en revue trois pièges courants de la visualisation que les communicateurs de données et les consommateurs de données devraient comprendre, ainsi que quelques suggestions pratiques pour les contourner.

Distorsion et perception

La qualité la plus importante d'une visualisation efficace est qu'elle représente fidèlement les données sous-jacentes. Il y a distorsion lorsque les données présentées ne peuvent être perçues avec précision. Le degré de distorsion de la visualisation est directement lié à la facilité de perception de l'information présentée. Lors de la conception de visualisations, il est important de se souvenir que des encodages visuels différents sont perçus différemment, ce qui peut mener à des résultats déformés et mal interprétés.

En 1957, le psychologue Stanley Smith Stevens, dans son ouvrage intitulé On the psychophysical law (le contenu de cette page est en anglais) a démontré l'existence d'une relation empirique, généralement non linéaire, entre l'ampleur physique et l'ampleur perçue d'un certain stimulus. Il a dégagé une relation de la formule $\psi \left(I\right)=k{I}^a$, où $I$ représente l'intensité physique du stimulus et $\psi \left(I\right)$ représente la sensation perçue (Stevens, 1957). La variable la plus importante ici est $a$, l'exposant qui relie la perception du stimulus à la magnitude physique réelle du stimulus ($k$ est une constante de proportionnalité pour adapter les unités). Notre perception varie en fonction de la manière dont les données sont encodées. Lors de l'expérience d'un codage avec $a$ inférieur à un, l'ampleur du stimulus a tendance à être sous-estimée. Lors de l'expérience d'un codage avec $a$ supérieur à un, l'ampleur du stimulus a tendance à être surestimée.

Figure 1 : La loi de puissance de Stevens

Aujourd'hui, cette relation connue sous le nom de la loi de puissance de Stevens est l'un des résultats les plus connus de la psychophysique et il est important de la comprendre pour la visualisation des données. La figure 1 illustre certains des encodages visuels testés par Stevens, ainsi que l'activité électrique à titre de référence. Certains codages, comme la saturation des couleurs, mènent à une surestimation de l'effet, tandis que d'autres codages, comme la zone, mènent à une sous-estimation de l'effet réel. Lorsque l'on utilise ces codages pour représenter des données, l'incapacité à percevoir les véritables données ou effets mènent à une distorsion. Il faut noter que si la capacité à percevoir la plupart des codages est non linéaire, la capacité à percevoir la longueur est linéaire.

Prenons l'exemple suivant, qui code les mêmes données en utilisant la zone et la longueur. Il est beaucoup plus difficile de discerner à quel point 96 est supérieur à 32 en regardant les cercles de la figure 2 qu'en regardant le diagramme à barres de la figure 3. De plus, il est presque indiscernable que l'aire du cercle 100 est plus grande que l'aire du cercle 96, alors qu'il est clair que 100 est plus grand que 96 quand on regarde la longueur des barres. La différence entre 100 et 96 est déformée lors de l'encodage de l'information en utilisant la zone.

Figure 2 : Graphique à cercles

Figure 3 : Graphique à barres

Les deux graphiques codent les mêmes données. Le premier graphique utilise la surface de chaque cercle pour coder les données, tandis que le second graphique utilise la longueur de chaque barre. Deux des cercles ont une surface presque indiscernable, alors qu'il est clair que les deux barres correspondantes sont de longueur différente.

Les visualisations de données utilisent souvent des encodages qui déforment les données, comme les cartes thermiques (saturation des couleurs, $a = 1.7$) et les diagrammes circulaires (surface, $a = 0.7$). Il est important de reconnaître les distorsions et d'examiner les chiffres réels qui sous-tendent la visualisation avant de porter des jugements hâtifs. Lorsque vous réalisez des visualisations et choisissez des encodages visuels, il est utile de comprendre la théorie de la perception visuelle. Ce sont souvent les visuels les plus simples qui sont les plus efficaces. Prenons le classement des encodages visuels du tableau 1 comme point de départ (Mackinlay, 1986). Mackinlay a formulé des recommandations sur l'encodage des différents types de données : données quantitatives, ordinales et nominales. L'efficacité des codages dépend du type de données. Par exemple, la couleur n'est pas un codage efficace pour les données quantitatives; en revanche, elle est très efficace pour les données nominales. Il est bon de coder les renseignements les plus importants en utilisant le codage le plus efficace et le moins déformé.

Tableau 1 : Le classement d'encodages visuels de Mackinlay pour différents types de données, classés du plus efficace au moins efficace.

Occlusion et surreprésentation

L'occlusion dans la visualisation des données se produit lorsque deux points de données se chevauchent, partiellement ou entièrement. Par exemple, deux points peuvent être directement superposés, ce qui ne permet pas au lecteur de savoir qu'il y a en fait plusieurs points de données. Par conséquent, il devient difficile de voir toute l'étendue des données présentées, et l'effet des points occultés ne peut être vu.

La surreprésentation, c'est-à-dire l'affichage de trop de données, est une cause fréquente d'occlusion. Cela peut se produire dans le but d'afficher le plus de données possible afin de donner au public une image entière. Prenons les figures 4 à 7, qui illustrent l'occlusion causée par la surreprésentation et présentent quelques solutions potentielles. Chacun de ces graphiques affiche le même ensemble de 10 000 points. Dans la figure 4, la répartition des points ne peut pas vraiment être vue à cause de l'occlusion. Il y a tellement de points qui se chevauchent que tout ce que l'on peut voir est une grande masse de points couvrant presque tout le quadrant inférieur gauche du graphique. Les graphiques suivants montrent quelques options possibles pour aider à réduire l'occlusion.

Les points de la figure 5 sont légèrement plus petits et plus transparents. En modifiant la transparence (souvent représentée par $\alpha$) le public peut mieux voir la répartition et les points occultés, bien que de nombreux points soient encore occultés près de l'origine.

Dans la figure 6, aucun point n'est représenté. Il y a plutôt un tracé de contours montrant la distribution des points, où les points sont fortement concentrés autour d'une petite région près de l'origine. Souvent, lorsqu'on traite de grands ensembles de données, tels que ceux générés par les simulations, les points spécifiques ne sont pas particulièrement intéressants; c'est plutôt le modèle général qui est important, et qui est saisi clairement par le tracé de contours.

Figure 4 : Nuage de points 1

Figure 5 : Nuage de points 2

Figure 6 : Tracé de contours

Figure 7 : Histogramme en 3D

La figure 7 montre un histogramme tridimensionnel. Les créateurs de visualisations qui souhaitent afficher un grand nombre de données peuvent être tentés d'ajouter un axe supplémentaire à une visualisation 3D, mais les graphiques en 3D rendent rarement la visualisation plus claire, car ils provoquent eux-mêmes une occlusion. Dans la figure 7, la nature tridimensionnelle du tracé signifie que les barres les plus hautes occultent les barres les plus courtes et que les barres à l'avant occultent les barres à l'arrière. Ainsi, si l'utilisation de la 3D peut réduire la surreprésentation, elle ne résout pas le problème de l'occlusion, et le public ne peut toujours pas voir l'ensemble des données. Les graphiques en 3D donnent presque toujours lieu à des occlusions, et la gestion des occlusions dans la visualisation 3D est un domaine de recherche assez actif en infographie. (Voir Trapp et coll., 2019; Wang et coll., 2019.)

En résumé, s'il est généralement judicieux de montrer aux lecteurs les données réelles, la représentation graphique excessive est contre-productive. L'occlusion causée par la surreprésentation peut parfois cacher la tendance principale des données. L'adaptation de certains éléments visuels, tels que la taille et la transparence des points, peut aider, mais il est également important de se demander si le tracé de tous les points de données individuels est nécessaire pour l'analyse présentée.

Redondance et encombrement

Pour mieux délimiter les différences dans les données, vous pouvez choisir de coder certaines valeurs de manière redondante en utilisant plusieurs caractéristiques; cette pratique est appelée codage redondant. Par exemple, vous pouvez choisir de distinguer deux classes en utilisant à la fois la couleur et la forme, par exemple des triangles orange et des carrés bleus, dans un nuage de points. Les codages redondants sont largement utilisés et sont censés améliorer la clarté des visualisations. En fait, plusieurs logiciels utilisent des encodages redondants par défaut pour certains visuels; le soutien empirique de cette pratique est cependant mitigé (Nothelfer et coll., 2017; Chun, 2017).

Il est important de se souvenir que les codages redondants ont un défaut, c'est-à-dire qu'ils sont encombrants et ne sont pas toujours utiles. Prenons les figures 8 et 9. La figure 8 présente un diagramme à barres avec la même information (32, 96, 100) codée de quatre manières différentes. Les termes le long de l'axe du x (faible, moyen, élevé) codent déjà les données, bien que de manière grossière. Il y a ensuite la longueur des barres elles-mêmes, qui sont également accompagnées de chiffres indiquant explicitement la valeur. Enfin, il existe une échelle de couleurs discrète où la couleur des barres représente également la valeur. Il existe quatre indices visuels distincts qui codent tous la même information. Ce graphique à barres représente un environnement sans pollution visuelle; c'est un graphique simple avec seulement trois barres. Dans les environnements à faible niveau de distraction visuelle, la redondance se résume généralement à un encombrement. Comparons la figure 9, qui est sans codage de couleurs. On pourrait dire que la visualisation est rendue plus efficace par la suppression d'un codage inutile qui aurait pu distraire les lecteurs des données réelles.

Figure 8

Figure 9

Comparons maintenant les figures 8 et 9 avec des environnements plus distrayants, comme le montrent les figures 10 à 12, qui présentent des données avec trois catégories qui ne sont pas clairement séparées. Dans des cas comme celui-ci, il existe des preuves empiriques que les encodages redondants aident à mieux segmenter les données, c'est-à-dire à distinguer les classes (Nothelfer et coll., 2017). Dans la figure 10, la catégorie est codée uniquement par la forme, dans la figure 11, la catégorie est codée uniquement par la couleur et dans la figure 12, la catégorie est codée de manière redondante en utilisant à la fois la forme et la couleur. Si l'on prend en considération uniquement la forme (figure 10), il est plus difficile de segmenter les catégories. Dans les figures 11 et 12, il est plus facile de dire qu'une catégorie a une variance plus faible que les autres catégories, qu'elle est étroitement groupée près de l'origine, et que la troisième catégorie est plus étalée. Dans un affichage distrayant comme celui-ci, le fait d'utiliser la redondance plutôt que l'encombrement, comme dans l'exemple précédent, peut en fait aider à réduire les distractions pour mieux délimiter les catégories. Cependant, les différentes catégories sont déjà assez clairement segmentées par la couleur. Cela tient probablement au fait que la couleur est un encodage plus efficace que la forme pour distinguer les groupes. L'encodage redondant peut ne pas apporter grand-chose dans ce cas, ce qui en fait un choix plus esthétique.

Figure 10

Figure 11

Figure 12

Il est important de tenir compte de la différence entre redondance et encombrement lors de la conception de visualisations. Dans le cas de visuels simples, il est peu probable que des codages redondants rendent le visuel plus clair, ils ne font que l'encombrer. Dans un affichage plus distrayant, certaines preuves empiriques laissent entendre que des encodages redondants peuvent aider; cependant, le choix d'un seul encodage très efficace peut également donner de bons résultats. La redondance dans un affichage distrayant ne fait probablement pas de mal et devient davantage un choix de style.

Conclusion

De bons visuels sont essentiels pour raconter l'histoire des données aussi efficacement que possible, et une visualisation efficace peut rendre les données plus faciles à comprendre pour un public plus large. Pour qu'une visualisation soit efficace, elle doit représenter fidèlement les données sous-jacentes. La visualisation des données pose fréquemment certains problèmes qui peuvent mener à des erreurs d'interprétation. Une certaine compréhension de la théorie de la perception visuelle peut aider les scientifiques des données à mieux concevoir et interpréter les visualisations de données afin de réduire la distorsion. L'affichage d'un trop grand nombre de données peut également être trompeur, car il peut entraîner une occlusion. Il faut envisager des modifications simples, comme la taille et la transparence, pour aider à réduire l'occlusion et se demander si le tracé de toutes les données est nécessaire aux fins de la visualisation. Enfin, il faut choisir la netteté plutôt que la redondance lorsque c'est possible. Les codages redondants n'apportent souvent pas beaucoup de valeur ajoutée et l'encombrement qu'ils créent peut nuire à l'histoire.

References

Chun, R. (2017). Redundant Encoding in Data Visualizations: Assessing Perceptual Accuracy and Speed. Visual Communication Quarterly (le contenu de cette page est en anglais), 24(3), 135-148.

Mackinlay, J. (1986). Automating the design of graphical presentation of relational information. ACM Transactionson Graphics (le contenu de cette page est en anglais), 5(2), 110-141.

Nothelfer, C., Gleicher, M.,& Franconeri, S. (2017). Redundant encoding strengthens segmentation and grouping in visual displays of data (le contenu de cette page est en anglais). Journal of Experimental Psychology: Human Perception and Performance, 43(9), 1667–1676.

Stevens, S. S. (1957). On the psychophysical law (le contenu de cette page est en anglais). Psychological Review, 64(3), 153–181.

Trapp, M., Dumke,F., & Döllner, J. (2019). Occlusion Management Techniques for the Visualization of Transportation Networks in Virtual 3D City Models (le contenu de cette page est en anglais). Proceedings of the 12th International Symposium on Visual Information Communication and Interaction

Wang, L., Zhao, H., Wang, Z., Wu, J.,Li, B., He, Z., & Popescu, V. (2019). Occlusion Management in VR: A Comparative Study (le contenu de cette page est en anglais). 2019 IEEE Conference on Virtual Reality and 3D User Interfaces (VR), 708-706.