(ns code.experiments.knn
  (:use (code.learners.knn knn_classifier)) 
  (:use (code.learners.kmeans k_means_model k_means_classifier))
  (:use (code.utils utils folds nway nway_new mw))
  (:use (code.preprocessors.rows sbbr1))
  (:use (code.preprocessors.utils bestk))
  (:use (incanter core stats charts)))
  
(def treatments1 [[1 "k1"] [2 "k2"] [4 "k4"] [8 "k8"] [16 "k16"] [32 "k32"] [64 "k64"] [128 "k128"] [256 "k256"] [512 "k512"]])  
(declare knn-new knn-new-b4)  
;----------------------------------------------------------------------
(defn knn-new [n D distance kn k1 n1]
  (loop [i 0 d (second D) results (transient [])]
    (if (empty? d) 
 			(let [ans (persistent! results)
            ans1 (apply bind-rows (map matrix (org-data (apply vector (apply concat (map second ans))))))
            sig! (overall ans1)
            ans2 (overall ans1)
            ans3 (apply concat (map first ans))] 			
	
	(vector sig! (second (first (filter #(= kn (first %)) treatments1))) (first D) (first ans2) (second ans2) ans3))
	(recur (inc i)
	       (rest d)
	       (conj! results 
		      (let [trainer (fn [data] 				
				      (let [data1	(run-csl data k1 n1)]
				         data1)) 
			    tester (fn [one model] 
				     (vector (last one) 
					     (knn-classifier
					      (butlast one)                       
				        kn
					      model ;(first model)
					      distance)))                       
			    klasses (fn []
				      (map #(last (first %)) (group-by (first d) (- (ncol (first d)) 1))))]    
       				 	

			(let [answer (nway-new n (first d) trainer tester distance)

				    brt (apply concat (map last answer))
				    pdpf (map #(abcd-stats 
									(first %) 
            		  (second %)
            			(klasses)) 
         					answer)]
         	[brt pdpf])))))))

(defn knn-new-b4 [n D distance kn k1 n1]
  (loop [i 0 d (second D) results (transient [])]
    (if (empty? d)
      (let [ans (persistent! results)
            ans1 (apply bind-rows (map matrix (org-data (apply vector (apply concat (map second ans))))))
            sig! (overall ans1)
            ans2 (overall ans1)
            ans3 (apply concat (map first ans))] 			
	
	(vector sig! (second (first (filter #(= kn (first %)) treatments1))) (first D) (first ans2) (second ans2) ans3))      
      (recur (inc i)
             (rest d)
             (conj! results 
		    (let [trainer (fn [data] 				
				                 data)
			  			tester (fn [one model] 
				   						(vector (last one) 
					   									(knn-classifier
					    									(butlast one)                       
               									kn
					    									model
					    									distance)))                       
			  			klasses (fn []
				    						(map #(last (first %)) (group-by (first d) (- (ncol (first d)) 1))))]
		      (let [answer (nway-new n (first d) trainer tester distance)
			    			brt (apply concat (map last answer))
			    			pdpf (map #(abcd-stats 
														(first %) 
														(second %)
														(klasses)) 
				      answer)]
					[brt pdpf])))))))
			
(defn knn-new! [n D distance kn k1 n1]
  (loop [i 0 d (second D) results (transient [])]
    (if (empty? d) 
 			(let [ans (persistent! results)
            ans1 (apply bind-rows (map matrix (org-data (apply vector (apply concat (map second ans))))))
            ans2 (map quantile (overall ans1))
            ans5 (overall ans1)
            ans3 (apply concat (map first (map first ans)))
            ans4 (apply concat (map second (map first ans)))] 			
	;(print 'pd (matrix [(first ans2)]) 'pf (matrix [(second ans2)])))
	(vector (second (first (filter #(= kn (first %)) treatments1))) (first D) (first ans5) (second ans5) [ans3 ans4]))
	(recur (inc i)
	       (rest d)
	       (conj! results 
		      (let [trainer (fn [data] 				
				      (run-csl data k1 n1))
			    tester (fn [one model] 
				     (vector (last one) 
					     (knn-classifier
					      (butlast one)                       
					      kn
					      model 
					      distance)))                       
			    klasses (fn []
				      (map #(last (first %)) (group-by (first d) (- (ncol (first d)) 1))))]    
       				 	

			(let [answer (nway-new! n (first d) trainer tester distance)

				    brt (apply concat (map last answer))
				    pdpf (map #(abcd-stats 
									(first %) 
            		  (second %)
            			(klasses)) 
         					answer)]
         	[brt pdpf])))))))

(defn knn-new-b4! [n D distance kn k1 n1]
  (loop [i 0 d (second D) results (transient [])]
    (if (empty? d)
      (let [ans (persistent! results)
            ans1 (apply bind-rows (map matrix (org-data (apply vector (apply concat (map second ans))))))
            ans2 (map quantile (overall ans1))
            ans3 (apply concat (map first (map first ans)))
            ans4 (apply concat (map second (map first ans)))] 			
	;(print 'pd (matrix [(first ans2)]) 'pf (matrix [(second ans2)])))
	(vector (second (first (filter #(= kn (first %)) treatments1))) (first D) (first ans2) (second ans2) [ans3 ans4]))      
      (recur (inc i)
             (rest d)
             (conj! results 
		    (let [trainer (fn [data] 				
				     data)
			  tester (fn [one model] 
				   (vector (last one) 
					   (knn-classifier
					    (butlast one)                       
					    kn
					    model 
					    distance)))                       
			  klasses (fn []
				    (map #(last (first %)) (group-by (first d) (- (ncol (first d)) 1))))]
		      (let [answer (nway-new! n (first d) trainer tester distance)
			    brt (apply concat (map last answer))
			    pdpf (map #(abcd-stats 
					(first %) 
					(second %)
					(klasses)) 
				      answer)]
			[brt pdpf])))))))			
			
(defn c-knn-b4 [n D distance kn k1 n1]
 (let [ansb4 (knn-new-b4! n D distance kn k1 n1)	
 			 brit2 (last ansb4)
 			 nln (first brit2)
 			 nun (second brit2)
 			 mapb4 (map #(vector % 1) nln)
       mapafter (map #(vector % 2) nun)        
       together (sort-by first (apply concat (vector mapb4 mapafter)))
       labels (map second together)
       scores (find-ranks (map first together))
       together-again (map #(vector %1 %2) scores labels)
       getb4 (filter #(= 1 (second %)) together-again) 
       getafter (filter #(= 2 (second %)) together-again)
       scores-b4 (map first getb4)
       scores-after (map first getafter)
       x-ax (matrix (range 0 (+ (count scores-b4) (count scores-after))))
       scoreb4 (quantile scores-b4)
       scoreafter (quantile scores-after)
       bd? (mw-0 scores-b4 scores-after)]
       
     {:brittle-level bd?
     :pd (nth (butlast ansb4) 2)
     :pf (nth (butlast ansb4) 3)}))
;(save (bind-columns x-ax (matrix (concat (repeat (count scores-b4) 4) (repeat (count scores-after) 10))) (matrix (concat scores-b4 scores-after))) "bd.dat")))
;    (conj (butlast ansb4) bd?)))

(defn c-knn-after [n D distance kn k1 n1 num]
 (let [ansafter (knn-new! n D distance kn k1 n1)	
 			 brit2 (last ansafter)
 			 nln (first brit2)
 			 nun (second brit2)
 			 mapb4 (map #(vector % 1) nln)
       mapafter (map #(vector % 2) nun)        
       together (sort-by first (apply concat (vector mapb4 mapafter)))
       labels (map second together)
       scores (find-ranks (map first together))
       together-again (map #(vector %1 %2) scores labels)
       getb4 (filter #(= 1 (second %)) together-again) 
       getafter (filter #(= 2 (second %)) together-again)
       scores-b4 (map first getb4)
       scores-after (map first getafter)
       x-ax (matrix (range 0 (count scores-b4)))
       scoreb4 (quantile scores-b4)
       scoreafter (quantile scores-after)
       bd? (mw-0 scores-b4 scores-after)
       pd (nth (butlast ansafter) 2)
       pf (nth (butlast ansafter) 3)]

		(save (bind-columns 
						(matrix (repeat (count pd) num))
						(matrix (repeat (count pd) kn))
						(matrix pd)
						(matrix pf))
			"wlt.csv")))						

;    {:brittle-level bd?
;     :pd (nth (butlast ansafter) 2)
;     :pf (nth (butlast ansafter) 3)}))
;    (save (bind-columns x-ax scores-b4 scores-after) "bda.dat")))     
     ;(conj (butlast ansafter) bd?)))
 			 			

(defn c-knn [n D distance kn k1 n1]
  (let [ansb4 (knn-new-b4 n D distance kn k1 n1)
        ansafter (knn-new n D distance kn k1 n1)
        sigpd (mw-1 (first (first ansb4)) (first (first ansafter)))
        sigpf (mw-1 (second (first ansb4)) (second (first ansafter)))
        b4 (last ansb4)
        after (last ansafter)
        mapb4 (map #(vector % 1) b4)
        mapafter (map #(vector % 2) after)        
        together (sort-by first (apply concat (vector mapb4 mapafter)))
        labels (map second together)
        scores (find-ranks (map first together))
        together-again (map #(vector %1 %2) scores labels)
        getb4 (filter #(= 1 (second %)) together-again) 
        getafter (filter #(= 2 (second %)) together-again)
        scores-b4 (map first getb4)
        scores-after (map first getafter)
        x-ax (matrix (range 0 (+ (count scores-b4) (count scores-after))))
        scoreb4 (quantile scores-b4)
        scoreafter (quantile scores-after)
        bd? (mw scores-b4 scores-after)]
        
       

;[(save (bind-columns 
;      x-ax 
;       (matrix (concat (repeat (count scores-b4) 4) (repeat (count scores-after) 10))) 
;       (matrix (concat scores-b4 scores-after)))
;      "bd0919.dat")
      
;(save (bind-columns
;       (range 0 (* 2 (count (nth ansb4 3))))
;       (concat (repeat (count (nth ansb4 3)) 4) (repeat (count (nth ansb4 3)) 10))    
;       (matrix (concat (nth ansb4 3) (nth ansafter 3)))
;       (matrix (concat (nth ansb4 4) (nth ansafter 4)))) "pdpf0919.csv")]))

			[bd? 
			'b4pd (quantile (nth ansb4 3)) 'afterpd (quantile (nth ansafter 3))  
			'b4pf (quantile (nth ansb4 4)) 'afterpf (quantile (nth ansafter 4))
			(save (bind-columns (range 0 (count scores-b4)) scores-b4 scores-after) "results21.csv")]))
;    [sigpd sigpf (conj (butlast ansb4) bd?) (conj (butlast ansafter) bd?)]))        

;---------------------------------------------------------
;-----------------Within System Check---------------------
;---------------------------------------------------------

(defn c1-knn-b4 [n D distance kn k1 n1 num]
 (let [ansb4 (knn-new-b4! n D distance kn k1 n1)	
 			 brit2 (last ansb4)
 			 nln (first brit2)
 			 nun (second brit2)
 			 mapb4 (map #(vector % 1) nln)
       mapafter (map #(vector % 2) nun)        
       together (sort-by first (apply concat (vector mapb4 mapafter)))
       labels (map second together)
       scores (find-ranks (map first together))
       together-again (map #(vector %1 %2) scores labels)
       getb4 (filter #(= 1 (second %)) together-again) 
       getafter (filter #(= 2 (second %)) together-again)
       scores-b4 (map first getb4)
       scores-after (map first getafter)
       x-ax (matrix (range 0 (+ (count scores-b4) (count scores-after))))
       scoreb4 (quantile scores-b4)
       scoreafter (quantile scores-after)
       bd? (mw-0 scores-b4 scores-after)]
		   
		(save (bind-columns 
						(matrix (repeat (+ (count scores-after) (count scores-b4)) num)) ;---data 
						(matrix (concat (repeat (count scores-b4) 4)
														(repeat (count scores-after) 10)))
						(matrix (concat scores-b4	scores-after)))
			"wltb4.csv")))
       
(defn c1-knn-after [n D distance kn k1 n1 num]
 (let [ansafter (knn-new! n D distance kn k1 n1)	
 			 brit2 (last ansafter)
 			 nln (first brit2)
 			 nun (second brit2)
 			 mapb4 (map #(vector % 1) nln)
       mapafter (map #(vector % 2) nun)        
       together (sort-by first (apply concat (vector mapb4 mapafter)))
       labels (map second together)
       scores (find-ranks (map first together))
       together-again (map #(vector %1 %2) scores labels)
       getb4 (filter #(= 1 (second %)) together-again) 
       getafter (filter #(= 2 (second %)) together-again)
       scores-b4 (map first getb4)
       scores-after (map first getafter)
       x-ax (matrix (range 0 (count scores-b4)))
       scoreb4 (quantile scores-b4)
       scoreafter (quantile scores-after)
       bd? (mw-0 scores-b4 scores-after)]       

		(save (bind-columns 
						(matrix (repeat (+ (count scores-after) (count scores-b4)) num)) ;---data 
						(matrix (concat (repeat (count scores-b4) 4)
														(repeat (count scores-after) 10)))
						(matrix (concat scores-b4	scores-after)))
			"wltafter.csv")))
			
(defn knn-new-b4-np [n D distance kn k1 n1]
  (loop [i 0 d (second D) results (transient [])]
    (if (empty? d)
      (let [ans (persistent! results)
            ans1 (apply bind-rows (map matrix (org-data (apply vector (apply concat (map second ans))))))
            ans2 (map quantile (overall ans1))
            ans3 (apply concat (map first ans))] 			
	
	(vector (second (first (filter #(= kn (first %)) treatments1))) (first D) (first ans2) (second ans2) ans3))      
      (recur (inc i)
             (rest d)
             (conj! results 
		    (let [trainer (fn [data] 				
				                 data)
			  			tester (fn [one model] 
				   						(vector (last one) 
					   									(knn-classifier
					    									(butlast one)                       
               									kn
					    									model
					    									distance)))                       
			  			klasses (fn []
				    						(map #(last (first %)) (group-by (first d) (- (ncol (first d)) 1))))]
		      (let [answer (nway-new n (first d) trainer tester distance)
			    			brt (apply concat (map last answer))
			    			pdnp (map #(abcd-stats1 
														(first %) 
														(second %)
														(klasses)) 
				      answer)]
					[brt pdnp])))))))			
					
(defn c-knn1 [n D D1 distance kn k1 n1]
  (let [ansb4 (knn-new-b4 n D distance kn k1 n1)
        ansafter (knn-new n D1 distance kn k1 n1)
        sigpd (mw-1 (first (first ansb4)) (first (first ansafter)))
        sigpf (mw-1 (second (first ansb4)) (second (first ansafter)))
        b4 (last ansb4)
        after (last ansafter)
        mapb4 (map #(vector % 1) b4)
        mapafter (map #(vector % 2) after)        
        together (sort-by first (apply concat (vector mapb4 mapafter)))
        labels (map second together)
        scores (find-ranks (map first together))
        together-again (map #(vector %1 %2) scores labels)
        getb4 (filter #(= 1 (second %)) together-again) 
        getafter (filter #(= 2 (second %)) together-again)
        scores-b4 (map first getb4)
        scores-after (map first getafter)
        x-ax (matrix (range 0 (+ (count scores-b4) (count scores-after))))
        scoreb4 (quantile scores-b4)
        scoreafter (quantile scores-after)
        bd? (mw scores-b4 scores-after)]
        
       

;[(save (bind-columns 
;      x-ax 
;       (matrix (concat (repeat (count scores-b4) 4) (repeat (count scores-after) 10))) 
;       (matrix (concat scores-b4 scores-after)))
;      "bd0919.dat")
      
;(save (bind-columns
;       (range 0 (* 2 (count (nth ansb4 3))))
;       (concat (repeat (count (nth ansb4 3)) 4) (repeat (count (nth ansb4 3)) 10))    
;       (matrix (concat (nth ansb4 3) (nth ansafter 3)))
;       (matrix (concat (nth ansb4 4) (nth ansafter 4)))) "pdpf0919.csv")]))

			[bd? 
			'b4pd (quantile (nth ansb4 3)) 'afterpd (quantile (nth ansafter 3))  
			'b4pf (quantile (nth ansb4 4)) 'afterpf (quantile (nth ansafter 4))
			(save (bind-columns (range 0 (count scores-b4)) scores-b4 scores-after) "results21.csv")]))
;    [sigpd sigpf (conj (butlast ansb4) bd?) (conj (butlast ansafter) bd?)]))  

(defn knn-new-fss [n D distance kn k1 n1 z]
  (loop [i 0 d (second D) results (transient [])]
    (if (empty? d) 
 			(let [ans (persistent! results)
            ans1 (apply bind-rows (map matrix (org-data (apply vector (apply concat (map second ans))))))
            sig! (overall ans1)
            ans2 (overall ans1)
            ans3 (apply concat (map first ans))] 			
	
	(vector sig! (second (first (filter #(= kn (first %)) treatments1))) (first D) (first ans2) (second ans2) ans3))
	(recur (inc i)
	       (rest d)
	       (conj! results 
		      (let [trainer (fn [data] 				
				      (let [goals (map int (unique-goals (first d)))
				      			data1 (fss data goals z)
				      			data2	(run-csl data1 k1 n1)]
				         data2)) 
			    tester (fn [one model] 
				     (vector (last one) 
					     (knn-classifier
					      (butlast one)                       
				        kn
					      model ;(first model)
					      distance)))                       
			    klasses (fn []
				      (map #(last (first %)) (group-by (first d) (- (ncol (first d)) 1))))]    
       				 	

			(let [answer (nway-new n (first d) trainer tester distance)

				    brt (apply concat (map last answer))
				    pdpf (map #(abcd-stats 
									(first %) 
            		  (second %)
            			(klasses)) 
         					answer)]
         	[brt pdpf])))))))