{"id":245632,"date":"2022-03-21T12:47:14","date_gmt":"2022-03-21T11:47:14","guid":{"rendered":"https:\/\/blog.jetbrains.com\/blog\/2022\/03\/21\/looking-at-python-through-the-eyes-of-a-neural-net\/"},"modified":"2022-05-11T16:33:22","modified_gmt":"2022-05-11T15:33:22","slug":"python-du-point-de-vue-du-reseau-neuronal","status":"publish","type":"blog","link":"https:\/\/blog.jetbrains.com\/fr\/blog\/2022\/03\/21\/python-du-point-de-vue-du-reseau-neuronal\/","title":{"rendered":"Python du point de vue du r\u00e9seau neuronal"},"content":{"rendered":"

Le plugin de saisie semi-automatique compl\u00e8te de ligne de code pour Python<\/a> est maintenant disponible en version b\u00eata publique<\/strong>. Dans cet article, nous pr\u00e9sentons une partie des technologies et des algorithmes utilis\u00e9s pour la cr\u00e9ation de ce plugin et partageons des statistiques sur la programmation en Python que nous avons collect\u00e9es au cours de ce processus.<\/p>\n

Qu’est-ce que la \u00ab saisie semi-automatique compl\u00e8te d’une ligne de code \u00bb ?<\/h2>\n

Vous connaissez d\u00e9j\u00e0 sans doute la saisie semi-automatique ou compl\u00e9tion de code, qui sugg\u00e8re le mot suivant celui que l’utilisateur saisit. Si ce n’est pas le cas, nous lui avons consacr\u00e9 une s\u00e9rie d’articles que vous pouvez consulter (un<\/a>, deux<\/a>, trois<\/a>, quatre<\/a>).<\/p>\n

La saisie semi-automatique compl\u00e8te de ligne de code va plus loin en sugg\u00e9rant de plus grands fragments de code. Entre autres, elle compl\u00e8te les param\u00e8tres d’appel de m\u00e9thode pour vous ou \u00e9crit le texte du message d’erreur. En termes d’exp\u00e9rience utilisateur, elle est proche de la saisie semi-automatique standard et utilise la m\u00eame fen\u00eatre contextuelle pour pr\u00e9senter les r\u00e9sultats :<\/p>\n

\"L'image<\/figure>\n

Toutefois, la technologie utilis\u00e9e pour cette forme \u00e9tendue de saisie semi-automatique est fondamentalement diff\u00e9rente.<\/p>\n

La saisie semi-automatique standard utilise l’analyse statique pour d\u00e9terminer les classes, m\u00e9thodes, variables de champ et mots-cl\u00e9s visibles depuis l’emplacement actuel, et s’appuie sur le machine learning pour s\u00e9lectionner les meilleures recommandations. La s\u00e9lection du meilleur \u00e9l\u00e9ment \u00e0 partir d’un ensemble pr\u00e9d\u00e9fini est un exemple de mod\u00e9lisation discriminative<\/strong>. La saisie semi-automatique compl\u00e8te de ligne de code fournit quant \u00e0 elle un nouveau bloc de code comprenant plusieurs \u00ab mots \u00bb. L’\u00e9criture de code s’assimile \u00e0 un processus cr\u00e9atif et fait un usage plus intensif des calculs. On parle alors de mod\u00e9lisation g\u00e9n\u00e9rative<\/strong>. Les r\u00e9seaux neuronaux constituent un outil de mod\u00e9lisation g\u00e9n\u00e9rative typique, que nous utilisons \u00e9galement.<\/p>\n

Voyons plus en d\u00e9tails ce qu’est la saisie semi-automatique compl\u00e8te de ligne de code et quelles sont les principales caract\u00e9ristiques de son fonctionnement. La question sur laquelle nous nous penchons plus particuli\u00e8rement aujourd’hui est : comment un r\u00e9seau neuronal per\u00e7oit-il votre programme ?<\/p>\n

Les algorithmes fonctionnant avec des langages de programmation utilisent tout un ensemble de techniques provenant du traitement du langage naturel. Au lieu d’utiliser les mots du langage d’origine, le r\u00e9seau neuronal a recours \u00e0 une s\u00e9quence de jetons appartenant \u00e0 un vocabulaire sp\u00e9cial. L’algorithme construit le vocabulaire en utilisant le processus d’encodage par paire d’octets<\/strong>. Nous allons tout d’abord voir un exemple en anglais simple, puis examiner comment cela fonctionne en Python.<\/p>\n

Encodage par paire d’octets dans les langages naturels<\/h2>\n

L’algorithme construit le vocabulaire au d\u00e9but de la phase d’apprentissage et rassemble les statistiques \u00e0 partir des textes utilis\u00e9s pour l’apprentissage. L’ensemble de jetons ne change pas apr\u00e8s cela et reste identique tout au long du traitement pendant la phase d’exploitation.<\/p>\n

Imaginons que le seul texte en anglais disponible pour l’apprentissage soit le dicton suivant :<\/p>\n

\"L'image<\/figure>\n

Ce dicton peut se v\u00e9rifier ou pas. Quoi qu’il en soit, il contient plusieurs mots qui se r\u00e9p\u00e8tent, ce qui aide \u00e0 comprendre l’algorithme. Quels types de jetons pourrons-nous en retirer pour une utilisation ult\u00e9rieure ? Nous initialisons la liste de jetons avec chacune des lettres (symboles) de notre phrase d’apprentissage :<\/p>\n

[i, f, y, o, u, a, l, w, s, d, h, t, g, e]<\/strong><\/p>\n

Notez que Unicode code chacune de ces lettres comme un octet unique, de sorte que les symboles et les octets sont ici \u00e9quivalents.<\/p>\n

Nous n’incluons pas d’espace, mais nous pouvons l’utiliser comme s\u00e9parateur naturel de jetons. Ce d\u00e9tail aura son importance par la suite.<\/p>\n

Apr\u00e8s l’initialisation, nous d\u00e9veloppons le vocabulaire de fa\u00e7on it\u00e9rative. Nous recherchons la concat\u00e9nation la plus fr\u00e9quente pour les deux entr\u00e9es existantes et la d\u00e9signons comme un nouveau jeton. Dans notre exemple, \u00ab you \u00bb et \u00ab always \u00bb sont r\u00e9p\u00e9t\u00e9s quatre fois, mais nous ne pouvons pas encore les ajouter, car aucun d’eux n’est une concat\u00e9nation de deux<\/strong> entr\u00e9es. Nous devons proc\u00e9der \u00e9tape par \u00e9tape, et le premier candidat est \u00ab yo \u00bb. Une fois le premier jeton d\u00e9fini, il devient ins\u00e9cable, et nous ne pouvons plus utiliser ses \u00e9l\u00e9ments s\u00e9par\u00e9ment. Ainsi, \u00ab ou \u00bb ne pourra jamais devenir un jeton, car cela demanderait de fractionner \u00ab yo \u00bb.<\/p>\n

\"Cette<\/figure>\n

Nous r\u00e9p\u00e9tons cette \u00e9tape pour trouver d’autres concat\u00e9nations de jetons fr\u00e9quentes et les ajouter au vocabulaire. L’algorithme arrivera \u00e0 \u00ab you \u00bb et \u00ab always \u00bb avant de traiter d’autres paires de symboles, telles que \u00ab wh \u00bb et \u00ab at \u00bb, qui n’apparaissent que deux fois. Un vocabulaire de taille 32 (puissance de deux) peut se pr\u00e9senter comme suit :<\/p>\n

[i, f, y, o, u, a, l, w, s, d, h, t, g, e, yo, ys, al, ays, ways, you, always, at, wh, what, if, il, id, ot, wil, do, did, ge]<\/strong><\/p>\n

Tout nouveau jeton ajout\u00e9 est une concat\u00e9nation de deux autres jetons, ce qui s’appelle un encodage de paire<\/strong>.<\/p>\n

\u00c0 ce stade, pour \u00e9viter toute confusion, il est utile de clarifier les choses concernant le concept de jeton : nous appellerons \u00ab mot \u00bb un \u00e9l\u00e9ment lexical de langage, tandis que nous appellerons \u00ab jeton \u00bb une entr\u00e9e de vocabulaire obtenue par encodage de paire d’octets. Certains jetons ne sont pas des mots (par exemple ays<\/code><\/mark>). Il peut \u00e9galement y avoir des mots qui ne sont pas des jetons (par exemple : will et get. Nous avons arr\u00eat\u00e9 la g\u00e9n\u00e9ration du vocabulaire avant de les inclure.)<\/p>\n

Le r\u00e9seau neuronal prend une entr\u00e9e et g\u00e9n\u00e8re une sortie en termes de jetons, non de mots. Les ressources de calcul requises d\u00e9pendent de l’\u00e9tendue du vocabulaire. Cette astuce nous permet de limiter la taille de la valeur voulue au lieu d’utiliser tous les mots du langage.<\/p>\n

La quantit\u00e9 de jetons dans l’entr\u00e9e est \u00e9galement essentielle pour la qualit\u00e9 et les performances. L’algorithme peut ne prendre en consid\u00e9ration qu’un seul fragment u texte (appel\u00e9 \u00ab contexte \u00bb) pour lequel il doit g\u00e9n\u00e9rer la suite. En utilisant des jetons \u00e9tendus, il devient possible de prendre de plus gros morceaux de texte en tant qu’entr\u00e9e. Heureusement, les langages de programmation offrent des options suppl\u00e9mentaires pour y parvenir.<\/p>\n

Du langage naturel aux langages de programmation<\/h2>\n

Les auteurs de syst\u00e8mes de traitement du langage naturel utilisent g\u00e9n\u00e9ralement les limites des mots en tant que limites absolues entre les jetons. La s\u00e9quence \u00ab John Smith \u00bb est plus fr\u00e9quente en anglais que \u00ab Trantor \u00bb, surtout lorsqu’il s’agit de non-fiction. Cependant, \u00ab Trantor \u00bb peut th\u00e9oriquement devenir un jeton dans le cadre d’un vocabulaire beaucoup plus large, car il s’agit d’un seul mot. Cela n’est pas possible pour \u00ab John Smith \u00bb, qui est en deux mots. Les jetons du langage naturel ne d\u00e9passent g\u00e9n\u00e9ralement pas les limites des mots.<\/p>\n

Avec les langages de programmation, la s\u00e9paration naturelle des jetons se fait au niveau de l’analyseur lexical : le mot se termine l\u00e0 o\u00f9 il est possible d’ins\u00e9rer un espace. Une variable, une constante et un mot-cl\u00e9 de langage n’ont pas de liens entre eux.<\/p>\n

Nous pensions pouvoir faire mieux pour les langages de programmation. Prenons l’expression Python classique suivante :<\/p>\n

for i in range(<\/mark><\/code><\/p>\n

Elle inclut de nombreux \u00e9l\u00e9ments lexicaux diff\u00e9rents, dont deux mots-cl\u00e9s de langage, une variable et une fonction. Pourtant, le programmeur Python (encore d\u00e9butant) en moi pense que for i in range(<\/mark><\/code> devrait \u00eatre une seule entr\u00e9e dans le vocabulaire. Le r\u00e9seau neuronal devrait utiliser une seule it\u00e9ration d’inf\u00e9rence au lieu de quatre ou cinq pour faire une pr\u00e9diction, afin de pr\u00e9server la capacit\u00e9 de calcul de votre ordinateur portable pour le contenu entre parenth\u00e8ses.<\/p>\n

L’id\u00e9e g\u00e9n\u00e9rale consiste \u00e0 d\u00e9limiter les jetons par des sauts de ligne au lieu d’\u00e9l\u00e9ments lexicaux. Notre objectif \u00e9tant la saisie semi-automatique d’une ligne<\/strong> de code, l’utilisation de la ligne comme unit\u00e9 de jeton est naturelle.<\/p>\n

La taille de notre vocabulaire est limit\u00e9e \u00e0 16 384, une autre puissance de 2 tr\u00e8s pratique. Nous avons initialis\u00e9 le processus avec des caract\u00e8res Unicode couvrant 99,99 % du texte et commenc\u00e9 \u00e0 traiter les r\u00e9f\u00e9rentiels Python avec des licences permissives.<\/p>\n

Dans les sections suivantes, vous allez d\u00e9couvrir les 16 384 constructions Python les plus populaires.<\/p>\n

Probl\u00e8mes dans le vocabulaire<\/h2>\n

L’inspection visuelle du vocabulaire a permis d’identifier quelques probl\u00e8mes syst\u00e9miques. Statistiquement, certaines entr\u00e9es sont pr\u00e9visibles, mais leur inclusion pr\u00e9sente des inconv\u00e9nients.<\/p>\n

La premi\u00e8re surprise : le chinois<\/h3>\n

Les 600 jetons environ qui sont apparus apr\u00e8s les octets \u00e9taient principalement des symboles Unicode pour des caract\u00e8res n’appartenant pas \u00e0 l’alphabet latin, tels que les caract\u00e8res chinois. Le chinois par lui-m\u00eame \u00e9tait une surprise, mais \u00e0 part cela, la signification des caract\u00e8res semble compr\u00e9hensible.<\/p>\n

Par exemple, la premi\u00e8re occurrence est le caract\u00e8re \u7684<\/mark><\/code>. Ce symbole est le plus souvent utilis\u00e9 comme \u00e9quivalent du possessif \u00ab \u2018s \u00bb en anglais. D’un point de vue statistique, il s’agit du caract\u00e8re chinois le plus fr\u00e9quent<\/a>. Certains \u00e9taient tr\u00e8s utilis\u00e9s dans notre ensemble de donn\u00e9es, mais moins dans le langage lui-m\u00eame. Par exemple, \u6570<\/mark><\/code> et \u7801<\/mark><\/code> se rapportent aux chiffres, tandis que \u7f51<\/mark><\/code> signifie \u00ab r\u00e9seau \u00bb. \u00c9tant donn\u00e9 le contexte de programmation, rien d’anormal ici. Il nous reste seulement \u00e0 comprendre pourquoi ces symboles sont apparus dans notre vocabulaire.<\/p>\n

Les caract\u00e8res non latins, notamment chinois, russes, japonais, cor\u00e9ens et parfois arabes, viennent des cha\u00eenes des docstrings Python. En toute logique, les gens tendent \u00e0 \u00e9crire leur documentation dans leur langue natale.<\/p>\n

L’inclusion de caract\u00e8res n’appartenant pas \u00e0 l’alphabet latin dans le vocabulaire comporte probablement plus d’inconv\u00e9nients que d’avantages, car ils occupent un espace qui serait mieux utilis\u00e9 par des constructs plus courants du langage de programmation. Avec ces caract\u00e8res, nous avons une meilleure prise en charge des noms de variables Unicode autoris\u00e9s en Python. Cependant, ils sont rarement utilis\u00e9s, et lorsqu’ils le sont, c’est principalement pour l’obfuscation de code.<\/p>\n

La deuxi\u00e8me surprise : l’indentation<\/h3>\n

Une autre chose d\u00e9sagr\u00e9able se produit lorsqu’on fait une recherche grep des mots-cl\u00e9s souvent utilis\u00e9s en d\u00e9but de ligne dans le vocabulaire, tels que return<\/code> :<\/p>\n

return<\/mark><\/code>
        return<\/mark><\/code>
    return<\/mark><\/code>
                return<\/mark><\/code>
return<\/mark><\/code><\/p>\n

(et beaucoup d’autres occurrences)<\/p>\n

Les fragments d’instruction return utiles apparaissent \u00e9galement avec toutes sortes d’indentations de d\u00e9but de ligne et on obtient donc plusieurs copies des jetons suivants dans le vocabulaire :<\/p>\n

return self.<\/mark><\/code>
return True<\/mark><\/code>
return False<\/mark><\/code>
return 0<\/mark><\/code>
return None<\/mark><\/code><\/p>\n

Conserver ces copies peut sembler peu pratique. Lorsque nous appelons la saisie semi-automatique, le caret est rarement au d\u00e9but d’une ligne. L’IDE suit l’indentation et l’utilisateur sera probablement d\u00e9j\u00e0 au bon emplacement lorsqu’il commencera \u00e0 saisir return. Par cons\u00e9quent, les instructions return avec des espaces de d\u00e9but de ligne ont peu de chances d’\u00eatre utilis\u00e9es.<\/p>\n

D’un autre c\u00f4t\u00e9, cela r\u00e9duit la longueur du contexte. Chaque retour indent\u00e9 sera un seul jeton au lieu de plusieurs.<\/p>\n

Instruction d’importation<\/h3>\n

L’un des autres probl\u00e8mes que nous avons recontr\u00e9s concernait les instructions d’importation impliquant des frameworks populaires tels que TensorFlow, PyTorch et Django, par exemple :<\/p>\n

from tensorflow.python.framework import ops<\/mark><\/code>
from django.conf import settings<\/mark><\/code><\/p>\n

De telles instructions apparaissent g\u00e9n\u00e9ralement une fois par fichier et sont g\u00e9n\u00e9ralement proches du d\u00e9but. De plus, les m\u00e9canismes de compl\u00e9tion de code et d’importation automatique classiques peuvent s’en charger. D’un autre c\u00f4t\u00e9, encore une fois, cela permet de prendre en compte de plus grands morceaux de code lors de la g\u00e9n\u00e9ration des suggestions de saisie semi-automatique. La question de savoir si ces longues instructions d’importation sont requises en tant que jetons reste ouverte.<\/p>\n

Examiner les donn\u00e9es<\/h3>\n

Le point \u00e0 retenir<\/strong> dans cette section est probablement l’importance de l’inspection visuelle des donn\u00e9es. Les r\u00e9sultats interm\u00e9diaires du traitement statistique des donn\u00e9es et des algorithmes bas\u00e9s sur le machine learning peuvent contenir des probl\u00e8mes syst\u00e9miques non couverts par les tests mais \u00e9vidents pour des experts humains.<\/p>\n

L’association des statistiques et heuristiques est souvent bien meilleure que les statistiques seules.<\/p>\n

Paires de symboles populaires<\/h2>\n

En faisant d\u00e9filer la fen\u00eatre vers le bas, nous arrivons aux combinaisons \u00e0 deux symboles. Il s’agit de comprendre pourquoi elles arrivent en haut de la liste. Certaines proviennent des mots-cl\u00e9s les plus communs du langage, tandis que d’autres r\u00e9sultent de conventions de nommage et d’habitudes de programmation.<\/p>\n

Savez-vous quelle est la combinaison de deux symboles la plus fr\u00e9quente en Python (apr\u00e8s le double espace blanc, bien s\u00fbr) ? C’est virgule+espace blanc, comme ceci : , <\/mark><\/code>. Cela fait sens ! Voyons la suite.<\/p>\n

se<\/mark><\/code> vient principalement de self.<\/mark><\/code> En fait, self.<\/mark><\/code> est la combinaison \u00e0 cinq symboles la plus fr\u00e9quente et l’un des jetons les plus utilis\u00e9s. Il est plus fr\u00e9quent que la plupart des s\u00e9quences \u00e0 deux et trois symboles, sauf celles qu’il contient.
in<\/mark><\/code> Youpi ! for i in range(<\/code>
re<\/mark><\/code> vient principalement de return<\/code>.
on<\/mark><\/code> est un cas int\u00e9ressant. La plupart de nos noms de variables, de champs, et m\u00eame de classes, se terminent par \u00ab tion \u00bb, \u00ab cion \u00bb ou \u00ab sion \u00bb. \u00ab None \u00bb et \u00ab json \u00bb sont deux autres contributeurs importants.
te<\/mark><\/code> semble myst\u00e9rieux au premier abord, mais une \u00e9tude plus approfondie du vocabulaire r\u00e9v\u00e8le l’abondance du mot \u00ab test \u00bb sous diff\u00e9rentes formes. Des mots tels que \u00ab date \u00bb, \u00ab text \u00bb, \u00ab state \u00bb, \u00ab write \u00bb et l’omnipr\u00e9sent \u00ab items \u00bb contribuent \u00e9galement \u00e0 la fr\u00e9quence de ce jeton.
= <\/mark><\/code> doit \u00eatre vraiment tr\u00e8s populaire. Si l’on change l’ordre, =<\/mark><\/code> n’est pas si fr\u00e9quent. La diff\u00e9rence ne peut pas \u00eatre inf\u00e9rieure au nombre d’op\u00e9rateurs !=.
or<\/mark><\/code> vient g\u00e9n\u00e9ralement de mots-cl\u00e9s tr\u00e8s utilis\u00e9s dans le langage, tels que or<\/code>, for<\/code> et import<\/code>.<\/p>\n

Combinaisons de symboles complexes<\/h2>\n

Jetons ignorant les limites<\/h3>\n

Deux jetons fr\u00e9quents, s[<\/mark><\/code>  et s.append(<\/mark><\/code> sont particuli\u00e8rement repr\u00e9sentatifs du travail avec les listes en Python. Nous utilisons g\u00e9n\u00e9ralement des noms de liste au pluriel : jours, marchandises, articles, lignes. Ces jetons illustrent la puissance des statistiques : ils s’affranchissent des limites des \u00e9l\u00e9ments lexicaux de Python pour exprimer la fa\u00e7on dont nous parlons anglais dans le code.<\/p>\n

Range<\/h3>\n

Revenons \u00e0 range, \u00e9voqu\u00e9 lorsque nous avons pr\u00e9sent\u00e9 les jetons de ligne compl\u00e8te. A-t-elle \u00e9t\u00e9 int\u00e9gr\u00e9e dans le vocabulaire ? En effet, elle est bien visible :<\/p>\n

for i in range(<\/mark><\/code><\/p>\n

De plus, il y a une instruction encore plus longue qui est fr\u00e9quente :<\/p>\n

for i in range(len(<\/mark><\/code><\/p>\n

Signalons au passage que i est le seul nom de compteur qui soit utilis\u00e9 assez souvent. Les autres, tels que j et k sont peu utilis\u00e9s.<\/p>\n

Instructions Return<\/h3>\n

Qu’est-ce que les programmeurs utilisent comme r\u00e9sultats de leurs fonctions ? Il n’y a pas de surprise concernant la fr\u00e9quence d’utilisation de :<\/p>\n

return False<\/mark><\/code>
return True<\/mark><\/code>
return None<\/mark><\/code><\/p>\n

Leur fr\u00e9quence d’utilisation est assez semblable, mais elles arrivent toutes derri\u00e8re return self<\/mark><\/code>. return 0<\/mark><\/code> est un autre exemple de jeton couramment utilis\u00e9. Les gens n’utilisent pas 1, 2 ou tout autre chiffre assez souvent pour qu’ils soient visibles dans les statistiques. Autres choses curieuses :<\/p>\n

return []<\/mark><\/code>
return super(<\/mark><\/code>
return data<\/mark><\/code>
return value<\/mark><\/code>
return not<\/mark><\/code>
return len(self.<\/mark><\/code><\/p>\n

Le dernier jeton est obtenu en combinant return<\/mark><\/code> et len(self.<\/mark><\/code>, car return len(<\/code> ne figure pas dans le vocabulaire.<\/p>\n

Classes<\/h3>\n

Existe-t-il des combinaisons avec le mot class suffisamment populaires pour faire partie des 16 384 \u00e9l\u00e9ments du vocabulaire ? La combinaison qui arrive en t\u00eate, et de loin, est class Test<\/mark><\/code>. Elle est suivie par deux autres combinaisons, qui arrivent loin derri\u00e8re :<\/p>\n

class Meta:<\/mark><\/code>
class Base<\/mark><\/code><\/p>\n

Les autres jetons significatifs incluant class<\/code> n’ont pas de lien avec les noms de classes :<\/p>\n

classifier<\/mark><\/code>
classification<\/mark><\/code>
issubclass(<\/mark><\/code>
@classmethod<\/mark><\/code>
Base class for<\/mark><\/code><\/p>\n

Les deux derniers viennent de la documentation.<\/p>\n

Synth\u00e8se<\/h2>\n

Le r\u00e9seau neuronal utilise le vocabulaire pour repr\u00e9senter le programme d’entr\u00e9e et construire les suggestions. La repr\u00e9sentation du programme est disponible d\u00e8s maintenant et les algorithmes de g\u00e9n\u00e9ration de code feront l’objet de prochains articles.<\/p>\n

Si nous prenons un fragment simple de code Python et ex\u00e9cutons le g\u00e9n\u00e9rateur de jetons (tokenizer), nous pouvons le voir de la m\u00eame fa\u00e7on que le r\u00e9seau neuronal le voit :<\/p>\n

\"Cette<\/figure>\n

Le g\u00e9n\u00e9rateur de jetons transforme ces 3 lignes en 15 jetons. Les mod\u00e8les bas\u00e9s sur GPT-2 peuvent avoir jusqu’\u00e0 1 024 \u00e9l\u00e9ments ; notre limite d’utilisation est de 384. Dans notre ensemble de donn\u00e9es d’apprentissage, la longueur m\u00e9diane d’une ligne est de 10 jetons, ce qui est un peu plus long que dans l’exemple ci-dessus. Nous pouvons estimer que le mod\u00e8le utilise un peu moins de 40 lignes de contexte pour g\u00e9n\u00e9rer les pr\u00e9dictions.<\/p>\n

Cet exemple montre \u00e9galement \u00e0 quel point le \u00ab mode de pens\u00e9e \u00bb du r\u00e9seau neuronal et celui de l’humain sont diff\u00e9rents. Nous comprenons que args<\/code> repr\u00e9sente la m\u00eame chose dans les deux premi\u00e8res lignes. Cependant, l’algorithme les voit diff\u00e9remment, il fractionne m\u00eame la deuxi\u00e8me ligne.<\/p>\n

Essayez le plugin de saisie semi-automatique de ligne de code pour Python<\/h2>\n

Parcourir et d\u00e9velopper le vocabulaire ont fait partie des \u00e9tapes pour atteindre nos objectifs en termes d’offre produit. Nous pr\u00e9voyons de proposer davantage d’articles techniques sur la fa\u00e7on dont le r\u00e9seau neuronal g\u00e9n\u00e8re du code et comment adapter ses performances aux capacit\u00e9s des ordinateurs portables des utilisateurs.<\/p>\n

En attendant, nous vous invitons \u00e0 essayer le fruit de notre travail, le plugin de saisie semi-automatique compl\u00e8te de ligne de code pour Python :<\/p>\n

https:\/\/plugins.jetbrains.com\/plugin\/14823-full-line-code-completion<\/a><\/p>\n\n\n

Auteur de l’article original en anglais<\/em> :<\/p>\n\n\n

\n
\n
\n
\n \"\"\n <\/div>\n
\n <\/div>\n <\/div>\n <\/div>\n <\/div>\n","protected":false},"author":813,"featured_media":234732,"comment_status":"closed","ping_status":"closed","template":"","categories":[623,5108],"tags":[603,3252],"cross-post-tag":[6951,6419],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/blog\/245632"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/blog"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/types\/blog"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/users\/813"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/comments?post=245632"}],"version-history":[{"count":10,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/blog\/245632\/revisions"}],"predecessor-version":[{"id":245648,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/blog\/245632\/revisions\/245648"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media\/234732"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media?parent=245632"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/categories?post=245632"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/tags?post=245632"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/cross-post-tag?post=245632"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}