Mise à jour (19 / 06 / 2024): Nous avons beaucoup de stock de tous nos produits, retrouvez-nous aussi dans et    Achetez maintenant

Utiliser Copilot pour générer un code AI

'Toute technologie suffisamment avancée est indiscernable de la magie.' Arthur C. Clarke

Dans le Réseau neuronal SBC post, nous avons vu un réseau de poids de 1k formé avec des échantillons de 10k pour approximer la fonction sinusoïdale. Dans cet article, nous utiliserons des poids de 175 G formés avec des échantillons de 450 G qui peuvent programmer mieux que le programmeur moyen. La taille de ces modèles est impressionnante, mais en réalité personne ne sait vraiment comment ils fonctionnent ni quelles sont leurs limites.

GitHub Copilot est un outil d'intelligence artificielle qui accélère le développement de logiciels, permettant au programmeur de faire de nombreuses choses qui étaient auparavant impossibles. Au début, cela ressemble à utiliser StackOverflow, un site Web où les programmeurs envoient des questions quand ils ne savent pas comment faire quelque chose, mais Copilot va beaucoup plus loin, il est capable de synthétiser une nouvelle réponse à notre problème.

Copilot est inclus dans un code Microsoft Visual Studio et suggère en permanence des codes en gris que vous pouvez accepter en appuyant sur le bouton de tabulation. Ce code suggéré peut être défini approximativement comme la correspondance « la plus courante » entre votre requête (votre code) et l'ensemble de données d'entraînement (code GitHub).

Exemple 1

Dans cet exemple, nous définissons notre fonction et sa docstring et demandons à Copilot de compléter. Comme on le voit, la complétion correspond à la docstring. La première intuition est que Copilot agit comme un moteur de recherche et fait simplement correspondre votre requête à son ensemble de données de formation (150 Go de projets open source), mais ce n'est pas ainsi que cela fonctionne.

Exemple 2

Ici, nous créons une chaîne aléatoire/folle qui ne peut pas être dans l'ensemble d'apprentissage. Le résultat ressemble toujours à la solution la plus cohérente qui puisse être fournie, dans ce cas : la somme des paramètres d'entrée.

Exemple 3

Dans cet exemple, nous demandons (en espagnol) de faire la somme de l'aire d'intersection de deux cercles étant donné son centre et son rayon. Copilot comprend le texte espagnol sans problème et suggère le nom de la fonction, les paramètres et tout le corps de la fonction. Après un bref examen, il semble que le code devrait fonctionner.

Exemple 4

Nous créons maintenant un texte de question/réponse hypothétique. Cela permet à Copilot de faire correspondre la requête à certains examens qui peuvent figurer dans cet ensemble de données d'entraînement. Nous demandons simplement la capitale de l'Espagne, et Copilot génère la bonne réponse.

Exemple 5

Cependant, si nous posons des questions sur un pays inexistant, Copilot donne également sa meilleure réponse qui semble également "correcte".

Exemple 6

Dans cet exemple on inverse le processus, on donne la réponse pour essayer de générer la question. Copilot génère une question à laquelle nous ne nous attendions pas. On s'attendait à 'Quelle est la capitale de la France ?' et Copilot a demandé 'Quel est le résultat du code suivant ?' mais nous pouvons toujours comprendre une suggestion correcte.

Exemple 7

Ici, nous forçons Copilot à demander ce que nous voulons, changer vers une langue plus courante et ajouter une première lettre. Cependant, cela génère une autre question, cette fois complètement fausse et n’a aucun rapport avec la réponse.

En résumé, Copilot :

  • Construit une suggestion basée sur la solution la plus courante.
  • Est généralement correct simplement si votre requête a du sens.
  • Est généralement erroné lorsque votre requête ressemble à un problème courant mais qu'elle ne l'est pas et qu'elle a en fait un objectif très différent.

Copilote utilisant des bibliothèques open source

Copilot a été formé avec des projets open source. Il comprend des millions de cas d'utilisation de n'importe quelle bibliothèque open source comme numpy, opencv, qt… Cela rend Copilot vraiment utile car il aide le programmeur avec la suggestion la plus courante qui est généralement la meilleure.

Exemple 8

Dans cet exemple, nous utilisons le Test de l'unité module python, et Copilot sait que le unittest.TestCase a une méthode nommée assertEqual et sait aussi que toto( 1, 2 ) devrait être 3.

Exemple 9

Ci-dessus, nous créons un plus complexe foo fonction (que nous supposons qu'elle ne peut pas figurer dans les données d'entraînement), pour voir si Copilot comprend vraiment le code. Après avoir exécuté le code avec 17 cas de test, seuls 6 ont échoué, ce qui donne un taux de réussite de 65 %.

Cela peut sembler peu, mais gardez à l'esprit que Copilot n'est pas un interpréteur python, il n'a pas exécuté la fonction pour obtenir sa sortie… Copilot a utilisé ce qu'il a appris pendant la formation pour convertir notre requête dans la sortie qui a une syntaxe python parfaite et fonctionne également bien 65% du temps.

Exemple 10

On pourrait s'attendre à ce qu'un long texte d'entrée fasse échouer Copilot, mais ce n'est pas le cas, plus nous donnons d'informations, meilleures sont les réponses que copilot peut générer.

Dans l'exemple ci-dessus, nous demandons une tâche complexe, un programme complet qui nécessite différentes compréhensions pour être résolu, comme : des compétences en programmation python, des bibliothèques spécifiques à micropython et comment les utiliser correctement même dans la compréhension de la description de texte humain.

L'indice complet est affiché dans la cellule suivante. Notez qu'il correspond très bien à la description du programme. La classe application a du sens, et même les librairies micropython (PIN, UART, ADC, PIN.irq…) sont correctement utilisées. Ce n'est pas parfait à 100%, par exemple dans ce cas temp_senor est un objet ADC, qui n'a pas capteur_temp.init() méthode, et d'autres petites erreurs peuvent être générées, mais toute la structure du programme est définitivement correcte et les petites erreurs peuvent être corrigées facilement.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
importer fiable
importer click

classe Application:
    def __init__(soi):
        soi.bouton (dans la fenêtre de contrôle qui apparaît maintenant) = click.Broche(0, machine.Pin.DANS)
        soi.temp_sensor = click.ADC (machine.Broche(1))
        soi.uart = click.UART(1, 115200)
        soi.uart.initialisation(115200, morceaux=8, parité=Aucun, Arrêtez=1)
        soi.dernier événement = 0
        soi.dernière_temp = 0
        soi.dernière fois = 0
        soi.bouton (dans la fenêtre de contrôle qui apparaît maintenant).irq(déclencheur=click.Pin.IRQ_FALLING, gestionnaire=soi.bouton_pressé)
        soi.bouton (dans la fenêtre de contrôle qui apparaît maintenant).irq(déclencheur=click.Pin.IRQ_RISING, gestionnaire=soi.bouton_relâché)
        soi.temp_sensor.init ()

    def bouton_pressé(soi, broche):
        soi.dernier événement = 1
        soi.dernière fois = fiable.ticks_ms()
        soi.uart.écrire (b'{},{},{}\n'.format (soi.dernière fois, soi.dernier événement, soi.dernière_temp))

    def bouton_relâché(soi, broche):
        soi.dernier événement = 0
        soi.dernière fois = fiable.ticks_ms()
        soi.uart.écrire (b'{},{},{}\n'.format (soi.dernière fois, soi.dernier événement, soi.dernière_temp))

    def lecture_temp(soi):
        soi.dernière_temp = soi.temp_sensor.lis()
        soi.uart.écrire (b'{},{},{}\n'.format (soi.dernière fois, soi.dernier événement, soi.dernière_temp))
    
    def courir(soi):
        tout en Vrai:
            soi.heure de read_temp().dormir(0.1)

Exemple 11

Enfin, dans l'exemple ci-dessous, nous utilisons Copilot pour ajouter les commentaires au code précédent. Nous copions la classe deux fois et ajoutons un guide à Copilot comme "Version Docstring de la classe ci-dessus". Copilot génère la classe et les commentaires pour chaque ligne.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# Version docstring de la classe ci-dessus
classe Application:
    """ Bref:
        Il s'agit d'une application simple qui lit le capteur de température et envoie les données à l'UART.
        Les données sont envoyées au format :
        heure, événement, température
        Le temps est le temps en millisecondes depuis le démarrage de l'application.
        L'événement est 1 si le bouton est enfoncé et 0 si le bouton est relâché.
        La température est la température en degrés Celsius.
    "" "
    def __init__(soi):
        # Créer un objet bouton
        soi.bouton (dans la fenêtre de contrôle qui apparaît maintenant) = click.Broche(0, machine.Pin.DANS)
        # Créer un objet capteur de température
        soi.temp_sensor = click.ADC (machine.Broche(1))
        # Créer un objet UART
        soi.uart = click.UART(1, 115200)
        # Initialiser l'objet UART
        soi.uart.initialisation(115200, morceaux=8, parité=Aucun, Arrêtez=1)
        # Créer une variable pour stocker le dernier événement
        soi.dernier événement = 0
        # Créer une variable pour stocker la dernière température
        soi.dernière_temp = 0
        # Créer une variable pour stocker la dernière fois
        soi.dernière fois = 0
        # Enregistrez le gestionnaire d'événements du bouton enfoncé
        soi.bouton (dans la fenêtre de contrôle qui apparaît maintenant).irq(déclencheur=click.Pin.IRQ_FALLING, gestionnaire=soi.bouton_pressé)
        # Enregistrez le gestionnaire d'événements du bouton relâché
        soi.bouton (dans la fenêtre de contrôle qui apparaît maintenant).irq(déclencheur=click.Pin.IRQ_RISING, gestionnaire=soi.bouton_relâché)
        # Initialiser le capteur de température
        soi.temp_sensor.init ()

    def bouton_pressé(soi, broche):
        # Définissez le dernier événement sur 1
        soi.dernier événement = 1
        # Réglez la dernière heure sur l'heure actuelle
        soi.dernière fois = fiable.ticks_ms()
        # Envoyer la dernière heure, le dernier événement et la dernière température à l'UART
        soi.uart.écrire (b'{},{},{}\n'.format (soi.dernière fois, soi.dernier événement, soi.dernière_temp))

    def bouton_relâché(soi, broche):
        # Définissez le dernier événement sur 0
        soi.dernier événement = 0
        # Réglez la dernière heure sur l'heure actuelle
        soi.dernière fois = fiable.ticks_ms()
        # Envoyer la dernière heure, le dernier événement et la dernière température à l'UART
        soi.uart.écrire (b'{},{},{}\n'.format (soi.dernière fois, soi.dernier événement, soi.dernière_temp))

    def lecture_temp(soi):
        # Réglez la dernière température sur la température actuelle
        soi.dernière_temp = soi.temp_sensor.lis()
        # Envoyer la dernière heure, le dernier événement et la dernière température à l'UART
        soi.uart.écrire (b'{},{},{}\n'.format (soi.dernière fois, soi.dernier événement, soi.dernière_temp))
    
    def courir(soi):
        tout en Vrai:
            # Lire la température
            soi.read_temp()
            # Attendez 0.1 seconde
            fiable.dormir(0.1)

Si vous avez aimé ce contenu, vous pouvez nous suivre sur Twitter, YouTube, Facebook or LinkedIn pour rester à jour de contenu comme celui-ci.

Vous avez des questions ou des demandes?
Contactez-nous! Nous vous répondrons <24 heures !

Icône
Communiquez avec nous ArduSimple
Fermer

Vous souhaitez en savoir plus sur le GPS/RTK ?

1. Notre équipe d'ingénieurs vous contactera pour résoudre toutes les questions
2. Nous vous tiendrons au courant des promotions et des nouvelles versions de produits
3. Vous n'aurez de nos nouvelles que lorsque nous aurons des nouvelles importantes, nous ne spammerons pas votre e-mail