Pourquoi est-il si une étude approfondie efficace est encore un mystère.
Dans cet article, nous allons essayer d'utiliser des réseaux de neurones pour dessiner l'image abstraite pour nous, alors interpréter ces images, afin d'avoir une meilleure compréhension du mystère de ce qui se passait à côté.
Après avoir lu cet article, vous apprendrez à générer une image, comme indiqué ci-dessous.
(Tout le contenu est inférieur à 100 lignes de code portable PyTorch Jupyter est venu avec :. Https: //github.com/paraschopra/abstract-art-neural-network)
Cette image est un cadre simple - réseau de génération de motif complexe (CPPN) généré.
(Vous pouvez apprendre par cet article.)
Article, les auteurs ont généré image abstraite par les réseaux de neurones écrits en JavaScript. Et cet article PyTorch les atteindre.
Procédé pour générer une image par le réseau neuronal de sorte qu'ils sont émis dans une image complète, par exemple, ce qui suit est appelé « générateur » Neural réseau bruit aléatoire comme entrée, et génère l'image entière dans la couche de sortie (et largeur * hauteur).
Et toute la production des images différentes, CPPN dans une position donnée (en entrée) de sortie de couleur de pixel.
Le non-respect de l'image ci-dessus et z r, les réseaux sont de pixel d'attention coordonnées x, y, et délivre le pixel devrait être la couleur (indiquée par c). modèle PyTorch du réseau tel est le suivant:
classe NN (nn.Module):
def __init __ (self):
Super (NN, auto-) .__ init __ ()
self.layers = nn.Sequential (nn.Linear (2, 16, polarisation = True),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 3, polarisation = Faux),
nn.Sigmoid ())
def vers l'avant (self, x):
self.layers de retour (x)
Notez qu'il accepte deux entrées et trois sorties (valeurs RVB des pixels). Procédé de génération d'une image entière est entrée à l'ensemble X, position Y de l'image souhaitée (taille spécifique), et la position X, Y sur les paramètres de couleur pour la couleur de sortie de réseau.
Peut-être, lorsque vous essayez d'exécuter le réseau de neurones ci-dessus, vous allez générer l'image suivante:
Peut-être vous serez plein de questions: Pourquoi proposez-vous que peu importe ce que l'emplacement x, y, sortie réseau est gris? Idéalement, cela ne devrait pas arriver, car si profondément ce réseau. Modifiez la valeur d'entrée devrait changer la valeur de sortie.
Lorsque chaque initialisation du réseau neuronal, étant donné que les paramètres d'initialisation aléatoire (poids et des biais), qui sont susceptibles de générer une nouvelle image. Mais souvent, même après quelques essais, vous obtenez ce des réseaux de neurones sont gris. Pourquoi?
Certains pourraient dire, est la fonction d'activation spécifique utilisé des problèmes -tanh. Tanh pluralité de couches ultérieures de séquences possibles dans la couche de sortie (le gris représentant toutes) de l'ordre de 0,5 à entrée numérique compressé. Toutefois, nous vous recommandons le début de l'article également utilisé tanh. Ce que nous avons fait était de convertir le blog écrit en JavaScript en utilisant les réseaux de neurones à PyTorch sans apporter aucune modification.
Où se trouve la racine du problème?
Quand un nouveau réseau de neurones est initialisé, PyTorch est comment initialiser les poids? Les forums d'utilisateurs, ils utilisent de -1 / sqrt (N) + 1 / sqrt (N) des nombres aléatoires pour initialiser les coefficients de pondération. Où n est un nombre de couches de connexions entrantes. Ainsi, pour la couche cachée, si N = 16, les poids seront initialisés entre -1/4 à +1/4. Ainsi, nous pouvons faire la conjecture suivante: produire une raison grise Suppose est parce que la gamme de poids est très faible, et peu de changement.
Si tous les poids dans le réseau entre -1/4 de +1/4, lorsqu'ils sont ajoutés ensemble et multipliée par une entrée, des effets similaires peuvent se produire dans le théorème de la limite centrale.
Théorème central limite (CLT) Preuve: Dans certains cas, l'ajout de variables aléatoires indépendantes, même si la variable d'origine lui-même est normalement distribué, ils sont convenablement normalisées et ont également tendance à être normalement distribués (officieusement connu sous le nom « cloche courbe « ).
Rappelez-vous comment calculer la valeur de la couche suivante.
Dans notre exemple, la première couche présente deux valeurs d'entrée (x, y), le second neurones de couche cachée 16. Par conséquent, chaque neurone dans la seconde couche des deux valeurs obtenues par un poids, les valeurs de poids entre -1/4 à +1/4. Ces valeurs sont additionnées puis, après avoir démarré la fonction d'activation tanh, à livrer à la nouvelle valeur de la troisième couche.
Or, dès le début de la seconde couche, il y a 16 entrées à transmettre à chacun des 16 neurones dans la troisième couche. Supposons que ces valeurs exprimées chacune par z, la valeur de la troisième couche de chaque neurone est le suivant:
Ceci est notre supposition une autre. En raison de la petite variance du poids (-1/4 à +1/4), la valeur de z (à savoir, entrée x, y par le poids, alors la fonction tanh) ne change pas trop (donc similaire). Donc, cette équation peut être considérée comme:
Pour chaque neurone, la valeur la plus probable de -0,25 à 0,25 en poids 16 et le droit est égal à zéro. Même dans la première couche, et n'est pas proche de zéro, le réseau des huit équations eu suffisamment de possibilités en fin de compte produire une valeur proche de zéro. Par conséquent, quelles que soient les valeurs d'entrée (x, y) sur la façon d'accéder à la fonction d'activation brute (poids multiplié par l'entrée complète) est toujours proche de zéro, tanh cartes à zéro (et donc la valeur de toutes les couches suivantes reste nul).
tanh axe x est l'entrée, y est l'arbre de sortie. Notez que 0 à 0 cartes.
Gris Quelle raison? En effet, la fonction en forme de S (la dernière fonction d'activation de la couche) prend zéro à cette valeur d'entrée, et des cartes à 0,5 (représentant gris, 0 représentant le noir et blanc pour 1).
Notez comment la fonction en forme de S mis en correspondance avec les valeurs d'entrée 0 à 0,5.
Étant donné que la cause profonde de petits changements de poids, notre étape suivante consiste à augmenter. Modifier la fonction d'initialisation par défaut, des poids assign de -100 à +100 (au lieu de -1/4 à +1/4). Maintenant, exécutez le réseau de neurones, nous pouvons obtenir:
Wow! Certains sont maintenant une des taches de couleur gris.
Maintenant, avec quelques progrès. Notre hypothèse est correcte. Mais l'image résultante est pas encore bien la structure. Il est trop simple.
Le réseau de neurones est réalisé en multipliant l'entrée avec les poids à la surface, en les poussant à travers tanh, la couleur de sortie finale en fonction de s-forme. Étant donné que nous avons fixé des poids, vous pouvez modifier l'entrée à l'image de sortie est plus intéressante? Bien sûr.
Notez que l'image ci-dessus est généré lorsque les x d'entrée, y comme les coordonnées des pixels originaux à partir de 0,0 à extrémité 128128 (qui correspond à la taille de l'image). Cela signifie que notre réseau n'a jamais été un nombre négatif en entrée, et à cause de ces grands nombres (tels que x, y peut être 100100), la fonction tanh soit obtenir un très grand nombre (il est comprimé à +1), ou pour donner un très petit nombre (qui est aplati à -1). Ceci est la raison pour laquelle nous voyons la combinaison simple des couleurs primaires (par exemple, 0,1,1 R, G, cyan sortie B que vous voyez dans la figure ci-dessus).
Comme au début de l'article mentionné dans l'article, nous allons normaliser x et y. Par conséquent, nous ne prenons pas x, mais l'entrée (x / image_size) -0,5. Cela signifie que la plage de valeurs de x et y est de -0,5 à 0,5 (sans tenir compte de la taille de l'image). Cela a donné lieu à l'image suivante:
Il y a des progrès!
Fait intéressant, une image dans la ligne de front a été de plus en plus vers le coin inférieur droit (en raison de valeurs x, y augmentent). Ici, étant donné que les valeurs x, y sont standardisées, et contient maintenant un nombre négatif, de sorte que ces lignes se développent uniformément vers l 'extérieur.
Cependant, l'image est encore assez belle.
Si vous regardez attentivement, vous trouverez au milieu de l'image semble avoir plus que le bord de la structure. Ce sont les mathématiques de Dieu nous donne à penser que nous devrions aller chercher magnifiée aux États-Unis.
Il y a trois façons un centre agrandi de l'image:
· Générer une grande image. Étant donné que les coordonnées de pixels sont normalisées, nous pouvons simplement lancer un réseau de neurones pour générer une image plus grande. Ensuite, nous pouvons zoomer à travers la partie centrale d'outils de retouche d'image, jetez un oeil à ce que nous avons trouvé.
* X et entrées y multiplié par une petite quantité (facteur d'échelle) qui réaliseraient effectivement les mêmes résultats avec la méthode précédente (et éviter de gaspiller nos calculs ennuyeux dans d'autres régions).
· Etant donné que la sortie est ré-établie en multipliant le droit d'entrée, afin de pouvoir être réduite par la valeur des autres valeurs de poids diminué, passant de -100 à + 100 + 3, -3 et ainsi au lieu de réduire les valeurs d'entrée (et se rappeler de ne pas trop réduit. PENSER si les poids seront de l'ordre de -0,25 à 0,25 gris il?).
Quand on utilise le second procédé de x et y est multipliée par 0,01, il y avait:
Lorsque la troisième méthode est initialisé et le poids est compris entre -3 et +3, ce qui est l'image que nous obtenons:
Ouvrez encore votre esprit?
Amorcer un changement du poids normal (moyenne 0 et d'écart type 1), et génère une pluralité d'images (le chiffre est dès le début de l'initialisation aléatoire).
Lors de l'enlèvement de la totalité de la couche cachée (entrée de mappage de sortie seulement):
Lorsque conservant une seule couche cachée (au lieu de la valeur par défaut 8 couche cachée):
En doublant le nombre de couches cachées à 16 couches:
Comme vous pouvez l'imaginer, le nombre de couches cachées, l'image devient de plus en plus complexe. Si la couche n'est pas doublé, mais le nombre de couches reste inchangé (8), mais le nombre de neurones dans chaque couche double (16-32), ce qui se passe? Nous obtenons:
Notez que, bien que dans les deux cas, le nombre total des poids du réseau sont semblables, mais le réseau comportant deux couches plus que chaque pixel du double réseau de neurones. représentation des pixels dans ces domaines, la fonction de changement rapide, donc si on fait un zoom plus loin, vous trouverez plus de structure. Pour la même mais le nombre de couches de chaque double réseau de neurones, qui fonctionne lissent tout à fait aussi « évolutivité » est faible.
Bien sûr, qui sont tous des réseaux de neurones profonds plus expressif autre façon de dire.
la complexité de la fonction de calcul croît de façon exponentielle avec la profondeur.
C'est ce que nous voyons. théorème d'approximation générale qui, en théorie, un réseau de neurones est assez grand, même s'il y a une couche cachée, vous pouvez représenter toutes les fonctions. En pratique, cependant, plus le réseau, plus compliqué l'entrée à la cartographie de sortie.
Si l'on prend le nombre de neurones dans chaque couche est de 8 à 128 (le nombre d'étages augmente).
Nerve - Pollock!
Si nous partons de chaque couche cachée neurone 128, et comme celui-ci dans les couches suivantes, ils sont progressivement réduits de moitié.
self.layers = nn.Sequential (nn.Linear (2, hidden_n, polarisation = True),
nn.Tanh (),
nn.Linear (128, 64, polarisation = Faux),
nn.Tanh (),
nn.Linear (64, 32, polarisation = Faux),
nn.Tanh (),
nn.Linear (32, 16, polarisation = Faux),
nn.Tanh (),
nn.Linear (16, 8, polarisation = Faux),
nn.Tanh (),
nn.Linear (8, 4, polarisation = Faux),
nn.Tanh (),
nn.Linear (4, 3, polarisation = Faux),
nn.Sigmoid ())
Nous obtenons:
Cela semble mieux que d'autres, plus « naturelle ».
Il y a beaucoup d'expériences que vous pouvez faire et obtenir une image intéressante, vous pouvez essayer plus de l'architecture, et le niveau d'activation.
