Latest / M365.FM – Podcast Microsoft 365, Copilot & IA en français / Copilot contre développeur dans Power BI : qui gagne en modélisation, DAX et conception de tableaux de bord ? (Doublage IA)

Transcript

Copilot contre développeur dans Power BI : qui gagne en modélisation, DAX et conception de tableaux de bord ? (Doublage IA) · M365.FM – Podcast Microsoft 365, Copilot & IA en français

0:00
Speaker 2: Prêt pour 10 jours consacrés à Microsoft 365, Copilot, l'IA,
0:04
Speaker 2: Azure et au Person, qui façonnent l'avenir du travail. En
0:08
Speaker 2: janvier prochain, la M365-ON est de retour et nous voyons
0:11
Speaker 2: plus grand. Rejoignez-nous pour des sessions en direct, des démonstrations
0:15
Speaker 2: concrètes et les conseils pratiques d'experts et de MVPs du
0:17
Speaker 2: monde entier. Pas de diapositives génériques, pas de jargon inutile.
0:22
Speaker 2: Nous abordons les vrais défis. Copilot Studio, les agents IA, Fabric,
0:26
Speaker 2: la sécurité, la gouvernance et l'automatisation... Que vous soyez professionnel,
0:31
Speaker 2: de l'informatique, développeur ou dirigeant, des sessions sont conçues pour vous.
0:35
Speaker 2: Avec 10 jours complets, vous pourrez explorer de nombreuses technologies
0:38
Speaker 2: et rejoindre une communauté mondiale. Suivez le direct et rapportez
0:42
Speaker 2: des idées pratiques à votre organisation. Janvier 2027, 10 jours,
0:47
Speaker 2: une seule communauté Microsoft. Les inscriptions sont ouvertes. Réservez votre
0:53
Speaker 2: place dès aujourd'hui. Rendez-vous sur m365con. net. Inscrivez-vous sur n365n. net. Nous
1:02
Speaker 2: nous retrouvons en direct en janvier. Si Microsoft Copilot peut
1:06
Speaker 2: créer un tableau de bord Power BI plus vite qu'un
1:08
Speaker 2: développeur expérimenté, qu'est-ce que cela signifie pour votre avenir professionnel?
1:11
Speaker 2: Dans cette vidéo, nous mettons cette question à l'épreuve lors
1:14
Speaker 2: d'un duel entre l'IA et l'expertise humaine. D'un côté, des
1:18
Speaker 2: années d'expérience de l'autre, l'automatisation par la machine. La vraie question,
1:22
Speaker 2: laquelle de ces options apporte une réelle valeur ajoutée en entreprise?
1:26
Speaker 2: La grande peur, les développeurs sont-ils remplaçables? La question majeure
1:29
Speaker 2: qui se pose est simple. Si Copilot peut générer des
1:32
Speaker 2: tableaux de bord complets en un clic, que deviennent ceux
1:34
Speaker 2: qui ont été formés pendant des années pour le faire manuellement?
1:38
Speaker 2: Ce n'est pas le genre d'interrogation que l'on peut écarter
1:39
Speaker 2: d'un revers de main. Pour les développeurs ayant bâti leur
1:42
Speaker 2: carrière sur la maîtrise du DAX Power BI et de
1:44
Speaker 2: la modélisation de données, la vitesse de déploiement de Copilot
1:46
Speaker 2: par Microsoft est déstabilisante et déstabilisant. Ce malaise repose sur
1:50
Speaker 2: une réalité bien tangible. Les outils de Microsoft 365 intègrent
1:53
Speaker 2: l'IA à une vitesse folle et chaque nouvelle version semble
1:56
Speaker 2: privilégier l'automatisation au détriment du contrôle manuel. Dane. Des fonctionnalités
2:01
Speaker 2: nécessitant autrefois des compétences où une formation repose désormais sur
2:04
Speaker 2: les suggestions d'une machine. Si vos revenus dépendent de ces compétences,
2:09
Speaker 2: il est naturel de craindre que le sol ne se
2:10
Speaker 2: dérobe sous vos pieds. Le fait de voir l'IA surpasser
2:13
Speaker 2: les humains dans des domaines jugés jusqu'ici intouchables ne fait
2:15
Speaker 2: qu'accentuer cette inquiétude. Des machines qui codent, des modèles de
2:20
Speaker 2: langage réussissant des examens professionnels, une IA générant en quelques
2:22
Speaker 2: secondes des designs exigeant auparavant des heures de création. Ces
2:26
Speaker 2: récits construisent une narration puissante. L'humain tâtonne, l'IA progresse. La
2:30
Speaker 2: question qui revient sans cesse est de savoir si nous
2:32
Speaker 2: serons les prochains sur la liste. Avec Copilot directement intégré
2:34
Speaker 2: dans l'écosystème Microsoft, les travailleurs n'ont même pas à choisir
2:36
Speaker 2: de rivaliser. Il est inséré directement dans les outils qu'ils
2:38
Speaker 2: utilisent déjà pour leur travail. La tension monte donc. Si
2:41
Speaker 2: le logiciel est déjà sur votre tableau de bord, prêt
2:43
Speaker 2: à produire des résultats instantanément, combien de temps avant qu'il
2:45
Speaker 2: ne soit jugé suffisant pour vous remplacer totalement? Mais Power
2:49
Speaker 2: BI n'est pas qu'un terrain de jeu de graphique en glissé-déposé.
2:52
Speaker 2: Sous la surface, il s'agit de structurer des données métiers complexes,
2:55
Speaker 2: de résoudre les conflits de définition et de s'assurer que
2:57
Speaker 2: les chiffres correspondent au processus réel. Euh... Quiconque a dû
3:01
Speaker 2: déboguer un modèle avec plusieurs tables de faits sait qu'il
3:02
Speaker 2: existe un gouffre entre la très visuelle et la fiabilité analytique.
3:07
Speaker 2: Ce contexte, ce jugement, ce n'est pas quelque chose qu'un
3:08
Speaker 2: algorithme maîtrise automatiquement. On peut comparer cela à l'arrivée des
3:11
Speaker 2: calculatrices dans les salles de classe il y a des décennies.
3:14
Speaker 2: Ont-elles supprimé le besoin de mathématiciens? Elles ont simplement changé
3:18
Speaker 2: la donne. Soudain, l'arithmétique fondamentale a eu moins de poids
3:21
Speaker 2: professionnel car les machines la géraient mieux. Mais le raisonnement
3:24
Speaker 2: de haut niveau et la logique appliquée n'ont fait que
3:26
Speaker 2: gagner en importance. C'est le même recalibrage que les développeurs
3:29
Speaker 2: soupçonnent ici. Les recherches montrent souvent que l'IA prospère lorsque
3:33
Speaker 2: les règles sont explicites et la tâche répétitive. Donnez-lui une
3:37
Speaker 2: formule à optimiser et elle le fera sans fatigue. Mais
3:40
Speaker 2: la nuance, cette zone grise où la bonne réponse dépend
3:42
Speaker 2: de la culture d'entreprise ou de la stratégie locale n'est
3:44
Speaker 2: pas là où les machines excellentes... Prenons quelque chose d'aussi
3:48
Speaker 2: pratique que Coppellot suggérant une nouvelle mesure. Le modèle peut
3:50
Speaker 2: renvoyer une somme ou une moyenne techniquement correcte, mais un
3:53
Speaker 2: développeur chevronné sait qu'elle nécessite un contexte de filtre ou
3:55
Speaker 2: un ajustement métier ou un ajustement métier. Un collègue a
3:58
Speaker 2: partagé ce moment précis... Le copilote a généré du DAX
4:02
Speaker 2: en moins de 3 secondes, mais il a dû faire
4:04
Speaker 2: une pause, tester et ajuster la mesure, car la machine
4:06
Speaker 2: ne comprenait pas ce que signifiaient les ventes valides selon
4:08
Speaker 2: la logique métier. L'IA était efficace, mais cette efficacité nécessitait
4:13
Speaker 2: une supervision. Alors qu'est-ce que cela signifie en pratique? Cela
4:16
Speaker 2: signifie que nous ne pouvons pas accepter sans examen les
4:18
Speaker 2: hypothèses abstraites sur l'IA qui prendrait nos emplois. Nous devons
4:21
Speaker 2: voir comment elle s'en sort lorsque la tâche exige à
4:23
Speaker 2: la fois rapidité et compréhension. Nous voulons savoir si Copilot
4:26
Speaker 2: s'effondre quand les tables deviennent complexes ou s'il peut tenir
4:29
Speaker 2: face au chaos des exigences réelles. C'est là que cette
4:33
Speaker 2: expérience est importante. Au lieu de tourner autour de la peur,
4:35
Speaker 2: la mettons directement à l'épreuve. Il y a d'un côté
4:38
Speaker 2: les compétences humaines de l'autre, même défi, même données. Copilot
4:42
Speaker 2: prouvera-t-il que la modélisation manuelle est obsolète ou le développeur
4:44
Speaker 2: montrera-t-il que l'interprétation humaine est toujours indispensable? Cette vidéo est
4:48
Speaker 2: notre façon de remplacer la spéculation par des preuves. Vous
4:50
Speaker 2: verrez Copilot testé sous les mêmes contraintes qu'un professionnel et
4:53
Speaker 2: les résultats. confirmeront ou apaiseront nos soupçons. Peut-être que la
4:57
Speaker 2: peur d'être remplacé est exagérée, ou peut-être que l'inquiétude est
5:00
Speaker 2: justifiée d'une manière que nous n'avons pas encore admise. Quoi
5:02
Speaker 2: qu'il en soit, cette compétition apportera de la clarté. Et
5:05
Speaker 2: en parlant de clarté, examinons le défi. L'humain face à Copilot.
5:09
Speaker 2: Un simple clic peut-il vraiment égaler des années de pratique
5:12
Speaker 2: structurées dans la modélisation de données, l'écriture de DAX et
5:14
Speaker 2: la création de visuels pertinents pour les décideurs? Et c'est
5:17
Speaker 2: ce que nous allons mettre à l'épreuve. Le principe est simple.
5:19
Speaker 2: Deux participants, un défi, le même ensemble de données? D'un côté,
5:23
Speaker 2: un développeur qui connaît Power BI sur le bout des doigts,
5:25
Speaker 2: ayant résolu d'innombrables relations rompues et mesures erronées en production.
5:30
Speaker 2: De l'autre côté, Copilot, au lieu de saisir des formules
5:32
Speaker 2: ou de déplacer des champs, il écoute les instructions et
5:34
Speaker 2: génère automatiquement du code et des graphiques. C'est la vitesse
5:38
Speaker 2: contre le jugement, l'automatisation contre le savoir-faire. La question clé est,
5:41
Speaker 2: quelle méthode fonctionne le mieux lorsqu'il s'agit d'un outil sur
5:43
Speaker 2: lequel une entreprise doit s'appuyer? Pour dépasser la théorie, nous
5:47
Speaker 2: avons choisi une tâche représentative de ce que les professionnels
5:49
Speaker 2: rencontrent au quotidien. Hum... Ce n'est ni assez trivial pour
5:53
Speaker 2: être résolu en quelques secondes par une démo, ni assez
5:55
Speaker 2: personnalisé pour être hors de portée d'une machine. Les deux
5:57
Speaker 2: parties reçoivent un jeu de données de vente avec plusieurs tables, commandes, clients,
6:00
Speaker 2: détails produits et périodes temporelles. La demande est simple à énoncer,
6:04
Speaker 2: connecter la source, établir les relations, créer les mesures de
6:06
Speaker 2: revenus et de profits, et les afficher dans un tableau
6:08
Speaker 2: de bord, et les afficher dans un tableau de bord.
6:10
Speaker 2: Mais quiconque a touché à Power BI sait que cette
6:12
Speaker 2: formulation cache une multitude de défis. Les relations ne s'alignent
6:15
Speaker 2: pas toujours parfaitement. Les calculs de profit peuvent être plus
6:18
Speaker 2: complexes qu'il n'y paraît. Et les visuels peuvent sembler corrects
6:20
Speaker 2: par défaut, mais ne rien dire sans contexte. Le développeur
6:24
Speaker 2: abordera cela comme pour les projets de ses clients. Étape 1.
6:27
Speaker 2: Vérifier l'intégrité des tables sources. Étape 2. Définir les relations
6:30
Speaker 2: délibérément plutôt que de se fier aux paramètres par défaut.
6:33
Speaker 2: Étape 3. Concevoir des mesures adaptées aux besoins métiers plutôt
6:35
Speaker 2: que de simples calculs arithmétiques. C'est un travail méthodique et constant.
6:39
Speaker 2: L'approche de copilote semble presque étrangère en comparaison. Vous tapez
6:42
Speaker 2: une requête, comme afficher les ventes par région sa gueuve,
6:44
Speaker 2: ou créer une mesure pour le profil net à gueuve,
6:45
Speaker 2: et quelques secondes plus tard, il génère le résultat. En théorie,
6:49
Speaker 2: une instruction peut éviter plusieurs minutes d'effort manuel, mais la
6:51
Speaker 2: vitesse ne garantit pas l'exactitude. Si Copilot construit une relation
6:55
Speaker 2: uniquement basée sur les noms de colonnes, il pourrait ne
6:57
Speaker 2: pas saisir la logique métier-réel. Une erreur de clé étrangère
7:01
Speaker 2: qu'un humain remarquerait rapidement pourrait passer inaperçue dans la suggestion
7:04
Speaker 2: de Copilot. C'est là que les enjeux entrent en jeu.
7:06
Speaker 2: Il ne s'agit pas seulement d'être le plus rapide, mais
7:08
Speaker 2: d'avoir raison. Une erreur de calcul dans une démonstration est
7:10
Speaker 2: sans conséquence. Une erreur de calcul dans un bilan trimestriel
7:13
Speaker 2: peut influencer des décisions lourdes de conséquences. Et pourtant, on
7:17
Speaker 2: ne peut nier l'attrait d'appuyer sur un bouton pour obtenir
7:18
Speaker 2: des résultats instantanés. C'est comme regarder deux athlètes concourir, mais
7:22
Speaker 2: avec l'un d'eux, propulsés par une machine à... Dans le sport,
7:26
Speaker 2: la technologie transforme souvent la compétition, chaussures, maillots et même
7:30
Speaker 2: analyse de performance. Ici, le parallèle est identique. Copilote est
7:33
Speaker 2: cette technologie conçue pour infléchir le processus lui-même. Alors que
7:36
Speaker 2: le développeur s'appuie sur sa propre expertise... Il est fascinant
7:40
Speaker 2: de voir si la puissance technologique surpasse le savoir-faire. Ce
7:43
Speaker 2: qui rend cette comparaison particulièrement intéressante, c'est le rythme de départ.
7:47
Speaker 2: Copilot prend rapidement les devants. En quelques secondes, après avoir
7:50
Speaker 2: choisi un jeu de données, il génère des visuels, propose
7:52
Speaker 2: des champs calculés et remplit une toile vierge de couleurs.
7:56
Speaker 2: Au premier coup d'œil, on a l'impression d'une avance que
7:58
Speaker 2: l'humain ne pourra jamais rattraper. La vitesse peut être trompeuse.
8:01
Speaker 2: Ses premiers graphiques peuvent sembler soignés mais être déconnectés des
8:04
Speaker 2: indicateurs réels. Peut-être que le chiffre d'affaires est mal extrait
8:06
Speaker 2: ou que les filtres ne correspondent pas aux attentes du rapport.
8:10
Speaker 2: L'éclat initial peut masquer de profondes failles. Pour le développeur,
8:13
Speaker 2: le démarrage paraît plus lent car il valide son travail
8:15
Speaker 2: au fur et à mesure. Il ne fait pas de
8:17
Speaker 2: grands effets d'annonce, mais pose des bases solides qui résisteront
8:19
Speaker 2: à l'examen. Alors que mesurons-nous exactement pour désigner le vainqueur?
8:24
Speaker 2: Trois choses. La vitesse, car finir plus vite a une
8:26
Speaker 2: valeur évidente face au délai. La précision, car des chiffres
8:29
Speaker 2: faux sont dangereux. Et la qualité, c'est-à-dire l'utilisabilité et la
8:33
Speaker 2: clarté du tableau de bord pour un décideur... Ces trois
8:37
Speaker 2: points assurent un juste équilibre entre puissance brute et conception réfléchie,
8:39
Speaker 2: conception réfléchie. Tout comme dans un match où les actions
8:42
Speaker 2: rapides marquent des points, mais où la constance fait les champions.
8:45
Speaker 2: Les moments spectaculaires comme l'exécution rigoureuse comptent ici. C'est le
8:49
Speaker 2: décor que nous avons planté. Deux joueurs, un jeu de
8:50
Speaker 2: données partagé, un mélange de mécanique, de logique et de présentation.
8:54
Speaker 2: Le cadre étant posé, il est temps de passer de
8:55
Speaker 2: la spéculation à l'observation. Voyons comment Copilote gère le premier
8:59
Speaker 2: obstacle majeur, passer des données à un résultat fonctionnel sans
9:02
Speaker 2: commettre d'erreur. Vitesse contre précision, les premiers résultats arrivent. Rapide
9:08
Speaker 2: ne signifie pas toujours juste et les premiers résultats le
9:10
Speaker 2: démontrent clairement. Copilot se lance directement dans l'action. En quelques
9:13
Speaker 2: secondes après avoir reçu les données, il a déjà produit
9:16
Speaker 2: des graphiques en barre, des courbes et plusieurs mesures d'axe
9:18
Speaker 2: qui semblent étonnamment soignées au premier regard. Pour un observateur,
9:23
Speaker 2: l'impression initiale est qu'il crée en quelques instants ce qui
9:25
Speaker 2: prend habituellement un temps considérable à un développeur humain. Cette
9:30
Speaker 2: vitesse est impressionnante, cela ne fait aucun doute. Mais le
9:32
Speaker 2: défi que nous testons ne consiste pas simplement à savoir
9:34
Speaker 2: si quelque chose s'affiche rapidement à l'écran. Le véritable test
9:37
Speaker 2: est de savoir si l'on peut réellement se fier à
9:38
Speaker 2: ces résultats lorsqu'ils sont soumis à une pression métier. Le
9:41
Speaker 2: développeur humain, par comparaison, semble presque lent. Il prend le
9:44
Speaker 2: temps d'explorer les tables, de tracer les relations et de
9:46
Speaker 2: vérifier les types de données avant même de placer un visuel.
9:50
Speaker 2: Au premier abord, cela semble inefficace, surtout face à la
9:52
Speaker 2: productivité instantanée de copilote. Mais voici ce qui est important,
9:56
Speaker 2: cette lenteur est délibérée. Chaque action vise à garantir que
10:00
Speaker 2: les chiffres ne s'effondreront pas plus tard sous des requêtes
10:02
Speaker 2: ou des filtres complexes. Ce n'est peut-être pas glamour, mais
10:06
Speaker 2: ce travail de fond assure que ce qui est construit
10:08
Speaker 2: repose sur des bases solides plutôt que sur une structure
10:10
Speaker 2: qui s'écroule dès que les hypothèses sont testées. C'est là
10:13
Speaker 2: que nous voyons la tension commencer à monter. Copilot gère
10:16
Speaker 2: facilement les bases. Calculer le chiffre d'affaires total, par exemple,
10:19
Speaker 2: ne pose aucun problème. Il reconnaît le bon champ, lui
10:21
Speaker 2: applique une somme et génère une mesure propre et fonctionnelle.
10:24
Speaker 2: Pour les débutants ou les managers qui souhaitent simplement une
10:26
Speaker 2: vue d'ensemble, c'est déjà précieux. Mais dès que les exigences
10:29
Speaker 2: dépassent la simplicité, des failles apparaissent. Prenons par exemple la
10:32
Speaker 2: marge bénéficiaire depuis l'année. Copilote crée une mesure qui semble
10:35
Speaker 2: correcte sous forme de formule, mais une fois appliquée, les
10:37
Speaker 2: totaux ne reflètent pas la logique métier prévue. Les filtres
10:41
Speaker 2: s'appliquent aux tables de manière incohérente. Certaines catégories sont surestimées,
10:43
Speaker 2: d'autres sous-estimées. En apparence, le graphique semble fonctionnel, mais en
10:46
Speaker 2: creusant un peu, les résultats sont trompeurs. Le développeur est
10:49
Speaker 2: plus lent sur la même demande. Au lieu de créer
10:51
Speaker 2: instantanément une mesure, il vérifie quelles colonnes définissent la marge bénéficiaire.
10:55
Speaker 2: Il ajuste explicitement les remises sur les produits. S'assure que
10:58
Speaker 2: les fonctions d'intelligence temporelle font référence à la table de
10:59
Speaker 2: calendrier appropriée. Ce test supplémentaire signifie qu'il ne publie aucun
11:03
Speaker 2: visuel tant qu'il n'est pas certain qu'il reflète la manière
11:04
Speaker 2: dont l'entreprise mesure réellement la marge. Le processus semble prudent
11:07
Speaker 2: parce qu'il l'est. C'est là toute la différence. Copilot privilégie
11:10
Speaker 2: un résultat immédiat, tandis que l'humain privilégie une validation étape
11:13
Speaker 2: par étape par étape. Si vous avez déjà essayé d'écrire
11:15
Speaker 2: une expression d'axe plus avancée, ce scénario devrait vous sembler familier.
11:19
Speaker 2: Les choses semblent simples au début, puis s'enlisent rapidement dans
11:21
Speaker 2: les essais et erreurs dès que les filtres, les relations
11:23
Speaker 2: et la logique personnalisées entrent en jeu. Et il s'avère
11:26
Speaker 2: que l'IA se heurte au même piège qui freine les
11:28
Speaker 2: apprenants humains. Arithmétique de base, aucun problème. Dès qu'il s'agit
11:31
Speaker 2: de modifier le contexte de filtre ou d'effectuer des agrégations personnalisées,
11:34
Speaker 2: tout devient soudainement instable. Voir qu'au pilote mal interprété, ce
11:37
Speaker 2: qui constitue le revenu d'un client actif est une erreur
11:39
Speaker 2: presque classique, que vous reconnaîtrez si vous avez déjà dû
11:41
Speaker 2: déboguer une fonction de calcul mal appliquée. Cette différence est
11:45
Speaker 2: importante car, si le prototypage rapide a une vraie valeur,
11:47
Speaker 2: les environnements de production exigent de la fiabilité. Les managers
11:50
Speaker 2: ne veulent pas seulement des chiffres qui apparaissent vite, ils
11:51
Speaker 2: veulent des chiffres qui peuvent défendre en réunion, des chiffres
11:53
Speaker 2: fiables pour prendre une décision sans remettre en cause les
11:55
Speaker 2: calculs sous-jacents. L'avance de copilote pour générer des brouillons serait
12:01
Speaker 2: fantastique pour le brainstorming ou l'exploration initiale. Mais en production,
12:05
Speaker 2: le risque que de petits décalages deviennent des erreurs de
12:07
Speaker 2: reporting majeurs devient un facteur limitant. Le compromis est évident
12:10
Speaker 2: à l'écran. La vitesse offre un avantage immédiat, mais la
12:13
Speaker 2: précision garantit la valeur à long terme. Tous les spectateurs
12:17
Speaker 2: peuvent voir que Copilot remporte haut la main ce premier
12:18
Speaker 2: round sur la vitesse. Difficile de contester des visuelles instantanées
12:22
Speaker 2: et des mesures générées automatiquement qui fonctionnent techniquement sans aucun effort.
12:25
Speaker 2: Mais côte à côte, le doute s'installe. Si chaque graphique
12:27
Speaker 2: doit être vérifié de toute façon, combien de temps gagnez-vous vraiment?
12:31
Speaker 2: Pour l'instant, Copilot a franchi la ligne d'arrivée le plus vite,
12:33
Speaker 2: mais il donne l'impression d'un athlète qui sprint au début
12:35
Speaker 2: sans paraître assez régulier pour gagner toute la course. Et
12:39
Speaker 2: le vrai test n'a même pas encore commencé. Créer des
12:42
Speaker 2: visualisations rapides est une chose, mais lorsqu'il s'agit de connecter
12:45
Speaker 2: des tables, de gérer plusieurs relations et de préserver un
12:47
Speaker 2: contexte de filtre précis, la pression monte. C'est là que
12:50
Speaker 2: la vitesse en surface importera moins que l'adaptabilité à la
12:52
Speaker 2: complexité métier, ce qui soulève la question critique suivante. Une
12:56
Speaker 2: fois que nous aborderons la modélisation de données relationnelles, l'automatisation
12:59
Speaker 2: montrera-t-elle ses limites ou qu'au pilote pourra-t-il maintenir son élan
13:01
Speaker 2: pour rapidement? Le point de rupture, la modélisation de données complexes,
13:05
Speaker 2: les démonstrations simples sont faciles. Le vrai test survient quand
13:08
Speaker 2: les données cessent d'être propres et commencent à se comporter
13:09
Speaker 2: comme dans le monde réel. Dans ce round du défi,
13:12
Speaker 2: l'accent est mis sur la modélisation complexe. Au lieu de
13:15
Speaker 2: travailler avec une table ordonnée de transaction commerciale, Copilot et
13:17
Speaker 2: notre développeur sont confrontés à un jeu de données multitable.
13:21
Speaker 2: Il y a des dossiers clients, des hiérarchies de produits,
13:23
Speaker 2: des commandes, des tables de remise, des retours et une
13:25
Speaker 2: table de calendrier séparée pour l'intelligence temporelle. Quiconque a déjà
13:29
Speaker 2: construit un modèle Power BI non trivial sait que c'est
13:32
Speaker 2: souvent là que tout se casse. Un graphique tape à
13:35
Speaker 2: l'œil ne signifie pas grand chose si la base, les
13:36
Speaker 2: relations et les champs calculés ne tiennent pas la route
13:39
Speaker 2: face à la logique métier réelle. L'approche de Copilot ici
13:42
Speaker 2: est d'automatiser. Il examine les noms de colonnes, scanne les
13:44
Speaker 2: clés similaires et propose des relations comme s'il s'agissait de
13:47
Speaker 2: correspondances évidentes. En apparence, cela semble utile, mais en réalité,
13:51
Speaker 2: les données métiers correspondent rarement de manière propre uniquement par
13:53
Speaker 2: le nom de colonne. Par exemple, Copilot repère un identifiant
13:55
Speaker 2: client dans deux tables et crée une jointure. Techniquement, cela fonctionne.
14:00
Speaker 2: Mais une fois le modèle testé avec les clients actifs
14:02
Speaker 2: par rapport aux clients perdus, la jointure gonfle les totaux,
14:04
Speaker 2: car elle ignore les champs de statut qui auraient dû
14:06
Speaker 2: être pris en compte. Cela produit un résultat, mais pas
14:09
Speaker 2: le bon résultat. Et le vrai problème est que la
14:11
Speaker 2: sortie semble toujours tout à fait correcte jusqu'à ce que
14:12
Speaker 2: vous creusiez pour comprendre pourquoi les chiffres semblaient étranges. A l'inverse,
14:15
Speaker 2: le développeur ne part pas du principe que l'identifiant client
14:17
Speaker 2: doit toujours correspondre directement. Il s'arrête pour vérifier comment l'entreprise
14:21
Speaker 2: définit un client actif dans le jeu de données. Cette
14:24
Speaker 2: prise de conscience change la manière dont il modélise la relation.
14:26
Speaker 2: Au lieu de laisser chaque client se lier, il introduit
14:28
Speaker 2: des filtres afin que seuls les clients actifs soient comptabilisés
14:30
Speaker 2: dans la mesure. Cela prend plus de temps, mais les
14:33
Speaker 2: totaux correspondent désormais aux attentes. Cette différence illustre le défi
14:36
Speaker 2: majeur auquel Copilot est confronté. Les machines peuvent deviner les jointures,
14:39
Speaker 2: mais elles ne peuvent pas facilement appliquer la nuance des
14:41
Speaker 2: règles organisationnelles qui ne sont pas explicitement écrites dans le schéma.
14:44
Speaker 2: Un autre exemple se manifeste avec le calcul du profit
14:46
Speaker 2: à travers plusieurs tables de faits. Copilot génère une relation
14:50
Speaker 2: automatisée entre la table des ventes et celle des remises,
14:52
Speaker 2: mais il choisit par défaut une jointure plusieurs à plusieurs
14:54
Speaker 2: car les deux tables incluent des clés qui se chevauchent.
14:57
Speaker 2: Quiconque a travaillé avec des relations plusieurs à plusieurs dans
14:59
Speaker 2: Power BI sait que cela peut entraîner des agressions gonflées,
15:01
Speaker 2: surtout si les filtres ne sont pas appliqués correctement. Copilot
15:04
Speaker 2: ne signale aucun avertissement. Le graphique qu'il crée semble soigné.
15:07
Speaker 2: mais comparé à la version du développeur, les marges bénéficiaires
15:09
Speaker 2: montent en flèche de manière irréaliste. D'un point de vue commercial,
15:12
Speaker 2: ces chiffres gonflés pourraient induire la direction en erreur en
15:14
Speaker 2: lui faisant croire que les performances sont bien meilleures qu'elles
15:16
Speaker 2: ne le sont réellement. Le développeur repère le problème rapidement.
15:19
Speaker 2: Il restructure le modèle en normalisant les données de remise
15:22
Speaker 2: et en les séparant dans une table de pont. Cette
15:25
Speaker 2: action convertit la relation en à plusieurs, ce qui permet
15:27
Speaker 2: une agrégation précise qui représente correctement les conditions commerciales. Ce
15:31
Speaker 2: moment souligne pourquoi le contexte est primordial. Pour Copilot, une
15:34
Speaker 2: jointure est une jointure. Pour un développeur BI, une jointure
15:36
Speaker 2: est une décision ayant un impact direct sur la manière
15:38
Speaker 2: dont la direction perçoit les performances de l'entreprise. Cette différence
15:41
Speaker 2: est le point de rupture que nous commençons à remarquer
15:43
Speaker 2: lorsque nous passons de tâches simples à une modélisation significative.
15:45
Speaker 2: Il y a aussi la question des champs calculés. Copilote
15:48
Speaker 2: peut rédiger des expressions d'axe, mais dès qu'il s'agit d'intelligence temporelle,
15:51
Speaker 2: les choses deviennent instables. Par exemple, il propose une mesure
15:54
Speaker 2: d'une année sur l'autre en utilisant une fonction intégrée, mais
15:56
Speaker 2: l'applique à la date de transaction dans la table des
15:58
Speaker 2: commandes au lieu de la table calendrier dédiée. Le résultat
16:02
Speaker 2: affiche des chiffres qui semblent plausibles, mais qui dérivent légèrement
16:04
Speaker 2: avec des périodes manquantes. Dans des scénarios réels, des erreurs
16:08
Speaker 2: subtiles comme celle-ci passent souvent inaperçues jusqu'à ce qu'une revue
16:10
Speaker 2: trimestrielle révèle des divergences. Le développeur, bien sûr, sait mieux faire.
16:14
Speaker 2: Il valide que les calculs utilisent la top calendrier appropriée
16:16
Speaker 2: et s'alignent sur la logique de l'exercice fiscal. Il ne
16:18
Speaker 2: s'agit pas seulement d'écrire une formule, mais de savoir quelle
16:20
Speaker 2: référence produit les résultats, dont dépend la direction. Observer les
16:24
Speaker 2: deux côtes à côtes est révélateur. Copilot génère des résultats
16:27
Speaker 2: impressionnants à une vitesse record, mais son assurance masque des
16:29
Speaker 2: erreurs fondamentales. Le développeur peut sembler plus lent, mais la
16:32
Speaker 2: précision de son modèle élimine tout risque de rapports trompeurs.
16:35
Speaker 2: Cela souligne vérité simple. IA détecte des modèles, mais ne
16:38
Speaker 2: comprend pas le sens, à moins que les règles ne
16:40
Speaker 2: lui soient fournies explicitement. La logique métier réside souvent en
16:44
Speaker 2: dehors des données, dans les conversations, les politiques et un
16:46
Speaker 2: contexte que Copilot ne peut déduire. C'est là que l'expertise
16:49
Speaker 2: humaine garde une longueur d'avance. Le flux de travail automatisé
16:52
Speaker 2: semble fluide jusqu'à ce que les règles changent ou que
16:53
Speaker 2: l'ambiguïté s'installe. C'est alors que les failles apparaissent. La modélisation
16:57
Speaker 2: complexe ne dépend pas de la rapidité d'affichage. d'un graphique,
17:00
Speaker 2: mais de la fiabilité de la logique sous-jacente face à l'analyse.
17:03
Speaker 2: Dans cette phase, le développeur en fait la démonstration parfaite.
17:05
Speaker 2: Copilote à tonnes, l'humain corrige et le modèle final reflète
17:08
Speaker 2: l'activité avec plus de justesse. Maintenant que les bases sont posées,
17:12
Speaker 2: l'attention se déplace. Avec des modèles construits et des calculs testés,
17:15
Speaker 2: la lumière se porte sur l'étape finale, transformée tout cela
17:17
Speaker 2: en tableau de bord utilisable par les décideurs. L'ultime étape,
17:21
Speaker 2: la qualité et l'utilisabilité du tableau de bord. Il ne
17:23
Speaker 2: s'agit pas seulement de vérifier si les chiffres correspondent. Un
17:25
Speaker 2: tableau de bord efficace doit faire plus qu'afficher des données.
17:27
Speaker 2: Il doit s'adresser directement aux personnes qui l'utilisent A ce stade,
17:30
Speaker 2: la question concerne moins la somme des calculs que l'utilisabilité.
17:35
Speaker 2: Vous pouvez avoir le modèle le plus précis au monde,
17:37
Speaker 2: si les dirigeants ne voient pas rapidement ce qui compte,
17:38
Speaker 2: sa valeur diminue. C'est là que nous commençons à remarquer
17:41
Speaker 2: un écart très différent entre Copilot et le développeur. Copilot
17:44
Speaker 2: reprend l'avantage grâce à sa vitesse pure. En quelques minutes,
17:46
Speaker 2: le canevas se remplit de graphiques, de filtres et de
17:48
Speaker 2: mises en page générées automatiquement. Il couvre l'essentiel, vente par région,
17:52
Speaker 2: revenu dans le temps, répartition par catégorie de produits. C'est
17:55
Speaker 2: indéniablement plus rapide que de construire chaque visuel à la main.
17:58
Speaker 2: L'automatisation est impressionnante car des tableaux de bord qui prendraient
18:01
Speaker 2: un après-midi apparaissent presque instantanément. Mais en examinant les résultats
18:04
Speaker 2: de plus près, l'enthousiasme retombe. Les visuels sont alignés, mais
18:07
Speaker 2: semblent génériques, presque comme des modèles préconçus. Il n'y a
18:10
Speaker 2: aucune réelle hiérarchisation. Le chiffre d'affaires apparaît au même niveau
18:12
Speaker 2: que des mesures moins critiques et les lacunes dans la
18:14
Speaker 2: narration sont visibles. Un responsable parcourant le tableau de bord
18:17
Speaker 2: obtiendrait des informations, mais pas de récits. Ce récit est
18:20
Speaker 2: précisément ce que le développeur humain privilégie. Au lieu de
18:23
Speaker 2: laisser Power BI insérer des graphiques dans des espaces réservés,
18:25
Speaker 2: le développeur se demande quelle est la première chose qu'un
18:27
Speaker 2: décideur doit voir La tendance des profits en haut, la
18:30
Speaker 2: tendance du taux d'attrition avant les détails régionaux. Le contexte
18:32
Speaker 2: ressort dans la façon dont les visuels sont ordonnés, dimensionnés
18:35
Speaker 2: et étiquetés. Les titres sont rédigés en langage métier clair
18:37
Speaker 2: plutôt qu'en nom de base de données brutes. Le produit
18:40
Speaker 2: fini est bien plus qu'une simple série de graphiques. C'est
18:42
Speaker 2: une histoire. Il guide l'utilisateur de la vue d'ensemble aux
18:44
Speaker 2: détails de manière cohérente. On sent que le tableau de
18:46
Speaker 2: bord est le fruit de réflexion et de temps, pas
18:48
Speaker 2: seulement de vitesse. C'est là que le contraste devient vraiment frappant.
18:51
Speaker 2: Copilote peut générer beaucoup de contenu très rapidement, mais la
18:53
Speaker 2: quantité n'est pas la qualité, surtout en analyse. Surtout en analyse.
18:57
Speaker 2: Par exemple, dans sa première version, Copilot affiche le montant
18:59
Speaker 2: total des remises dans un graphique isolé. Sur le papier,
19:02
Speaker 2: c'est une mesure valable. Dans le contexte, cela ne signifie
19:05
Speaker 2: pas grand-chose sans le relier aux marges. La direction ne
19:07
Speaker 2: se soucie pas du montant brut des remises accordées. Elle
19:10
Speaker 2: veut savoir si ces remises ont entamé la rentabilité ou
19:13
Speaker 2: augmenté le volume des ventes de manière appropriée. Ce lien
19:16
Speaker 2: est difficile à identifier pour l'IA car il nécessite de
19:18
Speaker 2: comprendre l'influence d'une mesure sur une autre. Le développeur, lui,
19:22
Speaker 2: modélise directement cette comparaison en opposant les remises aux bénéfices
19:24
Speaker 2: bruts et nets au fil du temps. L'histoire devient instantanément
19:27
Speaker 2: plus claire, car elle explique au lieu de simplement montrer.
19:31
Speaker 2: Les recherches sur la visualisation et la conception décisionnelle soulignent
19:33
Speaker 2: que les meilleurs tableaux de bord ne sont pas ceux
19:35
Speaker 2: avec le plus d'éléments, mais ceux qui communiquent le mieux,
19:37
Speaker 2: mais ceux qui communiquent. Les meilleures pratiques recommandent d'éviter la surcharge,
19:41
Speaker 2: de privilégier les comparaisons et d'aligner les KPI sur les
19:44
Speaker 2: objectifs de l'entreprise. Copilote peut imiter ces pratiques lorsqu'elles sont basiques.
19:50
Speaker 2: sur des règles comme aligner les chiffres ou suggérer un
19:53
Speaker 2: graphique en barres plutôt qu'un camembert. Mais pour coder des
19:56
Speaker 2: pratiques subtiles, l'art de choisir ce qui compte le plus
19:59
Speaker 2: reste hors de sa portée. Cela exige une connaissance approfondie
20:01
Speaker 2: à la fois des données et de la problématique métier.
20:04
Speaker 2: La différence pratique se ressent dans la perception des tableaux
20:06
Speaker 2: de bord par les différents publics. La production de Copilot
20:09
Speaker 2: ressemble à une ébauche soignée, utile pour l'exploration interne ou
20:12
Speaker 2: le brainstorming ou le brainstorming. Une équipe pourrait l'utiliser, l'ajuster
20:15
Speaker 2: et l'améliorer. Mais demandez-vous, iriez-vous en salle de réunion pour
20:18
Speaker 2: la présenter telle qu'elle? Probablement pas. En comparaison, le tableau
20:22
Speaker 2: de bord du développeur est plus long à concevoir mais
20:23
Speaker 2: semble immédiatement prêt pour une revue de direction. Il est structuré.
20:26
Speaker 2: Il communique une intention. La direction peut jeter un coup
20:29
Speaker 2: d'œil aux visuels principaux et comprendre les tendances critiques en
20:31
Speaker 2: quelques secondes. Ce que nous observons, c'est donc une distinction
20:33
Speaker 2: dans l'utilité. Copilot est expérimenté.