Bonjour et bienvenue dans ce tutoriel Python de Statoil, nous allons faire le premier pas vers la mise en œuvre
du modèle de théorie approfondie.
Nous sommes donc sur le point de mettre en œuvre l’ensemble du processus de l’algorithme de diffusion.
Et nous allons utiliser ce que nous avons créé auparavant.
C’est l’architecture du réseau de neurones qui permet de rejouer la mémoire pour l’intégrer dans l’ensemble du processus
d’apprentissage en file d'attente.
Et tout cet algorithme d'apprentissage va s'inscrire dans une classe.
C'est la dernière que nous faisons pour mettre en œuvre l'intelligence artificielle.
Et cette classe ne contiendra que des fonctions différentes.
Nous aurons donc les fonctions internes qui créeront et initialiseront toutes les variables attachées
à nos futurs objets de détournement qui représenteront le modèle lui-même et qui auront d’autres fonctions.
L’un d’eux sera bien sûr de choisir la bonne action à chaque fois.
Nous aurons également une fonction de base de la fonction de mise à jour pour obtenir ce noyau et avoir une idée de la progression
de l’apprentissage s’il se déroule bien.
Si l’exploration se déroule bien et si elle peut passer à l’exploitation, nous aurons une fonction sûre
pour sauver demain, c’est sauver le cerveau de la voiture et ensuite, charger la fonction.
Nous avons donc deux fonctions à remplir.
Nous allons faire une fonction pour chacun de peiner.
Et aujourd'hui, nous allons commencer avec la fonction de fin comme d'habitude lorsque nous faisons un cours.
Mais d'abord, n'oublions pas de présenter le cours afin que nous l'appelions D.
Q Et pour votre réseau, des parenthèses s’appellent.
Et puis nous allons avec notre première fonction.
Faisons donc cette définition puis double soulignement puis son double soulignement et sa parenthèse.
Donc, comme vous l'avez compris dans cette fonction, nous allons introduire les variables attachées à notre objet.
Nous allons donc avoir quelques lignes commençant tout seul et nous allons créer et initialiser toutes
les variables nécessaires à la mise en œuvre du réseau D2.
Ainsi, nous allons par exemple créer un objet ou un réseau car nous avons bien sûr besoin de notre réseau de
neurones profonds, puis de notre mémoire.
Nous allons créer une autre variable pour la mémoire.
Nous aurons donc une autre mémoire variable, mais ce n’est pas tout ce que nous devrons créer également.
Quelques variables pour la dernière date.
La dernière action et le dernier mot.
Bien sûr, vous connaissez les variables que vous voyez dans l'algorithme de diffusion.
Et puis quoi d'autre.
Nous aurons également besoin d’un optimiseur que vous connaissez pour réaliser une grille stochastique en termes de
pondération des données en fonction de leur contribution à l’erreur.
Lorsque l’intelligence artificielle commet une erreur, je pense que c’est donc essentiellement les variables que nous devons
maintenant créer et initialiser.
Mais dans cette fonction init, nous allons mettre deux arguments en premier, comme d'habitude, les arguments faisant référence
à notre objet.
Ensuite, puisque vous savez que nous allons créer un objet de la classe network.
Eh bien, puisque la classe réseau prend comme argument la taille d'entrée de la fonction init et l'action, c'est la même
chose ici.
Lors de la création d'un objet de la classe network, nous devrons choisir un argument de taille d'entrée
et l'argument réel.
Nous pouvons donc simplement les
copier ici et ici.
Donc, ces arguments vont maintenant devenir.
De plus, certains arguments n'ont pas duré.
Chaque fois que nous créons des objets futurs de la classe différente que des modèles de rôle futurs, nous devrons
spécifier la taille de la saisie. Je rappelle le nombre de dimensions dans les vecteurs qui
incluent vos états.
Vos états d'entrée et un certain nombre d'actions, qui correspond au nombre d'actions possibles que la voiture peut effectuer.
Alors je te le rappelle.
Ce sont soit aller à gauche aller tout droit ou aller à droite.
Ok parfait.
Ensuite, vous savez que vous allez créer un nouvel objet de la classe de mémoire de
relecture afin de créer l’objet de mémoire afin d’obtenir la mémoire des transitions et, dans les informations, l’argument de capacité.
Mais comme nous ne l'utilisons qu'une fois, en fait, lorsque nous créons de la mémoire et non plus
après, nous n'aurons pas besoin de spécifier l'argument de capacité.
Nous pourrions le faire, mais nous entrerons directement le nombre de transitions que nous voulons que notre mémoire ait.
Mais nous avons besoin d’un dernier argument, à savoir obtenir le paramètre dans le modèle de l’enseignant.
Rappelez-vous que ce paramètre gamma est le délai.
Et c’est un paramètre de l’équation et nous allons donc le mettre ici car nous l’utiliserons
ensuite plusieurs fois.
Alors mettons-le ici.
Nous allons l'appeler Gamma.
Donc, pour cela, il ne s'agit que du nom de l'argument, puis nous allons inclure tous les arguments dont vous aurez besoin pour
cela dans sa fonction.
Cela signifie donc que chaque fois que nous créons notre modèle de dictionnaire, c’est chaque fois que nous créons un objet de
l’enseignant en classe.
Eh bien, nous devrons spécifier comme arguments la taille de l’entrée, le nombre d’actions et le paramètre.
Et nous finirons avec les vraies valeurs pour eux.
D'accord, allons maintenant dans la fonction.
D'ACCORD.
Donc, au fond, cela va être facile.
Nous sommes sur le point de créer et d’initialiser toutes les variables dont nous avons besoin.
Et alors commençons par le premier.
Commençons par le gamma.
En fait, le coefficient de retard.
Donc, puisqu'il s'agit d'un voïvode qui veut être attaché à son objet, nous commençons par soi-même.
Ainsi, le gamma va être une variable de notre professeur et un modèle lui-même qui équivaut aux arguments qui seront entrés lors de
la création d'un objet de la classe de désaccord.
Alors Janna et là nous allons avec le deuxième argument.
Le deuxième argument va être la fenêtre de récompense.
Alors, quelle est cette fenêtre.
Eh bien, ce sera la fenêtre glissante de la moyenne des 100 derniers mots que vous utiliserez
simplement pour évaluer l’évolution de la performance qui, comme vous le savez, aura la signification du mot dans cette guerre
Windu qui glissera avec le temps.
Et ce que nous voulons observer, c’est la signification des 100 derniers mots qui augmente avec le temps.
Donc initialisons-le avec la fenêtre de soulignement de la récompense auto.
Et puis, puisque cela va être une fenêtre glissante de l'évolution de la moyenne des 100 derniers mots.
Eh bien, nous allons l’initialiser sous forme de liste vide, puis nous élargirons pour indiquer que nous travaillons des heures supplémentaires.
Très bien alors plus excitant.
Créons notre réseau de neurones.
Nous allons donc appeler cela un Mario autodidacte, car au fond, c'est le cœur des modèles.
Je l'appelle modèle et ce modèle ne sera rien d'autre qu'un sujet de cette classe et permettra de créer
un tel objet.
Nous prenons notre réseau de classes entre parenthèses et ici nous venons de mettre les arguments de la classe mais nous plaçons ces arguments dans
les arguments de la fonction init et par conséquent nous avons juste besoin de les copier
ici et de les coller dans la classe réseau puis nous aller avec cette ligne de code.
Nous créons un réseau de neurones pour un modèle d’apprentissage parfait, puis créons une mémoire.
Encore une fois, nous allons créer un nouveau Vargo que nous appelons mémoire autodidacte.
Et encore une fois, cela va être un objet de la classe de mémoire de rejeu.
Alors prenons simplement le nom ou la classe, copions encore, mais faisons face ici et entre parenthèses, nous devons définir la capacité,
car la capacité est un argument de la fonction et c'est le seul argument dont nous
avons besoin ici.
Alors, quelle capacité allons-nous choisir? Rappelez-vous que cela correspond au nombre de transitions
au nombre d'événements passés, indiquez la dernière action et le dernier mot.
Et ainsi, comme mentionné dans l’un des travaux du Priester, nous allons prendre cent mille cent mille transitions en
mémoire, puis nous allons échantillonner à partir de cette mémoire pour obtenir un petit nombre de
transitions aléatoires et celle sur laquelle le modèle ira.
Alors maintenant, nous avons notre mémoire parfaite.
Maintenant, obtenons notre optimiseur.
Encore une fois, nous créons une nouvelle variable que nous appelons optimiseur. Ainsi, l’optimiseur est une autre variable de notre future
retrait de la file d’objets que cet optimiseur.
Et maintenant, si nous remontons en arrière, vous pouvez voir que nous avons importé Upton torturé, une torche modulaire contenant tous les outils à
utiliser pour placer la grille au centre.
Donc, bien sûr, il contient des optimiseurs et nous lui avons donné le raccourci Upton. Nous allons donc
lui présenter le modèle, qui est la torche qui lui revient et à partir de ce module,
nous allons prendre un optimiseurs.
Comme vous pouvez le voir, ils sont tous énumérés ici.
Bon nombre d'entre eux sont excellents, par exemple Armor's Propp est un excellent optimiseur.
Il est par exemple fortement recommandé d’enregistrer les réseaux de neurones ou l’apprentissage en profondeur non supervisé.
Mais l’autre excellent et qu’il choisira est l’optimiseur d’atomes.
C'est celle que vous verrez avec celle-ci qui vous donnera une bonne voiture autonome.
Mais encore une fois, vous êtes totalement le bienvenu pour essayer d’autres, vous pouvez essayer l’appui-bras mais pour le métal, nous
choisirons Adam.
Alors j'appuie sur entrer.
Et en fait, vous remarquerez qu'il y a la capitale ici.
C'est parce que nous créons un objet de la classe Atom.
C'est une classe mais l'objet sera un optimiseur d'atomes lui-même.
Mais comme il s’agit d’une classe, nous devons définir quelques arguments. Les arguments de la classe Atom et
ceux-ci sont tous les paramètres permettant de personnaliser votre et votre optimiseur.
Ainsi, par exemple, il s’agit généralement du taux d’apprentissage de la décroissance ou de certains autres paramètres.
Et en plus de prendre tous les paramètres d’Ormeau, nous spécifierons un taux d’apprentissage.
C'est donc le début des paramètres de notre modèle.
Nous pouvons les obtenir avec le modèle de doute de soi.
Voilà donc le modèle que nous avons créé ici, modèle autodidacte de notre propre classe.
Donc modèle autodidacte, puis pour accéder aux paramètres du modèle, nous ajoutons un autre point, puis des
paramètres avec des parenthèses très simplement.
Il s’agit donc simplement de connecter l’optimiseur d’addon à notre réseau de neurones, celui que nous avons créé ici à nouveau. Comme
nous venons de le dire, nous allons ajouter un taux d’apprentissage et l’argument de ce principe est le nôtre.
Et nous allons lui attribuer une valeur telle que l'apprentissage ne se produise pas trop rapidement si nous obtenons
un taux d'apprentissage trop élevé, l'IA apprendra correctement.
Nous voulons donner à l'IA un peu de temps pour explorer les leçons de ses erreurs.
Vous savez quand nous punissons cela quand il commet des erreurs comme aller sur un sens ou s'approcher trop
près d'un mur.
Eh bien, nous voulons donner du temps pour apprendre.
Nous voulons que le réseau de neurones soit correctement daté.
Et donc, un bon rapport qualité-prix pour le taux d'apprentissage auquel j'ai abouti après avoir essayé plusieurs d'entre eux est 0. 2 ou un.
Très bien et c'est tout ce dont nous avons besoin pour créer un optimiseur.
Donc, fondamentalement, vous créez un objet de la classe Atom.
Génial.
Et puis les trois dernières variables dont nous avons besoin sont les variables composant nos événements de transition.
Donc, c'est la dernière date la dernière action et le dernier mot.
Et donc, c’est essentiellement ce que nous allons créer maintenant et nous aurons juste besoin de les initialiser.
Commençons donc par la dernière date, la dernière date que nous appellerons autodidacte.
Dernier état de soulignement et comment allez-vous l’initialiser?
Souvenez-vous bien que la dernière date est un vecteur de 5 dominations, un vecteur codé dans un état
de l'environnement.
Et pour rappel, ces cinq dimensions sont les trois signaux des trois capteurs laissés
droits et à droite ainsi que l’orientation et l’orientation moins.
Donc, ceci est un vecteur et un sens intuitif.
Mais pour le flambeau, il doit être plus qu'un vecteur.
En réalité, il doit s'agir d'un tenseur de torche.
Mais non seulement il doit s'agir d'un capteur de torche, mais il doit également comporter une autre dimension
que j'aime appeler une fausse dimension correspondant au lot.
Et c’est parce que les huit derniers seront l’entrée du réseau de neurones mais lorsqu’on travaille avec moi quand cela fonctionne en
général, que ce soit avec un flux plus dense, on porte une torche alors que les vecteurs d’entrée ne peuvent pas être
un simple vecteur en soi.
Il doit être dans un lot.
Le réseau ne peut accepter qu'un lot d'observations d'entrée et crée donc non seulement un tenseur pour
les vecteurs d'état d'entrée, mais nous allons également créer cette fausse dimension correspondant au lot.
Faisons ceci et commençons par initialiser un tenseur de torche pour faire cela, rien de
plus simple.
Nous prenons notre bibliothèque de torches puis point, puis nous allons utiliser la classe tenseur car, comme vous l’auriez peut-être deviné,
cela créera un objet de la classe tenseur qui est un objet tenseur.
Et dans ce tenseur, nous devons mettre un argument qui spécifiera la taille du tenseur.
Vous pouvez imaginer que cela vous prend comme un tableau ayant un seul type.
Mais fondamentalement, ce que cela va représenter maintenant est bien sûr cet état d'entrée que vous pouvez voir avec un vecteur et donc
pour spécifier le nombre d'éléments que la distance doit avoir.
Nous devons bien sûr utiliser la taille d’entrée car celle-ci correspond exactement au nombre de dimensions
de nos vecteurs d’état d’entrée.
Maintenant je devrais dire des tenseurs.
Et c’est ce que nous devons simplement entrer dans notre classe de tenseurs pour créer un objet tensor.
Eh bien c'est imprécis.
Et plus tard, la taille de l'entrée sera quantifiée.
D'accord c'est bon.
C'est la première chose faite.
Nous venons d'initialiser le tenseur comme il se doit.
Mais rappelez-vous que nous devons faire autre chose: créer cette fausse dimension, car c’est ce
à quoi le réseau s’attend pour ses entrées et créer celle-ci pour examen qui, en passant, doit être le premier moteur
à connaître les dommages que vous subissez. mis dans le lot sera la première fois que je
mentionne cela disons très bien.
Eh bien, pour ce faire, nous devons simplement ajouter cela, puis presser, puis entre parenthèses.
Nous devons mettre l’indice de cette grande dimension.
Et comme je viens de le dire, cette fausse dimension doit être la première animation de la dernière date et, depuis
les index et les octets et le zéro commencé, nous devons saisir zéro pour que ce nouveau moteur de paradigme devienne le premier
moteur de ligne.
Nous avons donc un premier moteur temporel correspondant au lot, puis le losange devrait répondre
à ce capteur qui contiendra les cinq éléments de vos états d'entrée, l'orientation des trois signaux et
l'orientation moins.
Et ensuite nous allons initialiser correctement nos états d’entrée.
Parfait.
Et puis deux variables à parcourir et cela sera beaucoup plus facile car la variable suivante est la dernière
action.
C’est un nouveau Roybal que nous créons pour la dernière action de Object.
Et rappelez-vous que dans le premier tutoriel de la section, je vous ai dit que les actions vont
être soit 0 1 ou 2, puis en utilisant le vecteur de rotation des actions, nous allons convertir ces index de ces actions en
angles de rotation que je rappelle à notre 0 20 ou moins 20.
Nous pouvons réellement rafraîchir notre mémoire avec cela.
Eh bien c'est exactement ici.
Action en rotation si l'action est zéro.
Cela correspondra au premier indice de zéro si l’action est 1.
Cela correspond à l'index un de ces vecteurs de 20 degrés et si l'action est
à nous aurons moins 20 degrés, ce sera l'angle de rotation de notre voiture lorsque nous jouerons l'action.
D'accord.
Et donc puisque l'action va être soit 0 1 ou 2 bien l'action est là pour un nombre
simple.
Et très simplement, nous pouvons l’initialiser à zéro.
Nous n'avons pas besoin de créer des dizaines ou d'entendre autre chose.
Nous avons juste besoin de l'initialiser avec zéro.
Et enfin.
Eh bien c'est le dernier mot.
C'est le soi qui est le dernier mot.
Nous y voilà.
Et encore une fois, le mot est un nombre flottant que je rappelle entre moins 1 et plus 1.
Donc, c'est encore le numéro.
Et comme pour l'action.
Nous allons l'initialiser à zéro et ensuite nous irons.
Félicitations sont dans sa fonction est prête.
Alors maintenant, nous sommes prêts à passer aux choses excitantes.
Et en réalité, la chose la plus importante pour l'IA est de décider quelle action jouer à chaque fois et à
chaque jeu. Et c'est exactement ce que nous allons faire dans le prochain tutoriel en créant la méthode de sélection de l'action.
Alors faisons ceci dans le prochain travail et jusque-là I.