# splitting wine into good and bad groups, we're saying here that wines that have a quality score between
# 2-6.5 are "bad" quality, and wines that are  between 6.5 - 8 are "good"
bins = (2, 6.5, 8)
group_names = ['bad', 'good']
red_wine_df['quality'] = pd.cut(red_wine_df['quality'], bins = bins, labels = group_names)

# however "bad" and "good" aren't good naming conventions for a model to read in, so we're going to 
# assign a numeric label for this value. LabelEncoder() will help us do this!


# Assigning a label to our quality variable
label_quality = LabelEncoder()


# Now changing our dataframe to reflect our new label
red_wine_df['quality'] = label_quality.fit_transform(red_wine_df['quality'])

# printing the head to ensure the transformation happened
red_wine_df.head()

# extracting all model inputs from the data set
all_inputs = red_wine_df[['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar',
'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density',
'pH', 'sulphates', 'alcohol']].values
# extracting quality labels
all_labels = red_wine_df['quality'].values
# a test to see what the inputs look like
all_inputs[:2]

# Next we will apply standard scaling
# standard scaling allows us to normalize all of the data such 
# that the distribution will have a mean value of 0 and a standard deviation of 1
# this step is useful when we want to compare data that corresponds to different units
sc = StandardScaler()
all_inputs = sc.fit_transform(all_inputs)

# the function, train_test_split, will take our inputs and labels and split them out into training 
# and testing subsections for us
# test_size parameter = proprotion of data that should be kept aside for testing, in this case 1/4 of the data
# random_state = theseed used by the random number generator
(training_inputs,
testing_inputs,
training_classes,
testing_classes) = train_test_split(all_inputs, all_labels, test_size=0.25, random_state=1)

#trying decision tree classfier 
from sklearn.tree import DecisionTreeClassifier


# Create the classifier
decision_tree_classifier = DecisionTreeClassifier()


# Train the classifier on the training set
decision_tree_classifier.fit(training_inputs, training_classes)


# Validate the classifier on the testing set using classification accuracy
decision_tree_classifier.score(testing_inputs, testing_classes)

#selecting the models and the model names in an array
models=[LogisticRegression(),
        LinearSVC(),
        SVC(kernel='rbf'),
        KNeighborsClassifier(),
        RandomForestClassifier(),
        DecisionTreeClassifier(),
        GradientBoostingClassifier(),
        GaussianNB()]
model_names=['Logistic Regression',
             'Linear SVM',
             'rbf SVM',
             'K-Nearest Neighbors',
             'Random Forest Classifier',
             'Decision Tree',
             'Gradient Boosting Classifier',
             'Gaussian NB']


# creating an accuracy array and a matrix to join the accuracy of the models
# and the name of the models so we can read the results easier
acc=[]
m={}


# next we're going to iterate through the models, and get the accuracy for each
for model in range(len(models)):
     clf=models[model]
     clf.fit(training_inputs,training_classes)
     pred=clf.predict(testing_inputs)
     acc.append(accuracy_score(pred,testing_classes))


m={'Algorithm':model_names,'Accuracy':acc}


# just putting the matrix into a data frame and listing out the results
acc_frame=pd.DataFrame(m)
acc_frame