Former un réseau neuronal pour distinguer les nombres pairs et impairs

14

Question: est-il possible de former un NN pour distinguer entre les nombres pairs et impairs en utilisant uniquement comme entrée les nombres eux-mêmes?

J'ai le jeu de données suivant:

Number Target
1      0
2      1
3      0
4      1
5      0
6      1
...   ...
99     0
100    1

J'ai formé un NN avec deux neurones d'entrée (l'un étant le nombre variable, l'autre étant un neurone de polarisation), neuf neurones dans la couche cachée et un neurone de sortie en utilisant un algorithme génétique très simple: à chaque époque, deux ensembles de poids se battent " l'un contre l'autre; celui avec l'erreur la plus élevée perd et il est remplacé par une version modifiée du gagnant.

Le script résout facilement les problèmes simples comme les opérateurs ET, OU et XOR, mais reste bloqué en essayant de classer les nombres pairs et impairs. À l'heure actuelle, le mieux qu'il a réussi à faire est d'identifier 53 numéros sur 100 et cela a pris plusieurs heures. Que je normalise ou non les entrées ne fait aucune différence.

Si je voulais tricher, je pourrais simplement prétraiter les données et envoyer% 2 au NN en entrée, mais je ne veux pas le faire; NN devrait être en mesure d'approximer toutes les fonctions, y compris l'opérateur modulo (je crois ). Qu'est-ce que je fais mal?

Edgar Derby
la source
1
Il semble que vous essayez d'approximer la fonction "mod" avec un réseau neuronal. C'est l'une de mes classes de problèmes préférées - "quand est-ce la bonne chose d'approcher un poulet comme une sphère". Les modèles d'éléments finis sont un excellent endroit pour cela. Quand je pose la question au réseau neuronal, j'aime penser en termes de "base". Nous savons que la réponse exacte contient la division par 2 et la troncature tandis que le réseau classique est la multiplication vectorielle et les fonctions sigmoïdes. Les NN sont mieux utilisés pour l'interpolation, pas pour l'extrapolation - votre domaine est-il donc limité?
EngrStudent
4
Je pense que votre question va plus loin que la réponse actuellement acceptée. Considérez la généralisation suivante: construisez un réseau neuronal (en utilisant uniquement les opérations qui peuvent se produire dans le cerveau) qui calculerait n mod k, où n et k sont ses entrées. Je me demande si cela est possible avec un réseau à action directe de taille fixe.
user66081

Réponses:

7

Comme pour toute tâche d'apprentissage automatique, la représentation de votre contribution joue un rôle crucial dans la façon dont vous apprenez et généralisez.

Je pense que le problème avec la représentation est que la fonction (modulo) est hautement non linéaire et pas lisse dans la représentation d'entrée que vous avez choisie pour ce problème.

J'essaierais ce qui suit:

  1. Essayez un meilleur algorithme d'apprentissage (rétropropagation / descente de gradient et ses variantes).

  2. Essayez de représenter les nombres en binaire en utilisant une précision de longueur fixe.

  3. Si votre représentation d'entrée est un nombre b-bit, je m'assurerais que votre ensemble d'entraînement n'est pas biaisé vers les petits ou les grands nombres. Avoir des nombres qui sont uniformément et indépendamment choisis au hasard dans la plage .[0,2b-1]

  4. Comme vous l'avez fait, utilisez un réseau multicouche (essayez d'abord 2 couches: c'est-à-dire caché + sortie, avant d'utiliser plus de couches).

  5. Utilisez un ensemble de formation + test séparé. N'évaluez pas vos performances sur l'ensemble d'entraînement.

Vimal
la source
Je pensais que l'exécution d'une transformation sur les entrées comme le calcul du logarithme naturel pourrait être utile.
EngrStudent
C'est possible. En fait, connaissant la réponse ici (modulo 2 n'est que le dernier bit), la représentation binaire du nombre brut fonctionnerait extrêmement bien. Connectez simplement le dernier bit d'entrée à la sortie. :) Il serait intéressant de voir si le modulo (non-power-of-2) fonctionne bien avec un réseau neuronal. Cela peut ne pas fonctionner aussi bien.
Vimal
Salut @Vimal, merci pour la réponse. Savez-vous si la représentation des entrées en binaire est toujours une bonne idée ou si cela s'est avéré utile dans ce cas spécifique?
Edgar Derby
@AnnoysParrot - il n'y a pas de "balles d'argent". Il n'y a pas de meilleure représentation universelle car la meilleure signifie des choses différentes et s'excluant mutuellement. La représentation binaire est utile dans ce cas, mais il y en a beaucoup là où elle ne l'est pas. Envisagez un apprentissage approfondi des données visuelles. Si vous aviez un neurone d'entrée distinct pour chaque bit d'entrée unique, vous auriez besoin d'environ 256 * 5,2 millions d'entrées pour une image de 5 mégapixels.
EngrStudent
2
D'accord avec @EngrStudent ici. Beaucoup de connaissances préalables sont nécessaires pour concevoir une représentation d'entrée appropriée ainsi que la topologie du réseau neuronal lui-même. Puisqu'un réseau de neurones est à peu près un équivalent continu et différenciable d'un circuit numérique, vous pouvez adapter la topologie du réseau en vous inspirant des circuits numériques pour l'addition / la multiplication / la division / le modulo / etc. Cet avant sur la topologie (au lieu d'une couche entièrement connectée) peut conduire à une formation plus rapide, une meilleure généralisation, etc., un peu comme le fonctionnement des convnets pour les images naturelles.
Vimal
6

Apprendre à classer les nombres pairs et impairs est un problème difficile. Un motif simple ne cesse de se répéter à l'infini. 2,4,6,8 ..... 1,3,5,7 .....

Les fonctions d'activation non linéaires comme sin (x) et cos (x) se comportent de manière similaire. Par conséquent, si vous changez vos neurones pour implémenter sin et cos au lieu de fonctions d'activation populaires comme tanh ou relu, je suppose que vous pouvez résoudre ce problème assez facilement en utilisant un seul neurone.

Les transformations linéaires précèdent toujours les transformations non linéaires. Par conséquent, un seul neurone finira par apprendre le péché (ax + b) qui, pour la bonne combinaison de a & b, produira alternativement des 0 et des 1 à la fréquence souhaitée que nous voulons, qui dans ce cas est 1.

Je n'ai jamais essayé le péché ou le cos dans mes réseaux neuronaux auparavant. Donc, je m'excuse si cela finit par être une très mauvaise idée.

Vignesh Sk
la source
5

Je travaille donc avec des réseaux neuronaux en ce moment et j'ai rencontré le même problème que vous. Ce que j'ai fini par faire était de représenter le nombre d'entrée sous forme de tableau avec des valeurs égales à la représentation binaire du nombre. Puisque ce que nous faisons est de classer, j'ai représenté ma sortie sous forme de tableau, pas une seule valeur. ex:

input = [
  [0, 0, 0, 1], // 1
  [0, 0, 1, 0], // 2
  [0, 0, 1, 1], // 3
  [0, 1, 0, 0]  // 4
]
output = [
  [1, 0], // odd
  [0, 1], // even
  [1, 0], // odd
  [0, 1]  // even
]

J'espère que cela t'aides!

William Gottschalk
la source
1
Exactement sur la base de votre réponse, j'ai créé le modèle ici stackoverflow.com/questions/53671491/…
prosti
Superbe! Cela montre à quel point la représentation des données est importante pour tout algorithme ML. Lorsque j'ai utilisé la représentation décimale, j'ai obtenu exactement 50% de précision, mais en suivant cette idée, j'ai obtenu une précision de 100% même sur des données invisibles. Merci. Voici l'implémentation: colab.research.google.com/drive/…
Kaushal28
2
En binaire, les nombres pairs se terminent toujours par 0 et les nombres impairs se terminent toujours par 1. Il n'est pas surprenant que le modèle fonctionne, car il est probable qu'il vient d'apprendre à cracher la valeur du dernier chiffre.
Syncrossus
2

J'arrive ici où était aux prises avec un problème similaire. J'écris donc ce que j'ai réussi.

Pour autant que je sache, une couche de perceptron est capable de résoudre tous les problèmes, ce qui peut être finalement simplifié pour diviser les objets dans n'importe quelle géométrie en utilisant une ligne droite. Et c'est ce genre de problème. Si vous dessinez le dernier bit de représentation binaire sur papier, vous pouvez également tracer une ligne, et tous les nombres impairs sont d'un côté, et même de l'autre. Pour la même raison, il est impossible de résoudre le problème xor avec un réseau à une seule couche.

D'accord. Ce problème semble très simple, alors prenons l'étape Heaviside comme fonction d'activation. Après avoir joué un peu avec mon numéro, j'ai réalisé que le problème ici est avec le biais. Je google un peu, et ce que j'ai trouvé, c'est que si vous restez avec la représentation géométrique, le biais vous permet de changer le lieu d'activation dans le système de coordonnées.

Problème très éducatif

user3486361
la source
1

Il est bien connu que les portes logiques NON, ET, OU peuvent toutes être effectuées avec des réseaux neuronaux très simples (NN), et que vous pouvez construire une calculatrice arithmétique complète avec des portes logiques en utilisant des nombres binaires en entrée. Par conséquent, vous devriez pouvoir créer un NN pour calculer n modulo k, pour tout nombre n et k exprimé en base 2.

Si vous souhaitez calculer n modulo k pour un nombre k fixe (par exemple k = 4), vous pouvez réellement créer un NN extrêmement simple qui fait cela: exprimez le nombre d'entrée n en base k et ignorez tous les chiffres autres que le rang le plus bas chiffre, et vous avez la réponse!

Bernard Montaron
la source
0

Une idée évitant l'utilisation du "mod 2" explicite dans l'entrée pourrait être de codifier le nombre comme une séquence de pixels, alors le problème revient à reconnaître si le segment peut être divisé en deux segments égaux. Il s'agit d'un problème de vision industrielle qui pourrait être appris par les réseaux conventionnels.

À l'autre extrême, si le nombre est stocké sous forme de flottant, la question se réduit (ou se généralise) pour reconnaître quand un nombre flottant est approximativement un entier.

arivero
la source
Pensée intéressante. Pouvez-vous expliquer comment aimeriez-vous codifier le nombre en pixels?
Jan Kukacka
eh bien, pensez "base 1". Pour codifier n, tracez une barre noire de n pixels. Je suppose que les noyaux de convolution remarqueront la différence entre un nombre impair et un nombre pair de pixels.
arivero
0

J'ai créé un tel réseau en ici .

La représentation donnée par @William Gottschalk était la fondation.

Il utilise seulement 1 neurone dans la première couche cachée avec 32 entrées. La couche de sortie n'a que 2 neurones pour un codage à chaud de 0 et 1.

prosti
la source
0

Ma solution

import numpy as np


def layer_1_z(x, w1, b1):
    return 1 / w1 * x + b1


def layer_2(x, w1, b1, w2, b2):
    y1 = layer_1_z(x, w1, b1)
    y2 = y1 - np.floor(y1)
    return w2 * y2 + b2


def layer_2_activation(x, w1, b1, w2, b2):
    y2 = layer_2(x, w1, b1, w2, b2)
    # return 1 / (1 + np.exp(-y2))
    return (y2 > 0) * 1


def loss(param):
    w1, b1, w2, b2 = param
    x = np.arange(0, 1000, 1)
    y_hat = layer_2_activation(x, w1, b1, w2, b2)
    y_true = (x % 2 > 0) * 1
    return sum(np.square(y_hat - y_true))


# %%

from sko.GA import GA

ga = GA(func=loss, n_dim=4, size_pop=50, max_iter=100, lb=[1, 0, 1, 0], ub=[32, 1, 2, 1], precision=1)
best_x, best_y = ga.run()
print('best_x:', best_x, '\n', 'best_y:', best_y)

for x in range(1001, 1200):
    y_hat = layer_2_activation(x, *best_x)
    print('input:{},divide by 2:{}'.format(x, y_hat == 0))

entrée: 1001, diviser par 2: entrée fausse: 1002, diviser par 2: entrée vraie: 1003, diviser par 2: entrée fausse: 1004, diviser par 2: entrée vraie: 1005, diviser par 2: entrée fausse: 1006, diviser par 2: entrée vraie: 1007, divisée par 2: entrée fausse: 1008, divisée par 2: entrée vraie: 1009, divisée par 2: entrée fausse: 1010, divisée par 2: entrée vraie: 1011, divisée par 2: entrée fausse : 1012, diviser par 2: entrée vraie: 1013, diviser par 2: entrée fausse: 1014, diviser par 2: entrée vraie: 1015, diviser par 2: entrée fausse: 1016, diviser par 2: entrée vraie: 1017, diviser par 2: entrée fausse: 1018, divisée par 2: entrée vraie: 1019, divisée par 2: entrée fausse: 1020, divisée par 2: entrée vraie: 1021, divisée par 2: entrée fausse: 1022, divisée par 2: entrée vraie: 1023, diviser par 2: entrée fausse: 1024, diviser par 2: entrée vraie: 1025, diviser par 2: entrée fausse: 1026, diviser par 2: entrée vraie: 1027, diviser par 2: entrée fausse: 1028, diviser par 2 : Entrée vraie: 1029, divisée par 2:Fausse entrée: 1030, divisée par 2: Vrai entrée: 1031, divisée par 2: Fausse entrée: 1032, divisée par 2: Vrai entrée: 1033, divisée par 2: Fausse entrée: 1034, divisée par 2: Vrai entrée: 1035, diviser par 2: entrée fausse: 1036, diviser par 2: entrée vraie: 1037, diviser par 2: entrée fausse: 1038, diviser par 2: entrée vraie: 1039, diviser par 2: entrée fausse: 1040, diviser par 2: vraie entrée: 1041, diviser par 2: entrée fausse: 1042, diviser par 2: entrée vraie: 1043, diviser par 2: entrée fausse: 1044, diviser par 2: entrée vraie: 1045, diviser par 2: entrée fausse: 1046, diviser par 2: entrée vraie: 1047, divisée par 2: entrée fausse: 1048, divisée par 2: entrée vraie: 1049, divisée par 2: entrée fausse: 1050, divisée par 2: entrée vraie: 1051, divisée par 2: entrée fausse : 1052, diviser par 2: entrée vraie: 1053, diviser par 2: entrée fausse: 1054, diviser par 2: entrée vraie: 1055, diviser par 2: entrée fausse: 1056, diviser par 2: entrée vraie: 1057, diviser par 2: Fausse entrée: 1058, divisée par 2:Entrée vraie: 1059, divisée par 2: entrée fausse: 1060, divisée par 2: entrée vraie: 1061, divisée par 2: entrée fausse: 1062, divisée par 2: entrée vraie: 1063, divisée par 2: entrée fausse: 1064, diviser par 2: entrée vraie: 1065, diviser par 2: entrée fausse: 1066, diviser par 2: entrée vraie: 1067, diviser par 2: entrée fausse: 1068, diviser par 2: entrée vraie: 1069, diviser par 2: fausse entrée: 1070, diviser par 2: entrée vraie: 1071, diviser par 2: entrée fausse: 1072, diviser par 2: entrée vraie: 1073, diviser par 2: entrée fausse: 1074, diviser par 2: entrée vraie: 1075, diviser par 2: entrée fausse: 1076, divisée par 2: entrée vraie: 1077, divisée par 2: entrée fausse: 1078, divisée par 2: entrée vraie: 1079, divisée par 2: entrée fausse: 1080, divisée par 2: entrée vraie : 1081, diviser par 2: entrée fausse: 1082, diviser par 2: entrée vraie: 1083, diviser par 2: entrée fausse: 1084, diviser par 2: entrée vraie: 1085, diviser par 2: entrée fausse: 1086, diviser par 2: entrée vraie: 1087, divisée par 2:Fausse entrée: 1088, divisée par 2: Vrai entrée: 1089, divisée par 2: Fausse entrée: 1090, divisée par 2: Vrai entrée: 1091, divisée par 2: Fausse entrée: 1092, divisée par 2: Vrai entrée: 1093, diviser par 2: entrée fausse: 1094, diviser par 2: entrée vraie: 1095, diviser par 2: entrée fausse: 1096, diviser par 2: entrée vraie: 1097, diviser par 2: entrée fausse: 1098, diviser par 2: vraie entrée: 1099, diviser par 2: entrée fausse: 1100, diviser par 2: entrée vraie: 1101, diviser par 2: entrée fausse: 1102, diviser par 2: entrée vraie: 1103, diviser par 2: entrée fausse: 1104, diviser par 2: entrée vraie: 1105, divisée par 2: entrée fausse: 1106, divisée par 2: entrée vraie: 1107, divisée par 2: entrée fausse: 1108, divisée par 2: entrée vraie: 1109, divisée par 2: entrée fausse : 1110, diviser par 2: entrée vraie: 1111, diviser par 2: entrée fausse: 1112, diviser par 2: entrée vraie: 1113, diviser par 2: entrée fausse: 1114, diviser par 2: entrée vraie: 1115, diviser par 2: Fausse entrée: 1116, divisée par 2:Entrée vraie: 1117, divisée par 2: Entrée fausse: 1118, divisée par 2: Entrée vraie: 1119, divisée par 2: Entrée fausse: 1120, divisée par 2: Entrée vraie: 1121, divisée par 2: Fausse entrée: 1122, diviser par 2: entrée vraie: 1123, diviser par 2: entrée fausse: 1124, diviser par 2: entrée vraie: 1125, diviser par 2: entrée fausse: 1126, diviser par 2: entrée vraie: 1127, diviser par 2: fausse entrée: 1128, diviser par 2: entrée vraie: 1129, diviser par 2: entrée fausse: 1130, diviser par 2: entrée vraie: 1131, diviser par 2: entrée fausse: 1132, diviser par 2: entrée vraie: 1133, diviser par 2: entrée fausse: 1134, divisée par 2: entrée vraie: 1135, divisée par 2: entrée fausse: 1136, divisée par 2: entrée vraie: 1137, divisée par 2: entrée fausse: 1138, divisée par 2: entrée vraie : 1139, diviser par 2: entrée fausse: 1140, diviser par 2: entrée vraie: 1141, diviser par 2: entrée fausse: 1142, diviser par 2: entrée vraie: 1143, diviser par 2: entrée fausse: 1144, diviser par 2: entrée vraie: 1145, divisée par 2:Fausse entrée: 1146, divisée par 2: Vrai entrée: 1147, divisée par 2: Fausse entrée: 1148, divisée par 2: Vrai entrée: 1149, divisée par 2: Fausse entrée: 1150, divisée par 2: Vrai entrée: 1151, diviser par 2: entrée fausse: 1152, diviser par 2: entrée vraie: 1153, diviser par 2: entrée fausse: 1154, diviser par 2: entrée vraie: 1155, diviser par 2: entrée fausse: 1156, diviser par 2: vraie entrée: 1157, diviser par 2: entrée fausse: 1158, diviser par 2: entrée vraie: 1159, diviser par 2: entrée fausse: 1160, diviser par 2: entrée vraie: 1161, diviser par 2: entrée fausse: 1162, diviser par 2: entrée vraie: 1163, divisée par 2: entrée fausse: 1164, divisée par 2: entrée vraie: 1165, divisée par 2: entrée fausse: 1166, divisée par 2: entrée vraie: 1167, divisée par 2: entrée fausse : 1168, diviser par 2: entrée vraie: 1169, diviser par 2: entrée fausse: 1170, diviser par 2: entrée vraie: 1171, diviser par 2: entrée fausse: 1172, diviser par 2: entrée vraie: 1173, diviser par 2: Fausse entrée: 1174, divisée par 2:Entrée vraie: 1175, divisée par 2: Entrée fausse: 1176, divisée par 2: Entrée vraie: 1177, divisée par 2: Entrée fausse: 1178, divisée par 2: Entrée vraie: 1179, divisée par 2: Fausse entrée: 1180, diviser par 2: entrée vraie: 1181, diviser par 2: entrée fausse: 1182, diviser par 2: entrée vraie: 1183, diviser par 2: entrée fausse: 1184, diviser par 2: entrée vraie: 1185, diviser par 2: fausse entrée: 1186, diviser par 2: entrée vraie: 1187, diviser par 2: entrée fausse: 1188, diviser par 2: entrée vraie: 1189, diviser par 2: entrée fausse: 1190, diviser par 2: entrée vraie: 1191, diviser par 2: entrée fausse: 1192, divisée par 2: entrée vraie: 1193, divisée par 2: entrée fausse: 1194, divisée par 2: entrée vraie: 1195, divisée par 2: entrée fausse: 1196, divisée par 2: entrée vraie : 1197, diviser par 2: entrée fausse: 1198, diviser par 2: entrée vraie: 1199, diviser par 2: fausseEntrée vraie: 1179, divisée par 2: Entrée fausse: 1180, divisée par 2: Entrée vraie: 1181, divisée par 2: Entrée fausse: 1182, divisée par 2: Entrée vraie: 1183, divisée par 2: Fausse entrée: 1184, diviser par 2: entrée vraie: 1185, diviser par 2: entrée fausse: 1186, diviser par 2: entrée vraie: 1187, diviser par 2: entrée fausse: 1188, diviser par 2: entrée vraie: 1189, diviser par 2: fausse entrée: 1190, diviser par 2: entrée vraie: 1191, diviser par 2: entrée fausse: 1192, diviser par 2: entrée vraie: 1193, diviser par 2: entrée fausse: 1194, diviser par 2: entrée vraie: 1195, diviser par 2: entrée fausse: 1196, diviser par 2: entrée vraie: 1197, diviser par 2: entrée fausse: 1198, diviser par 2: entrée vraie: 1199, diviser par 2: fausseEntrée vraie: 1179, divisée par 2: Entrée fausse: 1180, divisée par 2: Entrée vraie: 1181, divisée par 2: Entrée fausse: 1182, divisée par 2: Entrée vraie: 1183, divisée par 2: Fausse entrée: 1184, diviser par 2: entrée vraie: 1185, diviser par 2: entrée fausse: 1186, diviser par 2: entrée vraie: 1187, diviser par 2: entrée fausse: 1188, diviser par 2: entrée vraie: 1189, diviser par 2: fausse entrée: 1190, diviser par 2: entrée vraie: 1191, diviser par 2: entrée fausse: 1192, diviser par 2: entrée vraie: 1193, diviser par 2: entrée fausse: 1194, diviser par 2: entrée vraie: 1195, diviser par 2: entrée fausse: 1196, divisée par 2: entrée vraie: 1197, divisée par 2: entrée fausse: 1198, divisée par 2: entrée vraie: 1199, divisée par 2: fauxEntrée vraie: 1187, divisée par 2: Entrée fausse: 1188, divisée par 2: Entrée vraie: 1189, divisée par 2: Entrée fausse: 1190, divisée par 2: Entrée vraie: 1191, divisée par 2: Fausse entrée: 1192, diviser par 2: entrée vraie: 1193, diviser par 2: entrée fausse: 1194, diviser par 2: entrée vraie: 1195, diviser par 2: entrée fausse: 1196, diviser par 2: entrée vraie: 1197, diviser par 2: fausse entrée: 1198, diviser par 2: vrai entrée: 1199, diviser par 2: fauxEntrée vraie: 1187, divisée par 2: Entrée fausse: 1188, divisée par 2: Entrée vraie: 1189, divisée par 2: Entrée fausse: 1190, divisée par 2: Entrée vraie: 1191, divisée par 2: Fausse entrée: 1192, diviser par 2: entrée vraie: 1193, diviser par 2: entrée fausse: 1194, diviser par 2: entrée vraie: 1195, diviser par 2: entrée fausse: 1196, diviser par 2: entrée vraie: 1197, diviser par 2: fausse entrée: 1198, diviser par 2: vrai entrée: 1199, diviser par 2: faux


De plus, diviser par d'autres nombres (disons 7), c'est bien aussi:

import numpy as np


def layer_1_z(x, w1, b1):
    return 1 / w1 * x + b1


def layer_2(x, w1, b1, w2, b2):
    y1 = layer_1_z(x, w1, b1)
    y2 = y1 - np.floor(y1)
    return w2 * y2 + b2


def layer_2_activation(x, w1, b1, w2, b2):
    y2 = layer_2(x, w1, b1, w2, b2)
    # return 1 / (1 + np.exp(-y2))
    return (y2 > 0) * 1


def loss(param):
    w1, b1, w2, b2 = param
    x = np.arange(0, 1000, 1)
    y_hat = layer_2_activation(x, w1, b1, w2, b2)
    y_true = (x % 7 > 0) * 1
    return sum(np.square(y_hat - y_true))


# %%

from sko.GA import GA

ga = GA(func=loss, n_dim=4, size_pop=50, max_iter=100, lb=[1, 0, 1, 0], ub=[32, 1, 2, 1], precision=1)
best_x, best_y = ga.run()
print('best_x:', best_x, '\n', 'best_y:', best_y)

for x in range(1001, 1200):
    y_hat = layer_2_activation(x, *best_x)
    print('input:{},divide by 7:{}'.format(x, y_hat == 0))

entrée: 1001, diviser par 7: entrée vraie: 1002, diviser par 7: entrée fausse: 1003, diviser par 7: entrée fausse: 1004, diviser par 7: entrée fausse: 1005, diviser par 7: entrée fausse: 1006, diviser par 7: entrée fausse: 1007, diviser par 7: entrée fausse: 1008, diviser par 7: entrée vraie: 1009, diviser par 7: entrée fausse: 1010, diviser par 7: entrée fausse: 1011, diviser par 7: entrée fausse : 1012, diviser par 7: Fausse entrée: 1013, diviser par 7: Fausse entrée: 1014, diviser par 7: Fausse entrée: 1015, diviser par 7: Vrai entrée: 1016, diviser par 7: Fausse entrée: 1017, diviser par 7: Fausse entrée: 1018, divisée par 7: Fausse entrée: 1019, divisée par 7: Fausse entrée: 1020, divisée par 7: Fausse entrée: 1021, divisée par 7: Fausse entrée: 1022, divisée par 7: Vrai entrée: 1023, diviser par 7: Fausse entrée: 1024, diviser par 7: Fausse entrée: 1025, diviser par 7: Fausse entrée: 1026, diviser par 7: Fausse entrée: 1027, diviser par 7: Fausse entrée: 1028, diviser par 7 : Fausse entrée: 1029, divisée par 7:Vrai entrée: 1030, diviser par 7: Fausse entrée: 1031, diviser par 7: Fausse entrée: 1032, diviser par 7: Fausse entrée: 1033, diviser par 7: Fausse entrée: 1034, diviser par 7: Fausse entrée: 1035, diviser par 7: entrée fausse: 1036, diviser par 7: entrée vraie: 1037, diviser par 7: entrée fausse: 1038, diviser par 7: entrée fausse: 1039, diviser par 7: entrée fausse: 1040, diviser par 7: fausse entrée: 1041, diviser par 7: entrée fausse: 1042, diviser par 7: entrée fausse: 1043, diviser par 7: entrée vraie: 1044, diviser par 7: entrée fausse: 1045, diviser par 7: entrée fausse: 1046, diviser par 7: entrée fausse: 1047, diviser par 7: entrée fausse: 1048, diviser par 7: entrée fausse: 1049, diviser par 7: entrée fausse: 1050, diviser par 7: entrée vraie: 1051, diviser par 7: entrée fausse : 1052, diviser par 7: Fausse entrée: 1053, diviser par 7: Fausse entrée: 1054, diviser par 7: Fausse entrée: 1055, diviser par 7: Fausse entrée: 1056, diviser par 7: Fausse entrée: 1057, diviser par 7: Vrai entrée: 1058,diviser par 7: entrée fausse: 1059, diviser par 7: entrée fausse: 1060, diviser par 7: entrée fausse: 1061, diviser par 7: entrée fausse: 1062, diviser par 7: entrée fausse: 1063, diviser par 7: fausse entrée: 1064, diviser par 7: entrée vraie: 1065, diviser par 7: entrée fausse: 1066, diviser par 7: entrée fausse: 1067, diviser par 7: entrée fausse: 1068, diviser par 7: entrée fausse: 1069, diviser par 7: entrée fausse: 1070, diviser par 7: entrée fausse: 1071, diviser par 7: entrée vraie: 1072, diviser par 7: entrée fausse: 1073, diviser par 7: entrée fausse: 1074, diviser par 7: entrée fausse : 1075, diviser par 7: entrée fausse: 1076, diviser par 7: entrée fausse: 1077, diviser par 7: entrée fausse: 1078, diviser par 7: entrée vraie: 1079, diviser par 7: entrée fausse: 1080, diviser par 7: Fausse entrée: 1081, diviser par 7: Fausse entrée: 1082, diviser par 7: Fausse entrée: 1083, diviser par 7: Fausse entrée: 1084, diviser par 7: Fausse entrée: 1085, diviser par 7: Vrai entrée: 1086, divisé par 7:Fausse entrée: 1087, divisée par 7: Fausse entrée: 1088, divisée par 7: Fausse entrée: 1089, divisée par 7: Fausse entrée: 1090, divisée par 7: Fausse entrée: 1091, divisée par 7: Fausse entrée: 1092, diviser par 7: entrée vraie: 1093, diviser par 7: entrée fausse: 1094, diviser par 7: entrée fausse: 1095, diviser par 7: entrée fausse: 1096, diviser par 7: entrée fausse: 1097, diviser par 7: fausse entrée: 1098, diviser par 7: entrée fausse: 1099, diviser par 7: entrée vraie: 1100, diviser par 7: entrée fausse: 1101, diviser par 7: entrée fausse: 1102, diviser par 7: entrée fausse: 1103, diviser par 7: entrée fausse: 1104, diviser par 7: entrée fausse: 1105, diviser par 7: entrée fausse: 1106, diviser par 7: entrée vraie: 1107, diviser par 7: entrée fausse: 1108, diviser par 7: entrée fausse : 1109, diviser par 7: entrée fausse: 1110, diviser par 7: entrée fausse: 1111, diviser par 7: entrée fausse: 1112, diviser par 7: entrée fausse: 1113, diviser par 7: entrée vraie: 1114, diviser par 7: Fausse entrée: 1115,diviser par 7: entrée fausse: 1116, diviser par 7: entrée fausse: 1117, diviser par 7: entrée fausse: 1118, diviser par 7: entrée fausse: 1119, diviser par 7: entrée fausse: 1120, diviser par 7: vrai entrée: 1121, diviser par 7: entrée fausse: 1122, diviser par 7: entrée fausse: 1123, diviser par 7: entrée fausse: 1124, diviser par 7: entrée fausse: 1125, diviser par 7: entrée fausse: 1126, diviser par 7: entrée fausse: 1127, divisée par 7: entrée vraie: 1128, divisée par 7: entrée fausse: 1129, divisée par 7: entrée fausse: 1130, divisée par 7: entrée fausse: 1131, divisée par 7: entrée fausse : 1132, division par 7: entrée fausse: 1133, division par 7: entrée fausse: 1134, division par 7: entrée vraie: 1135, division par 7: entrée fausse: 1136, division par 7: entrée fausse: 1137, division par 7: Fausse entrée: 1138, divisée par 7: Fausse entrée: 1139, divisée par 7: Fausse entrée: 1140, divisée par 7: Fausse entrée: 1141, divisée par 7: Vrai entrée: 1142, divisée par 7: Fausse entrée: 1143, diviser par 7: Fausse entrée:1144, diviser par 7: entrée fausse: 1145, diviser par 7: entrée fausse: 1146, diviser par 7: entrée fausse: 1147, diviser par 7: entrée fausse: 1148, diviser par 7: entrée vraie: 1149, diviser par 7 : Fausse entrée: 1150, divisée par 7: Fausse entrée: 1151, divisée par 7: Fausse entrée: 1152, divisée par 7: Fausse entrée: 1153, divisée par 7: Fausse entrée: 1154, divisée par 7: Fausse entrée: 1155 , diviser par 7: entrée vraie: 1156, diviser par 7: entrée fausse: 1157, diviser par 7: entrée fausse: 1158, diviser par 7: entrée fausse: 1159, diviser par 7: entrée fausse: 1160, diviser par 7: Fausse entrée: 1161, divisée par 7: Fausse entrée: 1162, divisée par 7: Vrai entrée: 1163, divisée par 7: Fausse entrée: 1164, divisée par 7: Fausse entrée: 1165, divisée par 7: Fausse entrée: 1166, diviser par 7: entrée fausse: 1167, diviser par 7: entrée fausse: 1168, diviser par 7: entrée fausse: 1169, diviser par 7: entrée vraie: 1170, diviser par 7: entrée fausse: 1171, diviser par 7: fausse entrée: 1172, divisée par 7:Fausse entrée: 1173, divisée par 7: Fausse entrée: 1174, divisée par 7: Fausse entrée: 1175, divisée par 7: Fausse entrée: 1176, divisée par 7: Vrai entrée: 1177, divisée par 7: Fausse entrée: 1178, diviser par 7: entrée fausse: 1179, diviser par 7: entrée fausse: 1180, diviser par 7: entrée fausse: 1181, diviser par 7: entrée fausse: 1182, diviser par 7: entrée fausse: 1183, diviser par 7: vrai entrée: 1184, diviser par 7: entrée fausse: 1185, diviser par 7: entrée fausse: 1186, diviser par 7: entrée fausse: 1187, diviser par 7: entrée fausse: 1188, diviser par 7: entrée fausse: 1189, diviser par 7: entrée fausse: 1190, divisée par 7: entrée vraie: 1191, divisée par 7: entrée fausse: 1192, divisée par 7: entrée fausse: 1193, divisée par 7: entrée fausse: 1194, divisée par 7: entrée fausse : 1195, division par 7: entrée fausse: 1196, division par 7: entrée fausse: 1197, division par 7: entrée vraie: 1198, division par 7: entrée fausse: 1199, division par 7: faussediviser par 7: entrée fausse: 1175, diviser par 7: entrée fausse: 1176, diviser par 7: entrée vraie: 1177, diviser par 7: entrée fausse: 1178, diviser par 7: entrée fausse: 1179, diviser par 7: fausse entrée: 1180, diviser par 7: entrée fausse: 1181, diviser par 7: entrée fausse: 1182, diviser par 7: entrée fausse: 1183, diviser par 7: entrée vraie: 1184, diviser par 7: entrée fausse: 1185, diviser par 7: entrée fausse: 1186, diviser par 7: entrée fausse: 1187, diviser par 7: entrée fausse: 1188, diviser par 7: entrée fausse: 1189, diviser par 7: entrée fausse: 1190, diviser par 7: entrée vraie : 1191, diviser par 7: entrée fausse: 1192, diviser par 7: entrée fausse: 1193, diviser par 7: entrée fausse: 1194, diviser par 7: entrée fausse: 1195, diviser par 7: entrée fausse: 1196, diviser par 7: entrée fausse: 1197, divisée par 7: entrée vraie: 1198, divisée par 7: entrée fausse: 1199, divisée par 7: faussediviser par 7: entrée fausse: 1175, diviser par 7: entrée fausse: 1176, diviser par 7: entrée vraie: 1177, diviser par 7: entrée fausse: 1178, diviser par 7: entrée fausse: 1179, diviser par 7: fausse entrée: 1180, diviser par 7: entrée fausse: 1181, diviser par 7: entrée fausse: 1182, diviser par 7: entrée fausse: 1183, diviser par 7: entrée vraie: 1184, diviser par 7: entrée fausse: 1185, diviser par 7: entrée fausse: 1186, diviser par 7: entrée fausse: 1187, diviser par 7: entrée fausse: 1188, diviser par 7: entrée fausse: 1189, diviser par 7: entrée fausse: 1190, diviser par 7: entrée vraie : 1191, diviser par 7: entrée fausse: 1192, diviser par 7: entrée fausse: 1193, diviser par 7: entrée fausse: 1194, diviser par 7: entrée fausse: 1195, diviser par 7: entrée fausse: 1196, diviser par 7: entrée fausse: 1197, divisée par 7: entrée vraie: 1198, divisée par 7: entrée fausse: 1199, divisée par 7: fausseFausse entrée: 1178, divisée par 7: Fausse entrée: 1179, divisée par 7: Fausse entrée: 1180, divisée par 7: Fausse entrée: 1181, divisée par 7: Fausse entrée: 1182, divisée par 7: Fausse entrée: 1183, diviser par 7: entrée vraie: 1184, diviser par 7: entrée fausse: 1185, diviser par 7: entrée fausse: 1186, diviser par 7: entrée fausse: 1187, diviser par 7: entrée fausse: 1188, diviser par 7: fausse entrée: 1189, diviser par 7: entrée fausse: 1190, diviser par 7: entrée vraie: 1191, diviser par 7: entrée fausse: 1192, diviser par 7: entrée fausse: 1193, diviser par 7: entrée fausse: 1194, diviser par 7: entrée fausse: 1195, divisée par 7: entrée fausse: 1196, divisée par 7: entrée fausse: 1197, divisée par 7: entrée vraie: 1198, divisée par 7: entrée fausse: 1199, divisée par 7: fauxFausse entrée: 1178, divisée par 7: Fausse entrée: 1179, divisée par 7: Fausse entrée: 1180, divisée par 7: Fausse entrée: 1181, divisée par 7: Fausse entrée: 1182, divisée par 7: Fausse entrée: 1183, diviser par 7: entrée vraie: 1184, diviser par 7: entrée fausse: 1185, diviser par 7: entrée fausse: 1186, diviser par 7: entrée fausse: 1187, diviser par 7: entrée fausse: 1188, diviser par 7: fausse entrée: 1189, diviser par 7: entrée fausse: 1190, diviser par 7: entrée vraie: 1191, diviser par 7: entrée fausse: 1192, diviser par 7: entrée fausse: 1193, diviser par 7: entrée fausse: 1194, diviser par 7: entrée fausse: 1195, divisée par 7: entrée fausse: 1196, divisée par 7: entrée fausse: 1197, divisée par 7: entrée vraie: 1198, divisée par 7: entrée fausse: 1199, divisée par 7: fauxdiviser par 7: entrée fausse: 1185, diviser par 7: entrée fausse: 1186, diviser par 7: entrée fausse: 1187, diviser par 7: entrée fausse: 1188, diviser par 7: entrée fausse: 1189, diviser par 7: fausse entrée: 1190, division par 7: entrée vraie: 1191, division par 7: entrée fausse: 1192, division par 7: entrée fausse: 1193, division par 7: entrée fausse: 1194, division par 7: entrée fausse: 1195, division par 7: entrée fausse: 1196, diviser par 7: entrée fausse: 1197, diviser par 7: entrée vraie: 1198, diviser par 7: entrée fausse: 1199, diviser par 7: faussediviser par 7: entrée fausse: 1185, diviser par 7: entrée fausse: 1186, diviser par 7: entrée fausse: 1187, diviser par 7: entrée fausse: 1188, diviser par 7: entrée fausse: 1189, diviser par 7: fausse entrée: 1190, division par 7: entrée vraie: 1191, division par 7: entrée fausse: 1192, division par 7: entrée fausse: 1193, division par 7: entrée fausse: 1194, division par 7: entrée fausse: 1195, division par 7: entrée fausse: 1196, diviser par 7: entrée fausse: 1197, diviser par 7: entrée vraie: 1198, diviser par 7: entrée fausse: 1199, diviser par 7: faussediviser par 7: entrée vraie: 1198, diviser par 7: entrée fausse: 1199, diviser par 7: faussediviser par 7: entrée vraie: 1198, diviser par 7: entrée fausse: 1199, diviser par 7: fausse


Explication:

J'obtiens 2 solutions différentes. Ils sont tous les deux bons:
1. le péché comme activation
2. le plancher (ou int) comme activation

Il est impossible de trouver les meilleurs poids en utilisant la descente de gradient, et j'utilise un algorithme génétique (de scikit-opt )

guofei9987
la source
Bonjour Man, bienvenue sur CV et merci pour votre réponse détaillée. Pouvez-vous ajouter quelques explications au code que vous avez écrit?
Ferdi
J'obtiens 2 bonnes solutions, voir ici , 1. péché comme activation 2. étage (ou int) comme activation
guofei9987