Predicting a grocery store chain's customer satisfaction index

import os

from IPython.display import display
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

%matplotlib inline
plt.xkcd();

# Load data.
df = pd.read_csv(os.path.join('Data', 'ModelathonData.csv'), encoding='latin_1')
test = pd.read_csv(os.path.join('Data', 'FinalTestLabels.csv'), encoding='latin_1')
test.index = df[df['CSI'] == 0].index
df.update(test)

# DistanceToStore contains junk after a tab character. Strip that out.
df['DistanceToStore'] = df['DistanceToStore'].str.split('\t').apply(lambda x: x[0]).astype('float')

# InterviewDate is a string, let's parse it to datetime.
from datetime import datetime
df['InterviewDate'] = df['InterviewDate'].apply(lambda s: datetime.strptime(s, '%m/%d/%Y %H:%M').timestamp())

# Feature selection. Note: we want to predict CSI so it cannot be a feature.
labels =  df['CSI']
features = df[[x for x in df.columns 
                 if x.startswith('ShareBoughtAt') or x.endswith('Id')] + [
        'Gender', 
        'CSIaverage', 
        'InterviewDate', 
        'BirthYear', 
        'PurchasingPower', 
        'VisitsLast3Months', 
        'AmountLast3Months',
        'StoreSquaremeters',
        'DistanceToStore']]

from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler

# Split out test data.
X_test, y_test = features.iloc[test.index], labels.iloc[test.index]

# Whatever remains is our training data.
X_train, y_train = map(lambda x: x.iloc[~x.index.isin(test.index)], 
                       [features, labels])

# Normalize training data and split into test and validation sets.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_train, X_val, y_train, y_val = train_test_split(X_train, 
                                                  y_train, 
                                                  test_size=0.1)

from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier

classifiers = [RandomForestClassifier(),
               AdaBoostClassifier()]

# Also try XGBoost if it's installed.
try:
    from xgboost.sklearn import XGBClassifier
    classifiers.append(XGBClassifier())
except:
    pass

def train(clf):
    clf.fit(X_train, y_train)
    score = clf.score(X_val, y_val)
    print(clf, score)
    return clf

from multiprocessing import Pool
with Pool(len(classifiers)) as p:
    classifiers = p.map(train, classifiers)

import matplotlib.mlab as mlab

X = scaler.transform(X_test)
predictions = [y_test]
labels = ['Test data']
for i, clf in enumerate(classifiers):
    predictions.append(clf.predict(X))
    labels.append('{} ({:0.2f}% accuracy)'.format(type(clf).__name__, 
                                                  100*clf.score(X, y_test)))
colors = [c['color'] for c in plt.rcParams['axes.prop_cycle']][:len(predictions)]
plt.figure()
plt.hist(predictions, color=colors)
for i, p in enumerate(predictions):
    x = np.linspace(p.min(), p.max(), 100)
    plt.plot(x, y_test.size * mlab.normpdf(x, np.mean(p), np.std(p)), color=colors[i])
plt.title('CSI distributions')
plt.xlim([0, 10])
plt.ylim([0, y_test.size])
plt.legend(labels, loc='upper left', prop={'size': 9})
plt.xlabel('Customer Satisfaction Index')
plt.ylabel('Customers')
plt.tight_layout()