import numpy as np
import pandas as pd
import seaborn as sns
from sklearn import datasets
from sklearn.manifold import TSNE
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.model_selection import train_test_split, cross_val_score

import matplotlib.pyplot as plt
import ssl

ssl._create_default_https_context = ssl._create_unverified_context


pd.set_option('display.max_columns', None)

%matplotlib inline

from sklearn.datasets import load_wine
data = load_wine()
df = pd.DataFrame(data.data, columns=data.feature_names)
df['classes'] = pd.Categorical.from_codes(data.target, data.target_names)
print("Primer análisis de los datos")
df.head()

print("Descripción de los datos")
df.describe()

print("El número de líneas es: " + str(df.shape[0]) + " y el número de columnas: "+ str(df.shape[1]))

print("No existe ningún null")

df.isnull().sum()

print('Cálculo de la frecuéncia')
cols = df.columns
num_cols_no_categoric = df._get_numeric_data().columns

col_categoric=list(set(cols) - set(num_cols_no_categoric))
print("Frecuéncia")
print( pd.value_counts(df[col_categoric].values.flatten()))
frecuencia_data =pd.value_counts(df[col_categoric].values.flatten())

sns.catplot(x="classes", kind="count", palette="ch:.25", data=df);

print("Estadísticos descriptivos básicos:")
df[num_cols_no_categoric].describe()

print("Histograma de las variables: alcohol")

graf1  = sns.distplot(df['alcohol'],kde=0)

print("Histograma de las variables: color_intensity")
graf3  = sns.distplot(df['color_intensity'],kde=0,color="red")

print("Histograma de las variables: magnesium")
graf2  = sns.distplot(df['magnesium'],kde=0,color="green")

feats_to_explore = ['alcohol', 'magnesium', 'color_intensity']

for i in [0,1,2]:
    sns.distplot(df['alcohol'][data.target==i],
                 kde=False,label='{
                }'.format(i))

plt.legend()

for i in [0,1,2]:
    sns.distplot(df['color_intensity'][data.target==i],kde=False,label='{}'.format(i))

plt.legend()

for i in [0,1,2]:
    sns.distplot(df['magnesium'][data.target==i],kde=False,
                 label='{
                }'.format(i))

plt.legend()

for i in [0,1,2]:
    std = round(df["alcohol"][data.target==i].std(),3)
    sns.distplot(df['alcohol'][data.target==i],
                 kde=1,label='{} con std {}'.format(i,std))

plt.legend()

for i in [0,1,2]:
    std = round(df["color_intensity"][data.target==i].std(),3)
    sns.distplot(df['color_intensity'][data.target==i],
                 kde=1,label='{} con std {}'.format(i,std))

plt.legend()

for i in [0,1,2]:
    std = round(df["magnesium"][data.target==i].std(),3)
    sns.distplot(df['magnesium'][data.target==i],
                 kde=1,label='{} con std {}'.format(i,std))

plt.legend()

fig, (ax) = plt.subplots(1, 1, figsize=(10,6))
corr = df[feats_to_explore].corr()

hm = sns.heatmap(corr,
                 ax=ax,           # Axes in which to draw the plot, otherwise use the currently-active Axes.
                 cmap="coolwarm", # Color Map.
                 #square=True,    # If True, set the Axes aspect to “equal” so each cell will be square-shaped.
                 annot=True,
                 fmt='.2f',       # String formatting code to use when adding annotations.
                 #annot_kws={"size": 14},
                 linewidths=.05)

fig.subplots_adjust(top=0.93)
fig.suptitle('Wine Attributes Correlation Heatmap',
              fontsize=14,
              fontweight='bold')

feats_to_explore.append("classes")
sns.pairplot( hue="classes", data= df[feats_to_explore])

from sklearn.preprocessing import StandardScaler

features = data.feature_names
# Separating out the features
x = df.loc[:, features].values
# Separating out the target
y = df.loc[:,['classes']].values
# Standardizing the features
x = StandardScaler().fit_transform(x)

from sklearn.decomposition import PCA
pca = PCA(n_components=2)
principalComponents = pca.fit_transform(x)
principalDf = pd.DataFrame(data = principalComponents
             , columns = ['principal component 1', 'principal component 2'])
principalDf

finalDf = pd.concat([principalDf, df[['classes']]], axis = 1)
finalDf

fig = plt.figure(figsize = (8,8))
ax = fig.add_subplot(1,1,1)
ax.set_xlabel('Principal Component 1', fontsize = 15)
ax.set_ylabel('Principal Component 2', fontsize = 15)
ax.set_title('2 component PCA', fontsize = 20)
targets = ['class_0', 'class_1', 'class_2']
colors = ['r', 'g', 'b']
for target, color in zip(targets,colors):
    indicesToKeep = finalDf['classes'] == target
    ax.scatter(finalDf.loc[indicesToKeep, 'principal component 1']
               , finalDf.loc[indicesToKeep, 'principal component 2']
               , c = color
               , s = 50)
ax.legend(targets)
ax.grid()

features = data.feature_names
# Separating out the features
x = df.loc[:, features].values
y=data.target
from sklearn.manifold import TSNE

tsne_results = TSNE(n_components=2).fit_transform(x)

target_ids = range(len([0,1,2]))


from matplotlib import pyplot as plt
colors = 'r', 'g', 'b', 'c', 'm', 'y', 'k', 'w', 'orange', 'purple'
for i, c, label in zip(target_ids, colors, [0,1,2]):
    plt.scatter(tsne_results[y == i, 0], tsne_results[y == i, 1], c=c, label=label)
plt.legend()
plt.show()


sns.scatterplot(tsne_results[:,0], tsne_results[:,1], hue=y, legend='full')

# Spot Check Algorithms
train_data = []

from sklearn.ensemble import RandomForestClassifier



features = data.feature_names
# Separating out the features
x = df.loc[:, features].values
from sklearn.manifold import TSNE

tsne_results = TSNE(n_components=2).fit_transform(x)

from sklearn.model_selection import train_test_split

# Separating out the features

train_data.append(('Completo',df.loc[:, features].values))
train_data.append((' 2 dimensiones con PCA.',principalDf))
train_data.append(('2 dimensiones con TSNE.',tsne_results))


# Separating out the target
df['classes'] = data.target

y = df['classes']


from sklearn import preprocessing
y = preprocessing.label_binarize(y, classes=[0,1, 2])

# Split the data into training and testing sets



# evaluate each model in turn
names = []
for name, x in train_data:
    print('*******')
    print(name)
    train_features, test_features, train_labels, test_labels = train_test_split(x, y, test_size = 0.25, random_state = 42)
    print('Training Features Shape:', train_features.shape)
    print('Training Labels Shape:', train_labels.shape)
    print('Testing Features Shape:', test_features.shape)
    print('Testing Labels Shape:', test_labels.shape)
    rf = RandomForestClassifier(n_estimators = 10)
    cv_results = cross_val_score(rf, train_features, train_labels, cv=5, scoring='roc_auc')
    names.append(name)
    msg = "%s:  %f (%f)" % (name, cv_results.mean(), cv_results.std())
    print(msg)

x=df.loc[:, features].values

x=principalDf

y = preprocessing.label_binarize(y, classes=[0,1, 2])
train_features, test_features, train_labels, test_labels = train_test_split(x, y, test_size = 0.25, random_state = 42)

# Import the model we are using
from sklearn.ensemble import RandomForestClassifier
# Instantiate model with 1000 decision trees
rf = RandomForestClassifier(n_estimators = 10)
# Train the model on training data
rf.fit(train_features, train_labels);

# Use the forest's predict method on the test data
predictions = rf.predict(test_features)


import matplotlib.pyplot as plt

from sklearn.metrics import confusion_matrix
CM =  confusion_matrix( test_labels.argmax(axis=1), predictions.argmax(axis=1))


# Visualize it as a heatmap
import seaborn
seaborn.heatmap(CM, annot=True, fmt="d")
plt.show()

test = [10,50,100,200]
conf = ['n_estimators','max_depth','min_samples_split']

x=df.loc[:, features].values

x=principalDf

y = preprocessing.label_binarize(y, classes=[0,1, 2])
train_features, test_features, train_labels, test_labels = train_test_split(x, y, test_size = 0.25, random_state = 42)

# Import the model we are using
from sklearn.ensemble import RandomForestClassifier
# Instantiate model with 1000 decision trees

for num in test:
        print('*******')
        print('n_estimators' + str(num))
        rf = RandomForestClassifier(n_estimators = num)
        cv_results = cross_val_score(rf, train_features, train_labels, cv=5, scoring='roc_auc')
        names.append(name)
        msg = "%s:  %f (%f)" % (name, cv_results.mean(), cv_results.std())
        print(msg)



for num in test:
        print('*******')
        print('max_depth' + str(num))
        rf = RandomForestClassifier(max_depth = num)
        cv_results = cross_val_score(rf, train_features, train_labels, cv=5, scoring='roc_auc')
        names.append(name)
        msg = "%s:  %f (%f)" % (name, cv_results.mean(), cv_results.std())
        print(msg)



for num in test:
        print('*******')
        print('min_samples_split' + str(num))
        rf = RandomForestClassifier(min_samples_split = num)
        cv_results = cross_val_score(rf, train_features, train_labels, cv=5, scoring='roc_auc')
        names.append(name)
        msg = "%s:  %f (%f)" % (name, cv_results.mean(), cv_results.std())
        print(msg)