<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 IRIS DATASET
Lectura de datos
Antes de nada, hay que importar los paquetes y librerías que se van a necesitar durante el proceso.
Step1:  A continuación, se asignan los nombres de las columnas al dataset.
Step2:  Haciendo uso de la función read_csv se importa el archivo de datos de Iris Flower.
Step3:  Inspección de datos
Step4:  Antes de nada, es conveniente realizar una pequeña inspección de los datos. 
En este caso, se ha definido una función que grafica cada característica del dataset en función de las demás de forma automática.
Step5:  Tratamiento de datos
Una vez realizada la gráfica de los datos, conviene separar los datos en datos de entrenamiento y test. 
Para ello, se define la función splitTrainTest, que recibe un dataframe y el porcentaje de datos que serán de entrenamiento y test.
Step6:  Tras esto, se separan las 4 primeras columnas (datos numéricos) y la última (labels).
Step7:  Scikit-Learn no acepta strings como parámetros de funciones, por lo que hay que pasar los labels a formato numérico automáticamente.
Iris-setosa     -> 0
Iris-versicolor -> 1
Iris-virginica  -> 2
Step8:  Creación de un modelo
Haciendo uso de la función KNeighborsClassifier() creamos el modelo. En este caso, los parámetros irán por defecto. Los parámetros se pueden ver en la documentación de la implementación del algoritmo.
Step9:  Predicción
Step10:  Matriz de confusión
| 23 | 0  | 0  |
|----|----|----|
| 0  | 14 | 2  |
| 0  | 0  | 23 |
Step11:  ¿Qué algoritmo funciona mejor?
<ASSISTANT_TASK:>
Python Code:
## Autor: Mario Pérez Esteso <mario@geekytheory.com>
%pylab inline
import pandas as pd
import numpy as np
from sklearn import neighbors
from sklearn import preprocessing
import numpy as np
Explanation: IRIS DATASET
Lectura de datos
Antes de nada, hay que importar los paquetes y librerías que se van a necesitar durante el proceso.
End of explanation
columns = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class']
Explanation: A continuación, se asignan los nombres de las columnas al dataset.
End of explanation
iris = pd.read_csv('data/iris.data', names = columns)
Explanation: Haciendo uso de la función read_csv se importa el archivo de datos de Iris Flower.
End of explanation
iris.head(6)
Explanation: Inspección de datos
End of explanation
def plotDataset():
    labels = iris['class']
    labelencoder = preprocessing.LabelEncoder()
    labelencoder.fit(labels)
    plot_index = 1
    labels = labelencoder.transform(labels)
    colormap = np.array(['r', 'g', 'b'])
    plt.figure(figsize=(18,12))
    plt.clf()
    for i in range(0,4):
        for j in range(0,4):
            if i != j:  
                x = iris[columns[i]]
                y = iris[columns[j]]
                x_min, x_max = x.min() - .5, x.max() + .5
                y_min, y_max = y.min() - .5, y.max() + .5
                # Plot the training points
                plt.subplot(3, 4, plot_index)
                plt.scatter(x, y, c=colormap[labels], cmap=plt.cm.Paired)
                plt.xlabel(columns[i])
                plt.ylabel(columns[j])
                plt.title(columns[j]+" vs "+columns[i])
                plt.xlim(x_min, x_max)
                plt.ylim(y_min, y_max)
                plt.xticks(())
                plt.yticks(())
                plot_index = plot_index + 1
                
    plt.show()
    
plotDataset()
Explanation: Antes de nada, es conveniente realizar una pequeña inspección de los datos. 
En este caso, se ha definido una función que grafica cada característica del dataset en función de las demás de forma automática.
End of explanation
def splitTrainTest(dataframe, percentage=0.6):
    msk = np.random.rand(len(dataframe)) < percentage
    train = dataframe[msk]
    test = dataframe[~msk]
    return train, test
iris_train, iris_test = splitTrainTest(iris)
Explanation: Tratamiento de datos
Una vez realizada la gráfica de los datos, conviene separar los datos en datos de entrenamiento y test. 
Para ello, se define la función splitTrainTest, que recibe un dataframe y el porcentaje de datos que serán de entrenamiento y test.
End of explanation
iris_data_train = iris_train.ix[:,0:-1]
iris_data_test = iris_test.ix[:,0:-1]
iris_target_train = iris_train['class']
iris_target_test = iris_test['class']
iris_data_train.shape
Explanation: Tras esto, se separan las 4 primeras columnas (datos numéricos) y la última (labels).
End of explanation
le_train = preprocessing.LabelEncoder()
le_train.fit(iris_target_train)
iris_target_train_encoded = le_train.transform(iris_target_train)
le_test = preprocessing.LabelEncoder()
le_test.fit(iris_target_test)
iris_target_test_encoded = le_test.transform(iris_target_test)
testClasses = le_test.classes_
testClasses
Explanation: Scikit-Learn no acepta strings como parámetros de funciones, por lo que hay que pasar los labels a formato numérico automáticamente.
Iris-setosa     -> 0
Iris-versicolor -> 1
Iris-virginica  -> 2
End of explanation
classifier = neighbors.KNeighborsClassifier()
classifier.fit(iris_data_train, iris_target_train_encoded)
Explanation: Creación de un modelo
Haciendo uso de la función KNeighborsClassifier() creamos el modelo. En este caso, los parámetros irán por defecto. Los parámetros se pueden ver en la documentación de la implementación del algoritmo.
End of explanation
prediction = classifier.predict(iris_data_test)
accuracy = classifier.score(iris_data_test, iris_target_test_encoded)
print ("Predicted model accuracy: "+ str(accuracy))
prediction
Explanation: Predicción
End of explanation
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(iris_target_test_encoded, prediction)
def plot_confusion_matrix(cm, labels, title='Confusion matrix', cmap=plt.cm.Blues):
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(labels))
    plt.xticks(tick_marks, labels, rotation=45)
    plt.yticks(tick_marks, labels)
    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')
print('Confusion matrix, without normalization')
print(cm)
cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print('Normalized confusion matrix')
print(cm_normalized)
plt.figure(figsize=(10,10))
plot_confusion_matrix(cm_normalized, testClasses, title='Normalized confusion matrix')
plt.show()
Explanation: Matriz de confusión
| 23 | 0  | 0  |
|----|----|----|
| 0  | 14 | 2  |
| 0  | 0  | 23 |
End of explanation
algorithms = ['auto', 'ball_tree', 'kd_tree', 'brute']
for alg in algorithms:
    classifier = neighbors.KNeighborsClassifier(algorithm = alg)
    classifier.fit(iris_data_train, iris_target_train_encoded)
    prediction = classifier.predict(iris_data_test)
    accuracy = classifier.score(iris_data_test, iris_target_test_encoded)
    print ("Algorithm: " + alg)
    print ("Predicted model accuracy: " + str(accuracy))
    cm = confusion_matrix(iris_target_test_encoded, prediction)
    cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
    print('Normalized confusion matrix')
    print(cm_normalized)
    plt.figure(figsize=(10,10))
    plot_confusion_matrix(cm_normalized, testClasses, title='Normalized confusion matrix')
    plt.show()
Explanation: ¿Qué algoritmo funciona mejor?
End of explanation
<END_TASK>