Pourquoi voulons-nous toujours voir le nombre d'or? Tentative (infructueuse) d'analyse évolutive à l'aide de réseaux de neurones C ++

Récemment, je me suis demandé: notre désir de voir le nombre d'or partout lié à des choses purement culturelles est-il en quelque sorte, ou y a-t-il une sorte de schéma plus profond caché dans la structure de notre cerveau? Pour comprendre cela, j'ai décidé de faire quelques choses:

  1. Formuler une hypothèse spécifique concernant ce modèle. J'ai décidé que l'hypothèse la plus appropriée est que notre cerveau utilise un système de nombres basé sur la décomposition des nombres en degrés du nombre d'or, car certaines de ses caractéristiques sont très similaires au travail des réseaux neuronaux primitifs: le fait est que les degrés de la section dorée d'un ordre supérieur peuvent être étendus à l'infini le nombre de voies dans la somme des degrés d'un ordre inférieur et même des degrés négatifs. Ainsi, un degré supérieur est «excité» à partir de quelques degrés inférieurs, manifestant ainsi la même similitude avec un réseau neuronal.
  2. Décrivez une façon spécifique de le tester: j'ai choisi le tapis. simulation de l'évolution du cerveau par des changements aléatoires dans le réseau neuronal le plus simple possible - la matrice d'un opérateur linéaire.
  3. Créez des critères pour confirmer l'hypothèse. Mon critère était que le système numérique basé sur le nombre d'or est implémenté sur un moteur de réseau neuronal avec la même quantité d'informations avec moins d'erreurs que le binaire.

Puisque nous parlons de programmation, je décrirai plus en détail les deuxième et troisième points.

Pour simuler des changements aléatoires dans le cerveau au cours de l'évolution, j'ai utilisé la fonction rand_s (), car elle est cryptographiquement stable et, en conséquence, donnera un résultat «plus aléatoire». J'ai également utilisé comme critère que le réseau neuronal a réalisé le plus petit nombre d'erreurs en apprenant que lorsque la matrice dévie dans des directions aléatoires par de petites valeurs, son produit par le vecteur change d'environ le même module.

Quant au codage des données dans le vecteur lui-même, j'ai utilisé un vecteur à 28 dimensions pour deux nombres binaires à 14 chiffres et leur somme (après les 14 premiers caractères, il n'y a que 14 zéros à remplir) et un vecteur à 40 dimensions pour deux nombres dans le système avec un nombre d'or.

Le fichier d'entrée a le format suivant.

La première ligne est composée de deux entiers séparés par un espace, la dimension du vecteur et le nombre d'éléments dans l'ensemble d'apprentissage.

Toutes les lignes suivantes: la première ligne est l'entrée du réseau neuronal, la seconde est le résultat de traitement correct.

Voici un extrait de code de réseau neuronal qui est chargé de l'entraîner sur un échantillon de données d'entrée et les résultats corrects qui leur correspondent:

while (((d-mu)*(d-mu)>0.01)||(q<10)) // ,        ""    { s=0; //           for (k=0;k<m;k++) { for (i=0;i<n;i++) { (*(z+k*n+i))=0; } for (i=0;i<n;i++) { for (j=0;j<n;j++) { (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j)); } } //        for (i=0;i<n;i++) { s=s+((*(z+k*n+i))-(*(y+k*n+i)))*((*(z+k*n+i))-(*(y+k*n+i))); } //         s1=s+1; } while (s<s1) //      ,      ,    { s1=0; //      for (k=0;k<m;k++) { for (i=0;i<n;i++) { (*(z+k*n+i))=0; } }//  ()      rand_s(&p); k1 = (int) (p/((int) (UINT_MAX/n))); rand_s(&p); k2 = (int) (p/((int) (UINT_MAX/n))); //   ""  ,     rand_s(&p); h=((double) p/UINT_MAX)-0.5; //  h1=1; rand_s(&p); l=((int) ((double) p/UINT_MAX)*20); for (i=0;i<l;i++) { h1=h1/10; } h=h*h1; //,        for (k=0;k<m;k++) { for (i=0;i<n;i++) { for (j=0;j<n;j++) { if ((i==k1)&&(j==k2)) (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j))+h*(*(x+k*n+j)); else (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j)); } } //       for (i=0;i<n;i++) { s1=s1+((*(z+k*n+i))-(*(y+k*n+i)))*((*(z+k*n+i))-(*(y+k*n+i))); }//           } } (*(a+k1*n+k2))=(*(a+k1*n+k2))+h; //           s1=0; d=0; for (k1=0;k1<n;k1++) { for (k2=0;k2<n;k2++) { for (k=0;k<m;k++) { for (i=0;i<n;i++) { (*(z+k*n+i))=0; } } for (k=0;k<m;k++) { for (i=0;i<n;i++) { for (j=0;j<n;j++) { if ((i==k1)&&(j==k2)) (*(z+k*n+i))=(*(z+k*n+i))+((*(a+i*n+j))+0.1)*(*(x+k*n+j)); else (*(z+k*n+i))=(*(z+k*n+i))+(*(a+i*n+j))*(*(x+k*n+j)); } } } s1=0; for (k=0;k<m;k++) { for (i=0;i<n;i++) { s1=s1+((*(z+k*n+i))-(*(y+k*n+i)))*((*(z+k*n+i))-(*(y+k*n+i))); } } d=d+(s1-s)*(s1-s)/(n*m);//          } } mu=mu*((double) q/(q+1))+((double) d/(q+1));//         q=q+1; printf("%lf \n",mu);//         } 

J'ai également généré des données d'entrée au hasard, ce sont des nombres réels de zéro à un. De plus, en plus de l'échantillon d'entraînement, j'ai également généré un échantillon de test sur lequel j'ai testé mon réseau de neurones. De plus, pour chaque résultat obtenu par le réseau neuronal, j'ai calculé l'erreur quadratique moyenne, c'est-à-dire la racine du carré moyen de la différence entre les éléments du vecteur obtenu par le réseau neuronal et le vecteur contenant le résultat correct.
En conséquence, j'ai obtenu 1000 erreurs moyennes pour le résultat du fonctionnement du réseau neuronal avec ajout dans les systèmes numériques binaires et basés sur l'or. J'ai sélectionné la dimension du vecteur afin qu'ils stockent approximativement la même quantité d'informations à la fois à l'intérieur du système numérique et entre eux.

J'ai comparé les erreurs dans différents systèmes numériques avec des tests t appariés et c'est ce que j'ai obtenu.

Comparaison: Golden Ratio - Système binaire
Hypothèse: L'erreur dans le nombre d'or est en moyenne moindre.
Résultats:
t = -22,033
df = 999
p <0,001
D = -0,697 de Cohen (avec un nombre d'or, l'erreur est moindre)
Intervalle de confiance de 99% pour le d de Cohen:
de -inf à -0,615
Test de normalité de la distribution de Shapiro-Wilk:
W = 0,998 p = 0,382 (les distributions correspondent approximativement à la normale)
Statistiques descriptives:
Nombre d'or:
Moyenne arithmétique: 0,365
Écart type: 0,044
Système binaire:
Moyenne arithmétique: 0,414
Écart type: 0,055

J'ai décidé de conserver toutes les données utilisées dans cette petite étude artisanale pour l'instant comme preuve que je n'ai pas tiré les chiffres du plafond. Celui qui demande, je peux l'envoyer.

Maintenant aux conclusions. Étant donné que les réseaux de neurones, dont la formation est basée sur un changement aléatoire des connexions entre les neurones et la sélection des meilleurs d'entre eux (comme au cours de l'évolution), dans ce cas, ont montré qu'ils s'adaptent beaucoup mieux au nombre d'or qu'aux deux comme base du système numérique avec le même nombre informations, on peut supposer que l’évolution du cerveau des animaux, et en particulier de l’homme, a suivi une voie similaire.

UPD À partir du moment de la publication, l'auteur a mené une nouvelle étude dans laquelle il a pris en compte la correction du nombre de mesures et l'influence de la base du système numérique séparément de sa distance au nombre d'or en utilisant la régression linéaire. Le résultat a été décevant: la proximité de la base au nombre d'or augmente plutôt l'erreur que la réduit, de sorte que la sensation, comme toujours, est passée.

Source: https://habr.com/ru/post/fr478998/


All Articles