#
# Here we're setting variables so we don't have to keep entering these 
# strings. We can also now hide these values once, when we publish/share 
# this notebook.
#
import uuid

workspace_id='ff11c7e836424e0893675620a8341749'
authorization_token='fdf2c48c67d345459905ff25de7a8677'

# This is set here once so that any re-deployments of the web service below
# *replace* the existing web service, instead of creating a new one for 
# each deployment.

service_id = str(uuid.uuid4())

#
# This initializes the Azure Machine Learning Python Client, found:
# https://github.com/Azure/Azure-MachineLearning-ClientLibrary-Python
#
import pandas
from azureml import Workspace

ws = Workspace(
    workspace_id=workspace_id,
    authorization_token=authorization_token,
    endpoint='https://studioapi.azureml.net'
)

# In my workspace I have the data as a data set, I retrieve it for local 
# processing.

# This is how you read the data from a local file
frame = pandas.read_csv("DriverRisk.csv")

# This is how you read a dataset from the Azure Machine Learning Workspace and Convert it to a Pandas DataFrame.
#ds = ws.datasets['DriverRisk.csv']
#frame = ds.to_dataframe()

# Inspect the first few rows of data.
frame.head()

# Enumerate the existing column headings.
frame.columns

# Pick just the major determinants for the model
# TODO: Show the component analysis that motivates this selection.
feature_cols = ['ACCS', 'LANECS', 'TURNS', 'BRKS']

# Process the basic data into feature vector data and labeled category
# data. We use numpy and sklearn tools to massage the data.

import numpy as np
from sklearn.preprocessing import label_binarize

# Pull out features we care about and category labels
X = frame[feature_cols]
y_raw = frame.CATEGORY

# This creates four classes from the raw data
y = label_binarize(y_raw, classes=np.unique(y_raw))
n_classes = y.shape[1]

# We split the (limited amount of) data we have into training and test data.

import numpy as np
from sklearn.cross_validation import train_test_split

# Split data into train and test
random_state = np.random.RandomState(0)
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=.6, 
                                                    random_state=random_state)

# Here we actually instantiate and train the multi-classs classifier.

from sklearn import svm
from sklearn.multiclass import OneVsRestClassifier

# Build the one vs all classifier (and test it)
classifier = OneVsRestClassifier(svm.SVC(kernel='linear', probability=True, 
                                         random_state=random_state))

# Here we generate labels for the test data to compare against the actual
# labels.
y_score = classifier.fit(X_train, y_train).decision_function(X_test)

# We compute some basic statistics about the classifiers performance
# using the test data.

import numpy as np
obs = y_score
pred = y_test

mae = np.mean(abs(pred-obs))
rmse = np.sqrt(np.mean((pred-obs)**2))
rae = np.mean(abs(pred-obs))/np.mean(abs(obs-np.mean(obs)))
rse = np.mean((pred-obs)**2)/np.mean((obs-np.mean(obs))**2)

print("Mean Absolute Error: " + str(round(mae,6)))
print("Root Mean Squared Error: " + str(round(rmse,6)))
print("Relative Absolute Error: " + str(round(rae,6)))
print("Relative Squared Error: " + str(round(rse,6)))

# This shows how to generate the precision and recall curves.
# We generate these curves for each category.

from sklearn.metrics import precision_recall_curve
from sklearn.metrics import average_precision_score

# Compute Precision-Recall and plot curve
precision = dict()
recall = dict()
average_precision = dict()
for i in range(n_classes):
    precision[i], recall[i], _ = precision_recall_curve(y_test[:, i],
                                                        y_score[:, i])
    average_precision[i] = average_precision_score(y_test[:, i], y_score[:, i])

# Compute micro-average ROC curve and ROC area
precision["micro"], recall["micro"], _ = precision_recall_curve(y_test.ravel(),
    y_score.ravel())
average_precision["micro"] = average_precision_score(y_test, y_score,
                                                     average="micro")
# Later in the code ...

# Plot the precision and recall curves.
%matplotlib inline

import matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Plot Precision-Recall curve
plt.clf()
plt.plot(recall[0], precision[0], label='Precision-Recall curve')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.title('Precision-Recall example: AUC={0:0.2f}'.format(average_precision[0]))
plt.legend(loc="lower left")
plt.show()

# Plot Precision-Recall curve for each class
plt.clf()
plt.plot(recall["micro"], precision["micro"],
         label='micro-average Precision-recall curve (area = {0:0.2f})'
               ''.format(average_precision["micro"]))
for i in range(n_classes):
    plt.plot(recall[i], precision[i],
             label='Precision-recall curve of class {0} (area = {1:0.2f})'
                   ''.format(i, average_precision[i]))

plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.title('Extension of Precision-Recall curve to multi-class')
plt.legend(loc="lower right")
plt.show()

# This is how to deploy the model to Azure Machine Learning as a web
# service. By doing this, others can invoke the model with their telemetry
# data to get a risk rating for their data.
#
# This webservice is exactly the same as an Azure Machine Learning web
# service deployed from the AzureML Studio -- all the same examples and
# and sample code are available.

import uuid
from azureml import services

@services.publish(workspace_id, authorization_token)
# This is where we set the service_id, created above. Not including this
# line would result in a new service being created for each invocation.
@services.service_id(service_id)
@services.types(accs=float, lanecs=float, turns=float, brks=float)
@services.returns(float)
def demoservice(accs, lanecs, turns, brks):
    # predict the risk rating category
    return classifier.predict([accs, lanecs, turns, brks])

# Here's a simple test showing how to use the deployed web service.
test_row = 0
obs = y_raw.iloc[test_row]
feature_vec = X.iloc[test_row]
result = demoservice(feature_vec.ACCS, feature_vec.LANECS, 
                     feature_vec.TURNS, feature_vec.BRKS)
result