Un neurone est une fonction extrêmement simple qui prend un certain nombre de paramètres et retourne soit 0 (ou -1) soit 1 selon la valeur des arguments qui lui sont passés. Il multiplie chacun de ces argument par une valeur, additionne le tout et rajoute une constante. Si le résultat de cette opération est positive, alors il retourne 1, si elle est négative, il retourne -1.
L’intérêt de ce neurone, c’est qu’il est capable d’apprendre, c’est à dire que si on lui montre un jeu de données avec le résultat attendu, il va régler de lui même les constantes à utiliser pour sa petite opération et essayer de trouver une valeur idéale pour retourner la bonne réponse.
Ça vous intéresse, je vous suggère la lecture de la page Wikipedia et de faire vos propres recherches : https://en.wikipedia.org/wiki/Perceptron
Mon implémentation est sans doute très naïve et je suis certain qu’il existe une tonne de librairies qui le font beaucoup mieux que moi. Mais l’objectif ici est de comprendre le rouage de la chose, comment cela fonctionne. Une fois cela compris, il est certain que se tourner vers une librairie, complète, testée et optimisée est tout à fait recommandable pour faire un vrai projet en prod.
(setf data '(
(20 2000 1)
(40 1000 -1)
(30 3000 1)
(30 1000 -1)
(20 3000 1)
(40 2000 -1)
(40 4000 1)
(20 2000 -1)
(30 4000 1)
(20 4000 1)
(40 3000 -1)))
(defvar w '(1 1 1))
(defun magic (w x y)
(if (> (+ (first w) (* (second w) x) (* (third w) y)) 0)
1
-1))
(dolist (l data)
(format t "-----~%")
(format t "~A~%" l)
(let ((c (magic w (first l) (second l)))
(alpha 0.00001))
(format t "G/S=> ~A/~A~%" c (third l))
(setf (first w)
(+ (first w) (*
1
alpha
(- (third l) c))))
(setf (second w)
(+ (second w) (*
(first l)
alpha
(- (third l) c ))))
(setf (third w)
(+ (third w) (*
(second l)
alpha
(- (third l) c))))
(format t "~A~%" w)))