IA: apprentissage d'un neurone

Bonsoir.

Je n'ai pas bien saisi la logique de ton code, mais tout ce que je peux constater est qu'il entre dans un cycle infini entre  0010101010 et 1010111010.

Testé simplement en enregistrant dans un fichier les valeurs.

f = open('result', 'w')
i = 0
while True:
    # os.system('cls')
    # print('\nApprentissage ...')
    total = ''
    for input_nb in range(len(inputs)):
        learning_phase(input_nb)
    for input_nb in range(len(inputs)):
        total += str(get_output(input_nb))
    f.write(total + '\n')
    if total == '0000000010' or i == 1000:
        f.close()
        break
    # print(total)
    i += 1

Pourquoi, aucune idée ^^

Ce ne serait pas mieux de travailler avec du binaire ?

bonjour,

Tu devrais sortir de la boucle quand weights n'évolue plus, c'est à ce moment-là que l'apprentissage est terminé.

En fait, tu cherches des valeurs de w[] qui vont te donner, pour tous les i[]:

• somme(w[x]*i[x]) > 0 ssi tous les i[x] sont égaux à 1

Essaie avec deux entrées, quels sont les valeurs de w0 et de w1 qui sont des solutions de:

• w0 <= 0
• w1 <= 0
• w0 + w1 >0

Voici un bel exemple de situation où l'IA ne dispense pas d'utiliser son intelligence humaine.

Bonjour,

"Tu devrais sortir de la boucle quand weights n'évolue plus, c'est à ce moment-là que l'apprentissage est terminé."

Non, c'est terminé lorsque l'affichage final est 0000000010, c'est à dire lorsque le neurone répond 1 avec 

les 7 inputs à 1, et 0 dans tous les autres cas

L'affichage sur mon image ci-dessus montre qu'il y a des 1 pour d'autres entrées, ce qui n'est pas bon

En fait, je me demande si je ne suis pas dans le cas où les différente réponses ne forment pas un modèle

linéairement  séparable, et donc il n'y a pas de solution

Exemple:

si on apprend à un neurone à 2 entrées la fonction ET, que l'on trace un système d'axes pour y placer les

réponses 0 et 1, on peut tracer une ligne qui sépare les 0 des 1

par contre, si l'on essaie avec la fonction XOR, c'est impossible, l'apprentissage ne peut se faire,

pour y arriver il faut ajouter un 2eme neurone connecté au 1er

Bonjour yg_be,

et donc, tu as fait quoi, pour résumer tout ça ?

all right, je vais examiner tout ça :-)

.........................

Holà yg_be,

La grosse différence avec mon code, c'est l'ajout d'un 8eme poids avec un calcul de sa valeur à part

puisque ensuite on boucle de 0 à 6 pour mettre à jour les 7 poids sur les 7 entrées

Et on a bien le résultat attendu !

peux-tu expliquer cela ?

aurais-tu ajouté un "biais" ?

Moi, je l'avais fait dans mon réseau à 2 neurones pour la fonction XOR:

1er neurone avec 2 entrées et un biais =1

2eme neurone avec 3 entrées (dont la valeur de sortie du neurone 1) et un biais =1

Bonjour yg_be

je vois le truc

Merci pour tout

Holà yg_be,

Je dois quand même te donner la finalité de tout ceci

Voici ce que j'ai fait avec ton exemple:

# -*- coding:Latin-1 -*-
# Reconnaissance des chiffres de 0 à 9 sur l'affichage à 7 leds
# 10 neurones, chacun connecté aux 7 leds
#    _7_
# 2 |   | 3
#   |_6_|
# 1 |   | 4
#   |_ _|
#     5 
#07/02/2023 15:44:14

import os
import random
import pickle

def get_output(input_nb, neuron):
	''' checks if neuron fires on "input_nb" '''

	e_sum = -weights[neuron][L]
	for k in range(L): e_sum += inputs[input_nb][k]*weights[neuron][k]

	return(1 if e_sum > threshold else 0)

def learning_phase(input_nb,n):
	''' Learning phase : calculates the output of the neuron and updates the weights '''

	output = get_output(input_nb,n)
	expected_output = 0
	if(input_nb == n): expected_output = 1

	delta = expected_output - output
	weights[n][L] -= delta*L
	for k in range(L): weights[n][k] +=  delta * inputs[input_nb][k]

#Lecture des données
filename = 'chiffres_0_9.txt'
with open(filename, 'r') as ofi: block = ofi.read()

inputs = eval(block)
neurons_nb = len(inputs)
threshold = 0
L=7
weights = [[0 for j in range(L+1)] for i in range(neurons_nb)]
data_file = 'neurons_data.dat'

#Initialise les chaines représentant les suites de sorties valides par neurone
patterns = {}
for k in range(neurons_nb):
	patterns[k] = ''
	for n in range(len(inputs)):
		if(k == n):
			patterns[k] += '1'
		else:
			patterns[k] += '0'

#Apprentissage
print('Apprentissage ...')
i=0

for k in range(neurons_nb):
	while True:
		i+=1
		total = ''
		for input_nb in range (len(inputs)): learning_phase(input_nb,k)
		for input_nb in range (len(inputs)): total += str(get_output(input_nb,k))
	
		if(total == patterns[k]):
			print(total)
			break

print('\nApprentissage terminé en {} pas'.format(i))

#Enregistrement des poids
wl = []
for k in range(neurons_nb): wl.append(weights[k])

with open(data_file, 'wb') as fo:
	pickle.dump(neurons_nb, fo)
	pickle.dump(wl, fo)

print('Création du fichier {}'.format(data_file))

input('Entrée ...')

Les 10 listes de 0 et 1 représentent l'allumage ou non de chacune des 7 leds d'un affichage de chiffres

J'ai 10 neurones, chacun flashant sur un des 10 chiffres

En fin d'apprentissage, j'enregistre les poids dans un fichier (pickle, c'est pratique)

J'ai un 2eme programme qui lit le fichier, et identifie les chiffres que l'on initialise en cliquant les segments:

C'est ce qui reste à régler, en effet si on entre, par exemple, cette série: 1,0,0,0,0,0,0 qui ne correspond à

aucun chiffre, l'un des 10 neurones flashe

Ceci dit les 10 chiffres de 0 à 9 sont bien reconnus...

Bonjour yg_be,

oui, ce sera la prochaine étape

Pour cette fois, je ferme cet appel 

merci pour tout

Hello Yg_be,

J'ai réglé le problème en ajoutant les 118 combinaisons aux 10 premières