Bonjour et bienvenue dans la première partie de cette première partie de la mise en œuvre de l’IA, qui consiste à construire l’IA.
Et comme vous pouvez le voir, j’ai déjà ajouté une dimension à la structure de cette empreinte avec ces trois sections composant
la partie 1, qui montrent clairement comment nous allons construire cette IA.
Nous allons d'abord faire le cerveau.
Il n'y a rien d'autre que le réseau de neurones alors nous allons faire le corps qui va définir
comment les actions vont être jouées.
Et ensuite, une fois que nous aurons le cerveau et le corps, nous les assemblerons pour créer l'IA qui sera dans
la dernière partie de cette première partie.
Alors maintenant, vous pouvez déjà avoir une bonne vision de la structure de cette implémentation.
Nous fabriquons d'abord le cerveau, puis le corps, puis nous assemblons les deux pour créer l'IA.
Et puis c’est tout ce que nous allons commencer par la première section qui concerne la fabrication du cerveau.
Et cela va nous prendre pour des tutoriels.
Vous pouvez imaginer que faire un cerveau n'est pas comme faire un gâteau.
Donc, cela nécessitera plus d'un tutoriel.
Et bien sûr, comme d'habitude, nous allons représenter ce cerveau avec une classe, car nous aurons
besoin de plusieurs fonctions et afin d'avoir une structure de plusieurs fonctions qui sera organisée en quelque
sorte d'instructions.
Bien sûr, nous avons besoin d’un cours, c’est Berkeley, car jadis, nous avons créé ce cours.
Nous pourrons créer autant de cerveaux que nous le voulons en créant simplement des objets de cette classe.
Encore une fois, les classes en Python et, en général, les langages de programmation orientés objet sont très
pratiques car vous faites un modèle de quelque chose que vous voulez construire, puis vous êtes capable
de créer autant d’objets que vous voulez et définir dans la classe.
Et pour notre cerveau, les caractéristiques seront bien sûr.
Tout d’abord, l’architecture du réseau de neurones que je rappellerai sera celle de CNN et bien entendu de
deux fonctions différentes, telles que, par exemple, la transmission des signaux des neurones d’entrée aux neurones de sortie qui
seront bien entendu la fonction de Ford qui en sera chargée.
Alors faisons ceci, commençons à fabriquer le cerveau.
Cela va être très excitant.
C'est l'une de mes parties préférées.
Et donc allons droit au but.
Nous allons donc commencer par présenter la classe de cours et appeler cette classe.
Eh bien, j’ai hésité à appeler cela cerveau mais soyons plus directs et appelons CNN car en réalité le cerveau
est un réseau CNN.
Réseau neuronal convolutionnel.
Donc, pendant que vous regardez, vous pouvez appeler le cerveau si vous voulez, mais au moins, maintenant, nous savons ce que nous construisons.
Et CNN Quant au réseau de la voiture autonome, il va hériter de la fin de Mudgal.
Donc, rappelez-vous que la fin du module correspond à ce que nous avons mis ici et que nous voulons pouvoir utiliser
tous les outils de ceci et un module. Nous voulons donc utiliser cette technique dans la programmation
orientée objet qui est un héritage et qui nous permet de vous bien utiliser tous les outils d'une
classe parente et cette classe même sera sur ce module.
Nous y voilà.
Et maintenant, nous pouvons utiliser tous les outils et objets à la fin de ce module.
Très bien, maintenant que nous avons notre héritage, nous pouvons entrer dans la classe pour faire notre première fonction.
Et comme vous le savez probablement, la première fonction est la fonction finale qui définira toutes les variables
des futurs objets cérébraux.
Vous connaissez l'avenir et les objets qui seront créés.
Très bien alors faisons ceci.
Def alors deux soulignés dans les scores à nouveau.
Et maintenant, nous devons mettre quelques variables.
Donc tout d’abord, je voulais être moi-même, bien sûr, faire référence à l’objet.
Maintenant, je suppose que vous êtes assez à l'aise avec cela, alors nous allons ajouter une autre
variable qui sera le nombre d'actions dans l'environnement de Dumah.
Nous allons donc appeler ce numéro actions.
Nombre d'actions.
Et en réalité, cette variable n’est pas obligatoire pour la fonction.
C'est juste que si vous voulez tester l'idée, nous allons construire sur d'autres environnements.
Eh bien, ce sera très pratique car nous allons importer ce nombre d’actes horribles de Doom et
de wrappers Varman avec deux discrets et, ce faisant, vous saurez que le nom de
l’environnement saisit zéro.
Et donc, si vous voulez savoir comment expérimenter cela sur d'autres environnements et bien jouer à d'autres jeux, vous
n'aurez rien à faire car ce nombre d'actions obtiendra directement le nombre d'actions dans
l'environnement Dumor.
Tu vas jouer avec.
OK, voilà pour les deux arguments de cette fonction.
Alors maintenant, nous pouvons aller à l'intérieur et maintenant nous rappeler ce que nous devons faire.
La première chose à faire est d'activer l'héritage avec le super-fonctionnement.
Donc, c'est exactement comme pour la voiture autonome.
Nous prenons la superfonction puis à l'intérieur, nous commençons par entrer la classe qui définira le
réseau de neurones: CNN
Ensuite, nous devons entrer self pour faire référence à l'objet.
Mais souvenez-vous que ce n’est pas tout ce que nous devons ajouter ici à DOT, puis la fonction init avec des parenthèses.
Et en faisant cela, nous activons l'héritage.
Et maintenant, nous pouvons utiliser tous les outils de la fin et du module.
Bon maintenant, je pense qu'il est temps de construire l'architecture du réseau de neurones.
Et donc, comme vous vous en souvenez, nous allons construire un réseau de neurones convolutionnels de CNN simplement
parce que cette fois, l'IA aura des yeux et les yeux de l'œil seront les couches convolutionnelles de ce réseau neuronal
de convolution.
Et ensuite, après que ai ai visualisé les images avec les couches convolutives, il transmettra les signaux à
un réseau classique de neurones visuels.
C'est donc celui que nous avions auparavant avec des couches entièrement connectées.
Et c’est là qu’il essaiera de prédire les valeurs du cube pour chaque action possible que nous pouvons jouer.
Vous avez donc l’architecture en tête. Nous aurons d’abord des couches convolutives, puis des
couches entièrement connectées, qui constitueront le cerveau de notre IA.
Donc, ce que nous allons faire pour pouvoir faire un pas en arrière par rapport à ce que nous faisons.
Eh bien, faisons simplement cette architecture avec les variables que nous voulons créer.
Donc, en parlant de cette architecture, nous allons construire un CNN avec trois couches convolutives.
Et puis après cette couche cachée, cela signifie que nous aurons besoin de trois connexions convolutives et
de deux connexions complètes.
Et en parlant de connexions, c’est exactement ce que nous sommes sur le point de définir. Ce sont les
variables de la classe CNN. Par conséquent, je vais maintenant définir cinq variables.
Trois pour les connexions convolutionnelles et deux connexions politiques.
Alors faisons ceci.
Nous allons commencer par les connexions de convolution.
Je vais donc les appeler convolution autodidacte.
On va copier cela et basé sur le bas.
Et puis nous passons à la conviction de soi et à la conviction de soi trois qui
sont des connexions de convolution à cette première conclusion. Nous allons appliquer une certaine convolution
aux images d'entrée pour obtenir une première couche de convolution. couche en entrée et en appliquant
à nouveau une convolution, une seconde convolution est créée et cette convolution
obtient de nouvelles images, chacune détectant une caractéristique spécifique.
Nous allons donc obtenir ces nouvelles images dans une convolution puis appliquer cette convolution à ici pour
connecter ces nouvelles images de cette première couche de convolution à de nouvelles images d'une seconde couche de
convolution.
Et ces nouvelles images détecteront à nouveau certaines caractéristiques des images de la première convolution.
Il s’agit donc simplement de renforcer la détection future, puis l’émergence de la deuxième
convolution.
Nous avons appliqué la troisième convolution ici pour l'obtenir pour chacun d'eux.
Quelques images supplémentaires qui détectent encore plus de fonctionnalités dans les images d'entrée.
Et donc plus nous le faisons, plus nous appliquons des convolutions aux différentes couches d’images.
Plus nous sommes en mesure de détecter certaines caractéristiques, et c’est comme cela que l’œil comprendra où se trouvent les
monstres sur lesquels il doit tirer pour les tuer et où il devrait aller.
Il détectera également les murs des obstacles.
Eh bien, littéralement, il faut y aller et c'est grâce à ce que toutes ces couches convolutives détectent
dans les images d'origine.
D'accord, c'est donc pour la partie convolution de CNN.
Mais rappelez-vous qu'après les couches convolutives, nous devons aplatir tous les pixels obtenus par les différentes séries de
convolutions appliquées et en aplatissant tous les tableaux de pixels, nous obtenons cet énorme
vecteur qui deviendra l'entrée d'un réseau de neurones artificiels classique.
Et c'est là que nous obtenons nos lettres parfaitement connectées et donc nos connexions.
Et maintenant, nous devons créer deux nouvelles variables, car nous allons en avoir une ici et là dans
ce réseau de neurones artificiels classique et nous avons donc besoin d’une
connexion complète de cet énorme vecteur Flaten à celui-ci ici et là et une deuxième connexion complète entre celle-ci ici et
là et la couche de sortie composée des neurones de sortie qui sont les valeurs clés.
Faisons donc ces deux premières connexions et ensuite nous définirons toutes ces connexions.
Alors demandez la bande son dans le code que nous allons appeler eux-mêmes celui-là puis C autodidacte aussi.
Bon maintenant nous avons tous nos objets de valeur et savoir ce que nous devons faire est
bien entendu défini ensuite avec les classes du module moteur.
Cela signifie donc que nous allons créer l’architecture du réseau de neurones et c’est ce que
nous ferons demain.
Jusque là je