Solving A Simple Classification Problem with Python Fruits Lovers’ Edition

%matplotlib inline
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

fruits = pd.read_table('fruit_data_with_colors.txt')
fruits.head()

fruits.shape

print(fruits.fruit_name.unique())

fruits.groupby('fruit_name').size()

import seaborn as sns
sns.countplot(fruits['fruit_name'],label= 'Count')
plt.show()

fruits.drop('fruit_label',axis=1).plot(kind='box',subplots = True,
                                      layout=(2,2),sharex = False,
                                      sharey = False,figsize= (9,9),
                                      title ='Box Plot for each input variable')
plt.savefig('fruits_box')
plt.show()

import pylab as pl
fruits.drop('fruit_label',axis=1).hist(bins=30,figsize=(9,9))
pl.suptitle('Histogram for each numeric input variable')
plt.savefig('fruits_hist')
plt.show()

# Draw a matrix of scatter plots
from pandas.tools.plotting import scatter_matrix
from matplotlib import cm
feature_name = ['mass','width','height','color_score']
X = fruits[feature_name]
y = fruits['fruit_label']

cmap = cm.get_cmap('gnuplot')
scatter = pd.scatter_matrix(X,c=y,marker='o',s=40,hist_kwds={'bins':15},
                            figsize=(9,9),cmap = cmap)
plt.suptitle('Scatter-matrix for each input variable')

fruits.describe()

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=0)

# 将属性缩放到一个指定的最大和最小值（通常是1-0）之间，这可以通过preprocessing.MinMaxScaler类实现。
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()
logreg.fit(X_train,y_train)

print("Accuracy of Logistic regression classifier on training set:{0:.2f}"
      .format(logreg.score(X_train,y_train)))
print("Accuracy of Logistic regression classifier on test set:{0:.2f}"
      .format(logreg.score(X_test,y_test)))

from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier().fit(X_train,y_train)

print("Accuracy of Decision Tree classifier on training set:{0:.2f}"
      .format(clf.score(X_train,y_train)))
print("Accuracy of Decision Tree classifier on test set:{0:.2f}"
      .format(clf.score(X_test,y_test)))

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
print("Accuracy of K-NN classifier on training set:{0:.2f}"
      .format(knn.score(X_train,y_train)))
print("Accuracy of K-NN classifier on test set:{0:.2f}"
      .format(knn.score(X_test,y_test)))

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

lda = LinearDiscriminantAnalysis()
lda.fit(X_train,y_train)
print("Accuracy of LDA classifier on training set:{0:.2f}"
      .format(lda.score(X_train,y_train)))
print("Accuracy of LDA classifier on test set:{0:.2f}"
      .format(lda.score(X_test,y_test)))

#### Gaussian Naive Bayes(高斯朴素贝叶斯)

from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train,y_train)
print("Accuracy of GNB classifier on training set:{0:.2f}"
      .format(gnb.score(X_train,y_train)))
print("Accuracy of GNB classifier on test set:{0:.2f}"
      .format(gnb.score(X_test,y_test)))

from sklearn.svm import SVC
svm = SVC()
svm.fit(X_train,y_train)
print("Accuracy of SVM classifier on training set:{0:.2f}"
      .format(svm.score(X_train,y_train)))
print("Accuracy of SVM classifier on test set:{0:.2f}"
      .format(svm.score(X_test,y_test)))

from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
pred = knn.predict(X_test)
print(confusion_matrix(y_test,pred))
print(classification_report(y_test,pred))

import matplotlib.cm as cm
from matplotlib.colors import ListedColormap,BoundaryNorm
import matplotlib.patches as mpatches

X = fruits[['mass','width','height','color_score']]
y = fruits['fruit_label']
X_train,X_test,y_train, y_test = train_test_split(X,y,random_state=0)

def plot_fruit_knn(X, y, n_neighbors, weights):
    X_mat = X[['height', 'width']].as_matrix()
    y_mat = y.as_matrix()
    
    cmap_light = ListedColormap(['#FFAAAA','#AAFFAA','#AAAAFF','#AFAFAF'])
    cmap_bold = ListedColormap(['#FF0000','#00FF00','#0000FF','#AFAFAF'])
    
    clf = KNeighborsClassifier(n_neighbors,weights=weights)
    clf.fit(X_mat,y_mat)
    
    # Plot the decision boundary by assigning a color in the color map
    # to each mesh point.
    
    mesh_step_size = .01  # step size in the mesh
    plot_symbol_size = 50
    
    x_min, x_max = X_mat[:, 0].min() - 1, X_mat[:, 0].max() + 1
    y_min, y_max = X_mat[:, 1].min() - 1, X_mat[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, mesh_step_size),
                         np.arange(y_min, y_max, mesh_step_size))
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    
    # Put the result into a color plot
    Z = Z.reshape(xx.shape)
    plt.figure()
    plt.pcolormesh(xx, yy, Z, cmap=cmap_light)
# Plot training points
    plt.scatter(X_mat[:, 0], X_mat[:, 1], s=plot_symbol_size, c=y, cmap=cmap_bold, edgecolor = 'black')
    plt.xlim(xx.min(), xx.max())
    plt.ylim(yy.min(), yy.max())
    patch0 = mpatches.Patch(color='#FF0000', label='apple')
    patch1 = mpatches.Patch(color='#00FF00', label='mandarin')
    patch2 = mpatches.Patch(color='#0000FF', label='orange')
    patch3 = mpatches.Patch(color='#AFAFAF', label='lemon')
    plt.legend(handles=[patch0, patch1, patch2, patch3])
    plt.xlabel('height (cm)')
    plt.ylabel('width (cm)')
    plt.title("4-Class classification (k = %i, weights = '%s')"
           % (n_neighbors, weights))    
    plt.show()
plot_fruit_knn(X_train, y_train, 5, 'uniform')

k_range = range(1, 20)
scores = []
for k in k_range:
    knn = KNeighborsClassifier(n_neighbors = k)
    knn.fit(X_train, y_train)
    scores.append(knn.score(X_test, y_test))
plt.figure()
plt.xlabel('k')
plt.ylabel('accuracy')
plt.scatter(k_range, scores,edgecolors=None)
plt.xticks([0,5,10,15,20])