import numpy as np
import pandas as pd
from matplotlib.pyplot import *
from sklearn.naive_bayes import GaussianNB
from sklearn import tree
from sklearn.neighbors import NearestNeighbors
from sklearn.neighbors import KDTree
from sklearn.neural_network import MLPClassifier
from sklearn.decomposition import PCA
from sklearn.neighbors import KNeighborsClassifier
from sklearn import preprocessing
from sklearn.model_selection import cross_val_score

df = pd.read_csv('http://www.math.univ-toulouse.fr/~ncouella/yeast.csv',header=None,names=["mcg","vh","alm","mit","erl","pox","vac","nuc","class"])
# les attribut sont : les 8 premières collones des float et la dernière colonne une chaine de caractère
def RandomizeDataframe(df):
    df=df.iloc[np.random.permutation(len(df))]
    df=df.reset_index(drop=True)
    return df
df=RandomizeDataframe(df)



# separer le data frame en deux partie

def split(df,p):
    long=int((p/100)*len(df))
    return (df.ix[:long],df.ix[long:])
    #return df.values[df.index<int(len(df)*(p/100))],df.values[df.index >= int(len(df)*(p/100))]
    train,test =split(df,80)
train,test = split(df,80)


Xtrain=train[train.columns[0:8]]
Ytrain=train[train.columns[8]]
Xtest= test[test.columns[0:8]]
Ytest= test[test.columns[8]]
############## bayesien naif
clf=GaussianNB()
clf.fit(Xtrain,Ytrain)
predict=clf.predict(Xtest)

def prediction(labels,pred):
    bonne_pred=0
    taille=int(len(pred))
    for i in range(0,taille):
        if(labels[i]==pred[i]):
            bonne_pred=bonne_pred+1
    bonne_pred=(bonne_pred/taille)*100
    return(bonne_pred)
print(prediction(Ytrain,predict))
# prediction=9.090909090909092 % semble faible mais mieux que le hasard

X=df[df.columns[0:8]]
Y=df[df.columns[8]]

clf=tree.DecisionTreeClassifier()
clf.fit(Xtrain,Ytrain)
predict_tree=clf.predict(Xtest)
print(prediction(Ytrain,predict_tree))
# prediction arbre : 18.855218855218855 %


clf = KNeighborsClassifier(n_neighbors = 10)
pred_voisin = clf.fit(Xtrain,Ytrain).predict(Xtest)
print(prediction(Ytrain,pred_voisin))
# prediction pour 10 voisins 27.27272727272727 %
# ANN
clf = MLPClassifier(solver='lbfgs', alpha=1e-5,
                    hidden_layer_sizes=(5, 2), random_state=1)
clf.fit(Xtrain,Ytrain)
predict_ann=clf.predict(Xtest)
print(prediction(Ytrain,predict_ann))
# prediction 25.252525252525253 %

print("AVEC PCA MAINTENANT")

#data_scaled =DataFrame(preprocessing.scale(Xtrain),columns = Xtrain.columns)
#clf = PCA(n_components=4)
#clf.fit(Xtrain)
#Xtrain_reduit = clf.fit_transform(datascaled)
#acp = DataFrame(clf.components,columns=data_scaled.columns,index = ['var1','var2','var3','var4']).abs().sum(axis=0)
#acp_triee = acp.sort_values(ascending = False)
#for i in range(4):
#    print((acp_triee.axes[0])[i])
clf= PCA(n_components=4)
clf.fit(Xtrain)
Xtrain_reduit= clf.fit_transform(Xtrain)

clf= PCA(n_components=4)
clf.fit(Xtest)
Xtest_reduit= clf.fit_transform(Xtest)


clf=GaussianNB()
clf.fit(Xtrain_reduit,Ytrain)
predictPCA=clf.predict(Xtest_reduit)
print(prediction(Ytrain,predictPCA))
# Prediction gaussian  PCA 23.56902356902357

clf=tree.DecisionTreeClassifier()
clf.fit(Xtrain_reduit,Ytrain)
predict_treePCA=clf.predict(Xtest_reduit)
print(prediction(Ytrain,predict_treePCA))
# prediction arbre PCA : 28.95622895622896 %


clf = KNeighborsClassifier(n_neighbors = 10)
pred_voisinPCA = clf.fit(Xtrain_reduit,Ytrain).predict(Xtest_reduit)
print(prediction(Ytrain,pred_voisinPCA))
# prediction pour 10 voisins PCA 28.619528619528616 %
# ANN
clf = MLPClassifier(solver='lbfgs', alpha=1e-5,
                    hidden_layer_sizes=(5, 2), random_state=1)
clf.fit(Xtrain_reduit,Ytrain)
predict_annPCA=clf.predict(Xtest_reduit)
print(prediction(Ytrain,predict_annPCA))
# prediction PCA 26.936026936026934  %

#------------------------------------------------------------------------------
print("partie 4")

train50,test50 = split(df,50)


Xtrain50=train50[train50.columns[0:8]]
Ytrain50=train50[train50.columns[8]]
Xtest50= test50[test50.columns[0:8]]
Ytest50= test50[test50.columns[8]]

clf= PCA(n_components=4)
clf.fit(Xtrain50)
Xtrain_reduit50= clf.fit_transform(Xtrain50)

clf= PCA(n_components=4)
clf.fit(Xtest50)
Xtest_reduit50= clf.fit_transform(Xtest50)

#methode bayes naif

clf=GaussianNB(priors=None)
clf.fit(Xtrain_reduit50,Ytrain50)
predictPCA50=clf.predict(Xtest_reduit50)
print(prediction(Ytrain50,predictPCA50))

#ARBRE
def besttree(profondeurmin,profondeurmax,Xtrain_reduit50,Ytrain50,Xtest_reduit50):
    bestprofondeur=0
    bestprediction=0
    for i in range(profondeurmin,profondeurmax) :
        clf=tree.DecisionTreeClassifier(max_depth=i)
        clf.fit(Xtrain_reduit50,Ytrain50)
        predict_treePCA50=clf.predict(Xtest_reduit50)
        if (bestprediction<prediction(Ytrain50,predict_treePCA50)):
            bestprediction=prediction(Ytrain50,predict_treePCA50)
            bestprofondeur=i
    return(bestprofondeur,bestprediction)

profondeurT,predictionT=besttree(2,100,Xtrain_reduit50,Ytrain50,Xtest_reduit50)
print("La meilleure profondeur est :",profondeurT,"la prediction est égale à : ",predictionT)

# La meilleure profondeur est : 5 la prediction est égale à :  26.549865229110516

# VOISINS

def bestnbvoisin(nb_voisin_max,Xtrain_reduit50,Ytrain50,Xtest_reduit50):
    bestnbvoisin=1
    bestprediction=0
    for i in range(1,nb_voisin_max) :
        clf = KNeighborsClassifier(n_neighbors = i)
        pred_voisinPCA = clf.fit(Xtrain_reduit,Ytrain).predict(Xtest_reduit)
        print()
        if (bestprediction<prediction(Ytrain,pred_voisinPCA)):
            bestprediction=prediction(Ytrain,pred_voisinPCA)
            bestnbvoisin=i
    return(bestnbvoisin,bestprediction)

nbvoisin,predictionV=bestnbvoisin(100,Xtrain_reduit50,Ytrain50,Xtest_reduit50)
print("La meilleure nombre de voisin est :",nbvoisin,"la prediction est égale à : ",predictionV)
#La meilleure nombre de voisin est : 88 la prediction est égale à :  26.936026936026934

#ANN
def best_sizes(taillemax,Xtrain_reduit50,Ytrain50,Xtest_reduit50):
    bestsize=1
    bestprediction=0
    for i in range(1,taillemax) :
        clf = MLPClassifier(solver='lbfgs', alpha=1e-5,
                            hidden_layer_sizes=(i,), random_state=1)
        clf.fit(Xtrain_reduit,Ytrain)
        predict_annPCA=clf.predict(Xtrain_reduit50)
        if (bestprediction<prediction(Ytrain50,predict_annPCA50)):
            bestprediction=prediction(Ytrain50,predict_annPCA50)
            bestprofondeur=i
    return(bestsize,bestprediction)
bestsize,predictionann=bestnbvoisin(100,Xtrain_reduit50,Ytrain50,Xtest_reduit50)
print("La meilleure taille :",bestsize,"la prediction est égale à : ",predictionann)
# La meilleure taille : 4 la prediction est égale à :  24.915824915824917

print("Partie5")

clfNB=GaussianNB(priors=None)
scoreB = cross_val_score(clfNB, X, Y, cv=5)
print("Accuracy: %0.2f (+/- %0.2f) pour le bayesien naif" % (scoreB.mean(), scoreB.std() * 2))
# Accuracy: 0.15 (+/- 0.08) pour le bayesien naif

clft=tree.DecisionTreeClassifier(max_depth=profondeurT)
scoret = cross_val_score(clft, X, Y, cv=5)
print("Accuracy: %0.2f (+/- %0.2f) pour les arbres" % (scoret.mean(), scoret.std() * 2))
#Accuracy: 0.49 (+/- 0.02) pour les arbres

clfV = KNeighborsClassifier(n_neighbors = nbvoisin)
scoreV = cross_val_score(clfV, X, Y, cv=5)
print("Accuracy: %0.2f (+/- %0.2f) pour les voisins" % (scoreV.mean(), scoreV.std() * 2))
#Accuracy: 0.58 (+/- 0.03) pour les voisins
clfANN = MLPClassifier(solver='lbfgs', alpha=1e-5,
                    hidden_layer_sizes=(bestsize,), random_state=1)
scoreANN = cross_val_score(clfANN, X, Y, cv=5)
print("Accuracy: %0.2f (+/- %0.2f) pour l'ANN" % (scoreANN.mean(), scoreANN.std() * 2))
#Accuracy: 0.60 (+/- 0.03) pour l'ANN


print("partie6")

subplot(2,2,1)
bar(range(5),scoreB,align='center',alpha=0.5)
subplot(2,2,2)
bar(range(5),scoret,align='center',alpha=0.5)
subplot(2,2,3)
bar(range(5),scoreV,align='center',alpha=0.5)
subplot(2,2,4)
bar(range(5),scoreANN,align='center',alpha=0.5)


moy=[np.mean(scoreB),np.mean(scoret),np.mean(scoreV),np.mean(scoreANN)]
bar(range(4),moy,align='center',alpha=0.5)