Les jours où les ingénieurs électriques pouvaient se passer d'écrire ne serait-ce qu'une ligne de code sont révolus. Savoir coder est devenu une compétence requise, nécessaire pour tous les types d'ingénieurs. Bien que les ingénieurs n'aient pas besoin de comprendre comment écrire une application web complète, il est important qu'ils possèdent des compétences de base en script. L'analyse de grands ensembles de données, par exemple, nécessite certaines connaissances en programmation. Pour des tâches plus complexes, les ingénieurs peuvent se retrouver dans l'embarras, passant parfois des heures en ligne à rechercher une fonction ou une solution particulière. Avec la sortie de ChatGPT, le monde, sans aucun doute, a changé et le paysage de la génération de code automatisée également. Les ingénieurs sans un solide background peuvent désormais écrire du code de haute qualité avec l'aide de l'IA générative.
Dans des articles précédents tels que Utiliser ChatGPT pour le Scripting Altium et Utiliser ChatGPT pour les Tests Automatisés, nous avons examiné comment tirer parti de l'IA générative, spécifiquement ChatGPT, pour écrire du code pour nous. Jusqu'à présent, Google Bard (le concurrent de ChatGPT) était à la traîne, mais un nouveau modèle, Gemini, a annoncé qu'il surpassait son concurrent sur l'échelle de compréhension du langage multitâche massif (MMLU) :
Figure 1 : Indicateur de performance MMLU de Gemini. Source : https://deepmind.google/technologies/gemini/#capabilities
Dans cet article, nous allons comparer le moteur le plus sophistiqué de ChatGPT, GPT4, à Gemini Advanced (anciennement connu sous le nom d'Ultra), le moteur d'IA le plus avancé de Google, pour voir lequel est le meilleur pour générer du code.
Effectuer une comparaison totalement exhaustive entre les deux moteurs serait extrêmement difficile. Dans cet article, nous allons examiner comment ces deux moteurs génèrent du code standard écrit en Python (car c'est l'un des langages les plus pris en charge pour la rédaction de code par les LLMs). Ce n'est pas une science exacte car bien versus mal peut être très subjectif. Au lieu de cela, nous évaluerons chaque moteur simplement sur la base de si le code fonctionne et à quel point il a bien compris nos instructions.
Pour commencer, examinons une tâche de script très simple :
Développer un script d'automatisation Python qui, étant donné un chemin absolu vers un dossier, récupère les métadonnées de chaque fichier de manière récursive sous forme d'objet dictionnaire. Imprimer chaque objet dictionnaire ligne par ligne et inclure le chemin absolu.
Analysons d'abord le code renvoyé par GPT4 :
import os def get_file_metadata(directory): for foldername, subfolders, filenames in os.walk(directory): for filename in filenames: filepath = os.path.join(foldername, filename) metadata = { 'filename': filename, 'path': filepath, 'size': os.path.getsize(filepath), 'last_modified': os.path.getmtime(filepath) } print(metadata) get_file_metadata(os.path.dirname(os.path.abspath(__file__))) |
C'est concis, ça fonctionne et ça fait le travail. Je donnerais mon approbation. C'est aussi une tâche exceptionnellement triviale, mais c'est acceptable.
Maintenant, regardons le code renvoyé par Gemini Advanced :
import os def get_file_metadata(file_path): metadata = {} try: stat = os.stat(file_path) metadata['name'] = os.path.basename(file_path) metadata['size'] = stat.st_size # Taille en octets metadata['modified_time'] = stat.st_mtime # Horodatage de la dernière modification metadata['accessed_time'] = stat.st_atime # Horodatage du dernier accès except OSError: print(f"Erreur d'accès au fichier : {file_path}") return metadata def retrieve_metadata_recursively(folder_path): for root, _, files in os.walk(folder_path): for file in files: file_path = os.path.join(root, file) metadata = get_file_metadata(file_path) if metadata: print(f"Chemin absolu : {file_path}") # Imprime le chemin absolu print(metadata) if __name__ == '__main__': retrieve_metadata_recursively(os.path.dirname(os.path.abspath(__file__))) |
Gemini est un peu plus verbeux, certes, mais il a ajouté des gestions d'erreur ce qui, je suppose, est appréciable. C'est quelque peu long mais ça fonctionne donc on va lui accorder le bénéfice du doute.
Pour la prochaine tâche, je voulais voir comment les deux moteurs comprennent une langue donnée et créent un analyseur basé sur cette langue. Dans ce cas, nous allons construire un aspirateur web en utilisant l'invite suivante :
Écrivez un script Python utilisant BeautifulSoup ou Scrapy qui récupère les principaux titres des nouvelles de 'https://news.ycombinator.com' et les sort dans un objet dictionnaire.
Voici un extrait de la source de la page de 'https://news.ycombinator.com'. Utilisez ceci pour déterminer comment analyser les balises.
Écrivez un script Python utilisant BeautifulSoup ou Scrapy qui récupère les principaux titres des nouvelles de 'https://news.ycombinator.com' et les sort dans un objet dictionnaire. Voici un extrait de la source de la page de 'https://news.ycombinator.com'. Utilisez ceci pour déterminer comment analyser les balises. <html lang="fr" op="news"><head><meta name="referrer" content="origin"><meta name="viewport" content="width=device-width, initial-scale=1.0"><link rel="stylesheet" type="text/css" href="news.css?J16btoAd8hqdkSoIdLSk"> |
Comme vous le remarquerez, j'ai inclus du HTML dans ma demande. Ma demande réelle comprend plus de HTML mais je l'ai tronquée pour cet article. Voici ce que GPT4 a généré :
import requests # URL du site à scraper # Envoyer une requête GET à l'URL # Analyser le contenu HTML de la page en utilisant BeautifulSoup # Trouvez tous les titres des actualités # Dictionnaire pour stocker les titres où la clé est le rang et la valeur est le texte du titre # Bouclez à travers chaque titre, extrayez-le et stockez-le dans le dictionnaire # Affichez le dictionnaire |
Ce code fonctionne bien et fait ce qu’il est censé faire. J’espérais qu’il saurait, intuitivement, que je voulais le lien vers les articles mais je n’ai pas été explicite donc je ne peux pas utiliser cela comme un point contre la note de GPT4.
Voici ce que Gemini a généré :
import requests # Envoyez une requête HTTP GET au site web de Hacker News # Analyser le contenu HTML en utilisant BeautifulSoup # Trouver tous les éléments de classe 'athing', qui contiennent les articles de nouvelles # Créer un dictionnaire vide pour stocker les titres # Parcourir chaque article et extraire le titre et l'URL # Trouver l'élément URL # Ajouter le titre et l'URL au dictionnaire # Imprimer le dictionnaire des titres |
Cela fonctionne également et c'est assez similaire à la sortie de GPT4, mais ce code extrait réellement l'URL. C'est bien, mais encore une fois, ce n'est pas une attente. Dans ce défi, je dirais qu'ils sont, à peu près, identiques. Peut-être que Gemini marque un point supplémentaire pour avoir été devin.
Pour cette tâche, je souhaite créer une application web qui trace les graphiques boursiers de quelques tickers différents :
Créez une application web en Python qui montre les graphiques des actions suivantes : RIVN, TSLA, NKLA, FSR |
Celle-ci était définitivement plus compliquée. Elle nécessite un composant frontal (c.-à-d. des graphiques/images) et un composant backend (c.-à-d. la récupération des données d'une base de données boursière). J'ai généré d'innombrables applications avec GPT4 et je voulais voir comment Gemini se mesurait à cela. Voici ce que GPT4 a généré pour moi :
from flask import Flask, render_template_string app = Flask(__name__) @app.route('/') fig = go.Figure() for stock in stocks: graph_html = fig.to_html(full_html=False) return render_template_string(""" |
Figure 2 : Capture d'écran de l'application web générée par GPT4
C'est simple, épuré et direct. Sans fioritures mais efficace. Voici ce que Gemini a généré pour moi :
import flask app = flask.Flask(__name__) # Symboles boursiers # Récupérer les données boursières en utilisant yfinance @app.route('/') charts = [] return render_template('index.html', charts=charts) if __name__ == '__main__': |
Il m'a également été nécessaire de créer un nouveau fichier, index.html, dans un nouveau répertoire appelé templates:
<!DOCTYPE html> |
Figure 3: Capture d'écran de l'application web générée par Gemini Advanced
C'était définitivement plus sophistiqué, car cela incluait un histogramme et abstrayait le contenu HTML dans un nouveau fichier. Encore une fois, les deux étaient fonctionnels, donc, les deux reçoivent une note de passage.
Lorsque GPT4 a été lancé pour la première fois, il a fallu du temps pour comprendre comment le "solliciter" correctement. Lors de l'utilisation de l'IA générative pour écrire du code, les détails sont importants. En conséquence, beaucoup d'entre nous sont devenus des "Ingénieurs de Sollicitation" plus compétents au cours de cette dernière année. Malheureusement, cela peut introduire certains biais lors de la comparaison de GPT4 avec d'autres moteurs et je l'admets volontiers. Je sais comment GPT4 "fonctionne" plus que comment Gemini fonctionne. La manière dont je formule les sollicitations pour GPT4 pourrait être différente de ce que Gemini attend. Néanmoins, j'ai encore rencontré quelques problèmes très fondamentaux avec Gemini.
Un problème courant que j'ai rencontré avec Gemini lorsqu'il s'agissait d'interpréter des instructions concernait la génération de tests unitaires. Mon objectif initial était de couvrir les tests unitaires dans l'article mais, par frustration, j'ai complètement abandonné Gemini car il ne suivait jamais les instructions. Par exemple, je demandais à Gemini d'écrire un test unitaire en utilisant Pytest et de l'encapsuler dans une classe. Il générait le test en utilisant UnitTest à la place, ignorant totalement ma demande, mais encapsulait le code dans une classe. Je le corrigeais et il reconnaissait qu'il avait accidentellement utilisé UnitTest au lieu de Pytest. Il réécrivait ensuite le code en utilisant Pytest mais oubliait de le mettre dans une classe. Lorsque je lui demandais d'utiliser une construction Mock, il se rabattait par défaut sur le mock de UnitTest plutôt que sur le Mock de Pytest. Ce sont des nuances mais importantes lorsqu'on interagit avec l'IA générative.
Figure 4: Gemini Advanced ne suit pas les instructions
Le dépannage des échecs était un autre point douloureux. Le moteur de raisonnement de GPT4 s'est avéré assez puissant pour déboguer des erreurs en Python. Gemini... pas tant que ça. Quand je lui demandais de corriger certains problèmes, il se contentait de réécrire le code en ajoutant des indentations ou en échangeant des variables... une réponse totalement inutile.
Parfois, Gemini ne fonctionnait tout simplement pas. Il indiquait qu'il ne pouvait pas traiter ma demande. Dans d'autres cas, il se mettait à commenter sur... l'élection à venir ?
Figure 5: Gemini Advanced confus au sujet des élections à venir ?
Dans l'ensemble, la qualité du code générique produit par Gemini était assez compétitive face à GPT4. Cependant, l'expérience et son moteur de raisonnement laissaient beaucoup à désirer. Heureusement pour Google, ces éléments font partie de la mise en œuvre du LLM et non du LLM lui-même. Autrement dit, le LLM Gemini semble être, fondamentalement, assez bon et au niveau de GPT4, mais le code écrit autour de lui qui est utilisé dans l'expérience de chat a besoin d'aide. Avec le temps, nous verrons probablement Google itérer sur leur code et améliorer cette expérience et ce moteur de raisonnement.