View difference between Paste ID: erer2BnQ and NGwEZ5rg

 (define (n-mk lst) ;make new neuron
   (list 'n lst))
- (list 'n lst))
+
 (define (l-mk lst) ;make new layer
   (list 'l lst))
 
- (define (l-mk lst) ;make new layer
+(define (n-inp-lst x) ;return neuron wheights
   (cadr x))
- (list 'l lst))
+
 (define (n? x) ;check if x is neuron
   (if (= (car x) 'n) #t #f))
 
- (define (n-inp-lst x) ;return neuron wheights
+(define (l-neuron-lst x) ;returns list of  layers neurons
   (cadr x))
- (cadr x))
+
 (define (l? x) ;checks if x is a layer
   (if (= (car x) 'l) #t #f))
 
- (define (n? x) ;check if x is neuron
+(define (l-inp-wh l) ;shows all layer neurns input wheights
   (map (lambda(x)(n-inp-lst x)) (l-neuron-lst l)))
- (if (= (car x) 'n) #t #f))
+
 (define (l-out-wh l) ;returns all layer neuron output wheights
   (transpose (map (lambda(x)(n-inp-lst x)) (l-neuron-lst l)) '()  ))
 
- (define (l-neuron-lst x) ;returns list of layers neurons
+(define (net-inp-wh net) ;return all network input wheights
   (map (lambda(x)(l-inp-wh x)) net))
- (cadr x))
+
 (define (net-out-wh net) ;returns all network output wheights
   (map (lambda(x)(l-out-wh x)) net))
 
- (define (l? x) ;checks if x is a layer
+(define (net-mk-data lst) ;make network from data list
   (map (lambda(x)(l-mk-data x)) lst))
- (if (= (car x) 'l) #t #f))
+
 (define (l-mk-data lst) ;make layer from list
   (l-mk (map (lambda(x)(n-mk x)) lst)))
 
- (define (l-inp-wh l) ;shows all layer neurns input wheights
+(define (lst-push x lst) ;push
   (cons x lst))
- (map (lambda(x)(n-inp-lst x)) (l-neuron-lst l)))
+
 (define (lst-push-b x lst) ;push from the end
   (append lst (list x)))
 
- (define (l-out-wh l) ;returns all layer neuron output wheights
+(define (randomize n lst) ;randomize returns n random numbers
   (if (= n 0)
- (transpose (map (lambda(x)(n-inp-lst x)) (l-neuron-lst l)) '() ))
+	lst
   	(randomize (- n 1) (append (list (+ (random 9) 1) ) lst) )))
 
 (define (empty? lst) ;checks if the list is empty
- (define (net-inp-wh net) ;return all network input wheights
+  (if (= (length lst) 0) #t #f))
 
- (map (lambda(x)(l-inp-wh x)) net))
+(define (net-make lay) ;makes new network. lay consists of number of neuron for each layer
   (net-mk-new (car lay) (cdr lay) '()))
 
 (define (net-mk-new input n-lst lst) ;input - ammount of input neurons; n-lsts - list of neuron ammount for each layer
- (define (net-out-wh net) ;returns all network output wheights
+  (let ( (lst1 (lst-push-b (l-mk-new input (car n-lst) '()) lst)) )
   (if (= (length n-lst) 1) lst1 (net-mk-new (car n-lst) (cdr n-lst) lst1))))
- (map (lambda(x)(l-out-wh x)) net))
+
 (define (l-mk-new input n lst) ;makes new layer
   (let ( (lst1 (append lst (list (n-mk (lst-rand input))))) ) ; seit kluda
   (if (= n 1) (l-mk lst1) (l-mk-new input (- n 1) lst1))))
- (define (net-mk-data lst) ;make network from data list
+
 (define (lst-rand n) ;random returns n random numbers divided by 10
- (map (lambda(x)(l-mk-data x)) lst))
+  (map (lambda(x)(/ x 10)) (randomize n '()) ))
 
 (define (n-akt x param) ;neuron activation function
   (/ x (+ (abs x) param)))
- (define (l-mk-data lst) ;make layer from list
+
 (define (lst-sum lst);sums list
- (l-mk (map (lambda(x)(n-mk x)) lst)))
+  (apply + lst))
 
 (define (n-proc neuron input) ;process single neuron
   (n-akt (lst-sum (lst-mul (n-inp-lst neuron) input )) 4))
- (define (lst-push x lst) ;push
+
 (define (lst-mul a b) ;multiply each element of list a with same element of list b
- (cons x lst))
+  (map (lambda(x y)(* x y)) a b))
 
 (define (lst-if a b) ;if one of the lists consists of only one element it returns true
   (if (or (= (length a) 1) (= (length b) 1)) #t #f))
- (define (lst-push-b x lst) ;push from the end
+
 (define (l-proc l input) ;proceses a layer
- (append lst (list x)))
+  (map (lambda(x)(n-proc x input)) (n-inp-lst l)))
 
 (define (net-proc net input) ;proceses a network
   (net-proc2 net (l-check input)))
- (define (randomize n lst) ;randomize returns n random numbers
+
 (define (net-proc2 net input)
- (if (= n 0)
+	(let ( (l (l-proc (car net) input)) )
 	  (if (= 1 (length net)) l
- lst
+		(net-proc2 (cdr net) l))))
 
- (randomize (- n 1) (append (list (+ (random 9) 1) ) lst) )))
+(define (net-proc-res net input) ;returns a list of results for each layer
   (net-proc-res2 net (l-check input) '() ))
 
 (define (net-proc-res2 net input res)
- (define (empty? lst) ;checks if the list is empty
+	(let ( (l (l-proc (car net) input)) )
 	  (let ( (res1 (lst-push-b l res)) )
- (if (= (length lst) 0) #t #f))
+	  (if (= 1 (length net)) res1
 		(net-proc-res2 (cdr net) l res1)))))
 
 (define (l-err out err wh) ;counts error for layer
- (define (net-make lay) ;makes new network. lay consists of number of neuron for each layer
+  (lst-mul out (l-err*wh err wh)))
 
- (net-mk-new (car lay) (cdr lay) '()))
+(define (l-err*wh err wh) ;next l error * output wheights
   (map (lambda(y)(lst-sum y)) (map (lambda(x)(lst-mul err x)) wh)))
 
 (define (lst-2-mul a b) ;multiply 2 lists
- (define (net-mk-new input n-lst lst) ;input — ammount of input neurons; n-lsts — list of neuron ammount for each layer
+  (map (lambda(x y)(* x y)) a b))
 
- (let ( (lst1 (lst-push-b (l-mk-new input (car n-lst) '()) lst)) )
+(define (lst-lst-mul a b) ; miltiply list a with every list from b
   (map (lambda(x)(lst-mul-x x a)) b))
- (if (= (length n-lst) 1) lst1 (net-mk-new (car n-lst) (cdr n-lst) lst1))))
+
 (define (net-wh*err wh err) ;miltiply each wheight with error
   (map (lambda(x y)(lst-lst-mul x y)) wh err))
 
- (define (l-mk-new input n lst) ;makes new layer
+(define (net-err+wh err wh) ;add error to wheghts
   (map (lambda(x y)(l-err+wh x y)) err wh))
- (let ( (lst1 (append lst (list (n-mk (lst-rand input))))) ); seit kluda
+
 (define (lst-2-sum a b) ; adds to lists
- (if (= n 1) (l-mk lst1) (l-mk-new input (- n 1) lst1))))
+  (map (lambda(x y)(+ x y)) a b))
 
 (define (l-err+wh err wh) ;adds error to wheight for layer
   (map (lambda(x y)(lst-2-sum x y)) err wh))
- (define (lst-rand n) ;random returns n random numbers divided by 10
+
 (define (lst-put-num lst) ;ads number to each el. of list ex. (1 a)
- (map (lambda(x)(/ x 10)) (randomize n '()) ))
+  (lst-zip (sequence 0 (- (length lst) 1) '() ) lst ))
 
 (define (sequence from to res) ;creates sequency of numbers from to
 	(let ( (nr (append res (list from))))
- (define (n-akt x param) ;neuron activation function
+	  (if (= from to) nr (sequence (+ from 1) to nr ) )))
 
- (/ x (+ (abs x) param)))
+(define (lst-order-max lst) ;sort el.
   (hsort (lst-put-num lst)))
 
 (define (lst-zip a b) ; zip 2 lists
- (define (lst-sum lst);sums list
+  (map (lambda(x y)(list x y)) a b))
 
- (apply + lst))
+(define (hsort lst) ;sorts
   (if (empty? lst) '()
   (append
   (hsort (filter (lambda(x) (> (cadr x) (cadr (car lst)))) (cdr lst)))
- (define (n-proc neuron input) ;process single neuron
+  (list (car lst))
   (hsort (filter (lambda(x) (<= (cadr x) (cadr (car lst)))) (cdr lst))))))
- (n-akt (lst-sum (lst-mul (n-inp-lst neuron) input )) 4))
+
 (define (ssort lst) ;sort
   (if (empty? lst) '()
   (append
- (define (lst-mul a b) ;multiply each element of list a with same element of list b
+  (ssort (filter (lambda(x) (> x (car lst))) (cdr lst)))
   (list (car lst))
- (map (lambda(x y)(* x y)) a b))
+  (ssort (filter (lambda(x) (<= x (car lst))) (cdr lst))))))
 
 (define (net-study net lst spd) ;studys net for each example from the list smpl ((inp)(out))
 	(if (net-check-lst net lst) net
- (define (lst-if a b) ;if one of the lists consists of only one element it returns true
+	  (net-study (net-study-lst net lst spd) lst spd)))
 
- (if (or (= (length a) 1) (= (length b) 1)) #t #f))
+(define (net-proc-num net inp) ;process network and returns output number
   (caar (lst-order-max (net-proc net inp))))
 
 (define (net-check-lst net lst) ;parbauda sarakstu ar paraugiem
- (define (l-proc l input) ;proceses a layer
+  (lst-and (map (lambda(x)(net-check-smpl net x)) lst)))
 
- (map (lambda(x)(n-proc x input)) (n-inp-lst l)))
+(define (lst-and lst) ;accumulates list
   (lst-and2 (car lst) (cdr lst)))
 
 (define (lst-and2 a lst)
- (define (net-proc net input) ;proceses a network
+  (if (empty? lst) a (lst-and2 (and a (car lst)) (cdr lst))))
 
- (net-proc2 net (l-check input)))
+
 (define (net-check-smpl net x) ;checks one sample (input output)
   (let ( (inp (car x))
 		 (out (cadr x)) )
- (define (net-proc2 net input)
+  (if (= (caar (lst-order-max out)) (net-proc-num net inp)) #t #f)))
 
- (let ( (l (l-proc (car net) input)) )
+(define (net-study-lst net lst spd) ; studies network for smaples from lst. Smpl (input output)
   (let ( (x (net-study1 net (caar lst) (cadar lst) spd)) )
- (if (= 1 (length net)) l
+  (if (= 1 (length lst)) x
 	(net-study-lst x (cdr lst) spd))))
- (net-proc2 (cdr net) l))))
+
 (define (net-study1 net inp need spd)
   (net-study2 net (l-check inp) need spd))
 
- (define (net-proc-res net input) ;returns a list of results for each layer
+(define (net-study2 net inp need spd)
   (let ( (x (net-study3 net inp need spd)))
- (net-proc-res2 net (l-check input) '() ))
+     (if (= (caar (lst-order-max need))(caar (lst-order-max (net-proc x inp))))
 	   x
 	   (net-study2 x inp need spd))))
 
- (define (net-proc-res2 net input res)
+(define (slice lst from to)
   (let ( (lng (length lst)) )
- (let ( (l (l-proc (car net) input)) )
+	(take (drop lst from) (+ (- lng from) to))))
 
- (let ( (res1 (lst-push-b l res)) )
+(define (net-study3 net inp need spd)
   (let ((err (net-spd*err spd (slice (net-err net inp need) 1 0)))
- (if (= 1 (length net)) res1
+		(wh (net-inp-wh net))
 	    (out (slice (net-proc-res-out net inp) 0 -1)))
- (net-proc-res2 (cdr net) l res1)))))
+		(net-mk-data (net-err+wh wh (map (lambda(x y)(lst-lst-mul x y)) out err)))))
 
 (define (net-err2 out-lst err-lst wh-lst)
    (let ( (err-lst1 (lst-push (l-err (car out-lst) (car err-lst) (car wh-lst)) err-lst)) )
- (define (l-err out err wh) ;counts error for layer
+   (if (lst-if out-lst wh-lst) err-lst1 (net-err2 (cdr out-lst) err-lst1 (cdr wh-lst)))))
 
- (lst-mul out (l-err*wh err wh)))
+(define (net-err net inp need) ;networks error list for each neuron
   (let ( (wh-lst (reverse (net-out-wh net)))
 		 (err-lst (list (net-out-err net inp need)))
 		 (out-lst (reverse (slice (net-proc-res-out net inp) 0 -1))))
- (define (l-err*wh err wh) ;next l error * output wheights
+	  	 (net-err2 out-lst err-lst wh-lst)))
 
- (map (lambda(y)(lst-sum y)) (map (lambda(x)(lst-mul err x)) wh)))
+(define (net-spd*err spd err) ;multiply error with speed
   (map (lambda(x)(lst-mul-x spd x)) err))
 
 (define (lst-mul-x s lst) ;multiply list with x
- (define (lst-2-mul a b) ;multiply 2 lists
+  (map (lambda(x)(* s x)) lst))
 
- (map (lambda(x y)(* x y)) a b))
+(define (net-proc-res-out net inp) ;x*(1 - x) for each neuron output
   (lst-push inp (map (lambda(x)(l-proc-res-out x)) (net-proc-res net inp))))
 
 (define (l-proc-res-out lst)
- (define (lst-lst-mul a b); miltiply list a with every list from b
+	(map (lambda(x)(* x (- 1 x))) lst))
 
- (map (lambda(x)(lst-mul-x x a)) b))
+(define (l-out-err need fact) ;error of otput layer
   (map (lambda(x y)(n-out-err x y)) need fact))
 
 (define (n-out-err need fact) ;error of output neuron
- (define (net-wh*err wh err) ;miltiply each wheight with error
+  (* fact (- 1 fact)(- need fact)))
 
- (map (lambda(x y)(lst-lst-mul x y)) wh err))
+(define (net-out-err net inp need) ;networks error lists
   (l-out-err need (net-proc net inp)))
 
 (define (lst-print lst);prints list
- (define (net-err+wh err wh) ;add error to wheghts
+  (map (lambda(x)(and (newline)(display x))) lst)(newline))
 
- (map (lambda(x y)(l-err+wh x y)) err wh))
+(define (lst-print2 lst)
   (map (lambda(x)(lst-print x)) lst)(newline))
 
 (define (l-check lst) lst)
- (define (lst-2-sum a b); adds to lists
+
 (define (transpose lst res)
- (map (lambda(x y)(+ x y)) a b))
+  (if (empty? (car lst)) res
 	(transpose (lst-cdr lst) (append res (lst-car lst)))))
 
 (define (lst-cdr lst) ;cdr of all list elements
- (define (l-err+wh err wh) ;adds error to wheight for layer
+  (map (lambda(x)(cdr x)) lst))
 
- (map (lambda(x y)(lst-2-sum x y)) err wh))
+(define (lst-car lst) ;car of all list elements
   (list (map (lambda(x)(car x)) lst)))