Bonjour et bienvenue dans ce tutoriel sur Python.
Très bien, nous avons donc beaucoup d’excitatif devant les sols.
Nous allons commencer par créer l’architecture du réseau de neurones, c’est-à-dire créer le réseau
de neurones qui sera au cœur de notre intelligence artificielle et qui renverra l’action à 90 ans.
Alors faisons ceci.
Donc, puisque nous voulons que notre réseau de neurones soit objectif, nous allons le classer.
Et c'est parce que c'est beaucoup plus pratique.
Vous savez que la classe est le modèle de quelque chose que nous voulons construire.
Nous voulons construire un réseau de neurones et nous devons faire une sorte d’instructions qui seront toutes contenues
dans la classe.
Et dans cette classe, nous allons créer deux fonctions.
D'abord la fonction init qui est la fonction qui apparaît tout le temps lors de la création de classe.
Et cela définit fondamentalement la variable de votre objet qui est le réseau de neurones.
Vous connaissez les variables attachées à l'objet par opposition aux variables globales.
C’est donc dans cette fonction que sera définie l’architecture du nouveau réseau que vous connaissez, définissant
la couche d’entrée qui sera composée de cinq neurones d’entrée car nous avons cinq dimensions pour le
vecteur codé des états d’entrée.
Ensuite, nous définirons des couches cachées.
Vous commencerez peut-être avec une couche cachée et vous pourrez ensuite essayer d'autres architectures du
réseau de neurones.
Et bien sûr, nous nous retrouverons avec la couche de sortie qui contiendra les actions possibles que nous
pouvons jouer à chaque fois.
C'est donc exactement ce que nous ferons dans cette fonction.
Et ensuite, nous créerons une autre fonction dans la classe qui sera la fonction
directe et qui activera les neurones du réseau de neurones.
Vous savez que cela va activer les signaux et nous allons donc utiliser une fonction d'activation rectifiée
car nous avons bien sûr affaire à un problème purement non linéaire et cette fonction rectifiée rompt la linéarité.
Mais surtout, nous faisons en sorte que cette fonction Ford renvoie les valeurs q qui sont les sorties du réseau.
Mais nous avons une valeur clé pour chaque action.
Et plus tard, nous retournerons l'action finale en prenant le maximum des valeurs de clé ou en utilisant une
méthode souple Max.
Nous verrons cela après.
Donc, dans ce tutoriel, nous allons commencer par implémenter la fonction init puis
le suivant implémentera la fonction forward.
Alors faisons ceci.
Nous devons d’abord présenter notre classe.
Donc, nous commençons avec classe et nous donnons un nom à notre classe qui est l'endroit où nous pouvons l'appeler réseau.
Et ensuite, dans cette classe de réseau, je vais utiliser une technique de programmation par objet appelée héritage,
qui consiste simplement à hériter de tous les outils d'une classe parente.
Donc, notre classe de réseau que nous sommes sur le point de faire est un test enfant d’une classe plus grande qui est.
Et ce module.
Donc, il ne s'agit que d'hériter de tous les outils de cette classe de modules qui, bien entendu, permettent de mettre en œuvre
un réseau de neurones.
C'est donc un truc très puissant et évolutif dans la programmation orientée objet qui va en héritage.
Et pour le moment, nous héritons de cette classe de module.
Très bien et maintenant nous sommes prêts à entrer dans la classe.
Donc, j'appuie deux fois sur Entrée parce que nous allons créer deux fonctions et nous commençons par la
fonction de fin.
Donc, la fonction init doit être nommée de cette façon avec deux sur ce parcours puis à l'intérieur.
Et encore une fois, pour souligner que la syntaxe Python n’est que la façon dont nous devons le faire.
Et puis nous devons mettre les arguments.
Nous avons donc trois arguments.
Le premier est un argument obligatoire qui est en réalité soi et Soi.
Il n’ya pas de mystère à ce sujet qui fait référence à l’objet qui sera créé à partir de cette classe que nous sommes sur le point
de fabriquer.
Vous savez que nous faisons cette classe.
C'est comme une instruction quelque modèle du réseau de neurones que nous voulons construire.
Et puis, une fois que la classe est prête, nous pouvons créer autant de réseaux que nous le souhaitons.
Et chacun de ces nouveaux réseaux sera un objet de cette classe et, puisque nous allons
utiliser cet objet à d’autres fins, nous devons préciser quelles sont les variables de cet objet et aux
spudis que nous utilisons ce self faites référence à l'objet.
Donc, chaque fois que je veux utiliser disponible depuis mon objet, je vais utiliser self avant la variable
pour spécifier qu'il s'agit d'une variable de l'objet.
Très bien, voilà le premier argument, puis nous avons deux autres arguments qui
sont bien sûr le nombre de neurones d’entrée et le nombre de neurones de sortie.
Nous allons donc appeler le nombre de neurones d'entrée la taille d'entrée. Il s'agit en réalité de
cinq, car nos vecteurs d'entrée ont cinq dimensions: trois signaux, plus l'orientation plus l'orientation moins, qui sont
des vecteurs de valeurs codées décrivant un état de l'environnement.
Ces cinq valeurs suffisent à décrire un état de l'environnement.
Nous aurions pu penser à Moins de valeurs ou à plus de valeurs, mais c'est ce que j'ai essayé et cela a
du sens, car nous avons besoin d'un signal de la gauche devant nous et d'un autre à droite.
Vous savez, lorsque nous conduisons une voiture, nous aurions pu opter pour un signal 360. Vous savez, comme
les signaux situés en haut des voitures Google, que nous pouvons totalement conduire de manière autonome avec trois capteurs, puis nous avons
cette orientation et l'orientation moins pour vous savoir garder trace de l’objectif que vous tentiez d’atteindre.
Et puis nous avons bien sûr les neurones de sortie de notre réseau qui correspondent aux actions et nous avons
trois actions possibles allant de gauche à droite ou de droite.
Et donc je vais l'appeler et l'action et il y en aura trois.
D'accord.
Jusqu'ici, nous n'avons qu'à donner des noms aux entrées, puis nous utiliserons ces ballons de volley-ball pour faire les conditions à l'intérieur
du réseau de neurones.
Très bien alors et vous commencez par utiliser une autre astuce par la torche, cette astuce
est une fonction superficielle qui hérite du module
C'est pourquoi nous avons également dû utiliser l'héritage pour hériter du module.
C'est le premier à utiliser.
Et donc, fondamentalement, nous n’utilisons cette super-super-astuce que pour pouvoir utiliser les outils de module
beaucoup plus efficaces.
Et à l'intérieur de la super-fonction, il me suffit de spécifier d'abord le réseau.
C’est donc notre classe de contrôle de réseau que vous connaissez, car elle hérite de la classe parente du
module, puis de notre objet.
Et puis j'ajoute simplement cela et je suis dans une fonction comme celle-ci exactement comment nous l'avons nommée.
Très bien, alors c'est juste un truc qui consiste à utiliser tous les outils que j'ai.
Et dans ce module, nous pouvons passer à l'étape suivante qui consiste à spécifier la couche d'entrée.
Donc, fondamentalement, ce que je dois faire est d’introduire une nouvelle variable qui sera attachée à l’objet
et cette variable contiendra le nombre de neurones d’entrée.
Donc, ne pas confondre avec la taille d'entrée taille d'entrée est l'argument de la fonction de fin.
Mais ce n'est pas la variable qui est attachée à l'objet mais la variable qui est attachée
à l'objet.
Comme je viens de le dire, nous devons spécifier qu’il est plutôt attaché à l’objet, nous utilisons donc un
autodidacte et nous donnons maintenant un nom à cette première variable attachée à l’objet.
Et ainsi, nous pouvons simplement donner le même nom que l’entrée.
Nous pouvons appeler cela la taille d'entrée et nous dirons qu'elle est égale aux arguments d'une fonction qui est la taille d'entrée.
D'accord.
Chaque fois que je crée un objet de la classe network et que je spécifie la taille d'entrée, par
exemple, je mets 5.
Il y aura 5 ici et donc la variable de taille d'entrée de notre objet aura la valeur
5 parce que cette taille d'entrée sera ici 5 et donc notre nouveau réseau aura 5 neurones d'entrée dans
la couche d'entrée.
D'accord.
Et puis c'est la même chose pour l'autre variable que nous voulons attacher aux objets.
Et comme vous l'avez peut-être deviné, il s'agira d'une variable pour le nombre de neurones de sortie.
Et dire que nous prenons nous-mêmes l'objet et que nous donnons un nom à cette seconde variable de l'objet
que nous allons appeler et à l'action.
Et ce sera égal à cet argument ici étant donné le nombre d'actions qui est le nombre de neurones
de sortie.
Et donc nous le fixons réellement à l'action et l'action sera égale à trois.
Par conséquent, la variable et l'action attachée à notre objet sur un réseau obtiendront la valeur de trois.
En fait, nous pouvons voir un avertissement ici qui dit nom non défini.
Et puis bien c'est parce que nous utilisons ici le.
Et puis raccourci.
Et nous devons utiliser un raccourci ici.
Et pour notre flambeau commencer et à Mudgal et puis il va disparaître.
Et c'est parti.
Parfait.
À l'heure actuelle, nous avons de nouveaux avertissements. Tous les avertissements ici sont juste pour spécifier que ce que nous importons n'est pas
encore utilisé.
C'est bon, nous les utiliserons après.
Très bien alors nous avons deux autres variables que nous voulons définir pour objet.
Et ce seront les connexions complètes des connexions complètes entre les différentes couches de notre réseau
de neurones.
Donc, comme nous voulons créer un réseau de neurones composé d’une seule tête dans leur monde, il
y aura deux connexions complètes.
Il y aura une première connexion complète entre la couche d'entrée et la couche masquée.
Et une seconde connexion complète entre la colline et la couche de sortie.
Commençons donc par la première connexion complète.
Nous allons l'appeler SE1. Encore une fois, j'utilise moi-même ici pour spécifier que FC est une variable de mon objet pour résoudre ce
problème.
FC un qui sera égal à.
Et maintenant, nous utilisons le module N dans et nous allons utiliser une fonction appelée R linéaire et c’est
précisément pour établir cette connexion complète entre les neurones et la couche d’entrée aux neurones cachés.
Et qu'est-ce que je veux dire par connexion complète.
Cela signifie que tous les neurones de la couche d'entrée seront tous connectés à tous les neurones
de l'ici.
Et donc pour établir cette connexion, nous utilisons cette fonction linéaire à laquelle nous devons ajouter des arguments.
Et comme vous pouvez le constater, ces arguments figurent dans les fonctionnalités.
C’est donc le nombre de neurones de la première loi sur laquelle vous souhaitez connecter des entités, c’est-à-dire
le nombre de neurones de la deuxième couche à connecter, la couche de droite qui
est la couche cachée et vraie.
Donc, en vélo, nous garderons la valeur par défaut, c'est-à-dire pour avoir un biais et pas seulement un poids
lié à la course, il faudra attendre et un biais pour chaque couche.
Et si bien voyons ce que nous devons entrer.
Le premier argument des entités est donc le nombre de neurones d’entrée dans la couche d’entrée.
Et alors où est-il.
Eh bien c'est en fait imprécis.
C’est l’argument de notre fonction init qui nous permettra plus tard de combattre l’orientation à trois signaux
et l’orientation de Mannus.
Alors on y va.
Lorsque les premiers arguments et la taille, puis le deuxième argument sont des fonctionnalités à savoir c'est le nombre de neurones que nous
voulons avoir dans la deuxième couche.
La deuxième couche qui sera entièrement connectée à la première couche.
Et maintenant, la question est de savoir combien de neurones voulons-nous dans cette couche cachée.
Eh bien, j'ai beaucoup d'entraînement aux paramètres.
J'ai beaucoup expérimenté.
C'est ce que nous faisons ou c'est ce que nous faisons plus en profondeur.
En général, nous expérimentons beaucoup pour voir quel serait le meilleur réseau de neurones pour notre
problème spécifique.
J'ai donc essayé de nombreuses valeurs et j'ai fini par choisir 30 pistes dans une couche cachée. Vous verrez qu'avec ce
nombre, vous obtiendrez de très bons résultats, mais n'hésitez pas à changer l'architecture du réseau
de neurones.
N'hésitez pas à jouer avec.
Vous pouvez non seulement modifier le nombre de neurones dans l'ici et là, mais vous pouvez également ajouter
quelques couches supplémentaires afin d'obtenir une voiture encore meilleure, mais 30 neurones Hinna nous fourniront un bon réseau neuronal et
une bonne cause.
C'est ce que nous recherchons.
Et c'est parti.
Nous avons vraiment notre première connexion complète avec cette fonction linéaire.
Nous établissons la connexion entre la couche d’entrée et la jambe cachée.
Et maintenant, il est temps d'établir la deuxième connexion complète, à savoir la connexion complète entre la couche masquée
et la couche de sortie.
Alors on y va.
Nous allons appeler cette deuxième connexion complète à C2.
Nous y voilà.
Et encore, cela est disponible pour plus d'objets utilisant Saphir.
Et là encore, nous utilisons.
En fait, nous pouvons copier ceci parce que nous allons utiliser le module N dans le module, puis la fonction linéaire.
Mais nous devons d'abord modifier les arguments bien sûr.
C'est la même chose en premier lieu, c'est le nombre de neurones que nous allons avoir dans la première couche de la connexion.
Donc c'est le caché là.
Et donc cela fait 30 et puis le deuxième argument est le nombre de neurones dans la deuxième couche de la connexion
et cela correspond à la couche de sortie et à la sortie qu’elle a.
Et les neurones réels qui seront plus tard trois, car nous avons trois actions possibles, mais nous devons jusqu’à présent utiliser
les noms que nous avons définis.
C'est le nom de l'argument de la fonction init et par conséquent nous entrons ici et l'action et
c'est parti.
Tout d’abord nos connexions de nuplets re.
Et deuxièmement, toute fonction est Israël.
C'est donc ce que nous allons initialiser notre objet chaque fois que nous créons un objet à partir de la classe network.
Et donc, dès que nous créons bien un objet, toutes ces variables pour variables ici ont une taille et une réaction.
Vous et un deux seront définis.
Et c’est ainsi que nous obtiendrons l’architecture de notre réseau d’animaux pour chaque objet que nous créons.
Chaque objet correspondra à un réseau de neurones de cinq neurones d’entrée, de 30 neurones cachés et de trois neurones
de sortie.
Alors on y va.
Nous en avons terminé avec cette première fonction et nous pouvons maintenant passer à la deuxième fonction
qui est la fonction de transfert et qui sera utilisée pour activer les neurones du réseau de neurones à
l’aide de la fonction d’activation du redresseur et surtout pour revenir aux valeurs de cube les sorties d'un seul réseau.
J'ai donc hâte de le faire dans le prochain tutoriel et jusque-là I.