Comment puis-je faire en sorte que mon réseau traite également les rotations de l'entrée?

J'essaie de programmer mon propre système pour faire fonctionner un réseau neuronal. Pour réduire le nombre de nœuds nécessaires, il a été suggéré de le faire traiter également les rotations de l'entrée.

Mon réseau vise à apprendre et à prédire le jeu de la vie de Conway en regardant chaque carré et ses carrés environnants dans une grille, et en donnant la sortie pour ce carré. Son entrée est une chaîne de 9 bits:

Ce qui précède est représenté par 010 001 111.

Il existe cependant trois autres rotations de cette forme, et toutes produisent le même résultat:

Ma topologie de réseau est de 9 nœuds d'entrée et 1 nœud de sortie pour l'état suivant du carré central dans l'entrée. Comment puis-je construire la ou les couches cachées de façon à ce qu'elles prennent chacune la même rotation, réduisant ainsi le nombre d'entrées possibles au quart de l'original?

Éditer:

Il y a aussi un retournement de chaque rotation qui produit un résultat identique. L'intégration de ceux-ci réduira mes entrées de 1 / 8ème. Avec le planeur, mon objectif est que toutes ces entrées soient traitées exactement de la même manière. Est-ce que cela devra être fait avec le prétraitement, ou puis-je l'intégrer dans le réseau?

Si je comprends bien, votre nœud de sortie unique sera le prochain état du carré au milieu. Vous n'avez pas à vous soucier du nombre de nœuds dans les couches cachées alors que vous disposez de ressources suffisantes pour entraîner le modèle. Ce problème est très facile à apprendre pour un réseau de neurones, donc pas de problème de taille.

Vous devez suivre une formation supervisée, ce qui signifie que vous devez alimenter les données d'entrée et la sortie attendue correspondante. Vous devez être sûr que dans vos données d'entraînement, les 4 rotations sont affectées à la même sortie. De cette façon, votre réseau devrait apprendre à les traiter de la même manière.

Vous m'avez rendu curieux alors je me suis essayé. Ma solution a pu apprendre à 100% correctement en une vingtaine d'époques en quelques secondes sur mon ancien ordinateur portable. J'ai seulement légèrement modifié la sortie pour qu'elle soit catégorique [0,1] ou [1,0] mais cela donne le même résultat que vous recherchez. Juste pour référence, voici le code écrit en python:

from keras.models import Sequential
from keras.layers import Input, Dense
from keras.models import Model
from keras import optimizers
from keras.utils.np_utils import to_categorical
import helper

x_,y_ = helper.fnn_csv_toXY("conway.csv","output",False)
y_binary = to_categorical(y_)

model = Sequential()
model.add(Dense(100, activation='relu', kernel_initializer='glorot_uniform',input_shape =(9,)))
model.add(Dense(20, activation='relu', kernel_initializer='glorot_uniform'))
model.add(Dense(2, activation='softmax'))
adam=optimizers.Adam()
model.compile(optimizer=adam,
              loss='categorical_crossentropy',
              metrics=['acc'])
model.fit(x_, y_binary, epochs=100)

Vous avez identifié une optimisation dans votre espace problématique et souhaitez l'intégrer dans votre réseau neuronal. Je suggère le prétraitement: composez votre optimisation avec un réseau neuronal qui fait un sous-ensemble de ce que vous voulez.

En d'autres termes, normalisez votre entrée en codant manuellement un algorithme de rotation qui fait pivoter les entrées pour capturer l'équivalence mise en évidence dans votre message. Ensuite, alimentez la sortie de cette transformation vers votre réseau de neurones, pour la formation et toutes les autres utilisations. Cela signifie que vous entraînez le réseau neuronal à s'attaquer au sous-problème que vous avez identifié - les rotations sont redondantes.

Testez votre normalisateur en générant une entrée aléatoire, en le faisant pivoter vers les quatre transformations potentielles, exécutez le normalisateur sur chacune d'entre elles, puis vérifiez qu'elles sont toutes équivalentes.

Pour être puriste à ce sujet, commencez par considérer l'entrée différemment, comme un tableau circulaire de taille quatre, chaque élément contenant une paire de bits, et en plus un bit central:

... 01, 01, 11, 10 ...

0

Tout au long de la conception du réseau, poursuivez cette structure circulaire et ce paradigme de point central.