multiplication binaire avec numpy

a marqué ce sujet comme résolu.
Auteur du sujet

Salut !

J’ai la chance d’être en option informatique depuis 2 années, après avoir apris word et Excel l’année dernière, nous sommes passés aux choses sérieuses. La programmation !

En résumé, le prof nous donne un programme, on bidouille dessus (changer le texte affiché, la couleur etc) et on fait pareil pour l’épreuve.

Et la semaine passée il nous a donné un programme python utilisant numpy qui est capable de faire des additions binaires. Il suffit de donner les chiffres (en binaires et concaténés) d’entrées, puis la sortie attendu. Ensuite on peut donner de nouveaux chiffres que numpy est capable d’additioner.

L’exercice qu’il y aura dans l’épreuve c’est de changer l’addition en multiplication.
Le problème c’est qu’on a jamais étudié comment fonctionne une AI (même si après avoir lu l’excellent tuto de Melepe je commence à y comprendre quelque chose). Ni python d’ailleurs, ni les fonctions. Bref, on va juste bidouillé les entrées et les sorties attendues et si ça marche pas, bonne chance pour réparer le code.

J’ai créé un script qui génère les entrées et les sorties attendues pour les tables de multiplications de 1 à 10 * 1 à 10 malheureusement le programme n’est pas capable de faire les multiplications meme avec des valeurs utilisées pour l’entraînement.

Si quelqu’un a une idée de ce qui ne fonctionne pas, je suis preneur !

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
import numpy as np

def nonlin(x,deriv=False):
  if(deriv==True):
      return x*(1-x)

  return 1/(1+np.exp(-x))
    
#Forme du reseau

inputs = 8    #nombre de bits en entrée


neuronsOnFirstLayer = 16 # aucune idée de ce que c'est mais c'était le double de neuronsOnSecondLayer avant mes changements donc j'ai aussi doublé

neuronsOnSecondLayer = 8 #nombre de bits en sortie


#Enlever la dernière colonne
#X2 = np.delete(X1,-1,1)
#print(X2)


#premier nombre = 4 premiers bits, dernier nombre = 4 dernier bits
inputData = np.array([    [0,0,0,1,0,0,0,1],
                      [0,0,0,1,0,0,1,0],
                      [0,0,0,1,0,0,1,1],
                      [0,0,0,1,0,1,0,0],
                      [0,0,0,1,0,1,0,1],
                      [0,0,0,1,0,1,1,0],
                      [0,0,0,1,0,1,1,1],
                      [0,0,0,1,1,0,0,0],
                      [0,0,0,1,1,0,0,1],
                      [0,0,1,0,0,0,0,1],
                      [0,0,1,0,0,0,1,0],
                      [0,0,1,0,0,0,1,1],
                      [0,0,1,0,0,1,0,0],
                      [0,0,1,0,0,1,0,1],
                      [0,0,1,0,0,1,1,0],
                      [0,0,1,0,0,1,1,1],
                      [0,0,1,0,1,0,0,0],
                      [0,0,1,0,1,0,0,1],
                      [0,0,1,1,0,0,0,1],
                      [0,0,1,1,0,0,1,0],
                      [0,0,1,1,0,0,1,1],
                      [0,0,1,1,0,1,0,0],
                      [0,0,1,1,0,1,0,1],
                      [0,0,1,1,0,1,1,0],
                      [0,0,1,1,0,1,1,1],
                      [0,0,1,1,1,0,0,0],
                      [0,0,1,1,1,0,0,1],
                      [0,1,0,0,0,0,0,1],
                      [0,1,0,0,0,0,1,0],
                      [0,1,0,0,0,0,1,1],
                      [0,1,0,0,0,1,0,0],
                      [0,1,0,0,0,1,0,1],
                      [0,1,0,0,0,1,1,0],
                      [0,1,0,0,0,1,1,1],
                      [0,1,0,0,1,0,0,0],
                      [0,1,0,0,1,0,0,1],
                      [0,1,0,1,0,0,0,1],
                      [0,1,0,1,0,0,1,0],
                      [0,1,0,1,0,0,1,1],
                      [0,1,0,1,0,1,0,0],
                      [0,1,0,1,0,1,0,1],
                      [0,1,0,1,0,1,1,0],
                      [0,1,0,1,0,1,1,1],
                      [0,1,0,1,1,0,0,0],
                      [0,1,0,1,1,0,0,1],
                      [0,1,1,0,0,0,0,1],
                      [0,1,1,0,0,0,1,0],
                      [0,1,1,0,0,0,1,1],
                      [0,1,1,0,0,1,0,0],
                      [0,1,1,0,0,1,0,1],
                      [0,1,1,0,0,1,1,0],
                      [0,1,1,0,0,1,1,1],
                      [0,1,1,0,1,0,0,0],
                      [0,1,1,0,1,0,0,1],
                      [0,1,1,1,0,0,0,1],
                      [0,1,1,1,0,0,1,0],
                      [0,1,1,1,0,0,1,1],
                      [0,1,1,1,0,1,0,0],
                      [0,1,1,1,0,1,0,1],
                      [0,1,1,1,0,1,1,0],
                      [0,1,1,1,0,1,1,1],
                      [0,1,1,1,1,0,0,0],
                      [0,1,1,1,1,0,0,1],
                      [1,0,0,0,0,0,0,1],
                      [1,0,0,0,0,0,1,0],
                      [1,0,0,0,0,0,1,1],
                      [1,0,0,0,0,1,0,0],
                      [1,0,0,0,0,1,0,1],
                      [1,0,0,0,0,1,1,0],
                      [1,0,0,0,0,1,1,1],
                      [1,0,0,0,1,0,0,0],
                      [1,0,0,0,1,0,0,1],
                      [1,0,0,1,0,0,0,1],
                      [1,0,0,1,0,0,1,0],
                      [1,0,0,1,0,0,1,1],
                      [1,0,0,1,0,1,0,0],
                      [1,0,0,1,0,1,0,1],
                      [1,0,0,1,0,1,1,0],
                      [1,0,0,1,0,1,1,1],
                      [1,0,0,1,1,0,0,0],
                      [1,0,0,1,1,0,0,1]]) 

# On ajoute le 1 de plus 

X = np.c_[inputData,np.ones(inputData.shape[0])]

y = np.array([[0,0,0,0,0,0,0,1],
              [0,0,0,0,0,0,1,0],
              [0,0,0,0,0,0,1,1],
              [0,0,0,0,0,1,0,0],
              [0,0,0,0,0,1,0,1],
              [0,0,0,0,0,1,1,0],
              [0,0,0,0,0,1,1,1],
              [0,0,0,0,1,0,0,0],
              [0,0,0,0,1,0,0,1],
              [0,0,0,0,0,0,1,0],
              [0,0,0,0,0,1,0,0],
              [0,0,0,0,0,1,1,0],
              [0,0,0,0,1,0,0,0],
              [0,0,0,0,1,0,1,0],
              [0,0,0,0,1,1,0,0],
              [0,0,0,0,1,1,1,0],
              [0,0,0,1,0,0,0,0],
              [0,0,0,1,0,0,1,0],
              [0,0,0,0,0,0,1,1],
              [0,0,0,0,0,1,1,0],
              [0,0,0,0,1,0,0,1],
              [0,0,0,0,1,1,0,0],
              [0,0,0,0,1,1,1,1],
              [0,0,0,1,0,0,1,0],
              [0,0,0,1,0,1,0,1],
              [0,0,0,1,1,0,0,0],
              [0,0,0,1,1,0,1,1],
              [0,0,0,0,0,1,0,0],
              [0,0,0,0,1,0,0,0],
              [0,0,0,0,1,1,0,0],
              [0,0,0,1,0,0,0,0],
              [0,0,0,1,0,1,0,0],
              [0,0,0,1,1,0,0,0],
              [0,0,0,1,1,1,0,0],
              [0,0,1,0,0,0,0,0],
              [0,0,1,0,0,1,0,0],
              [0,0,0,0,0,1,0,1],
              [0,0,0,0,1,0,1,0],
              [0,0,0,0,1,1,1,1],
              [0,0,0,1,0,1,0,0],
              [0,0,0,1,1,0,0,1],
              [0,0,0,1,1,1,1,0],
              [0,0,1,0,0,0,1,1],
              [0,0,1,0,1,0,0,0],
              [0,0,1,0,1,1,0,1],
              [0,0,0,0,0,1,1,0],
              [0,0,0,0,1,1,0,0],
              [0,0,0,1,0,0,1,0],
              [0,0,0,1,1,0,0,0],
              [0,0,0,1,1,1,1,0],
              [0,0,1,0,0,1,0,0],
              [0,0,1,0,1,0,1,0],
              [0,0,1,1,0,0,0,0],
              [0,0,1,1,0,1,1,0],
              [0,0,0,0,0,1,1,1],
              [0,0,0,0,1,1,1,0],
              [0,0,0,1,0,1,0,1],
              [0,0,0,1,1,1,0,0],
              [0,0,1,0,0,0,1,1],
              [0,0,1,0,1,0,1,0],
              [0,0,1,1,0,0,0,1],
              [0,0,1,1,1,0,0,0],
              [0,0,1,1,1,1,1,1],
              [0,0,0,0,1,0,0,0],
              [0,0,0,1,0,0,0,0],
              [0,0,0,1,1,0,0,0],
              [0,0,1,0,0,0,0,0],
              [0,0,1,0,1,0,0,0],
              [0,0,1,1,0,0,0,0],
              [0,0,1,1,1,0,0,0],
              [0,1,0,0,0,0,0,0],
              [0,1,0,0,1,0,0,0],
              [0,0,0,0,1,0,0,1],
              [0,0,0,1,0,0,1,0],
              [0,0,0,1,1,0,1,1],
              [0,0,1,0,0,1,0,0],
              [0,0,1,0,1,1,0,1],
              [0,0,1,1,0,1,1,0],
              [0,0,1,1,1,1,1,1],
              [0,1,0,0,1,0,0,0],
              [0,1,0,1,0,0,0,1]]) 


np.random.seed(1)
# randomly initialize our weights with mean 0

syn0 = 2*np.random.random((inputs+1,neuronsOnFirstLayer)) - 1
syn1 = 2*np.random.random((neuronsOnFirstLayer+1,neuronsOnSecondLayer)) - 1


def calculateOutput(data):
    #We add the extra 1 needed
    l0 = np.c_[data,np.ones(data.shape[0])]
    l1 = nonlin(np.dot(l0,syn0))
    #The extra 1 too
    l1 = np.c_[l1,np.ones(l1.shape[0])]
    l2 = nonlin(np.dot(l1,syn1))
    return l2


#Boucle d'apprentissage

for j in range(6000): #on peut changer le chiffre

  # Feed forward through layers 0, 1, and 2
    l0 = X
    l1 = nonlin(np.dot(l0,syn0))
    #print(l1)
    # Add the one at the end
    l1 = np.c_[l1,np.ones(l1.shape[0])]
    #print(l1)
    l2 = nonlin(np.dot(l1,syn1))

    # how much did we miss the target value?
    l2_error = y - l2
    
##    if (j% 10000) == 0:
##        print("Error:" + str(np.mean(np.abs(l2_error))))
        
    # in what direction is the target value?
    # were we really sure? if so, don't change too much.
    l2_delta = l2_error*nonlin(l2,deriv=True)

    # how much did each l1 value contribute to the l2 error (according to the weights)?
    l1_error = l2_delta.dot(syn1.T)
    
    # in what direction is the target l1?
    # were we really sure? if so, don't change too much.
    l1_delta = l1_error * nonlin(l1,deriv=True)
    #Remove the last column
    l1_delta = np.delete(l1_delta,-1,1)
    syn1 += l1.T.dot(l2_delta)
    syn0 += l0.T.dot(l1_delta)



#On change l'entrée inconnue ici
tmp = []
for a in calculateOutput(np.array([[1,1,1,1,1,1,1,1]])): 
       for z in a:
               tmp.append(int (round(z)))
       print(tmp)

`

Les seuls choses qu’il a expliqué c’est

1
2
3
4
5
6
7
8
9
inputs = 8    #nombre de bits en entrée
neuronsOnFirstLayer = 16 # aucune idée de ce que c'est mais il a dit qu'il fallait essayer différente valeur jusque à ce que ça marche
neuronsOnSecondLayer = 8 
...
inputData #l'entree 
...
 y # qui est la sortie attendue.
# y et inputData sont utilisé dans l'entrainement. 
#la boucle d'entrainement peut être augmentée pour plus s'entrainer sur les données d'entrées

Les résultats ne sont jamais bon même sur des données que j’ai donné en apprentissage par exemple 15 * 15 donc [1,1,1,1, 1,1,1,1] en entrée me sors [0,0,1,1, 1,1,1,1] alors que je devrais avoir [1,1,1,0 ,0,0,0,1] en sortie ($15*15 = 225$)

Et [1,0,0,1,0,1,0,1] (9*5) = [0,0,1,0,1,1,0,1] = 45 et pourtant il me sors

J’ai tenté de changer les valeurs de neuronsOnFirstLayer mais rien n’y fait. C’est toujours faux.

J’ai réfléchis : dans ma sortie 8 bits je peux stocker 255 valeurs mes entrées sont en 4 bits donc 15 valeurs donc $15*15 = 225$ ça rentre, bref je suis toujours pas plus avancé surtout sans comprendre comment agit le code du prof.

Édité par d3m0t3p

conseil: le thé est meilleur avec un zeste de citron

+0 -0
Auteur du sujet

Je ne crois pas qu’il soit utile d’utiliser un système d’IA pour faire du calcul binaire ;)

Drulac

Salut je suis 100% d’accord mais bon je ne choisis pas les exercices que le prof choisis. En plus il a dit que ce serait dans l’épreuve donc j’essaye de le faire pour pas me planter à l’heure du teste.

conseil: le thé est meilleur avec un zeste de citron

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte