GUI_windows.py

from tkinter import *
from tkinter import ttk
from tkinter import filedialog
from tkinter import messagebox
import numpy as np
import re 
import pandas as pd
from collections import Counter
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.decomposition import PCA, KernelPCA
from sklearn import svm, grid_search
from sklearn.model_selection import KFold
from sklearn.cross_validation import cross_val_score, cross_val_predict
from sklearn import metrics
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.cross_validation import KFold
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn import svm
from sklearn.cross_validation import cross_val_score
import numpy as np
import pandas as pd
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
import numpy as np
import re 
import pandas as pd
from collections import Counter
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.decomposition import PCA, KernelPCA
from sklearn import svm, grid_search
from sklearn.model_selection import KFold
from sklearn.cross_validation import cross_val_score, cross_val_predict
from sklearn import metrics
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.cross_validation import KFold
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn import svm
from sklearn.cross_validation import cross_val_score
import numpy as np
import pandas as pd
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
import tkinter as tk
from tkinter import *
from tkinter import ttk
from tkinter import filedialog
from tkinter import messagebox
import numpy as np
import re 
import pandas as pd
from collections import Counter
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.decomposition import PCA, KernelPCA
from sklearn import svm, grid_search
from sklearn.model_selection import KFold
from sklearn.cross_validation import cross_val_score, cross_val_predict
from sklearn import metrics
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.cross_validation import KFold
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn import svm
from sklearn.cross_validation import cross_val_score
import numpy as np
import pandas as pd
from sklearn.cross_validation import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
import tkinter as tk
import random
from sklearn import cluster, datasets, mixture
from sklearn.neighbors import kneighbors_graph
from sklearn.preprocessing import StandardScaler
from itertools import cycle, islice
from sklearn.cluster import KMeans
import numpy as np
from sklearn import cluster
import networkx as nx
from collections import defaultdict
import seaborn as sns
import pandas as pd
import numpy as np
from sklearn.metrics.cluster import normalized_mutual_info_score
from sklearn.metrics.cluster import adjusted_rand_score
from sklearn.cluster import AgglomerativeClustering
from sklearn.cluster import AffinityPropagation




    
root = Tk()
# width x height + x_offset + y_offset:
root.geometry("160x125+550+160") 

def comma():
   messagebox.showinfo( "CLUSTERING TOOL", "You have selected to proceed with the clustering tool") 
   messagebox.showinfo( "CLUSTERING TOOL", "Please insert the dataset you want to perform clustering on.")
   filename = filedialog.askopenfilename()
   file=filename
   master = Tk()
   def show_values():
    print (w.get())
    d=pd.read_excel(file)
   # - keep the names here of all the genes ......sos the column must be called 'gene '
    names=d['gene']
   # - keep the number of genes in your dataset 
    m=len(names)-1
    print('\n-- Your genes are beeing processed ...')
   # take out the names 
    pi=d.drop(['gene'], axis=1)
   #- keep  all the values in a variable called TI
    ΤΙ= pi.iloc[:,0:].values
    name=np.array(names)
    X = np.array(ΤΙ)
   
#-------------------------------------------------------------------------------
#----------------------------DO THE FITTING ----------------------------------
#------------------------------------------------------------------------------

    kmeans = KMeans(n_clusters=int(w.get()), random_state=0).fit(X)
    agglom = AgglomerativeClustering(n_clusters=int(w.get()), linkage="ward").fit(X)
    m=kmeans.labels_
    n= agglom.labels_
    teliko=pd.DataFrame(list(zip(name,m)),columns=['GENES','CLUSTER '])
    teliko.to_excel('kMEANS_cluster.xlsx', engine='xlsxwriter')
    print('d')
    teliko=pd.DataFrame(list(zip(name,n)),columns=['GENES','CLUSTER '])
    teliko.to_excel('agglom_cluster.xlsx', engine='xlsxwriter')
    print('dd')
    messagebox.showinfo( "CLUSTERING TOOL", "You are ready to see your results!")

   w = Scale(master, from_=0, to=200, length=600, orient=HORIZONTAL)
   w.pack()
   Button(master, text='Selected clusters', command=show_values).pack()
   Button(master, text='Close', command=master.destroy).pack()
   
 
       
       

def comme():
   messagebox.showinfo( "CLASSIFICATION TOOL", "You have selected to proceed with the classification tool") 
   messagebox.showinfo( "CLASSIFICATION TOOL", "Select your training set.") 
 
   
   def clean_dataset(df):
       assert isinstance(df, pd.DataFrame), "df needs to be a pd.DataFrame"
       df.dropna(inplace=True)
       indices_to_keep = ~df.isin([np.nan, np.inf, -np.inf]).any(1)
       return df[indices_to_keep].astype(np.float64)
    
    
    #---------------------------------------------------------------------------
    #-------------------------OPEN DATA ----------------------------------------
    #-------------------------------------------------------------------------- 
    
   filename = filedialog.askopenfilename()
   messagebox.showinfo( "CLASSIFICATION TOOL", "Thank you,insert the data you want to classify.")
   filenam = filedialog.askopenfilename()
   df=pd.read_excel(filename)
   df=clean_dataset(df)
    #-keep in x the variable and as y the validation 
   x = df.iloc[:,1:].values
   y = df.iloc[:,0].values
    #-rename them 
   data_input = x
   data_output = y
    #-set parameters for the kfold validation
   kf = KFold(10, n_folds = 5, shuffle=True)
    #-set parameters for the classifiers    
   rf_class = RandomForestClassifier(n_estimators=10)
   log_class = LogisticRegression()
   svm_class = svm.SVC()
   nn_class = KNeighborsClassifier(n_neighbors=3)
   svc_class= SVC(kernel="linear", C=0.025)
   gausian_class= GaussianProcessClassifier(1.0 * RBF(1.0))
   dtc_class = DecisionTreeClassifier(max_depth=5)
   mpl_class = MLPClassifier(alpha=1)
   abc_class = AdaBoostClassifier()
   bnb_class= GaussianNB()
    
    
   accu=[]#-- here we will keep all the accuracies of each classifier 
    
    #print("Random Forests: ")
    #print(cross_val_score(rf_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracy1 = cross_val_score(rf_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracy1)
    #print("Accuracy of Random Forests is: " , accuracy1)
    
    #print("\n\nsvm-linear: ")
    #print(cross_val_score(svc_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracysvc = cross_val_score(svc_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracysvc)
    #print("Accuracy of svm-linear is: " , accuracysvc)
    
    #print("\n\nGaussian process classifier: ")
    #print(cross_val_score(gausian_class, data_input, data_output, scoring='accuracy', cv = 10))
    #accuracygausian = cross_val_score(gausian_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
    #accu.append(accuracygausian)
    #print("Accuracy of  Gaussian process classifier is: " , accuracygausian)
    
    #print("\n\nDesicion tree classifier : ")
    #print(cross_val_score(dtc_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracydtc = cross_val_score(dtc_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracydtc)
    #print("Accuracy of Desicion tree classifier is: " , accuracydtc)
    
    #print("\n\nMPL: ")
    #print(cross_val_score(mpl_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracympl = cross_val_score(mpl_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracympl)
    #print("Accuracy of MPL Classifier is: " , accuracympl)
    
    
    #print("\n\nAdaBoostClassifier: ")
    #print(cross_val_score(abc_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracyabc = cross_val_score(abc_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracyabc)
    #print("Accuracy of AdaBoostClassifier is: " , accuracyabc)
    
    
    #print("\n\nGaussianNB:")# default is rbf
    #print(cross_val_score(bnb_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracybnb = cross_val_score(bnb_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracybnb)
    #print("Accuracy of GaussianNB is: " , accuracybnb)
    
    #print("\n\nSVM:")# default is rbf
    #print(cross_val_score(svm_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracy2 = cross_val_score(svm_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracy2)
    #print("Accuracy of SVM is: " , accuracy2)
    
    
    #print("\n\nLog:")
    #print(cross_val_score(log_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracy3 = cross_val_score(log_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracy3)
    #print("Accuracy of nLog is: " , accuracy3)
    
    #print("\n\nNN:")
    #print(cross_val_score(nn_class, data_input, data_output, scoring='accuracy', cv = 10))
   accuracy = cross_val_score(nn_class, data_input, data_output, scoring='accuracy', cv = 10).mean() * 100
   accu.append(accuracy)
    #print("Accuracy of NN is: " , accuracy)
    
    
    #### -- here we will display the user which classifier we suggest them to use for their analysis 
    
   bac=max(accu)
   name =[]
    
   if bac == accuracy1:
       name.append('Random Forest')
   elif bac == accuracy2:
       name.append('SVM')
   elif bac == accuracy3:
       name.append('nLog')
   elif bac == accuracysvc:
       name.append('SVC-LINEAR')
   elif bac == accuracygausian:
       name.append('Gausian process')
   elif bac == accuracydtc:
       name.append('Decision Tree')
   elif bac == accuracympl:
       name.append('MPL')
   elif bac == accuracyabc:
       name.append('AdaBoost')
   elif bac == accuracybnb:
       name.append('GaussianNB')
   else:
       name.append('knn')
    
    #-------------------------------------------------------------------------------------------
    #-display all the results 
   print("\n\n--Summing up :")
    
   classi=['Random Forests','SVM','nLog','SVC-linear','DecisionTree','MPL','AdaBoost','GaussianNB','NN']
   accur=[accuracy1,accuracy2,accuracy3,accuracysvc,accuracydtc,accuracympl,accuracyabc,accuracybnb,accuracy]
   tog=zip(classi,accur)
   teliko=pd.DataFrame(list(zip(classi,accur)),columns=['Classifier','Accuracy'])
   tel=teliko.sort_values(by=['Accuracy'], ascending=False)
   tel.to_excel('accuracies.xlsx', engine='xlsxwriter')
   print(tel)
    
    
    
   def printSomething():
        # if you want the button to disappear:
        # button.destroy() or button.pack_forget()
       label = Label(root, text=tel)
        #this creates a new label to the GUI
       label.pack() 
    
   root = Tk()
   
   button = Button(root, text="CLICK HERE TO VIEW ACCURACIES", command=printSomething) 
   button.pack()
   root.mainloop()
   root = tk.Tk()
   v = tk.IntVar()
   v.set(1)  # initializing the choice, i.e. Python
    
   languages = [
     
    ("knn") ,      
    ("Randomforest"),       
    ("LogisticRegretion"),       
    ("SVM"),
    ("SVM-linear"),       
    ("GaussianProcess"),       
    ("DecisionTree"),   
    ("MPL"),
    ("ΑdaBoost"),     
    ("GaussianNB"),       
    ("all")
   ]
   
   def ShowChoice():
        
       df=pd.read_excel(filename)
        #df=clean_dataset(df)
        #-keep in x the variable and as y the validation 
       x = df.iloc[:,1:].values
       y = df.iloc[:,0].values
        #-rename the variables 
       data_input = x
       data_output = y
        
        #---------------------------------------------------------------------------
        #-------------------------OPEN REAL DATA ----------------------------------------
        #--------------------------------------------------------------------------  
        #-open the dataset that you want to run your analysis on 
       d=pd.read_excel(filenam)
        #d=clean_dataset(df)
        # - keep the names here of all the genes ......sos the column must be called 'gene '
       names=d['gene']
        # - format the matrix so than there will only be int inside 
       m=len(names)-1
       print('\n-- There are in total',m,'genes in your dataset')
       pi=d.drop(['gene'], axis=1)
        #- keep  all the values in a variable called X 
       X = pi.iloc[:,0:].values
       tixera=[]# here are saved in good form all the values for predict 
        #mikos=1 # here i define how many i want to run the test on 
       def stringator(listind):
           stri=" ".join(str(x) for x in listind)
           T=re.sub("\s+", ",", stri.strip())
           return T
       mikos = m-2
       for t in range(mikos):
           M=X[t+1]
           MM=(int(x) for x in M)
           l=stringator(MM)
           tixera.append(l)
       print('naiiiiiii')
           
        #------------------------------------------------------------------------
        #--------------------------LEARNNG PART ---------------------------------
        #-------------------------------------------------------------------------
        
        #-Do the fitting on our data .
       knn = KNeighborsClassifier(n_neighbors=3)
       rf = RandomForestClassifier(n_estimators=10)
       lg= LogisticRegression()
       svmo = svm.SVC()
       svc= SVC(kernel="linear", C=0.025)
       dtc= DecisionTreeClassifier(max_depth=5)
       mpl= MLPClassifier(alpha=1)
       abc= AdaBoostClassifier()
       bnb= GaussianNB()
        
       svmo.fit(x,y)
       knn.fit(x,y)
       rf.fit(x,y)
       lg.fit(x,y)
       svc.fit(x,y)
       dtc.fit(x,y)
       mpl.fit(x,y)
       abc.fit(x,y)
       bnb.fit(x,y)
        
        #------------------------------------------------------------------------
        #--------------------------PREDICTION PART KNN---------------------------------
        #-------------------------------------------------------------------------
        
        #------------------------------------------------------------------------
        #--------------------------PREDICTION PART KNN---------------------------------
        #-------------------------------------------------------------------------
        
       if v.get() == 0 or v.get() == 10:
           
               
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=knn.predict([ti])
               pred.append(ni[0])
           #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
           print('knn-done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_knn.xlsx', engine='xlsxwriter')
           #messagebox.showinfo( "CLUSTERING TOOL", "You are ready to see your results!")

            
           if  v.get() == 1 or v.get() == 10:
                
                #------------------------------------------------------------------------
                #--------------------------PREDICTION PART RF---------------------------------
                #-------------------------------------------------------------------------
                
               pred=[]
               for st in range(mikos):
                   t=tixera[st]
                   ti=[int(s) for s in t.split(',')]
                   ni=rf.predict([ti])
                   pred.append(ni[0])
                #------------------------------------------------------------------------
                #--------------------------Create final matrix ---------------------------------
                #-------------------------------------------------------------------------
                # given that in training 1 was as good target and as a bad one 
               tava=[]
               for pr in pred :
                   if pr > 0.95 :
                       t=' GOOD potential target'
                       tava.append(t)
                   else :
                       t=' BAD potential target'
                       tava.append(t)
               name=[]
               for st in range(mikos):
                   t=names[st]
                   name.append(t)
                   print('rf-done')

                
                    
                #for st in range(mikos):
                   # print('The gene',name[st],'is according to our algorithm',tava[st])
                   
               teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
               teliko.to_excel('output_rf.xlsx', engine='xlsxwriter')
                
               if  v.get() == 2 or v.get() == 10:
                    
                    #------------------------------------------------------------------------
                    #--------------------------PREDICTION PART RF---------------------------------
                    #-------------------------------------------------------------------------
                    
                   pred=[]
                   for st in range(mikos):
                       t=tixera[st]
                       ti=[int(s) for s in t.split(',')]
                       ni=lg.predict([ti])
                       pred.append(ni[0])
                    #------------------------------------------------------------------------
                    #--------------------------Create final matrix ---------------------------------
                    #-------------------------------------------------------------------------
                    # given that in training 1 was as good target and as a bad one 
                   tava=[]
                   for pr in pred :
                       if pr > 0.95 :
                           t=' GOOD potential target'
                           tava.append(t)
                       else :
                           t=' BAD potential target'
                           tava.append(t)
                   name=[]
                   for st in range(mikos):
                       t=names[st]
                       name.append(t)
                       print('logistic done')
                        
                    
                        
                    #for st in range(mikos):
                       # print('The gene',name[st],'is according to our algorithm',tava[st])
                       
                   teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
                   teliko.to_excel('output_lg.xlsx', engine='xlsxwriter')
                    
                   if  v.get() == 3 or v.get() == 10 :
                        
                        #------------------------------------------------------------------------
                        #--------------------------PREDICTION PART RF---------------------------------
                        #-------------------------------------------------------------------------
                        
                       pred=[]
                       for st in range(mikos):
                           t=tixera[st]
                           ti=[int(s) for s in t.split(',')]
                           ni=svmo.predict([ti])
                           pred.append(ni[0])
                        #------------------------------------------------------------------------
                        #--------------------------Create final matrix ---------------------------------
                        #-------------------------------------------------------------------------
                        # given that in training 1 was as good target and as a bad one 
                       tava=[]
                       for pr in pred :
                           if pr > 0.95 :
                               t=' GOOD potential target'
                               tava.append(t)
                           else :
                               t=' BAD potential target'
                               tava.append(t)
                       name=[]
                       for st in range(mikos):
                           t=names[st]
                           name.append(t)
                           print('svm-done')
                            
                        
                            
                        #for st in range(mikos):
                           # print('The gene',name[st],'is according to our algorithm',tava[st])
                           
                       teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
                       teliko.to_excel('output_svm.xlsx', engine='xlsxwriter')
                       if v.get() == 4 or v.get() == 10:
            
                            #------------------------------------------------------------------------
                            #--------------------------PREDICTION PART RF---------------------------------
                            #-------------------------------------------------------------------------
                            
                           pred=[]
                           for st in range(mikos):
                               t=tixera[st]
                               ti=[int(s) for s in t.split(',')]
                               ni=svc.predict([ti])
                               pred.append(ni[0])
                            #------------------------------------------------------------------------
                            #--------------------------Create final matrix ---------------------------------
                            #-------------------------------------------------------------------------
                            # given that in training 1 was as good target and as a bad one 
                           tava=[]
                           for pr in pred :
                               if pr > 0.95 :
                                   t=' GOOD potential target'
                                   tava.append(t)
                               else :
                                   t=' BAD potential target'
                                   tava.append(t)
                           name=[]
                           for st in range(mikos):
                               t=names[st]
                               name.append(t)
                               print('svmlineardone')
                            
                                
                            #for st in range(mikos):
                               # print('The gene',name[st],'is according to our algorithm',tava[st])
                               
                           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
                           teliko.to_excel('output_svc.xlsx', engine='xlsxwriter')
                           if v.get() == 5  or v.get() == 10:
            
                                #------------------------------------------------------------------------
                                #--------------------------PREDICTION PART RF---------------------------------
                                #-------------------------------------------------------------------------
                                
                                
                                #------------------------------------------------------------------------
                                #--------------------------Create final matrix ---------------------------------
                                #-------------------------------------------------------------------------
                                # given that in training 1 was as good target and as a bad one 
                               print('paaame')
                               if v.get() == 6 or v.get() == 10 :
            
                                    #------------------------------------------------------------------------
                                    #--------------------------PREDICTION PART RF---------------------------------
                                    #-------------------------------------------------------------------------
                                    
                                   pred=[]
                                   for st in range(mikos):
                                       t=tixera[st]
                                       ti=[int(s) for s in t.split(',')]
                                       ni=dtc.predict([ti])
                                       pred.append(ni[0])
                                    #------------------------------------------------------------------------
                                    #--------------------------Create final matrix ---------------------------------
                                    #-------------------------------------------------------------------------
                                    # given that in training 1 was as good target and as a bad one 
                                   tava=[]
                                   for pr in pred :
                                       if pr > 0.95 :
                                           t=' GOOD potential target'
                                           tava.append(t)
                                       else :
                                           t=' BAD potential target'
                                           tava.append(t)
                                   name=[]
                                   for st in range(mikos):
                                       t=names[st]
                                       name.append(t)
                                       print('dtree done')
                                        
                                    
                                        
                                    #for st in range(mikos):
                                       # print('The gene',name[st],'is according to our algorithm',tava[st])
                                       
                                   teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
                                   teliko.to_excel('output_dtc.xlsx', engine='xlsxwriter')
                                   if v.get() == 7  or v.get() == 10 :
            
                                        #------------------------------------------------------------------------
                                        #--------------------------PREDICTION PART RF---------------------------------
                                        #-------------------------------------------------------------------------
                                        
                                       pred=[]
                                       for st in range(mikos):
                                           t=tixera[st]
                                           ti=[int(s) for s in t.split(',')]
                                           ni=mpl.predict([ti])
                                           pred.append(ni[0])
                                        #------------------------------------------------------------------------
                                        #--------------------------Create final matrix ---------------------------------
                                        #-------------------------------------------------------------------------
                                        # given that in training 1 was as good target and as a bad one 
                                       tava=[]
                                       for pr in pred :
                                           if pr > 0.95 :
                                               t=' GOOD potential target'
                                               tava.append(t)
                                           else :
                                               t=' BAD potential target'
                                               tava.append(t)
                                       name=[]
                                       for st in range(mikos):
                                           t=names[st]
                                           name.append(t)
                                           print('mpl done')
                                            
                                        
                                            
                                        #for st in range(mikos):
                                           # print('The gene',name[st],'is according to our algorithm',tava[st])
                                           
                                       teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
                                       teliko.to_excel('output_mpl.xlsx', engine='xlsxwriter')
                                       if v.get() == 8 or v.get() == 10 :
                                          
                                            #------------------------------------------------------------------------
                                            #--------------------------PREDICTION PART RF---------------------------------
                                            #-------------------------------------------------------------------------
                                            
                                           pred=[]
                                           for st in range(mikos):
                                               t=tixera[st]
                                               ti=[int(s) for s in t.split(',')]
                                               ni=abc.predict([ti])
                                               pred.append(ni[0])
                                           #------------------------------------------------------------------------
                                            #--------------------------Create final matrix ---------------------------------
                                            #-------------------------------------------------------------------------
                                            # given that in training 1 was as good target and as a bad one 
                                           tava=[]
                                           for pr in pred :
                                               if pr > 0.95 :
                                                   t=' GOOD potential target'
                                                   tava.append(t)
                                               else :
                                                   t=' BAD potential target'
                                                   tava.append(t)
                                           name=[]
                                           for st in range(mikos):
                                               t=names[st]
                                               name.append(t)
                                               print('adaboost done')
                                            
                                                
                                            #for st in range(mikos):
                                               # print('The gene',name[st],'is according to our algorithm',tava[st])
                                               
                                           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
                                           teliko.to_excel('output_adaboost.xlsx', engine='xlsxwriter')
                                           if v.get() == 9 or v.get() == 10 :
           
                                                #------------------------------------------------------------------------
                                                #--------------------------PREDICTION PART RF---------------------------------
                                                #-------------------------------------------------------------------------
                                                
                                               pred=[]
                                               for st in range(mikos):
                                                   t=tixera[st]
                                                   ti=[int(s) for s in t.split(',')]
                                                   ni=bnb.predict([ti])
                                                   pred.append(ni[0])
                                                #------------------------------------------------------------------------
                                                #--------------------------Create final matrix ---------------------------------
                                                #-------------------------------------------------------------------------
                                                # given that in training 1 was as good target and as a bad one 
                                               tava=[]
                                               for pr in pred :
                                                   if pr > 0.95 :
                                                       t=' GOOD potential target'
                                                       tava.append(t)
                                                   else :
                                                       t=' BAD potential target'
                                                       tava.append(t)
                                               name=[]
                                               for st in range(mikos):
                                                   t=names[st]
                                                   name.append(t)
                                                   print('gausian nb. done')
                                                   
                                                
                                                    
                                                #for st in range(mikos):
                                                   # print('The gene',name[st],'is according to our algorithm',tava[st])
                                                   
                                               teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
                                               teliko.to_excel('output_bnb.xlsx', engine='xlsxwriter')
                                        
                                            
                                
                            
       elif  v.get() == 1 :
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=rf.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('rf done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_rf.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")

            
       elif  v.get() == 2 :
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=lg.predict([ti])
               pred.append(ni[0])
           #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('lg done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_lg.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")
       elif v.get() == 3:
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=svmo.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('svm done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_svm.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")
       elif v.get() == 4 :
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=svc.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('svm linear done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_svc.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")
       elif v.get() == 16 :
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=gausian.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_gausianprocess.xlsx', engine='xlsxwriter')
            
       elif v.get() == 6 :
           
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=dtc.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('det.trees done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_dtc.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")
       elif v.get() == 7:
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=mpl.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('mpl done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_mpl.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")
       elif v.get() == 8 :
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=abc.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('adaboost done')
                
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_adaboost.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")
       elif v.get() == 9 :
            
            #------------------------------------------------------------------------
            #--------------------------PREDICTION PART RF---------------------------------
            #-------------------------------------------------------------------------
            
           pred=[]
           for st in range(mikos):
               t=tixera[st]
               ti=[int(s) for s in t.split(',')]
               ni=bnb.predict([ti])
               pred.append(ni[0])
            #------------------------------------------------------------------------
            #--------------------------Create final matrix ---------------------------------
            #-------------------------------------------------------------------------
            # given that in training 1 was as good target and as a bad one 
           tava=[]
           for pr in pred :
               if pr > 0.95 :
                   t=' GOOD potential target'
                   tava.append(t)
               else :
                   t=' BAD potential target'
                   tava.append(t)
           name=[]
           for st in range(mikos):
               t=names[st]
               name.append(t)
               print('nb')
            
                
            #for st in range(mikos):
               # print('The gene',name[st],'is according to our algorithm',tava[st])
               
           teliko=pd.DataFrame(list(zip(name,tava)),columns=['GENES','TARGET VALIDATION '])
           teliko.to_excel('output_bnb.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLASSIFICATION TOOL", "You are ready to see your results!")
       if v.get() == 10 :
           print('\n-- Since you have chosen to use all classifiers, a cross validation of all results will be done.')
           genes=[]
           counter=0
           
           outputs=['output_adaboost.xlsx','output_rf.xlsx','output_svm.xlsx','output_lg.xlsx','output_knn.xlsx','output_dtc.xlsx','output_svc.xlsx','output_mpl.xlsx','output_bnb.xlsx']
           for files in outputs :
               counter+=1
               df=pd.read_excel(files)
               d=np.array(df)
               for x in d:
                   if x[1] == ' GOOD potential target':
                       genes.append(x[0])
               print('done processing the :',counter,'file')
            
           counted_genes=Counter(genes)
           name=[]
           number=[]
           a1_sorted_keys = sorted(counted_genes, key=counted_genes.get, reverse=True)
           for r in a1_sorted_keys:
               name.append(r)
               number.append(counted_genes[r])
            
           df=pd.DataFrame(list(zip(name,number)),columns=['GENES','NO OCCURRENCES '])
            #df=pd.DataFrame.from_dict(counted_genes,orient='index',columns=['number of times validated as a good potential target'])
           d=np.array(df)
           dd=[]
           for x in d:
               if x[1]>1:
                   dd.append(x)
           l=pd.DataFrame(dd,columns=['GENES','NO OCCURRENCES '])
           print(l)
           df.to_excel('crossvalidated.xlsx', engine='xlsxwriter')
           messagebox.showinfo( "CLUSTERING TOOL", "You are ready to see your results!")

    
        
   tk.Label(root, 
            text="""Choose your classifier:""",
            justify = tk.LEFT,
            padx = 20).pack()
    
   for val, language in enumerate(languages):
       tk.Radiobutton(root, 
                     text=language,
                     padx = 20, 
                     variable=v, 
                     command=ShowChoice,
                     value=val).pack(anchor=tk.W)
   root.mainloop()
       

    
    


    
  



languages = ['CLASSIFICATION','CLUSTERING']
button = range(2)
for i in range(2):
   ct = [random.randrange(256) for x in range(3)]
   brightness = int(round(0.299*ct[0] + 0.587*ct[1] + 0.114*ct[2]))
   ct_hex = "%02x%02x%02x" % tuple(ct)
   bg_colour = '#' + "".join(ct_hex)
   l = tk.Button(root, 
                text=languages[i], 
                fg='White' if brightness < 120 else 'Black', 
                bg=bg_colour,
                command = comma if i == 1 else comme )


   l.place(x = 20, y = 30 + i*30, width=120, height=25)
 

          
root.mainloop()