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.
!