#|

(defvar test-score '(#(0.1 0.9 0.9 0.1) #(0.9 0.9 0.1 0.9) #(0.1 0.9 0.9 0.1) #(0.9 0.9 0.1 0.9) #(0.1 0.9 0.9 0.1) #(0.9 0.9 0.1 0.9) #(0.1 0.9 0.9 0.1) #(0.9 0.9 0.1 0.9))
)


;test-score
definition d'un reso et procedure d'apprentissage ...
(setf pulse3g nil)
;(mlpJ pulse3g 8 4 4) ;;<- cree un nouveau reseau de neurones type mlp 
(setf (recurrent-layer pulse3g) 0)
(setf (in-size  pulse3g) 4)
(setf (recurrent-layer-activation pulse3g) #(0 0 0 0))
(setf *MAINSTOP* nil)
(defvar *memlost* 0)
(inspect pulse3g)

(make-instance 'main-ann-window :ann pulse3g)
(make-trace-window *history-error* 1 50 "")



#|
(loop until *MAINSTOP*
      do
      (dotimes (k 50)
        (format t "~%STEP K = ~S~%" K)
        (when (null *MAINSTOP*)
        (learn  pulse3g
                (butlast test-score)
                (cdr test-score)
                :temp .005
                :slope (+ .99 (random .02))
                :learn (+ .05 (random .1))   
                :error .001
                :stop 100 ;(- 500 (floor (* 10 k)))
                :thresh 1.0
                :input-func nil
                :out-func #'logistic
                :hidden-func #'logistic 
                :method 'sequence
                :monitor t
                :verbose nil))
        )
      )
|#

(copy-mlpj pulse3g pulse3g-A)

(make-trace-window
  (apply #'append (mapcar #'(lambda (x) (coerce x 'list)) test-score))
  6 100  "test-score")

(make-trace-window
  (let ((r (list (elt test-score 0))))
      (setf (recurrent-layer-activation pulse3g) #(0 0 0 0))
      (dotimes (n 50 (apply #'append (lvectors->ldl (reverse r))))
          (push (run-mlpj pulse3g (car r)
                                       :out-func #'logistic 
                                       :hidden-func #'logistic
                                       :thresh 1.
                                       :temp .0
                                       :slope .9)
                     r)))
  6 100 "pulse3g run")


(make-trace-window
  (let ((r (list (elt test-score 0))))
    (setf (recurrent-layer-activation pulse3g) #(0 0 0 0))
       (dotimes (n 100 (apply #'append (lvectors->ldl (reverse r))))
           (dotimes (n (length (recurrent-layer-activation pulse3g)))
         (setf (elt (recurrent-layer-activation pulse3g) n)
               (+ (elt (recurrent-layer-activation pulse3g) n)
                              (- (random *memlost*) (/ *memlost* 2)))))
           (push (run-mlp pulse3g (car r)
                                         :out-func #'logistic 
                                         :hidden-func #'logistic
                                         :thresh 1.
                                         :temp .0  ;<- temperature !
                                         :slope .99)
                      r)
           
           ))
  6 100 "pulse3g run")


(setf *memlost* .0)
(setf *memlost* .4)
(setf *memlost* 3.0)

(make-trace-window
  (let ((r (list (elt test-score 0))))
    (setf (recurrent-layer-activation pulse3g) #(0 0 0 0))
       (dotimes (n 100 (apply #'append (lvectors->ldl (reverse r))))
           (dotimes (n (length (recurrent-layer-activation pulse3g)))
         (setf (elt (recurrent-layer-activation pulse3g) n)
               (* (elt (recurrent-layer-activation pulse3g) n)
                              *memlost*)))
           (push (run-mlp pulse3g (car r)
                                         :out-func #'logistic 
                                         :hidden-func #'logistic
                                         :thresh 1.
                                         :temp .0
                                         :slope .99)
                      r)
           
           ))
  6 100 "pulse3g run")

(setf *memlost* .4)


(make-trace-window
  (let ((r (list (elt test-score 0))))
    (setf (recurrent-layer-activation pulse3g) #(0 0 0 0))
       (dotimes (n 100 (apply #'append (lvectors->ldl (reverse r))))
           (dotimes (n (length (recurrent-layer-activation pulse3g)))
         (setf (elt (recurrent-layer-activation pulse3g) n)
               (* (elt (recurrent-layer-activation pulse3g) n)
                              *memlost*)))
           (push (run-mlp pulse3g (car r)
                                         :out-func #'boltzmann 
                                         :hidden-func #'boltzmann
                                         :thresh 1.
                                         :temp .01
                                         :slope .99)
                      r)
           
           ))
  6 100 "pulse3g run")


(make-trace-window
  (let ((r (list (elt test-score 0))))
    (setf (recurrent-layer-activation pulse3g) #(0 0 0 0))
       (dotimes (n 100 (apply #'append (lvectors->ldl (reverse r))))
           (push (run-mlp pulse3g (car r)
                                         :out-func #'logistic 
                                         :hidden-func #'boltzmann
                                         :thresh 1.
                                         :temp .01
                                         :slope .99)
                      r)
           
           ))
  6 100 "pulse3g run")


(make-trace-window
  (let ((r (list (elt test-score 0))))
    (setf (recurrent-layer-activation pulse3g) #(0 0 0 0))
       (dotimes (n 100 (apply #'append (lvectors->ldl (reverse r))))
           
           (push (run-mlp pulse3g (car r)
                                         :out-func #'binary 
                                         :hidden-func #'boltzmann
                                         :thresh 1.
                                         :temp .9
                                         :slope .99)
                      r)
           
           ))
  6 100 "pulse3g run")


(save pulse3g)
(save-history-score *history-error*)
|#