Wine Classification using k Nearest Neighbour from Scratch

Jul 17, 2023 | python machine-learning clustering matplotlib seaborn

I created a machine learning model to categorize types of Italian wine. This project features a custom implementation of the k Nearest Neighbour algorithm. I also developed the nested cross validation logic without using external libraries. The work explores model stability when handling data with Gaussian noise.

Back to Projects

Abstract

This project documents the development of a professional machine learning pipeline for wine classification using the Scikit Learn Wine dataset. It features a custom implementation of the k Nearest Neighbor algorithm and nested cross validation without reliance on external machine learning libraries. The study includes comprehensive exploratory data analysis and visualizes how Gaussian noise affects feature relationships and model stability. By evaluating multiple distance metrics such as Euclidean, Manhattan, Minkowski, and Cosine distances, the project demonstrates the impact of hyperparameter selection on classification performance.

Machine Learning Coursework

For the coursework, please make sure to implement your own code and not use libraries except where explicitly asked. You will need to present your own code that performs nested cross-validation and the k-nearest neighbour algorithm, build confusion matrices, and estimate distances between data samples.

The purpose of this coursework is to help you get familiar with common python modules and functions used for ML in python. It also provides practical experience implementing ML methods in python. You will gain experience regarding parameter selection for ML methods. Additionally, you will gain practical experience on evaluating ML methods and applying cross-validation.

Please do not use libraries that implement k-NN or cross-validation as we want to see your code. Remember to comment all of your code. You can also make use of Jupyter Markdown to improve the layout of your code and documentation. Please add docstrings to all of your functions so that users can get information on inputs and outputs. When a question allows a free-form answer, please create a new markdown cell below and answer the question in the notebook. Always save your notebook when you are done. Upload your completed notebook using the VLE.

Plagiarism: please make sure that the material you submit has been created by you. Any sources you use for code should be properly referenced. Your code will be checked for plagiarism using appropriate software.

Marking

The grades in this coursework are allocated approximately as follows:

	mark
Data exploration (+ 2 questions)	9
Code, docu. & comments (KNN + Evaluation + NCV)	12
Results (KNN folds + Summary + Confusion matrices)	9
Final questions:	9
Overall quality & use of Markdown	6
Total available	45

1. Exploratory Data Analysis

In this coursework, we are going to be working with the Wine dataset. This is a 178 sample dataset that categorises 3 different types of Italian wine using 13 different features. The code below loads the Wine dataset and selects a subset of features for you to work with.

# set matplotlib backend to inline
%matplotlib inline

# import modules
from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from copy import deepcopy as cp

# load data
wine=datasets.load_wine()
#print(wine.DESCR)

# this dataset has 13 features, we will only choose a subset of these
df_wine = pd.DataFrame(wine.data, columns = wine.feature_names )
selected_features = ['alcohol','flavanoids','color_intensity','ash']

# extract the data as numpy arrays of features, X, and target, y
X = df_wine[selected_features].values
y = wine.target

1.1. Visualising the data

The first part of tackling any ML problem is visualising the data in order to understand some of the properties of the problem at hand. When there are only a small number of classes and features, it is possible to use scatter plots to visualise interactions between different pairings of features.

The following image shows what such a visualisation might look like on the Iris dataset that you worked on during the Topic exercises.

Your first task is to recreate a similar grid for the Wine dataset, with each off-diagonal subplot showing the interaction between two features, and each of the classes represented as a different colour. The on-diagonal subplots (representing a single feature) should show a distribution (or histogram) for that feature.

You should create a function that, given data X and labels y, plots this grid. The function should be invoked something like this:

myplotGrid(X,y,...)

where X is your training data and y are the labels (you may also supply additional optional arguments). You can use an appropriate library to help you create the visualisation. You might want to code it yourself using matplotlib functions scatter and hist - however, this is not strictly necessary here, so try not spend too much time on this.

Get Row List

The function below is to find and extract the starting and ending positions of each target values. Returns a list as shown below.

[0,34,56,100]

The lists above means that the starting position of the first target value is 0 and the ending position is 33. Then, the starting of the second target value is 34 and the ending position is 55, and the pattern continues.

def getRowNoList(y:iter):

    """
    Returns the list of values that correspond to the starting and ending position of each target values

    Parameter
    ---------
    y : iter

    Returns
    -------
    list

    Examples
    --------
    How to use the list?
      Returns a list like [0,3,10,20]
      This means that the first target values starts from 0, and ends at 2
      Second target value starts from 3 to 9.
      Last target value starts from 10 until 19

    Warnings
    --------
    This function assumes that the list is sorted and in order based on the target values.
        For example:
        Expected input: [1,1,1,2,2,2,3,3]
        Returns: [0,3,6,7]

        Bad input: [0,1,0,1,0,0,1]
        Returns: [0,1,2,3,4,6,6]
    """

    # store the index values of the target, y
    rowNoList = [0]
    previousRow = None

    # loop through y to find out
    for rowNo, row in enumerate(y):

        # set the first value
        if previousRow == None:
            previousRow = row

        else:
            # if the previous row is not the same as current row
            if previousRow != row:

                # change the previous row
                previousRow = row
                # store the index when it is not the same
                rowNoList.append(rowNo)

            # append if it is the last value
            if rowNo == len(y)-1:
                rowNoList.append(rowNo)
    return rowNoList

Get My Colors

The function below is to set a fixed preset of colors that I would like to use throughout the notebook.

def getMyColors():

    """
    A predetermined list of colors for the use of plotting
    The colors that are in the list are predefined and allowed values from matplotlib, https://matplotlib.org/stable/gallery/color/named_colors.html

    Returns
    -------
    list
        A list of strings, values

    """

    return ['orange', 'seagreen', 'darkblue']

myplotGrid Function

# define plotting function
def myplotGrid(X, y):

    """
    Plots the dataset in a specific way based on a given example

    Parameters
    ---------
    X: iter
        The dataset
    y: iter
        The target values

    Warnings
    --------
    This function is predetermined to plot a specific way.
    Any other datasets with more than or less than 4 columns, will not work

    """

    # get the list of target value starting and ending position
    rowNoList = getRowNoList(y)

    # setting the figure and subplots
    fig = plt.subplots(4,4,figsize=(15,15))
    plotColumn = 0 # column pointer
    plotRow = 0 # row pointer
    colors = getMyColors() # cycle different fixed colors for different y values

    # loop through the columns in X
    for feature in X.columns:
        plotColumn += 1 # add 1 to point to the next column
        plotRow = 0 # reset the pointer

        # loop through the columns in X again
        for feature2 in X.columns:

            # indicate which plot to use amongst the subplot
            plt.subplot(4,4,plotColumn+plotRow)

            # if the columns are the same, plot a histogram
            if feature == feature2:
                for num in range(0, len(rowNoList)-1):
                    plt.hist(X[feature][rowNoList[num]:rowNoList[num+1]],
                    bins=10, color=colors[num], alpha=0.5)
                plt.xlabel(feature)

            # if the column are not the same, plot a scatter plot
            else:
                for num in range(0, len(rowNoList)-1):
                    plt.scatter(
                        X[feature][rowNoList[num]:rowNoList[num+1]],
                        X[feature2][rowNoList[num]:rowNoList[num+1]],
                        color=colors[num],
                        alpha=0.5)
                plt.xlabel(feature)
                plt.ylabel(feature2)

            plotRow+=4 # add 4 so that it points to the next row

    # insert a legend at the top right corner
    plt.legend("012", loc='center left', bbox_to_anchor=(1.05,4.25))
    plt.show()

# run the plotting function
df_X = pd.DataFrame(X, columns=selected_features) # make X into a dataframe
myplotGrid(df_X, y)

1.2. Exploratory Data Analysis under noise

When data are collected under real-world settings they usually contain some amount of noise that makes classification more challenging. In the cell below, invoke your exploratory data analysis function above on a noisy version of your data X.

Try to perturb your data with some Gaussian noise,

# initialize random seed to replicate results over different runs
mySeed = 12345
np.random.seed(mySeed)
XN=X+np.random.normal(0,0.5,X.shape)

and then invoke

myplotGrid(XN,y)

# noise code
# initialize random seed to replicate results over different runs
mySeed = 12345
np.random.seed(mySeed)

# adding the random normal/gaussian values to X
XN=X+np.random.normal(0,0.5,X.shape)

# convert the X with noise into a dataframe
df_XN = pd.DataFrame(XN, columns=selected_features)

myplotGrid(df_XN,y)

Q1. Exploratory data analysis

Based on your exploratory analysis, if you were to build a classifier using only two of the available features, which ones would you choose and why? Please answer as fully as you can.

Answer

Based on looking at the data visually with the current plots, the combinations of flavanoids and color intensity have more distinct separation between the types of wine. This observation holds true with or without the gaussian noise. Other combinations of using only two features seem to have many overlapping values that make it hard to distinguish from one another. However, this is only with a visual glance at the data without any processing done. The flavanoids and alcohol combination seem to be a good pick as well. However, it became less usable after the noise was added. It still seems to be the better second option compared to the rest. At the further end of each of the groups of data, we can see that the targets can still be uniquely identified. Towards the middle of the data, the separation is less clear as shown in the slightly transparent blue circle.

fig = plt.subplots(2,2,figsize=(10,10))

rowNoList = getRowNoList(y)
colors = getMyColors()

plt.subplot(2,2,1)
for num in range(0,len(rowNoList)-1):
    plt.scatter(
        df_X['flavanoids'][rowNoList[num]:rowNoList[num+1]],
        df_X['color_intensity'][rowNoList[num]:rowNoList[num+1]],
        color=colors[num],
        alpha=0.5)
plt.title("Before Noise")
plt.xlabel('flavanoids')
plt.ylabel('color_intensity')

plt.subplot(2,2,2)
for num in range(0,len(rowNoList)-1):
    plt.scatter(
        df_XN['flavanoids'][rowNoList[num]:rowNoList[num+1]],
        df_XN['color_intensity'][rowNoList[num]:rowNoList[num+1]],
        color=colors[num],
        alpha=0.5)
plt.title("After Noise")
plt.xlabel('flavanoids')
plt.ylabel('color_intensity')

plt.subplot(2,2,3)
for num in range(0,len(rowNoList)-1):
    plt.scatter(
        df_X['flavanoids'][rowNoList[num]:rowNoList[num+1]],
        df_X['alcohol'][rowNoList[num]:rowNoList[num+1]],
        color=colors[num],
        alpha=0.5)
plt.title("Before Noise")
plt.xlabel('flavanoids')
plt.ylabel('alcohol')

plt.subplot(2,2,4)
for num in range(0,len(rowNoList)-1):
    plt.scatter(
        df_XN['flavanoids'][rowNoList[num]:rowNoList[num+1]],
        df_XN['alcohol'][rowNoList[num]:rowNoList[num+1]],
        color=colors[num],
        alpha=0.5)
plt.scatter(1.67,12.6, s=10000, alpha=0.2)
plt.title("After Noise")
plt.xlabel('flavanoids')
plt.ylabel('alcohol')
plt.show()

Answer

If we were to use a correlation matrix to choose two features, we can see that the combination of flavanoids and color intensity is not the one with the highest absolute value. This is despite the fact that it visually looked like it had good separation of groups of data points. The correlation matrix would say otherwise because the color intensity and alcohol combination has the highest absolute value of 0.55. The other combination mentioned earlier has only got 0.17.

# Correlation of selected features
df_X.corr()

                  alcohol  flavanoids  color_intensity       ash
alcohol          1.000000    0.236815         0.546364  0.211545
flavanoids       0.236815    1.000000        -0.172379  0.115077
color_intensity  0.546364   -0.172379         1.000000  0.258887
ash              0.211545    0.115077         0.258887  1.000000

# Visualization for the correlation above
fig, ax = plt.subplots(figsize=(12,10))
sns.heatmap(df_X.corr(), annot=True)

Q2. Data with noise

What do you observe by plotting the data without noise compared to plotting with added Gaussian noise?

Answer

With the added noise to the data, it has made some of the combinations an even lesser choice than when there is no noise. One example is the combination of flavanoids and ash. Before the noise was added, it looked like it could be used to differentiate the types of wines. It may not be the obvious pick compared to the ones mentioned above, but it seemed usable. Once the noise is added, less distinction between the groups of data can be seen.

fig = plt.subplots(1,2,figsize=(10,5))

rowNoList = getRowNoList(y)
colors = getMyColors()

plt.subplot(1,2,1)
for num in range(0,len(rowNoList)-1):
    plt.scatter(
        df_X['flavanoids'][rowNoList[num]:rowNoList[num+1]],
        df_X['ash'][rowNoList[num]:rowNoList[num+1]],
        color=colors[num],
        alpha=0.5)
plt.title("Before Noise")
plt.xlabel('flavanoids')
plt.ylabel('ash')

plt.subplot(1,2,2)
for num in range(0,len(rowNoList)-1):
    plt.scatter(
        df_XN['flavanoids'][rowNoList[num]:rowNoList[num+1]],
        df_XN['ash'][rowNoList[num]:rowNoList[num+1]],
        color=colors[num],
        alpha=0.5)
plt.title("After Noise")
plt.xlabel('flavanoids')
plt.ylabel('ash')

plt.show()

2. Implementing kNN

In the cell below, develop your own code for performing k-Nearest Neighbour classification. You may use the scikit-learn k-NN implementation from the labs as a guide and as a way of verifying your results. It is important that your implementation does not use any libraries other than the basic numpy and matplotlib functions.

Define a function that performs k-NN given a set of data. Your function should be invoked in a way similar to this.

y* = mykNN(X,y,X*,options)

In this case, X is your training data and y is your training outputs. X_ are your testing data and y_ are your predicted outputs for X_. The options argument should at least contain the number of neighbours to consider as well as the distance function employed. You can implement this as a list or a set of separate arguments depending on how you choose to implement the function.

It helps to break the problem into various sub-problems that are implemented as helper functions. For example, you might want to implement separate functions for calculating the distances between two vectors. You could also create another function that uncovers the nearest neighbours to a given vector.

List of Distance Measure

The following are different types of distance measures that can be used for the K-Nearest Neighbour function. Different distance measures could change the result. Therefore, it could act as a parameter when optimizing the k-NN.

# list of distance measures
# euclidean distance
def euclidean_distance(x:iter, y:iter):

    """
    Returns the Euclidean Distance of two different list

    Parameters
    ----------
    x: iter
        list of int, float

    y: iter
        list of int, float

    Returns
    -------
    float


    Warnings
    --------
    This function assumes that a list will be provided. Even if it is only calculate a single value.
    If users want to calculate the distance between two points, an iterable must be provided.
    Expected Input: x = [10]
    Expected Input: y = [7]
    Returns: 3

    The function also works best with at least 2 values in the list, if there is only one value, it will act like a subtraction function.
    """

    distance = 0
    for pointer in range(0,len(x)):
        distance += (x[pointer] - y[pointer])**2
    return np.sqrt(distance)

# manhattan distance
def manhattan_distance(x:iter, y:iter):

    """
    Returns the Manhattan Distance of two different list

    Parameters
    ----------
    x: iter
        list of int, float

    y: iter
        list of int, float

    Returns
    -------
    float

    Warnings
    --------
    This function assumes that a list will be provided. Even if it is only calculate a single value.
    If users want to calculate the distance between two points, an iterable must be provided.
    Expected Input: x = [10]
    Expected Input: y = [7]
    Returns: 3

    The function also works best with at least 2 values in the list, if there is only one value, it will act like a subtraction function.
    """

    distance = 0
    for pointer in range(0,len(x)):
        distance += abs(x[pointer]-y[pointer])
    return distance

# minkowski distance
def minkowski_distance(x:iter, y:iter, p = 3):

    """
    Returns the Euclidean Distance of two different list

    Parameters
    ----------
    x: iter
        list of int, float

    y: iter
        list of int, float

    p: int/float, optional, default = 3
        Default for this value is 3, because 2 means it will function like Euclidean Distance. 1 for Manhattan Distance.

    Returns
    -------
    float


    Warnings
    --------
    This function assumes that a list will be provided. Even if it is only calculate a single value.
    If users want to calculate the distance between two points, an iterable must be provided.
    Expected Input: x = [10]
    Expected Input: y = [7]
    Returns: 3

    The function also works best with at least 2 values in the list, if there is only one value, it will act like a subtraction function.
    """

    distance = 0
    for pointer in range(0, len(x)):
        distance += abs(x[pointer]-y[pointer])**p
    return distance**(1/p)

# cosine distance
def cosine_distance(x:iter, y:iter):

    """
    Returns the Cosine Distance of two different list

    Parameters
    ----------
    x: iter
        will need to have at least 2 values in the iter for it to be useful

    y: iter
        will need to have at least 2 values in the iter for it to be useful

    Returns
    -------
    float

    Warnings
    --------
    This function requires user to have at least 2 values in their list because this function calculates the distance between a vector.
    For example:
    a = [110]
    y = [8]
    >> 0.0

    a = [5]
    y = [3]
    >> 0.0
    """

    nominator = 0
    denominator_x = 0
    denominator_y = 0

    for pointer in range(0, len(x)):
        nominator += x[pointer]*y[pointer]
        denominator_x += x[pointer]**2
        denominator_y += y[pointer]**2

    return 1 - ((nominator / (np.sqrt(denominator_x) * np.sqrt(denominator_y))))

Create a List of Distance Measure

# calculate the list of distances
def listDistanceMeasures(x, X:iter, distance_measure:str, minkowski_p = 3):

    """
    Returns a list of distance measure calculated from the values in x against all the values in X

    Parameters
    ----------
    x: iter
        Contain a list of values from the columns it is from

    X: iter
        Contain a list of values from the columns it is from

    distance_measure: str
        Strictly only accepts [EUCLIDEAN, MANHATTAN, CITYBLOCK, MINKOWSKI, COSINE]

    minkowski_p: int/float, optional, default =
        Default for this value is 3, so that result can vary. This is because a value of 2, p = 2, means it will function like Euclidean Distance and p = 1 for Manhattan Distance.

    Returns
    -------
    list
        Returns a list of distance measure

    Raises
    ------
    Exception
        Prompts exception if the input for distance_measure is not of the expected values, [EUCLIDEAN, MANHATTAN, CITYBLOCK, MINKOWSKI, COSINE]

    Warnings
    --------
    This function assumes that user will provide the x and X wtih values of the same number of columns and dimension.
    If x consists of a list of 3 values, the X should consists a collection of list of a similar size.
    For example, if the inputs are:

    a = [10,10,10]
    b = [[10,10],[10,10],[10,10]]
    >> IndexError: list index out of range

    a = [[10,10],[10,10]]
    b = [[[10,10],[10,10]],[[10,10],[10,10]]]
    >> TypeError: unsupported operand type(s) for -: 'list' and 'int'

    """

    result = []

    # loop X
    for dataPoint in X:

        # if distance measure is Euclidean distance
        if distance_measure.upper() == "EUCLIDEAN":
            result.append(euclidean_distance(x,dataPoint))

        # if distance measure is Manhattan distance or Cityblock method
        elif distance_measure.upper() == "MANHATTAN" or distance_measure == "CITYBLOCK":
            result.append(manhattan_distance(x,dataPoint))

        # if distance measure is Minkowski distance
        elif distance_measure.upper() == "MINKOWSKI":
            result.append(minkowski_distance(x, dataPoint, minkowski_p))

        # if distance measure is Consine distance
        elif distance_measure.upper() == "COSINE":
            result.append(cosine_distance(x, dataPoint))

        else:
        # if distance measure parameter not within the choice
            raise Exception("distance_measure only take these options: ['EUCLIDEAN', 'MANHATTAN' or 'CITYBLOCK', 'MINKOWSKI', 'COSINE']")

    return result

Predict/Decide y Value

# decide the target value
def decideValue(nearestNeighbours, targetValues):

    """
    Takes a list of values and decide which target group the given value belongs to

    Parameters
    ----------
    nearestNeighbours: iter
        list of values that are closest to a given point

    targetValues: iter
        list of values of y

    Returns
    -------
    int
        the most voted y value
    """

    # using the index of nearest neighbours, get their y values
    candidates = targetValues[nearestNeighbours]

    # count y values' occurrence
    majorityVotes = {}

    for candidate in candidates:
        if candidate not in majorityVotes.keys():
            majorityVotes[candidate] = 1
        else:
            majorityVotes[candidate] += 1
    #print("Majority Votes:", majorityVotes)

    # find the which y value has the highest count in count list
    maxCountKey = [key for key, value in majorityVotes.items() if value == max(majorityVotes.values())]
    #print("maxCountKey:", maxCountKey)

    # TIEBREAKER
    # if there are more than one y value, or keys
    if len(maxCountKey) > 1:

        # if the first and second values are not equal
        if nearestNeighbours[0] != nearestNeighbours[1]:
            return targetValues[nearestNeighbours[0]] # use the value with shortest distance

        # if the first and second values are equal
        else:
            return targetValues[nearestNeighbours[np.random.randint(2)]] # randomly select between the two
    else:
        # return the only value in the list
        return maxCountKey[0]

myKNN

# mykNN code

def mykNN(X,y,k,distance_measure,trainIndex,testIndex):

    """

    Parameters
    ----------
    X:iter
        the full dataset

    y:iter
        the list of target values corresponding to the dataset

    k:int
        the number of neighbours for the nearest neighbour algorithm

    distance_measure:list
        the list of distance measure method

    trainIndex
        the list of indices that is used for training

    testIndex
        the list of indices used for testing

    Returns
    -------
    list
        returns a list of the predicted values

    """

    yPredicted = []
    X_train = X[trainIndex]
    y_train = y[trainIndex]

    # loop throught X
    for dataPoint in X_train:
        # calculate distance between the data point and list of X
        distanceMeasureList = listDistanceMeasures(dataPoint, X_train, distance_measure)

        # list the index of nearest neighbours
        # need to start from the 2nd value of the list because the closest data point and the lowest distance measure is itself.
        nearestNeighboursIndex = np.argsort(distanceMeasureList)[1:k+1]
        #print("nearest neighbours",nearestNeighboursIndex)
        #print("y values:", y_train[nearestNeighboursIndex])

        # append the decided y to result
        yPredicted.append(decideValue(nearestNeighboursIndex, y_train))
        #print(a)

    # set the test dataset and y test
    X_test = X[testIndex]
    y_test = y[testIndex]

    # this will be used to store the previous set and the test set gradually
    growingIndex = cp(trainIndex)

    # looping the X test set
    for counter, dataPoint in enumerate(X_test):

        # appends the current X test point
        growingIndex.append(testIndex[counter])

        # list the distance between what is in Xtrain with the new X test point added
        distanceMeasureList = listDistanceMeasures(dataPoint,X[growingIndex],distance_measure)

        # list the indices of nearest neighbours that are in the distanceMeasureList according to the value of k
        nearestNeighboursIndex = np.argsort(distanceMeasureList)[1:k+1]

        #
        yPredicted.append(decideValue(nearestNeighboursIndex, y[growingIndex[:len(growingIndex)]]))

    # based on the requirements above, the function need to return the predicted values
    return yPredicted

3. Classifier evaluation [3 pts]

In the cell below, implement your own classifier evaluation code. This should include some way of calculating confusion matrices, as well as common metrics like accuracy.

Write some additional code that lets you display the output of your confusion matrices in a useful and easy-to-read manner.

You might want to test your functions on some test data, and compare the results to the sklearn library versions.

class classifierEvaluator:
    """
    Evaluates the Classifier with Actual Values and Predicted Values

    Attributes
    ----------
    actualValues: iter
        The list of actual values. The correct and definite value of the classification

    predictedValues: iter
        The list of predicted values from the classifier

    Methods
    -------
    accuracy()
        returns the accuracy for the predicted values

    confusionMatrix()
        returns a dictionary consisting of the confusion matrix for the predicted values

    description()
        prints the list of all the statistical measure available in the class

    errorRate()
        returns the error rate, which is 1 - accuracy

    recall(classValue:int)
        returns the recall of the given class value

    precision(classValue:int)
        returns the precision of a given class value

    specificity(classValue:int)
        returns the specificity of a given class value

    fmeasure(recall, fmeasure, classValue)
        returns the fmeasure of a given class value

    truePositive(classValue)
        returns the true positive rate of a given class value

    trueNegative(classValue)
        return the true negative rate of a given class value

    falsePositive(classValue)
        returns the false positive rate of a given class value

    falseNegative(classValue)
        returns the false negative rate of a given class value

    """

    def __init__(self, actualValues:iter, predictedValues:iter):
        self.actualValues = actualValues
        self.predictedValues = predictedValues

        # get list of unique values from both list
        result = []
        uniqueActualValues = np.unique(actualValues) # get unique values from actual value list
        uniquePredictedValues = np.unique(predictedValues) # get unique values from predicted value list

        # get both lists of unique values
        for actual in uniqueActualValues:
            result.append(actual)
        for predicted in uniquePredictedValues:
            result.append(predicted)

        # get unique values from both unique lists
        self.classValues = np.unique(result)

    # accuracy
    def accuracy(self):

        """
        Returns the accuracy of the predicted values.

        Returns
        -------
        float

        """

        result = 0
        for row in range(0,len(self.actualValues)):
            if self.actualValues[row] == self.predictedValues[row]:
                result += 1
        return result/len(self.actualValues)

    # error rate - 1 - accuracy
    def _getErrorRate(self):

        """

        Returns
        -------
        float
            accuracy - 1

        """
        return 1 - self.accuracy()

    def errorRate(self):
        return self._getErrorRate()

    # recall - True Positive / True Positive + False Negatives
    def _getRecall(self, classValue):

        """
        returns the recall value of a specific class

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """
        tp = self._getTruePositive(classValue)
        fn = self._getFalseNegative(classValue)

        return tp / (tp + fn)

    def recall(self, classValue):
        return self._getRecall(classValue)

    # precision - True Positive / True Positive + False Positive
    def _getPrecision(self, classValue):

        """
        returns the precision value of a specific class

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """
        tp = self._getTruePositive(classValue)
        fp = self._getFalsePositive(classValue)

        return tp / (tp + fp)

    def precision(self, classValue):
        return self._getRecall(classValue)

    # specificity - True Negative / True Negative + False Positive
    def _getSpecificity(self, classValue):

        """
        returns the specificity value of a specific class

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """
        tn = self._getTrueNegative(classValue)
        fp = self._getFalsePositive(classValue)

        return tn / (tn + fp )

    def specificity(self, classValue):
        return self._getSpecificity(classValue)

    # F-measure - 2 * Recall * Precision / Recall + Precision
    def _get_fMeasure(self, classValue):
        """
        returns the recall value of a specific class

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """
        recall = self._getRecall(classValue)
        precision = self._getPrecision(classValue)

        if recall == 0 and precision == 0:
            return 0
        else:
            return 2 * recall * precision / (recall + precision)

    def fMeasure(self, classValue):
        return self._get_fMeasure(classValue)

    # all result

    def _getConfusionMatrix(self):

        """
        Returns the confusion matrix

        Returns
        -------
        dict
            a dictionary consisting of each class value

        """
        results = []

        for classValue in self.classValues:
            classDict = {}

            for classValue2 in self.classValues:
                classDict[classValue2] = 0

            for row in range(0, len(self.actualValues)):

                predicted = self.predictedValues[row]
                actual = self.actualValues[row]

                if classValue == actual:
                    classDict[predicted] += 1

            results.append(classDict)

        return results

    def confusionMatrix(self):
        return self._getConfusionMatrix()

    def printConfusionMatrix(self):

        print("Confusion Matrix ==========")

        print("Predicted Values:  ", end="")
        for classValue in self.classValues:
            print("    {}|".format(classValue),end="")
        print()

        for rowNo, result in enumerate(self._getConfusionMatrix()):
            print("Actual Values: {} - ".format(self.classValues[rowNo]),end = "")
            for value in result.values():
                lenStrVal = len(str(value))
                if lenStrVal == 1:
                    print("   ", value, end = " ")
                elif lenStrVal == 2:
                    print("  ", value, end = " ")
                elif lenStrVal == 3:
                    print(" ",value,end = " ")
                else:
                    print(value,end= " ")
            print()

    # “true positive” for correctly predicted event values.
    def _getTruePositive(self, classValue):
        """
        returns true positive of a given class value

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """
        confusionMatrix = self._getConfusionMatrix()
        return confusionMatrix[classValue][classValue]

    def truePositive(self, classValue):
        return self._getTruePositive(classValue)

    # “false positive” for incorrectly predicted event values.
    def _getFalsePositive(self, classValue):

        """
        returns false positive of a given class value

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """

        confusionMatrix = self._getConfusionMatrix()
        result = 0
        for classValueLoop in self.classValues:
            if classValueLoop != classValue:
                result += confusionMatrix[classValueLoop][classValue]
        return result

    def falsePositive(self, classValue):
        return self._getFalsePositive(classValue)

    # “true negative” for correctly predicted no-event values.
    def _getTrueNegative(self, classValue):

        """
        returns true negative of a given class value

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """

        confusionMatrix = self._getConfusionMatrix()
        result = 0

        for classValueLoop in self.classValues:
            if classValueLoop != classValue:
                for value in confusionMatrix[classValueLoop]:
                    if value != classValue:
                        result += confusionMatrix[classValueLoop][value]
        return result

    def trueNegative(self, classValue):
        return self._getTrueNegative(classValue)

    # “false negative” for incorrectly predicted no-event values.
    def _getFalseNegative(self, classValue):

        """
        returns false negative of a given class value

        Parameters
        ----------
        classValue:int
            the desired class value

        Returns
        -------
        float

        """
        confusionMatrix = self._getConfusionMatrix()

        result = 0
        for value in confusionMatrix[classValue]:
            if value != classValue:
                result += confusionMatrix[classValue][value]
        return result

    def falseNegative(self, classValue):
        return self._getFalseNegative(classValue)

    def description(self):
        """
        prints the all the stats available for the confusion matrix and the performance of the classifier

        """
        self.printConfusionMatrix()

        print("\nAccuracy: {:.2f}%".format(self.accuracy()*100))
        print("Error Rate: {:.2f}%".format(self._getErrorRate()*100))

        for classValue in self.classValues:

            tp = self._getTruePositive(classValue)
            tn = self._getTrueNegative(classValue)
            fp = self._getFalsePositive(classValue)
            fn = self._getFalseNegative(classValue)

            print("\nClass: ", classValue)
            print("TP - {}".format(tp), end =" | ")
            print("TN - {}".format(tn), end =" | ")
            print("FP - {}".format(fp), end =" | ")
            print("FN - {}".format(fn), end =" | ")
            print()

            print("  {:.2f}% - Recall:".format(self._getRecall(classValue)*100),end="")
            print(" TP / TP + FN")
            print("  {:.2f}% - Precision:".format(self._getPrecision(classValue)*100),end="")
            print(" TP / TP + FP")
            print("  {:.2f}% - Specificity:".format(self._getSpecificity(classValue)*100),end="")
            print(" TN / TN + FP")
            print("  {:.2f}% -".format(self._get_fMeasure(classValue)*100), end="")
            print(" Fmeasure: ", end="")
            print(" 2 * Recall * Precision / (Recall + Precision)")
            print()

# test evaluation code
np.random.seed(mySeed)
indicesOrder = np.random.permutation(np.arange(0,len(X),1))
trainIndex = list(indicesOrder[:150])
testIndex = indicesOrder[150:]
y_ = mykNN(X,y,10,"euclidean",trainIndex,testIndex)

evaluation = classifierEvaluator(y[testIndex], y_[-len(testIndex):])
evaluation.description()

Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     0     0
Actual Values: 1 -     1    11     0
Actual Values: 2 -     0     0     8

Accuracy: 96.43%
Error Rate: 3.57%

Class:  0
TP - 8 | TN - 19 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 16 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 20 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

4. Nested Cross-validation using your implementation of k-NN

In the cell below, please develop your own code for performing 5-fold nested cross-validation along with your implementation of k-NN. You must write your own code. The scikit-learn module may only be used for verification purposes.

Your code for nested cross-validation should invoke your kNN function. The cross validation function should be invoked in a way similar to this.

accuracies_fold = myNestedCrossVal(X,y,5,list(range(1,11)),['euclidean','manhattan'],mySeed)

In this example, X is your data matrix that contains all samples and features for each sample. The number 5 is the number of folds, and y represents your known output labels. The range evaluates the neighbour parameter from 1 to 10. The list evaluates the distances on the validation sets. Finally, mySeed is a random seed to enable us to replicate your results.

Notes

You should perform nested cross-validation on both your original data and the data perturbed by noise. You should evaluate at least two distance functions and a number of neighbours from 1 to 10. Your function should return a list of accuracies per fold. For each fold, your function should print the following information.

The accuracy per distinct set of parameters on the validation set.
The best set of parameters for the fold after validation.
The confusion matrix per fold on the testing set.


# myNestedCrossVal code

def myNestCrossVal(X,y,nFolds,K,distanceMeasureMethods,mySeed,accuracy_base):

    """
    Performs KNN with Cross Validation

    Parameters
    ----------
    X:iter
        full dataset

    y:iter
        list of actual target values

    nFolds:int
        number of folds or the number of division of dataset desired

    K:int
        number of nearest neighbour for the kNN to take into consideration for voting

    distanceMeasureMethods:iter
        list of so distance measure methods to use

    mySeed:int
        a value to make sure that the random values generated are repeatable

    accuracy_base
        returns the accuracy using only the test size or the whole entire dataset

    Returns
    -------
    list
      consisting of 3 dictionaries, with the parameters as keys, and accuracy as value.

        First dictionary consists of the final accuracy of each run
            {'euclidean | K-Neighbour: 1': 28.764, 'euclidean | K-Neighbour: 2': 28.764, .... 'cosine | K-Neighbour: 9': 28.427, 'cosine | K-Neighbour: 10': 28.652}

        Second dictionary consists of the accuracy of values of each fold
            {'euclidean | K-Neighbours: 1 | Fold: 0': 37.64, 'euclidean | K-Neighbours: 1 | Fold: 1': 33.708, .... 'cosine | K-Neighbours: 10 | Fold: 4': 38.202}

        Third dictionary consists of the confusion matrix, recall, precision, specificity, fmeasure, tn, tp, fn, fp of every parameter

    Warnings
    --------
    distanceMeasureMethods
        assumes users will strictly only use ['EUCLIDEAN', 'MANHATTAN', 'CITYBLOCK', 'MINKOWSKI', 'COSINE']

    accuracy_base
        assumes users will strictly only use ['FULL', 'TEST']

    """

    # initiate the dictionaries
    finalResults = {}
    finalFoldResults = {}
    confusionMatrixResults = {}

    # set random seed
    np.random.seed(mySeed)

    # permutation done on the indices
    indicesOrder = np.random.permutation(np.arange(0,len(X),1))

    # split it into the desire number of folds
    indices = np.array_split(indicesOrder,nFolds)

    # looping the distance methods
    for distanceMeasureMethod in distanceMeasureMethods:

        # looping the K list
        for k in K:

            finalAccuracy = 0

            # looping the different
            for foldNo, fold in enumerate(indices):

                # test fold is the current fold in indices
                testFold = fold

                # drop current fold, remaining will be the training folds
                remainingFolds = np.delete(range(0,nFolds),foldNo)

                # to store the indices used for training
                trainingFolds = []

                # looping through the remaining folds
                for remainingFold in remainingFolds:

                    # loop through the values inside the remaining fold
                    for value in indices[remainingFold]:

                        # append it to the training folds list, so that all of them are in one list
                        trainingFolds.append(value)

                # run the kNN
                y_ = mykNN(X, y, k, distanceMeasureMethod,trainingFolds,testFold)

                # if the accuracy base is 'TEST', only use the testing set as denominator
                if accuracy_base.upper() == 'TEST':
                    result = cp(classifierEvaluator(y[testFold],y_[-(len(testFold)):]))

                # if the accuracy base is 'FULL', use the full dataset into consideration including the training set
                elif accuracy_base.upper() == 'FULL':
                    result = cp(classifierEvaluator(y,y_))

                # else raise an exception as accuracy_base strictly only receives FULL and TEST
                else:
                    raise Exception("accuracy_base strictly only accepts 'FULL' or 'TEST'")


                foldResultKey = distanceMeasureMethod + " | K-Neighbours: " + str(k) + " | Fold: " + str(foldNo)
                finalFoldResults[foldResultKey] = round(result.accuracy()*100, 3)
                print(foldResultKey," ================================================")
                print(result.description())
                print("============================================================")

                # add all the required things to confusion matrix dictionary
                for classValue in result.classValues:
                    baseKey = distanceMeasureMethod + " - k=" + str(k) + " - " + "class=" + str(classValue) + " - "

                    # tp
                    if (baseKey + "tp") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "tp"] += result.truePositive(classValue)
                    else:
                        confusionMatrixResults[baseKey + "tp"] = result.truePositive(classValue)

                    # tn
                    if (baseKey + "tn") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "tn"] += result.trueNegative(classValue)
                    else:
                        confusionMatrixResults[baseKey + "tn"] = result.trueNegative(classValue)

                    # fp
                    if (baseKey + "fp") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "fp"] += result.falsePositive(classValue)
                    else:
                        confusionMatrixResults[baseKey + "fp"] = result.falsePositive(classValue)

                    # fn
                    if (baseKey + "fn") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "fn"] += result.falseNegative(classValue)
                    else:
                        confusionMatrixResults[baseKey + "fn"] = result.falseNegative(classValue)

                    # recall
                    if (baseKey + "recall") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "recall"] += result.recall(classValue)
                    else:
                        confusionMatrixResults[baseKey + "recall"] = result.recall(classValue)

                    # precision
                    if (baseKey + "precision") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "precision"] += result.precision(classValue)
                    else:
                        confusionMatrixResults[baseKey + "precision"] = result.precision(classValue)

                    # specificity
                    if (baseKey + "specificity") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "specificity"] += result.specificity(classValue)
                    else:
                        confusionMatrixResults[baseKey + "specificity"] = result.specificity(classValue)

                    # fmeasure
                    if (baseKey + "fmeasure") in confusionMatrixResults:
                        confusionMatrixResults[baseKey + "fmeasure"] += result.fMeasure(classValue)
                    else:
                        confusionMatrixResults[baseKey + "fmeasure"] = result.fMeasure(classValue)

                    if foldNo == nFolds-1:
                        confusionMatrixResults[baseKey + "recall"] /= nFolds
                        confusionMatrixResults[baseKey + "precision"] /= nFolds
                        confusionMatrixResults[baseKey + "specificity"] /= nFolds
                        confusionMatrixResults[baseKey + "fmeasure"] /= nFolds

                if foldNo == nFolds-1:
                    resultKey = distanceMeasureMethod + " | K-Neighbour: " + str(k)
                    finalAccuracy += result.accuracy()
                    finalResults[resultKey] = round(finalAccuracy / nFolds * 100, 3)

                else:

                    finalAccuracy += result.accuracy()


    return [finalResults, finalFoldResults, confusionMatrixResults]

Results

The code block below prints out a long list of confusion matrices at every fold. It also displays the final accuracy results.

# set the groups of parameters
nFolds = 5
K = [x for x in range(1,11)]
distanceMeasureMethods = ["Euclidean", "Manhattan", "Minkowski", "Cosine"]
mySeed = 12345

# evaluate clean data code
print("EVALUATING CLEAN DATA =================")
cleanResults = myNestCrossVal(X,y,nFolds,K,distanceMeasureMethods,mySeed,'test')
print("Fold Level Details -------------------------------------------------------")
for cleanResult in cleanResults[1]:
    print(cleanResult, " - ", cleanResults[1][cleanResult])

print("Overall Accuracy -------------------------------------------------")
for cleanResult in cleanResults[0]:
    print(cleanResult, " - ", cleanResults[0][cleanResult])

# evaluate noisy data code
print("EVALUATING NOISY DATA ==================")
print("Fold Level Details -------------------------------------------------------")
noisyResults = myNestCrossVal(XN,y,nFolds,K,distanceMeasureMethods,mySeed,'test')
for noisyResult in noisyResults[1]:
    print(noisyResult, " - ", noisyResults[1][noisyResult])

print("Overall Accuracy -------------------------------------------------")
for noisyResult in noisyResults[0]:
    print(noisyResult, " - ", noisyResults[0][noisyResult])

Code Output

EVALUATING CLEAN DATA =================
Euclidean | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     1     7

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 17 | FP - 2 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  88.24% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     1     7

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 17 | FP - 2 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  88.24% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     1    14     1
Actual Values: 2 -     0     1     7

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     1    14     1
Actual Values: 2 -     0     1     7

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 11 | TN - 22 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 0 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     0     8

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 18 | FP - 1 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  93.75% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  93.75% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     0     8

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 18 | FP - 1 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  93.75% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  93.75% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 19 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 21 | FP - 0 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 2 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    13     1
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 2 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    13     1
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 3 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 20 | FP - 1 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 19 | FP - 4 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 24 | FP - 1 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  73.68% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 8 | TN - 22 | FP - 2 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  76.19% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 8 | TN - 22 | FP - 2 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  76.19% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 15 | FP - 4 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  78.95% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     2    11     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 2 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 21 | FP - 1 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 3 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 24 | FP - 1 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     2    11     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 2 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 21 | FP - 1 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Fold Level Details -------------------------------------------------------
Euclidean | K-Neighbours: 1 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 1 | Fold: 1  -  88.889
Euclidean | K-Neighbours: 1 | Fold: 2  -  91.667
Euclidean | K-Neighbours: 1 | Fold: 3  -  91.429
Euclidean | K-Neighbours: 1 | Fold: 4  -  94.286
Euclidean | K-Neighbours: 2 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 2 | Fold: 1  -  88.889
Euclidean | K-Neighbours: 2 | Fold: 2  -  91.667
Euclidean | K-Neighbours: 2 | Fold: 3  -  91.429
Euclidean | K-Neighbours: 2 | Fold: 4  -  94.286
Euclidean | K-Neighbours: 3 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 3 | Fold: 1  -  94.444
Euclidean | K-Neighbours: 3 | Fold: 2  -  94.444
Euclidean | K-Neighbours: 3 | Fold: 3  -  88.571
Euclidean | K-Neighbours: 3 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 4 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 4 | Fold: 1  -  91.667
Euclidean | K-Neighbours: 4 | Fold: 2  -  94.444
Euclidean | K-Neighbours: 4 | Fold: 3  -  88.571
Euclidean | K-Neighbours: 4 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 5 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 5 | Fold: 1  -  94.444
Euclidean | K-Neighbours: 5 | Fold: 2  -  94.444
Euclidean | K-Neighbours: 5 | Fold: 3  -  88.571
Euclidean | K-Neighbours: 5 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 6 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 6 | Fold: 1  -  91.667
Euclidean | K-Neighbours: 6 | Fold: 2  -  94.444
Euclidean | K-Neighbours: 6 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 6 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 7 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 7 | Fold: 1  -  94.444
Euclidean | K-Neighbours: 7 | Fold: 2  -  91.667
Euclidean | K-Neighbours: 7 | Fold: 3  -  88.571
Euclidean | K-Neighbours: 7 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 8 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 8 | Fold: 1  -  94.444
Euclidean | K-Neighbours: 8 | Fold: 2  -  91.667
Euclidean | K-Neighbours: 8 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 8 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 9 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 9 | Fold: 1  -  94.444
Euclidean | K-Neighbours: 9 | Fold: 2  -  88.889
Euclidean | K-Neighbours: 9 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 9 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 10 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 10 | Fold: 1  -  94.444
Euclidean | K-Neighbours: 10 | Fold: 2  -  88.889
Euclidean | K-Neighbours: 10 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 10 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 1 | Fold: 0  -  94.444
Manhattan | K-Neighbours: 1 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 1 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 1 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 1 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 2 | Fold: 0  -  94.444
Manhattan | K-Neighbours: 2 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 2 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 2 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 2 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 3 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 3 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 3 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 3 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 3 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 4 | Fold: 0  -  94.444
Manhattan | K-Neighbours: 4 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 4 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 4 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 4 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 5 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 5 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 5 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 5 | Fold: 3  -  91.429
Manhattan | K-Neighbours: 5 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 6 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 6 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 6 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 6 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 6 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 7 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 7 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 7 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 7 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 7 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 8 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 8 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 8 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 8 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 8 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 9 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 9 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 9 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 9 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 9 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 10 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 10 | Fold: 1  -  94.444
Manhattan | K-Neighbours: 10 | Fold: 2  -  91.667
Manhattan | K-Neighbours: 10 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 10 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 1 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 1 | Fold: 1  -  88.889
Minkowski | K-Neighbours: 1 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 1 | Fold: 3  -  94.286
Minkowski | K-Neighbours: 1 | Fold: 4  -  94.286
Minkowski | K-Neighbours: 2 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 2 | Fold: 1  -  88.889
Minkowski | K-Neighbours: 2 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 2 | Fold: 3  -  94.286
Minkowski | K-Neighbours: 2 | Fold: 4  -  94.286
Minkowski | K-Neighbours: 3 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 3 | Fold: 1  -  91.667
Minkowski | K-Neighbours: 3 | Fold: 2  -  94.444
Minkowski | K-Neighbours: 3 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 3 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 4 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 4 | Fold: 1  -  91.667
Minkowski | K-Neighbours: 4 | Fold: 2  -  94.444
Minkowski | K-Neighbours: 4 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 4 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 5 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 5 | Fold: 1  -  94.444
Minkowski | K-Neighbours: 5 | Fold: 2  -  94.444
Minkowski | K-Neighbours: 5 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 5 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 6 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 6 | Fold: 1  -  91.667
Minkowski | K-Neighbours: 6 | Fold: 2  -  94.444
Minkowski | K-Neighbours: 6 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 6 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 7 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 7 | Fold: 1  -  94.444
Minkowski | K-Neighbours: 7 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 7 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 7 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 8 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 8 | Fold: 1  -  94.444
Minkowski | K-Neighbours: 8 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 8 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 8 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 9 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 9 | Fold: 1  -  91.667
Minkowski | K-Neighbours: 9 | Fold: 2  -  88.889
Minkowski | K-Neighbours: 9 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 9 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 10 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 10 | Fold: 1  -  94.444
Minkowski | K-Neighbours: 10 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 10 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 10 | Fold: 4  -  97.143
Cosine | K-Neighbours: 1 | Fold: 0  -  83.333
Cosine | K-Neighbours: 1 | Fold: 1  -  91.667
Cosine | K-Neighbours: 1 | Fold: 2  -  88.889
Cosine | K-Neighbours: 1 | Fold: 3  -  85.714
Cosine | K-Neighbours: 1 | Fold: 4  -  91.429
Cosine | K-Neighbours: 2 | Fold: 0  -  83.333
Cosine | K-Neighbours: 2 | Fold: 1  -  91.667
Cosine | K-Neighbours: 2 | Fold: 2  -  88.889
Cosine | K-Neighbours: 2 | Fold: 3  -  85.714
Cosine | K-Neighbours: 2 | Fold: 4  -  91.429
Cosine | K-Neighbours: 3 | Fold: 0  -  86.111
Cosine | K-Neighbours: 3 | Fold: 1  -  94.444
Cosine | K-Neighbours: 3 | Fold: 2  -  88.889
Cosine | K-Neighbours: 3 | Fold: 3  -  82.857
Cosine | K-Neighbours: 3 | Fold: 4  -  97.143
Cosine | K-Neighbours: 4 | Fold: 0  -  86.111
Cosine | K-Neighbours: 4 | Fold: 1  -  94.444
Cosine | K-Neighbours: 4 | Fold: 2  -  88.889
Cosine | K-Neighbours: 4 | Fold: 3  -  82.857
Cosine | K-Neighbours: 4 | Fold: 4  -  97.143
Cosine | K-Neighbours: 5 | Fold: 0  -  86.111
Cosine | K-Neighbours: 5 | Fold: 1  -  91.667
Cosine | K-Neighbours: 5 | Fold: 2  -  88.889
Cosine | K-Neighbours: 5 | Fold: 3  -  82.857
Cosine | K-Neighbours: 5 | Fold: 4  -  94.286
Cosine | K-Neighbours: 6 | Fold: 0  -  86.111
Cosine | K-Neighbours: 6 | Fold: 1  -  91.667
Cosine | K-Neighbours: 6 | Fold: 2  -  88.889
Cosine | K-Neighbours: 6 | Fold: 3  -  82.857
Cosine | K-Neighbours: 6 | Fold: 4  -  94.286
Cosine | K-Neighbours: 7 | Fold: 0  -  86.111
Cosine | K-Neighbours: 7 | Fold: 1  -  88.889
Cosine | K-Neighbours: 7 | Fold: 2  -  86.111
Cosine | K-Neighbours: 7 | Fold: 3  -  82.857
Cosine | K-Neighbours: 7 | Fold: 4  -  94.286
Cosine | K-Neighbours: 8 | Fold: 0  -  86.111
Cosine | K-Neighbours: 8 | Fold: 1  -  91.667
Cosine | K-Neighbours: 8 | Fold: 2  -  88.889
Cosine | K-Neighbours: 8 | Fold: 3  -  82.857
Cosine | K-Neighbours: 8 | Fold: 4  -  94.286
Cosine | K-Neighbours: 9 | Fold: 0  -  88.889
Cosine | K-Neighbours: 9 | Fold: 1  -  91.667
Cosine | K-Neighbours: 9 | Fold: 2  -  88.889
Cosine | K-Neighbours: 9 | Fold: 3  -  85.714
Cosine | K-Neighbours: 9 | Fold: 4  -  94.286
Cosine | K-Neighbours: 10 | Fold: 0  -  88.889
Cosine | K-Neighbours: 10 | Fold: 1  -  91.667
Cosine | K-Neighbours: 10 | Fold: 2  -  91.667
Cosine | K-Neighbours: 10 | Fold: 3  -  85.714
Cosine | K-Neighbours: 10 | Fold: 4  -  94.286
Overall Accuracy -------------------------------------------------
Euclidean | K-Neighbour: 1  -  92.698
Euclidean | K-Neighbour: 2  -  92.698
Euclidean | K-Neighbour: 3  -  94.365
Euclidean | K-Neighbour: 4  -  93.81
Euclidean | K-Neighbour: 5  -  94.365
Euclidean | K-Neighbour: 6  -  93.238
Euclidean | K-Neighbour: 7  -  93.81
Euclidean | K-Neighbour: 8  -  93.238
Euclidean | K-Neighbour: 9  -  92.683
Euclidean | K-Neighbour: 10  -  92.683
Manhattan | K-Neighbour: 1  -  92.143
Manhattan | K-Neighbour: 2  -  92.143
Manhattan | K-Neighbour: 3  -  93.81
Manhattan | K-Neighbour: 4  -  93.254
Manhattan | K-Neighbour: 5  -  94.381
Manhattan | K-Neighbour: 6  -  93.238
Manhattan | K-Neighbour: 7  -  93.238
Manhattan | K-Neighbour: 8  -  93.238
Manhattan | K-Neighbour: 9  -  93.238
Manhattan | K-Neighbour: 10  -  93.238
Minkowski | K-Neighbour: 1  -  93.27
Minkowski | K-Neighbour: 2  -  93.27
Minkowski | K-Neighbour: 3  -  93.81
Minkowski | K-Neighbour: 4  -  93.81
Minkowski | K-Neighbour: 5  -  94.365
Minkowski | K-Neighbour: 6  -  93.81
Minkowski | K-Neighbour: 7  -  93.81
Minkowski | K-Neighbour: 8  -  93.81
Minkowski | K-Neighbour: 9  -  92.698
Minkowski | K-Neighbour: 10  -  93.81
Cosine | K-Neighbour: 1  -  88.206
Cosine | K-Neighbour: 2  -  88.206
Cosine | K-Neighbour: 3  -  89.889
Cosine | K-Neighbour: 4  -  89.889
Cosine | K-Neighbour: 5  -  88.762
Cosine | K-Neighbour: 6  -  88.762
Cosine | K-Neighbour: 7  -  87.651
Cosine | K-Neighbour: 8  -  88.762
Cosine | K-Neighbour: 9  -  89.889
Cosine | K-Neighbour: 10  -  90.444
EVALUATING NOISY DATA ==================
Fold Level Details -------------------------------------------------------
Euclidean | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     0    11     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 10 | TN - 23 | FP - 0 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 23 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 8 | TN - 25 | FP - 1 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     1    11

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 10 | TN - 21 | FP - 2 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 22 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 3 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     1    12     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 22 | FP - 0 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     2     1
Actual Values: 1 -     0    14     1
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 0 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     1    12     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 22 | FP - 0 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     2     1
Actual Values: 1 -     0    14     1
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 0 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 8 | TN - 25 | FP - 1 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 1 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    13     1
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 19 | FP - 3 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 22 | FP - 1 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 22 | FP - 1 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1    10

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 8 | TN - 24 | FP - 2 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     0    11     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 23 | FP - 0 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 24 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 8 | TN - 25 | FP - 1 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     1    15     0
Actual Values: 2 -     0     0     8

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 18 | FP - 1 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  93.75% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  93.75% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 3 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 19 | FP - 3 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     3    10     2
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 19 | FP - 3 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     6    10     0
Actual Values: 2 -     0     1     7

Accuracy: 71.43%
Error Rate: 28.57%

Class:  0
TP - 8 | TN - 18 | FP - 6 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  57.14% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 15 | FP - 4 | FN - 6 |
  62.50% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  78.95% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     4     5     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 4 | TN - 25 | FP - 1 | FN - 5 |
  44.44% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  57.14% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 15 | FP - 5 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  73.68% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     3    10     2
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 19 | FP - 3 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     6    10     0
Actual Values: 2 -     0     1     7

Accuracy: 71.43%
Error Rate: 28.57%

Class:  0
TP - 8 | TN - 18 | FP - 6 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  57.14% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 15 | FP - 4 | FN - 6 |
  62.50% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  78.95% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     4     5     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 4 | TN - 25 | FP - 1 | FN - 5 |
  44.44% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  57.14% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 15 | FP - 5 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  73.68% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     4     9     2
Actual Values: 2 -     0     0     7

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 13 | TN - 18 | FP - 4 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  81.82% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 20 | FP - 1 | FN - 6 |
  60.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  72.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     4     1
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     1    11

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 8 | TN - 21 | FP - 2 | FN - 5 |
  61.54% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 20 | FP - 5 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  64.29% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  72.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 8 | TN - 20 | FP - 4 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 3 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     6     3     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0    11

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 6 | TN - 23 | FP - 3 | FN - 3 |
  66.67% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  88.46% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 17 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.00% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     3    10     2
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 14 | TN - 19 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 0 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     3     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     0    11

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 9 | TN - 19 | FP - 4 | FN - 4 |
  69.23% - Recall: TP / TP + FN
  69.23% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  69.23% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     5    11     0
Actual Values: 2 -     0     0     8

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 8 | TN - 19 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  79.17% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 16 | FP - 3 | FN - 5 |
  68.75% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  73.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     6     3     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 6 | TN - 25 | FP - 1 | FN - 3 |
  66.67% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  75.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 3 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  85.00% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     4     9     1
Actual Values: 2 -     0     0    10

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 11 | TN - 20 | FP - 4 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  73.33% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  81.48% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 21 | FP - 1 | FN - 5 |
  64.29% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  75.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     5     9     1
Actual Values: 2 -     0     0     7

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 13 | TN - 17 | FP - 5 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  72.22% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 20 | FP - 1 | FN - 6 |
  60.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  72.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     4     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 72.22%
Error Rate: 27.78%

Class:  0
TP - 8 | TN - 19 | FP - 4 | FN - 5 |
  61.54% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 20 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     5    11     0
Actual Values: 2 -     0     0     8

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 8 | TN - 19 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  79.17% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 16 | FP - 3 | FN - 5 |
  68.75% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  73.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     6     3     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 6 | TN - 24 | FP - 2 | FN - 3 |
  66.67% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  70.59% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 3 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  85.00% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     4    10     1
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 18 | FP - 4 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  81.82% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 11 | TN - 19 | FP - 4 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  73.33% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  78.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 23 | FP - 2 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  76.19% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     5    11     0
Actual Values: 2 -     0     0     8

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 8 | TN - 19 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  79.17% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 16 | FP - 3 | FN - 5 |
  68.75% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  73.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     5     4     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 5 | TN - 25 | FP - 1 | FN - 4 |
  55.56% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 4 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     2    11     1
Actual Values: 2 -     0     0    10

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 22 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 22 | FP - 0 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     5    10     0
Actual Values: 2 -     0     0     7

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 12 | TN - 17 | FP - 5 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  70.59% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 19 | FP - 2 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 10 | TN - 19 | FP - 4 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     6    10     0
Actual Values: 2 -     0     0     8

Accuracy: 74.29%
Error Rate: 25.71%

Class:  0
TP - 8 | TN - 18 | FP - 6 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  57.14% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 16 | FP - 3 | FN - 6 |
  62.50% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  68.97% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     4     5     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 4 | TN - 24 | FP - 2 | FN - 5 |
  44.44% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  53.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 15 | FP - 5 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  72.22% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  78.79% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     4    11     0
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 18 | FP - 4 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  81.82% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 19 | FP - 2 | FN - 4 |
  73.33% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  78.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 10 | TN - 19 | FP - 4 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 8 | TN - 20 | FP - 4 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 3 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     3     6     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 3 | TN - 24 | FP - 2 | FN - 6 |
  33.33% - Recall: TP / TP + FN
  60.00% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  42.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 14 | FP - 6 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  68.42% - Precision: TP / TP + FP
  70.00% - Specificity: TN / TN + FP
  76.47% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     4     9     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 22 | FP - 0 | FN - 5 |
  64.29% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     5     9     1
Actual Values: 2 -     0     0     7

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 12 | TN - 17 | FP - 5 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  70.59% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 19 | FP - 2 | FN - 6 |
  60.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  69.23% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     3     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 75.00%
Error Rate: 25.00%

Class:  0
TP - 9 | TN - 19 | FP - 4 | FN - 4 |
  69.23% - Recall: TP / TP + FN
  69.23% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  69.23% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 21 | FP - 4 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  84.00% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 10 | TN - 20 | FP - 4 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     5     4     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0    11

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 5 | TN - 23 | FP - 3 | FN - 4 |
  55.56% - Recall: TP / TP + FN
  62.50% - Precision: TP / TP + FP
  88.46% - Specificity: TN / TN + FP
  58.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 4 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     4     9     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 22 | FP - 0 | FN - 5 |
  64.29% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     5    10     0
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 17 | FP - 5 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  72.22% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 10 | TN - 19 | FP - 4 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 20 | FP - 4 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  69.23% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  75.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 17 | FP - 2 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     5     4     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0    11

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 5 | TN - 23 | FP - 3 | FN - 4 |
  55.56% - Recall: TP / TP + FN
  62.50% - Precision: TP / TP + FP
  88.46% - Specificity: TN / TN + FP
  58.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 4 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 1 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 1 | Fold: 2  -  88.889
Euclidean | K-Neighbours: 1 | Fold: 3  -  82.857
Euclidean | K-Neighbours: 1 | Fold: 4  -  91.429
Euclidean | K-Neighbours: 2 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 2 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 2 | Fold: 2  -  88.889
Euclidean | K-Neighbours: 2 | Fold: 3  -  82.857
Euclidean | K-Neighbours: 2 | Fold: 4  -  91.429
Euclidean | K-Neighbours: 3 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 3 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 3 | Fold: 2  -  91.667
Euclidean | K-Neighbours: 3 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 3 | Fold: 4  -  91.429
Euclidean | K-Neighbours: 4 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 4 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 4 | Fold: 2  -  91.667
Euclidean | K-Neighbours: 4 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 4 | Fold: 4  -  91.429
Euclidean | K-Neighbours: 5 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 5 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 5 | Fold: 2  -  86.111
Euclidean | K-Neighbours: 5 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 5 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 6 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 6 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 6 | Fold: 2  -  91.667
Euclidean | K-Neighbours: 6 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 6 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 7 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 7 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 7 | Fold: 2  -  83.333
Euclidean | K-Neighbours: 7 | Fold: 3  -  88.571
Euclidean | K-Neighbours: 7 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 8 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 8 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 8 | Fold: 2  -  86.111
Euclidean | K-Neighbours: 8 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 8 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 9 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 9 | Fold: 1  -  86.111
Euclidean | K-Neighbours: 9 | Fold: 2  -  88.889
Euclidean | K-Neighbours: 9 | Fold: 3  -  88.571
Euclidean | K-Neighbours: 9 | Fold: 4  -  97.143
Euclidean | K-Neighbours: 10 | Fold: 0  -  97.222
Euclidean | K-Neighbours: 10 | Fold: 1  -  88.889
Euclidean | K-Neighbours: 10 | Fold: 2  -  88.889
Euclidean | K-Neighbours: 10 | Fold: 3  -  85.714
Euclidean | K-Neighbours: 10 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 1 | Fold: 0  -  94.444
Manhattan | K-Neighbours: 1 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 1 | Fold: 2  -  86.111
Manhattan | K-Neighbours: 1 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 1 | Fold: 4  -  91.429
Manhattan | K-Neighbours: 2 | Fold: 0  -  94.444
Manhattan | K-Neighbours: 2 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 2 | Fold: 2  -  86.111
Manhattan | K-Neighbours: 2 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 2 | Fold: 4  -  91.429
Manhattan | K-Neighbours: 3 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 3 | Fold: 1  -  91.667
Manhattan | K-Neighbours: 3 | Fold: 2  -  88.889
Manhattan | K-Neighbours: 3 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 3 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 4 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 4 | Fold: 1  -  91.667
Manhattan | K-Neighbours: 4 | Fold: 2  -  86.111
Manhattan | K-Neighbours: 4 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 4 | Fold: 4  -  94.286
Manhattan | K-Neighbours: 5 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 5 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 5 | Fold: 2  -  88.889
Manhattan | K-Neighbours: 5 | Fold: 3  -  85.714
Manhattan | K-Neighbours: 5 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 6 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 6 | Fold: 1  -  91.667
Manhattan | K-Neighbours: 6 | Fold: 2  -  86.111
Manhattan | K-Neighbours: 6 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 6 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 7 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 7 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 7 | Fold: 2  -  88.889
Manhattan | K-Neighbours: 7 | Fold: 3  -  91.429
Manhattan | K-Neighbours: 7 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 8 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 8 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 8 | Fold: 2  -  86.111
Manhattan | K-Neighbours: 8 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 8 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 9 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 9 | Fold: 1  -  86.111
Manhattan | K-Neighbours: 9 | Fold: 2  -  88.889
Manhattan | K-Neighbours: 9 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 9 | Fold: 4  -  97.143
Manhattan | K-Neighbours: 10 | Fold: 0  -  97.222
Manhattan | K-Neighbours: 10 | Fold: 1  -  88.889
Manhattan | K-Neighbours: 10 | Fold: 2  -  88.889
Manhattan | K-Neighbours: 10 | Fold: 3  -  88.571
Manhattan | K-Neighbours: 10 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 1 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 1 | Fold: 1  -  83.333
Minkowski | K-Neighbours: 1 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 1 | Fold: 3  -  82.857
Minkowski | K-Neighbours: 1 | Fold: 4  -  91.429
Minkowski | K-Neighbours: 2 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 2 | Fold: 1  -  83.333
Minkowski | K-Neighbours: 2 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 2 | Fold: 3  -  82.857
Minkowski | K-Neighbours: 2 | Fold: 4  -  91.429
Minkowski | K-Neighbours: 3 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 3 | Fold: 1  -  86.111
Minkowski | K-Neighbours: 3 | Fold: 2  -  88.889
Minkowski | K-Neighbours: 3 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 3 | Fold: 4  -  88.571
Minkowski | K-Neighbours: 4 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 4 | Fold: 1  -  83.333
Minkowski | K-Neighbours: 4 | Fold: 2  -  94.444
Minkowski | K-Neighbours: 4 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 4 | Fold: 4  -  94.286
Minkowski | K-Neighbours: 5 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 5 | Fold: 1  -  83.333
Minkowski | K-Neighbours: 5 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 5 | Fold: 3  -  94.286
Minkowski | K-Neighbours: 5 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 6 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 6 | Fold: 1  -  83.333
Minkowski | K-Neighbours: 6 | Fold: 2  -  91.667
Minkowski | K-Neighbours: 6 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 6 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 7 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 7 | Fold: 1  -  86.111
Minkowski | K-Neighbours: 7 | Fold: 2  -  86.111
Minkowski | K-Neighbours: 7 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 7 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 8 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 8 | Fold: 1  -  83.333
Minkowski | K-Neighbours: 8 | Fold: 2  -  86.111
Minkowski | K-Neighbours: 8 | Fold: 3  -  85.714
Minkowski | K-Neighbours: 8 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 9 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 9 | Fold: 1  -  86.111
Minkowski | K-Neighbours: 9 | Fold: 2  -  88.889
Minkowski | K-Neighbours: 9 | Fold: 3  -  88.571
Minkowski | K-Neighbours: 9 | Fold: 4  -  97.143
Minkowski | K-Neighbours: 10 | Fold: 0  -  97.222
Minkowski | K-Neighbours: 10 | Fold: 1  -  83.333
Minkowski | K-Neighbours: 10 | Fold: 2  -  88.889
Minkowski | K-Neighbours: 10 | Fold: 3  -  85.714
Minkowski | K-Neighbours: 10 | Fold: 4  -  97.143
Cosine | K-Neighbours: 1 | Fold: 0  -  86.111
Cosine | K-Neighbours: 1 | Fold: 1  -  83.333
Cosine | K-Neighbours: 1 | Fold: 2  -  86.111
Cosine | K-Neighbours: 1 | Fold: 3  -  71.429
Cosine | K-Neighbours: 1 | Fold: 4  -  82.857
Cosine | K-Neighbours: 2 | Fold: 0  -  86.111
Cosine | K-Neighbours: 2 | Fold: 1  -  83.333
Cosine | K-Neighbours: 2 | Fold: 2  -  86.111
Cosine | K-Neighbours: 2 | Fold: 3  -  71.429
Cosine | K-Neighbours: 2 | Fold: 4  -  82.857
Cosine | K-Neighbours: 3 | Fold: 0  -  88.889
Cosine | K-Neighbours: 3 | Fold: 1  -  80.556
Cosine | K-Neighbours: 3 | Fold: 2  -  77.778
Cosine | K-Neighbours: 3 | Fold: 3  -  80.0
Cosine | K-Neighbours: 3 | Fold: 4  -  82.857
Cosine | K-Neighbours: 4 | Fold: 0  -  86.111
Cosine | K-Neighbours: 4 | Fold: 1  -  86.111
Cosine | K-Neighbours: 4 | Fold: 2  -  77.778
Cosine | K-Neighbours: 4 | Fold: 3  -  77.143
Cosine | K-Neighbours: 4 | Fold: 4  -  88.571
Cosine | K-Neighbours: 5 | Fold: 0  -  83.333
Cosine | K-Neighbours: 5 | Fold: 1  -  80.556
Cosine | K-Neighbours: 5 | Fold: 2  -  72.222
Cosine | K-Neighbours: 5 | Fold: 3  -  77.143
Cosine | K-Neighbours: 5 | Fold: 4  -  85.714
Cosine | K-Neighbours: 6 | Fold: 0  -  86.111
Cosine | K-Neighbours: 6 | Fold: 1  -  83.333
Cosine | K-Neighbours: 6 | Fold: 2  -  80.556
Cosine | K-Neighbours: 6 | Fold: 3  -  77.143
Cosine | K-Neighbours: 6 | Fold: 4  -  85.714
Cosine | K-Neighbours: 7 | Fold: 0  -  91.667
Cosine | K-Neighbours: 7 | Fold: 1  -  80.556
Cosine | K-Neighbours: 7 | Fold: 2  -  77.778
Cosine | K-Neighbours: 7 | Fold: 3  -  74.286
Cosine | K-Neighbours: 7 | Fold: 4  -  80.0
Cosine | K-Neighbours: 8 | Fold: 0  -  88.889
Cosine | K-Neighbours: 8 | Fold: 1  -  83.333
Cosine | K-Neighbours: 8 | Fold: 2  -  77.778
Cosine | K-Neighbours: 8 | Fold: 3  -  80.0
Cosine | K-Neighbours: 8 | Fold: 4  -  77.143
Cosine | K-Neighbours: 9 | Fold: 0  -  86.111
Cosine | K-Neighbours: 9 | Fold: 1  -  77.778
Cosine | K-Neighbours: 9 | Fold: 2  -  75.0
Cosine | K-Neighbours: 9 | Fold: 3  -  85.714
Cosine | K-Neighbours: 9 | Fold: 4  -  80.0
Cosine | K-Neighbours: 10 | Fold: 0  -  86.111
Cosine | K-Neighbours: 10 | Fold: 1  -  83.333
Cosine | K-Neighbours: 10 | Fold: 2  -  77.778
Cosine | K-Neighbours: 10 | Fold: 3  -  82.857
Cosine | K-Neighbours: 10 | Fold: 4  -  80.0
Overall Accuracy -------------------------------------------------
Euclidean | K-Neighbour: 1  -  89.302
Euclidean | K-Neighbour: 2  -  89.302
Euclidean | K-Neighbour: 3  -  90.429
Euclidean | K-Neighbour: 4  -  90.429
Euclidean | K-Neighbour: 5  -  90.46
Euclidean | K-Neighbour: 6  -  91.571
Euclidean | K-Neighbour: 7  -  90.476
Euclidean | K-Neighbour: 8  -  90.46
Euclidean | K-Neighbour: 9  -  91.587
Euclidean | K-Neighbour: 10  -  91.571
Manhattan | K-Neighbour: 1  -  89.317
Manhattan | K-Neighbour: 2  -  89.317
Manhattan | K-Neighbour: 3  -  92.127
Manhattan | K-Neighbour: 4  -  91.0
Manhattan | K-Neighbour: 5  -  91.571
Manhattan | K-Neighbour: 6  -  92.143
Manhattan | K-Neighbour: 7  -  92.714
Manhattan | K-Neighbour: 8  -  91.587
Manhattan | K-Neighbour: 9  -  91.587
Manhattan | K-Neighbour: 10  -  92.143
Minkowski | K-Neighbour: 1  -  89.302
Minkowski | K-Neighbour: 2  -  89.302
Minkowski | K-Neighbour: 3  -  89.873
Minkowski | K-Neighbour: 4  -  91.571
Minkowski | K-Neighbour: 5  -  92.73
Minkowski | K-Neighbour: 6  -  91.587
Minkowski | K-Neighbour: 7  -  91.032
Minkowski | K-Neighbour: 8  -  89.905
Minkowski | K-Neighbour: 9  -  91.587
Minkowski | K-Neighbour: 10  -  90.46
Cosine | K-Neighbour: 1  -  81.968
Cosine | K-Neighbour: 2  -  81.968
Cosine | K-Neighbour: 3  -  82.016
Cosine | K-Neighbour: 4  -  83.143
Cosine | K-Neighbour: 5  -  79.794
Cosine | K-Neighbour: 6  -  82.571
Cosine | K-Neighbour: 7  -  80.857
Cosine | K-Neighbour: 8  -  81.429
Cosine | K-Neighbour: 9  -  80.921
Cosine | K-Neighbour: 10  -  82.016

5. Summary of results [6 pts]

Using your results from above, fill out the following table using the clean data:
Because of the large amount of parameters that can be used, I will be showing 5 different parameter settings so we can also see if any identification of any trend can be found. The above code will print a list of all the possible parameter within this notebook and also capture the values of every fold.

The table as shown here is using k = 1 and using the distance measure Euclidean distance

Fold	accuracy	k	distance
1	97.222	1	Euclidean
2	88.889	1	Euclidean
3	91.667	1	Euclidean
4	33.146	1	Euclidean
5	35.393	1	Euclidean
total $\mu$	*92.699*		$\sigma$ $\pm$ 2.834

This table as shown is using k = 5 and using the distance measure of Euclidean. As compared to the one above, accuracy has increased a by almost 2% but the standard deviation has increased as well. This shows that the range between the folds are wider than the previous one.

Fold	accuracy	k	distance
1	97.222	5	Euclidean
2	94.444	5	Euclidean
3	94.444	5	Euclidean
4	88.571	5	Euclidean
5	97.143	5	Euclidean
total $\mu$	*94.366*		$\sigma$ $\pm$ 3.145

In this table, we are still using k = 5, but the distance measure is now Manhattan instead, to see if any difference can be seen. The accuracy for this table is about the same as the one above but the standard deviation for this one is lower, which shows that the accuracy between the folds were less volatile.

Fold	accuracy	k	distance
1	97.222	5	Manhattan
2	94.444	5	Manhattan
3	91.667	5	Manhattan
4	91.429	5	Manhattan
5	97.143	5	Manhattan
total $\mu$	*94.381*		$\sigma$ $\pm$ 2.521

Then, for the next table, k = 10 with the Manhattan Distance measure. Once again, no significant trend can be seen or form yet as the difference is once again, not enough to form any insight or opinion. The increase in k from 1 to 5 does look like it has improvement but not from k = 5 to 10. As for standard deviation, no particular trend can be seen or formed. Especially with this set of parameters as shown below, having a standard deviation up to 4.281 due to the fold number 4 having an accuracy of 85 only.

Fold	accuracy	k	distance
1	97.222	10	Manhattan
2	94.444	10	Manhattan
3	91.667	10	Manhattan
4	85.714	10	Manhattan
5	97.143	10	Manhattan
total $\mu$	*93.238*		$\sigma$ $\pm$ 4.281

Lastly, using back the same number of k, k = 10, we now try using Cosine distance. This set of parameter performed the worst, as its accuracy is only 90.44. More to be looked into to fully decide which set of parameters are the best.

Fold	accuracy	k	distance
1	88.889	10	Cosine
2	91.667	10	Cosine
3	91.667	10	Cosine
4	85.714	10	Cosine
5	85.714	10	Cosine
total $\mu$	*90.444*		$\sigma$ $\pm$ 2.917

Conclusion for this observation is that, an increase in k, could seem to improve accuracy but only from 1 to 5 and not 5 to 10. Currently, the optimal measure distance in these set of parameters is Manhattan.

Now fill out the following table using the noisy data:

Now, using the same set of parameters used above, we can see if there is any observable difference between the noisy data and clean data. The following table is euclidean distance with k = 1

Fold	accuracy	k	distance
1	97.222	1	Euclidean
2	86.111	1	Euclidean
3	88.889	1	Euclidean
4	82.857	1	Euclidean
5	91.429	1	Euclidean
total $\mu$	*89.302*		$\sigma$ $\pm$ 4.881

Currently, if we were to compare to the clean data, accuracy has seem to drop about 3% and an increase in standard deviation by about 2 times.

Then, the next following k = 5 and still euclidean distance.

Fold	accuracy	k	distance
1	97.222	5	Euclidean
2	86.111	5	Euclidean
3	86.111	5	Euclidean
4	85.714	5	Euclidean
5	97.143	5	Euclidean
total $\mu$	*90.460*		$\sigma$ $\pm$ 5.491

We can observe that even with the increased in k, accuracy has only improve by 1% but the standard deviation increased further.

Next, the following table is one with k = 5 and using manhattan distance.

Fold	accuracy	k	distance
1	97.222	5	Manhattan
2	91.667	5	Manhattan
3	86.111	5	Manhattan
4	88.571	5	Manhattan
5	97.143	5	Manhattan
total $\mu$	*91.571*		$\sigma$ $\pm$ 4.726

Using Manhattan seem to have some improvement as well in terms of accuracy as well as standard deviation

Next, using Manhattan with the k = 10

Fold	accuracy	k	distance
1	97.222	10	Manhattan
2	91.667	10	Manhattan
3	86.111	10	Manhattan
4	88.571	10	Manhattan
5	97.143	10	Manhattan
total $\mu$	*92.1428*		$\sigma$ $\pm$ 4.117

Surprisingly, accuracy increased along with the number of k. This could be because the data with the added noise, have bigger range that the one with clean data. Hence, if when we increase the k, the algorithm can take more values and evaluate properly.

Lastly, we will use the same k, k = 10 with the Cosine distance method.

Fold	accuracy	k	distance
1	86.111	10	Manhattan
2	83.333	10	Manhattan
3	77.778	10	Manhattan
4	82.857	10	Manhattan
5	80.000	10	Manhattan
total $\mu$	*82.016*		$\sigma$ $\pm$ 2.872

This set of parameters unfortunately performed the worse with only 82% accuracy.

Let's include k = 10 with the Minkowski. But for the Minkowski distance used in assignment, default value of p is 3 because 1 is similar to Manhattan distance while p = 2 is equivalent to Euclidean.

Fold	accuracy	k	distance
1	97.222	10	Minkowski
2	88.889	10	Minkowski
3	88.889	10	Minkowski
4	85.714	10	Minkowski
5	97.143	10	Minkowski
total $\mu$	*93.809*		$\sigma$ $\pm$ 3.322

Overall, using the data without noise resulted in having slightly higher accuracy, but there are many things that could still be further experimented such as minkowski p value can also be a parameter to further investigate for an optimal value. Additionally, the k parameter is also limited to only 1 to 10, but what if the noise data could take advantage of the higher k due to having noise in the data.

5.2. Confusion matrix summary

Summarise the overall results of your nested cross validation evaluation of your K-NN algorithm using two summary confusion matrices (one for the noisy data, one for the clean data). You might want to adapt your myNestedCrossVal code above to also return a list of confusion matrices.

Use or adapt your evaluation code above to print the two confusion matrices below. Make sure you label the matrix rows and columns. You might also want ot show class-relative precision and recall.

# set the groups of parameters
nFolds = 5
K = [x for x in range(1,11)]
distanceMeasureMethods = ["Euclidean", "Manhattan", "Minkowski", "Cosine"]
mySeed = 12345

print('CLEAN')
# clean data summary results

# evaluate clean data code
print("EVALUATING CLEAN DATA =================")
cleanResults = myNestCrossVal(X,y,nFolds,K,distanceMeasureMethods,mySeed,'test')
for cleanResult in cleanResults[2]:
    print(cleanResult, " - ", cleanResults[2][cleanResult])


# evaluate noisy data code
print("EVALUATING NOISY DATA ==================")
noisyResults = myNestCrossVal(XN,y,nFolds,K,distanceMeasureMethods,mySeed,'test')
for noisyResult in noisyResults[2]:
    print(noisyResult, " - ", noisyResults[2][noisyResult])

Code Output

CLEAN
EVALUATING CLEAN DATA =================
Euclidean | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     1     7

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 17 | FP - 2 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  88.24% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     1     7

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 17 | FP - 2 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  88.24% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     1    14     1
Actual Values: 2 -     0     1     7

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     1    14     1
Actual Values: 2 -     0     1     7

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 11 | TN - 22 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 0 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     0     8

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 18 | FP - 1 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  93.75% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  93.75% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 2 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 24 | FP - 1 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     0    15     1
Actual Values: 2 -     0     0     8

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 18 | FP - 1 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  93.75% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  93.75% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 25 | FP - 0 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 14 | TN - 19 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 21 | FP - 0 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 14 | TN - 20 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 21 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     0     0
Actual Values: 1 -     3    12     1
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 0 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 2 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    13     1
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 2 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    13     1
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 13 | TN - 21 | FP - 1 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 26 | FP - 1 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 3 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 20 | FP - 1 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 19 | FP - 4 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 24 | FP - 1 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  73.68% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     2    13     1
Actual Values: 2 -     0     0     8

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 8 | TN - 22 | FP - 2 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  76.19% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 26 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.30% - Specificity: TN / TN + FP
  94.12% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 11 | TN - 21 | FP - 3 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 1 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     4     7     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 13 | TN - 19 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 7 | TN - 25 | FP - 0 | FN - 4 |
  63.64% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  77.78% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 8 | TN - 22 | FP - 2 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  76.19% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 15 | FP - 4 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  78.95% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     2    11     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 2 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 21 | FP - 1 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 3 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 24 | FP - 1 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     2    11     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 2 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 21 | FP - 1 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  84.62% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 2 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     0     0
Actual Values: 1 -     3     8     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 13 | TN - 20 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.96% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 25 | FP - 0 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 20 | FP - 0 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean - k=1 - class=0 - tp  -  56
Euclidean - k=1 - class=0 - tn  -  114
Euclidean - k=1 - class=0 - fp  -  5
Euclidean - k=1 - class=0 - fn  -  3
Euclidean - k=1 - class=0 - recall  -  0.9521478521478521
Euclidean - k=1 - class=0 - precision  -  0.9521478521478521
Euclidean - k=1 - class=0 - specificity  -  0.956734569778048
Euclidean - k=1 - class=0 - fmeasure  -  0.9370379972920808
Euclidean - k=1 - class=1 - tp  -  64
Euclidean - k=1 - class=1 - tn  -  101
Euclidean - k=1 - class=1 - fp  -  6
Euclidean - k=1 - class=1 - fn  -  7
Euclidean - k=1 - class=1 - recall  -  0.8968506493506494
Euclidean - k=1 - class=1 - precision  -  0.8968506493506494
Euclidean - k=1 - class=1 - specificity  -  0.9418997493734336
Euclidean - k=1 - class=1 - fmeasure  -  0.9058393458393459
Euclidean - k=1 - class=2 - tp  -  45
Euclidean - k=1 - class=2 - tn  -  128
Euclidean - k=1 - class=2 - fp  -  2
Euclidean - k=1 - class=2 - fn  -  3
Euclidean - k=1 - class=2 - recall  -  0.9282467532467532
Euclidean - k=1 - class=2 - precision  -  0.9282467532467532
Euclidean - k=1 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=1 - class=2 - fmeasure  -  0.9405677655677656
Euclidean - k=2 - class=0 - tp  -  56
Euclidean - k=2 - class=0 - tn  -  114
Euclidean - k=2 - class=0 - fp  -  5
Euclidean - k=2 - class=0 - fn  -  3
Euclidean - k=2 - class=0 - recall  -  0.9521478521478521
Euclidean - k=2 - class=0 - precision  -  0.9521478521478521
Euclidean - k=2 - class=0 - specificity  -  0.956734569778048
Euclidean - k=2 - class=0 - fmeasure  -  0.9370379972920808
Euclidean - k=2 - class=1 - tp  -  64
Euclidean - k=2 - class=1 - tn  -  101
Euclidean - k=2 - class=1 - fp  -  6
Euclidean - k=2 - class=1 - fn  -  7
Euclidean - k=2 - class=1 - recall  -  0.8968506493506494
Euclidean - k=2 - class=1 - precision  -  0.8968506493506494
Euclidean - k=2 - class=1 - specificity  -  0.9418997493734336
Euclidean - k=2 - class=1 - fmeasure  -  0.9058393458393459
Euclidean - k=2 - class=2 - tp  -  45
Euclidean - k=2 - class=2 - tn  -  128
Euclidean - k=2 - class=2 - fp  -  2
Euclidean - k=2 - class=2 - fn  -  3
Euclidean - k=2 - class=2 - recall  -  0.9282467532467532
Euclidean - k=2 - class=2 - precision  -  0.9282467532467532
Euclidean - k=2 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=2 - class=2 - fmeasure  -  0.9405677655677656
Euclidean - k=3 - class=0 - tp  -  58
Euclidean - k=3 - class=0 - tn  -  112
Euclidean - k=3 - class=0 - fp  -  7
Euclidean - k=3 - class=0 - fn  -  1
Euclidean - k=3 - class=0 - recall  -  0.9818181818181818
Euclidean - k=3 - class=0 - precision  -  0.9818181818181818
Euclidean - k=3 - class=0 - specificity  -  0.9400679031113814
Euclidean - k=3 - class=0 - fmeasure  -  0.9357676800697396
Euclidean - k=3 - class=1 - tp  -  62
Euclidean - k=3 - class=1 - tn  -  106
Euclidean - k=3 - class=1 - fp  -  1
Euclidean - k=3 - class=1 - fn  -  9
Euclidean - k=3 - class=1 - recall  -  0.8718506493506494
Euclidean - k=3 - class=1 - precision  -  0.8718506493506494
Euclidean - k=3 - class=1 - specificity  -  0.9894736842105264
Euclidean - k=3 - class=1 - fmeasure  -  0.9247436599160738
Euclidean - k=3 - class=2 - tp  -  48
Euclidean - k=3 - class=2 - tn  -  128
Euclidean - k=3 - class=2 - fp  -  2
Euclidean - k=3 - class=2 - fn  -  0
Euclidean - k=3 - class=2 - recall  -  1.0
Euclidean - k=3 - class=2 - precision  -  1.0
Euclidean - k=3 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=3 - class=2 - fmeasure  -  0.9787114845938376
Euclidean - k=4 - class=0 - tp  -  58
Euclidean - k=4 - class=0 - tn  -  112
Euclidean - k=4 - class=0 - fp  -  7
Euclidean - k=4 - class=0 - fn  -  1
Euclidean - k=4 - class=0 - recall  -  0.9818181818181818
Euclidean - k=4 - class=0 - precision  -  0.9818181818181818
Euclidean - k=4 - class=0 - specificity  -  0.9400679031113814
Euclidean - k=4 - class=0 - fmeasure  -  0.9357676800697396
Euclidean - k=4 - class=1 - tp  -  62
Euclidean - k=4 - class=1 - tn  -  105
Euclidean - k=4 - class=1 - fp  -  2
Euclidean - k=4 - class=1 - fn  -  9
Euclidean - k=4 - class=1 - recall  -  0.8718506493506494
Euclidean - k=4 - class=1 - precision  -  0.8718506493506494
Euclidean - k=4 - class=1 - specificity  -  0.9799498746867169
Euclidean - k=4 - class=1 - fmeasure  -  0.9183397190293743
Euclidean - k=4 - class=2 - tp  -  47
Euclidean - k=4 - class=2 - tn  -  128
Euclidean - k=4 - class=2 - fp  -  2
Euclidean - k=4 - class=2 - fn  -  1
Euclidean - k=4 - class=2 - recall  -  0.9714285714285715
Euclidean - k=4 - class=2 - precision  -  0.9714285714285715
Euclidean - k=4 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=4 - class=2 - fmeasure  -  0.9633268692092221
Euclidean - k=5 - class=0 - tp  -  59
Euclidean - k=5 - class=0 - tn  -  111
Euclidean - k=5 - class=0 - fp  -  8
Euclidean - k=5 - class=0 - fn  -  0
Euclidean - k=5 - class=0 - recall  -  1.0
Euclidean - k=5 - class=0 - precision  -  1.0
Euclidean - k=5 - class=0 - specificity  -  0.931734569778048
Euclidean - k=5 - class=0 - fmeasure  -  0.9378546365914786
Euclidean - k=5 - class=1 - tp  -  61
Euclidean - k=5 - class=1 - tn  -  107
Euclidean - k=5 - class=1 - fp  -  0
Euclidean - k=5 - class=1 - fn  -  10
Euclidean - k=5 - class=1 - recall  -  0.8593506493506494
Euclidean - k=5 - class=1 - precision  -  0.8593506493506494
Euclidean - k=5 - class=1 - specificity  -  1.0
Euclidean - k=5 - class=1 - fmeasure  -  0.9228388980113118
Euclidean - k=5 - class=2 - tp  -  48
Euclidean - k=5 - class=2 - tn  -  128
Euclidean - k=5 - class=2 - fp  -  2
Euclidean - k=5 - class=2 - fn  -  0
Euclidean - k=5 - class=2 - recall  -  1.0
Euclidean - k=5 - class=2 - precision  -  1.0
Euclidean - k=5 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=5 - class=2 - fmeasure  -  0.9787114845938376
Euclidean - k=6 - class=0 - tp  -  59
Euclidean - k=6 - class=0 - tn  -  111
Euclidean - k=6 - class=0 - fp  -  8
Euclidean - k=6 - class=0 - fn  -  0
Euclidean - k=6 - class=0 - recall  -  1.0
Euclidean - k=6 - class=0 - precision  -  1.0
Euclidean - k=6 - class=0 - specificity  -  0.931734569778048
Euclidean - k=6 - class=0 - fmeasure  -  0.9378546365914786
Euclidean - k=6 - class=1 - tp  -  61
Euclidean - k=6 - class=1 - tn  -  105
Euclidean - k=6 - class=1 - fp  -  2
Euclidean - k=6 - class=1 - fn  -  10
Euclidean - k=6 - class=1 - recall  -  0.8593506493506494
Euclidean - k=6 - class=1 - precision  -  0.8593506493506494
Euclidean - k=6 - class=1 - specificity  -  0.9799498746867169
Euclidean - k=6 - class=1 - fmeasure  -  0.9105236270753512
Euclidean - k=6 - class=2 - tp  -  46
Euclidean - k=6 - class=2 - tn  -  128
Euclidean - k=6 - class=2 - fp  -  2
Euclidean - k=6 - class=2 - fn  -  2
Euclidean - k=6 - class=2 - recall  -  0.9464285714285715
Euclidean - k=6 - class=2 - precision  -  0.9464285714285715
Euclidean - k=6 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=6 - class=2 - fmeasure  -  0.9500915750915752
Euclidean - k=7 - class=0 - tp  -  59
Euclidean - k=7 - class=0 - tn  -  110
Euclidean - k=7 - class=0 - fp  -  9
Euclidean - k=7 - class=0 - fn  -  0
Euclidean - k=7 - class=0 - recall  -  1.0
Euclidean - k=7 - class=0 - precision  -  1.0
Euclidean - k=7 - class=0 - specificity  -  0.9230389176041349
Euclidean - k=7 - class=0 - fmeasure  -  0.9314506957047792
Euclidean - k=7 - class=1 - tp  -  60
Euclidean - k=7 - class=1 - tn  -  107
Euclidean - k=7 - class=1 - fp  -  0
Euclidean - k=7 - class=1 - fn  -  11
Euclidean - k=7 - class=1 - recall  -  0.8411688311688312
Euclidean - k=7 - class=1 - precision  -  0.8411688311688312
Euclidean - k=7 - class=1 - specificity  -  1.0
Euclidean - k=7 - class=1 - fmeasure  -  0.9112599506428907
Euclidean - k=7 - class=2 - tp  -  48
Euclidean - k=7 - class=2 - tn  -  128
Euclidean - k=7 - class=2 - fp  -  2
Euclidean - k=7 - class=2 - fn  -  0
Euclidean - k=7 - class=2 - recall  -  1.0
Euclidean - k=7 - class=2 - precision  -  1.0
Euclidean - k=7 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=7 - class=2 - fmeasure  -  0.9787114845938376
Euclidean - k=8 - class=0 - tp  -  59
Euclidean - k=8 - class=0 - tn  -  110
Euclidean - k=8 - class=0 - fp  -  9
Euclidean - k=8 - class=0 - fn  -  0
Euclidean - k=8 - class=0 - recall  -  1.0
Euclidean - k=8 - class=0 - precision  -  1.0
Euclidean - k=8 - class=0 - specificity  -  0.9230389176041349
Euclidean - k=8 - class=0 - fmeasure  -  0.9314506957047792
Euclidean - k=8 - class=1 - tp  -  60
Euclidean - k=8 - class=1 - tn  -  106
Euclidean - k=8 - class=1 - fp  -  1
Euclidean - k=8 - class=1 - fn  -  11
Euclidean - k=8 - class=1 - recall  -  0.8411688311688312
Euclidean - k=8 - class=1 - precision  -  0.8411688311688312
Euclidean - k=8 - class=1 - specificity  -  0.9894736842105264
Euclidean - k=8 - class=1 - fmeasure  -  0.9053486205936296
Euclidean - k=8 - class=2 - tp  -  47
Euclidean - k=8 - class=2 - tn  -  128
Euclidean - k=8 - class=2 - fp  -  2
Euclidean - k=8 - class=2 - fn  -  1
Euclidean - k=8 - class=2 - recall  -  0.975
Euclidean - k=8 - class=2 - precision  -  0.975
Euclidean - k=8 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=8 - class=2 - fmeasure  -  0.9654761904761905
Euclidean - k=9 - class=0 - tp  -  59
Euclidean - k=9 - class=0 - tn  -  109
Euclidean - k=9 - class=0 - fp  -  10
Euclidean - k=9 - class=0 - fn  -  0
Euclidean - k=9 - class=0 - recall  -  1.0
Euclidean - k=9 - class=0 - precision  -  1.0
Euclidean - k=9 - class=0 - specificity  -  0.914343265430222
Euclidean - k=9 - class=0 - fmeasure  -  0.9254736842105263
Euclidean - k=9 - class=1 - tp  -  59
Euclidean - k=9 - class=1 - tn  -  106
Euclidean - k=9 - class=1 - fp  -  1
Euclidean - k=9 - class=1 - fn  -  12
Euclidean - k=9 - class=1 - recall  -  0.822987012987013
Euclidean - k=9 - class=1 - precision  -  0.822987012987013
Euclidean - k=9 - class=1 - specificity  -  0.9894736842105264
Euclidean - k=9 - class=1 - fmeasure  -  0.8924831235176063
Euclidean - k=9 - class=2 - tp  -  47
Euclidean - k=9 - class=2 - tn  -  128
Euclidean - k=9 - class=2 - fp  -  2
Euclidean - k=9 - class=2 - fn  -  1
Euclidean - k=9 - class=2 - recall  -  0.975
Euclidean - k=9 - class=2 - precision  -  0.975
Euclidean - k=9 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=9 - class=2 - fmeasure  -  0.9654761904761905
Euclidean - k=10 - class=0 - tp  -  59
Euclidean - k=10 - class=0 - tn  -  109
Euclidean - k=10 - class=0 - fp  -  10
Euclidean - k=10 - class=0 - fn  -  0
Euclidean - k=10 - class=0 - recall  -  1.0
Euclidean - k=10 - class=0 - precision  -  1.0
Euclidean - k=10 - class=0 - specificity  -  0.914343265430222
Euclidean - k=10 - class=0 - fmeasure  -  0.9254736842105263
Euclidean - k=10 - class=1 - tp  -  59
Euclidean - k=10 - class=1 - tn  -  106
Euclidean - k=10 - class=1 - fp  -  1
Euclidean - k=10 - class=1 - fn  -  12
Euclidean - k=10 - class=1 - recall  -  0.822987012987013
Euclidean - k=10 - class=1 - precision  -  0.822987012987013
Euclidean - k=10 - class=1 - specificity  -  0.9894736842105264
Euclidean - k=10 - class=1 - fmeasure  -  0.8924831235176063
Euclidean - k=10 - class=2 - tp  -  47
Euclidean - k=10 - class=2 - tn  -  128
Euclidean - k=10 - class=2 - fp  -  2
Euclidean - k=10 - class=2 - fn  -  1
Euclidean - k=10 - class=2 - recall  -  0.975
Euclidean - k=10 - class=2 - precision  -  0.975
Euclidean - k=10 - class=2 - specificity  -  0.9849002849002849
Euclidean - k=10 - class=2 - fmeasure  -  0.9654761904761905
Manhattan - k=1 - class=0 - tp  -  56
Manhattan - k=1 - class=0 - tn  -  112
Manhattan - k=1 - class=0 - fp  -  7
Manhattan - k=1 - class=0 - fn  -  3
Manhattan - k=1 - class=0 - recall  -  0.950865800865801
Manhattan - k=1 - class=0 - precision  -  0.950865800865801
Manhattan - k=1 - class=0 - specificity  -  0.9397055842708018
Manhattan - k=1 - class=0 - fmeasure  -  0.9212169035099675
Manhattan - k=1 - class=1 - tp  -  62
Manhattan - k=1 - class=1 - tn  -  102
Manhattan - k=1 - class=1 - fp  -  5
Manhattan - k=1 - class=1 - fn  -  9
Manhattan - k=1 - class=1 - recall  -  0.8661688311688313
Manhattan - k=1 - class=1 - precision  -  0.8661688311688313
Manhattan - k=1 - class=1 - specificity  -  0.9508088402825244
Manhattan - k=1 - class=1 - fmeasure  -  0.89557211995506
Manhattan - k=1 - class=2 - tp  -  46
Manhattan - k=1 - class=2 - tn  -  128
Manhattan - k=1 - class=2 - fp  -  2
Manhattan - k=1 - class=2 - fn  -  2
Manhattan - k=1 - class=2 - recall  -  0.9464285714285715
Manhattan - k=1 - class=2 - precision  -  0.9464285714285715
Manhattan - k=1 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=1 - class=2 - fmeasure  -  0.9500915750915752
Manhattan - k=2 - class=0 - tp  -  56
Manhattan - k=2 - class=0 - tn  -  112
Manhattan - k=2 - class=0 - fp  -  7
Manhattan - k=2 - class=0 - fn  -  3
Manhattan - k=2 - class=0 - recall  -  0.950865800865801
Manhattan - k=2 - class=0 - precision  -  0.950865800865801
Manhattan - k=2 - class=0 - specificity  -  0.9397055842708018
Manhattan - k=2 - class=0 - fmeasure  -  0.9212169035099675
Manhattan - k=2 - class=1 - tp  -  62
Manhattan - k=2 - class=1 - tn  -  102
Manhattan - k=2 - class=1 - fp  -  5
Manhattan - k=2 - class=1 - fn  -  9
Manhattan - k=2 - class=1 - recall  -  0.8661688311688313
Manhattan - k=2 - class=1 - precision  -  0.8661688311688313
Manhattan - k=2 - class=1 - specificity  -  0.9508088402825244
Manhattan - k=2 - class=1 - fmeasure  -  0.89557211995506
Manhattan - k=2 - class=2 - tp  -  46
Manhattan - k=2 - class=2 - tn  -  128
Manhattan - k=2 - class=2 - fp  -  2
Manhattan - k=2 - class=2 - fn  -  2
Manhattan - k=2 - class=2 - recall  -  0.9464285714285715
Manhattan - k=2 - class=2 - precision  -  0.9464285714285715
Manhattan - k=2 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=2 - class=2 - fmeasure  -  0.9500915750915752
Manhattan - k=3 - class=0 - tp  -  59
Manhattan - k=3 - class=0 - tn  -  110
Manhattan - k=3 - class=0 - fp  -  9
Manhattan - k=3 - class=0 - fn  -  0
Manhattan - k=3 - class=0 - recall  -  1.0
Manhattan - k=3 - class=0 - precision  -  1.0
Manhattan - k=3 - class=0 - specificity  -  0.9230389176041349
Manhattan - k=3 - class=0 - fmeasure  -  0.9314506957047792
Manhattan - k=3 - class=1 - tp  -  60
Manhattan - k=3 - class=1 - tn  -  107
Manhattan - k=3 - class=1 - fp  -  0
Manhattan - k=3 - class=1 - fn  -  11
Manhattan - k=3 - class=1 - recall  -  0.8411688311688312
Manhattan - k=3 - class=1 - precision  -  0.8411688311688312
Manhattan - k=3 - class=1 - specificity  -  1.0
Manhattan - k=3 - class=1 - fmeasure  -  0.9112599506428907
Manhattan - k=3 - class=2 - tp  -  48
Manhattan - k=3 - class=2 - tn  -  128
Manhattan - k=3 - class=2 - fp  -  2
Manhattan - k=3 - class=2 - fn  -  0
Manhattan - k=3 - class=2 - recall  -  1.0
Manhattan - k=3 - class=2 - precision  -  1.0
Manhattan - k=3 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=3 - class=2 - fmeasure  -  0.9787114845938376
Manhattan - k=4 - class=0 - tp  -  58
Manhattan - k=4 - class=0 - tn  -  110
Manhattan - k=4 - class=0 - fp  -  9
Manhattan - k=4 - class=0 - fn  -  1
Manhattan - k=4 - class=0 - recall  -  0.9833333333333332
Manhattan - k=4 - class=0 - precision  -  0.9833333333333332
Manhattan - k=4 - class=0 - specificity  -  0.9230389176041349
Manhattan - k=4 - class=0 - fmeasure  -  0.9227550435308661
Manhattan - k=4 - class=1 - tp  -  60
Manhattan - k=4 - class=1 - tn  -  106
Manhattan - k=4 - class=1 - fp  -  1
Manhattan - k=4 - class=1 - fn  -  11
Manhattan - k=4 - class=1 - recall  -  0.8411688311688312
Manhattan - k=4 - class=1 - precision  -  0.8411688311688312
Manhattan - k=4 - class=1 - specificity  -  0.990909090909091
Manhattan - k=4 - class=1 - fmeasure  -  0.904381643764584
Manhattan - k=4 - class=2 - tp  -  48
Manhattan - k=4 - class=2 - tn  -  128
Manhattan - k=4 - class=2 - fp  -  2
Manhattan - k=4 - class=2 - fn  -  0
Manhattan - k=4 - class=2 - recall  -  1.0
Manhattan - k=4 - class=2 - precision  -  1.0
Manhattan - k=4 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=4 - class=2 - fmeasure  -  0.9787114845938376
Manhattan - k=5 - class=0 - tp  -  59
Manhattan - k=5 - class=0 - tn  -  111
Manhattan - k=5 - class=0 - fp  -  8
Manhattan - k=5 - class=0 - fn  -  0
Manhattan - k=5 - class=0 - recall  -  1.0
Manhattan - k=5 - class=0 - precision  -  1.0
Manhattan - k=5 - class=0 - specificity  -  0.9313722509374683
Manhattan - k=5 - class=0 - fmeasure  -  0.9387840290381124
Manhattan - k=5 - class=1 - tp  -  61
Manhattan - k=5 - class=1 - tn  -  107
Manhattan - k=5 - class=1 - fp  -  0
Manhattan - k=5 - class=1 - fn  -  10
Manhattan - k=5 - class=1 - recall  -  0.8536688311688312
Manhattan - k=5 - class=1 - precision  -  0.8536688311688312
Manhattan - k=5 - class=1 - specificity  -  1.0
Manhattan - k=5 - class=1 - fmeasure  -  0.9191417240419055
Manhattan - k=5 - class=2 - tp  -  48
Manhattan - k=5 - class=2 - tn  -  128
Manhattan - k=5 - class=2 - fp  -  2
Manhattan - k=5 - class=2 - fn  -  0
Manhattan - k=5 - class=2 - recall  -  1.0
Manhattan - k=5 - class=2 - precision  -  1.0
Manhattan - k=5 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=5 - class=2 - fmeasure  -  0.9787114845938376
Manhattan - k=6 - class=0 - tp  -  59
Manhattan - k=6 - class=0 - tn  -  110
Manhattan - k=6 - class=0 - fp  -  9
Manhattan - k=6 - class=0 - fn  -  0
Manhattan - k=6 - class=0 - recall  -  1.0
Manhattan - k=6 - class=0 - precision  -  1.0
Manhattan - k=6 - class=0 - specificity  -  0.9230389176041349
Manhattan - k=6 - class=0 - fmeasure  -  0.9314506957047792
Manhattan - k=6 - class=1 - tp  -  60
Manhattan - k=6 - class=1 - tn  -  106
Manhattan - k=6 - class=1 - fp  -  1
Manhattan - k=6 - class=1 - fn  -  11
Manhattan - k=6 - class=1 - recall  -  0.8411688311688312
Manhattan - k=6 - class=1 - precision  -  0.8411688311688312
Manhattan - k=6 - class=1 - specificity  -  0.9894736842105264
Manhattan - k=6 - class=1 - fmeasure  -  0.9053486205936296
Manhattan - k=6 - class=2 - tp  -  47
Manhattan - k=6 - class=2 - tn  -  128
Manhattan - k=6 - class=2 - fp  -  2
Manhattan - k=6 - class=2 - fn  -  1
Manhattan - k=6 - class=2 - recall  -  0.975
Manhattan - k=6 - class=2 - precision  -  0.975
Manhattan - k=6 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=6 - class=2 - fmeasure  -  0.9654761904761905
Manhattan - k=7 - class=0 - tp  -  59
Manhattan - k=7 - class=0 - tn  -  110
Manhattan - k=7 - class=0 - fp  -  9
Manhattan - k=7 - class=0 - fn  -  0
Manhattan - k=7 - class=0 - recall  -  1.0
Manhattan - k=7 - class=0 - precision  -  1.0
Manhattan - k=7 - class=0 - specificity  -  0.9230389176041349
Manhattan - k=7 - class=0 - fmeasure  -  0.9314506957047792
Manhattan - k=7 - class=1 - tp  -  60
Manhattan - k=7 - class=1 - tn  -  106
Manhattan - k=7 - class=1 - fp  -  1
Manhattan - k=7 - class=1 - fn  -  11
Manhattan - k=7 - class=1 - recall  -  0.8411688311688312
Manhattan - k=7 - class=1 - precision  -  0.8411688311688312
Manhattan - k=7 - class=1 - specificity  -  0.9894736842105264
Manhattan - k=7 - class=1 - fmeasure  -  0.9053486205936296
Manhattan - k=7 - class=2 - tp  -  47
Manhattan - k=7 - class=2 - tn  -  128
Manhattan - k=7 - class=2 - fp  -  2
Manhattan - k=7 - class=2 - fn  -  1
Manhattan - k=7 - class=2 - recall  -  0.975
Manhattan - k=7 - class=2 - precision  -  0.975
Manhattan - k=7 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=7 - class=2 - fmeasure  -  0.9654761904761905
Manhattan - k=8 - class=0 - tp  -  59
Manhattan - k=8 - class=0 - tn  -  110
Manhattan - k=8 - class=0 - fp  -  9
Manhattan - k=8 - class=0 - fn  -  0
Manhattan - k=8 - class=0 - recall  -  1.0
Manhattan - k=8 - class=0 - precision  -  1.0
Manhattan - k=8 - class=0 - specificity  -  0.9230389176041349
Manhattan - k=8 - class=0 - fmeasure  -  0.9314506957047792
Manhattan - k=8 - class=1 - tp  -  60
Manhattan - k=8 - class=1 - tn  -  106
Manhattan - k=8 - class=1 - fp  -  1
Manhattan - k=8 - class=1 - fn  -  11
Manhattan - k=8 - class=1 - recall  -  0.8411688311688312
Manhattan - k=8 - class=1 - precision  -  0.8411688311688312
Manhattan - k=8 - class=1 - specificity  -  0.9894736842105264
Manhattan - k=8 - class=1 - fmeasure  -  0.9053486205936296
Manhattan - k=8 - class=2 - tp  -  47
Manhattan - k=8 - class=2 - tn  -  128
Manhattan - k=8 - class=2 - fp  -  2
Manhattan - k=8 - class=2 - fn  -  1
Manhattan - k=8 - class=2 - recall  -  0.975
Manhattan - k=8 - class=2 - precision  -  0.975
Manhattan - k=8 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=8 - class=2 - fmeasure  -  0.9654761904761905
Manhattan - k=9 - class=0 - tp  -  59
Manhattan - k=9 - class=0 - tn  -  110
Manhattan - k=9 - class=0 - fp  -  9
Manhattan - k=9 - class=0 - fn  -  0
Manhattan - k=9 - class=0 - recall  -  1.0
Manhattan - k=9 - class=0 - precision  -  1.0
Manhattan - k=9 - class=0 - specificity  -  0.9230389176041349
Manhattan - k=9 - class=0 - fmeasure  -  0.9314506957047792
Manhattan - k=9 - class=1 - tp  -  60
Manhattan - k=9 - class=1 - tn  -  106
Manhattan - k=9 - class=1 - fp  -  1
Manhattan - k=9 - class=1 - fn  -  11
Manhattan - k=9 - class=1 - recall  -  0.8411688311688312
Manhattan - k=9 - class=1 - precision  -  0.8411688311688312
Manhattan - k=9 - class=1 - specificity  -  0.9894736842105264
Manhattan - k=9 - class=1 - fmeasure  -  0.9053486205936296
Manhattan - k=9 - class=2 - tp  -  47
Manhattan - k=9 - class=2 - tn  -  128
Manhattan - k=9 - class=2 - fp  -  2
Manhattan - k=9 - class=2 - fn  -  1
Manhattan - k=9 - class=2 - recall  -  0.975
Manhattan - k=9 - class=2 - precision  -  0.975
Manhattan - k=9 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=9 - class=2 - fmeasure  -  0.9654761904761905
Manhattan - k=10 - class=0 - tp  -  59
Manhattan - k=10 - class=0 - tn  -  110
Manhattan - k=10 - class=0 - fp  -  9
Manhattan - k=10 - class=0 - fn  -  0
Manhattan - k=10 - class=0 - recall  -  1.0
Manhattan - k=10 - class=0 - precision  -  1.0
Manhattan - k=10 - class=0 - specificity  -  0.9230389176041349
Manhattan - k=10 - class=0 - fmeasure  -  0.9314506957047792
Manhattan - k=10 - class=1 - tp  -  60
Manhattan - k=10 - class=1 - tn  -  106
Manhattan - k=10 - class=1 - fp  -  1
Manhattan - k=10 - class=1 - fn  -  11
Manhattan - k=10 - class=1 - recall  -  0.8411688311688312
Manhattan - k=10 - class=1 - precision  -  0.8411688311688312
Manhattan - k=10 - class=1 - specificity  -  0.9894736842105264
Manhattan - k=10 - class=1 - fmeasure  -  0.9053486205936296
Manhattan - k=10 - class=2 - tp  -  47
Manhattan - k=10 - class=2 - tn  -  128
Manhattan - k=10 - class=2 - fp  -  2
Manhattan - k=10 - class=2 - fn  -  1
Manhattan - k=10 - class=2 - recall  -  0.975
Manhattan - k=10 - class=2 - precision  -  0.975
Manhattan - k=10 - class=2 - specificity  -  0.9849002849002849
Manhattan - k=10 - class=2 - fmeasure  -  0.9654761904761905
Minkowski - k=1 - class=0 - tp  -  56
Minkowski - k=1 - class=0 - tn  -  114
Minkowski - k=1 - class=0 - fp  -  5
Minkowski - k=1 - class=0 - fn  -  3
Minkowski - k=1 - class=0 - recall  -  0.9521478521478521
Minkowski - k=1 - class=0 - precision  -  0.9521478521478521
Minkowski - k=1 - class=0 - specificity  -  0.956734569778048
Minkowski - k=1 - class=0 - fmeasure  -  0.9370379972920808
Minkowski - k=1 - class=1 - tp  -  64
Minkowski - k=1 - class=1 - tn  -  102
Minkowski - k=1 - class=1 - fp  -  5
Minkowski - k=1 - class=1 - fn  -  7
Minkowski - k=1 - class=1 - recall  -  0.8968506493506494
Minkowski - k=1 - class=1 - precision  -  0.8968506493506494
Minkowski - k=1 - class=1 - specificity  -  0.9524260651629073
Minkowski - k=1 - class=1 - fmeasure  -  0.911521164021164
Minkowski - k=1 - class=2 - tp  -  46
Minkowski - k=1 - class=2 - tn  -  128
Minkowski - k=1 - class=2 - fp  -  2
Minkowski - k=1 - class=2 - fn  -  2
Minkowski - k=1 - class=2 - recall  -  0.9532467532467532
Minkowski - k=1 - class=2 - precision  -  0.9532467532467532
Minkowski - k=1 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=1 - class=2 - fmeasure  -  0.9538030596854126
Minkowski - k=2 - class=0 - tp  -  56
Minkowski - k=2 - class=0 - tn  -  114
Minkowski - k=2 - class=0 - fp  -  5
Minkowski - k=2 - class=0 - fn  -  3
Minkowski - k=2 - class=0 - recall  -  0.9521478521478521
Minkowski - k=2 - class=0 - precision  -  0.9521478521478521
Minkowski - k=2 - class=0 - specificity  -  0.956734569778048
Minkowski - k=2 - class=0 - fmeasure  -  0.9370379972920808
Minkowski - k=2 - class=1 - tp  -  64
Minkowski - k=2 - class=1 - tn  -  102
Minkowski - k=2 - class=1 - fp  -  5
Minkowski - k=2 - class=1 - fn  -  7
Minkowski - k=2 - class=1 - recall  -  0.8968506493506494
Minkowski - k=2 - class=1 - precision  -  0.8968506493506494
Minkowski - k=2 - class=1 - specificity  -  0.9524260651629073
Minkowski - k=2 - class=1 - fmeasure  -  0.911521164021164
Minkowski - k=2 - class=2 - tp  -  46
Minkowski - k=2 - class=2 - tn  -  128
Minkowski - k=2 - class=2 - fp  -  2
Minkowski - k=2 - class=2 - fn  -  2
Minkowski - k=2 - class=2 - recall  -  0.9532467532467532
Minkowski - k=2 - class=2 - precision  -  0.9532467532467532
Minkowski - k=2 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=2 - class=2 - fmeasure  -  0.9538030596854126
Minkowski - k=3 - class=0 - tp  -  58
Minkowski - k=3 - class=0 - tn  -  112
Minkowski - k=3 - class=0 - fp  -  7
Minkowski - k=3 - class=0 - fn  -  1
Minkowski - k=3 - class=0 - recall  -  0.9818181818181818
Minkowski - k=3 - class=0 - precision  -  0.9818181818181818
Minkowski - k=3 - class=0 - specificity  -  0.9400679031113814
Minkowski - k=3 - class=0 - fmeasure  -  0.9357676800697396
Minkowski - k=3 - class=1 - tp  -  62
Minkowski - k=3 - class=1 - tn  -  105
Minkowski - k=3 - class=1 - fp  -  2
Minkowski - k=3 - class=1 - fn  -  9
Minkowski - k=3 - class=1 - recall  -  0.8718506493506494
Minkowski - k=3 - class=1 - precision  -  0.8718506493506494
Minkowski - k=3 - class=1 - specificity  -  0.9799498746867169
Minkowski - k=3 - class=1 - fmeasure  -  0.9183397190293743
Minkowski - k=3 - class=2 - tp  -  47
Minkowski - k=3 - class=2 - tn  -  128
Minkowski - k=3 - class=2 - fp  -  2
Minkowski - k=3 - class=2 - fn  -  1
Minkowski - k=3 - class=2 - recall  -  0.9714285714285715
Minkowski - k=3 - class=2 - precision  -  0.9714285714285715
Minkowski - k=3 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=3 - class=2 - fmeasure  -  0.9633268692092221
Minkowski - k=4 - class=0 - tp  -  58
Minkowski - k=4 - class=0 - tn  -  112
Minkowski - k=4 - class=0 - fp  -  7
Minkowski - k=4 - class=0 - fn  -  1
Minkowski - k=4 - class=0 - recall  -  0.9818181818181818
Minkowski - k=4 - class=0 - precision  -  0.9818181818181818
Minkowski - k=4 - class=0 - specificity  -  0.9400679031113814
Minkowski - k=4 - class=0 - fmeasure  -  0.9357676800697396
Minkowski - k=4 - class=1 - tp  -  62
Minkowski - k=4 - class=1 - tn  -  105
Minkowski - k=4 - class=1 - fp  -  2
Minkowski - k=4 - class=1 - fn  -  9
Minkowski - k=4 - class=1 - recall  -  0.8718506493506494
Minkowski - k=4 - class=1 - precision  -  0.8718506493506494
Minkowski - k=4 - class=1 - specificity  -  0.9799498746867169
Minkowski - k=4 - class=1 - fmeasure  -  0.9183397190293743
Minkowski - k=4 - class=2 - tp  -  47
Minkowski - k=4 - class=2 - tn  -  128
Minkowski - k=4 - class=2 - fp  -  2
Minkowski - k=4 - class=2 - fn  -  1
Minkowski - k=4 - class=2 - recall  -  0.9714285714285715
Minkowski - k=4 - class=2 - precision  -  0.9714285714285715
Minkowski - k=4 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=4 - class=2 - fmeasure  -  0.9633268692092221
Minkowski - k=5 - class=0 - tp  -  59
Minkowski - k=5 - class=0 - tn  -  111
Minkowski - k=5 - class=0 - fp  -  8
Minkowski - k=5 - class=0 - fn  -  0
Minkowski - k=5 - class=0 - recall  -  1.0
Minkowski - k=5 - class=0 - precision  -  1.0
Minkowski - k=5 - class=0 - specificity  -  0.931734569778048
Minkowski - k=5 - class=0 - fmeasure  -  0.9378546365914786
Minkowski - k=5 - class=1 - tp  -  61
Minkowski - k=5 - class=1 - tn  -  107
Minkowski - k=5 - class=1 - fp  -  0
Minkowski - k=5 - class=1 - fn  -  10
Minkowski - k=5 - class=1 - recall  -  0.8593506493506494
Minkowski - k=5 - class=1 - precision  -  0.8593506493506494
Minkowski - k=5 - class=1 - specificity  -  1.0
Minkowski - k=5 - class=1 - fmeasure  -  0.9228388980113118
Minkowski - k=5 - class=2 - tp  -  48
Minkowski - k=5 - class=2 - tn  -  128
Minkowski - k=5 - class=2 - fp  -  2
Minkowski - k=5 - class=2 - fn  -  0
Minkowski - k=5 - class=2 - recall  -  1.0
Minkowski - k=5 - class=2 - precision  -  1.0
Minkowski - k=5 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=5 - class=2 - fmeasure  -  0.9787114845938376
Minkowski - k=6 - class=0 - tp  -  59
Minkowski - k=6 - class=0 - tn  -  111
Minkowski - k=6 - class=0 - fp  -  8
Minkowski - k=6 - class=0 - fn  -  0
Minkowski - k=6 - class=0 - recall  -  1.0
Minkowski - k=6 - class=0 - precision  -  1.0
Minkowski - k=6 - class=0 - specificity  -  0.931734569778048
Minkowski - k=6 - class=0 - fmeasure  -  0.9378546365914786
Minkowski - k=6 - class=1 - tp  -  61
Minkowski - k=6 - class=1 - tn  -  106
Minkowski - k=6 - class=1 - fp  -  1
Minkowski - k=6 - class=1 - fn  -  10
Minkowski - k=6 - class=1 - recall  -  0.8593506493506494
Minkowski - k=6 - class=1 - precision  -  0.8593506493506494
Minkowski - k=6 - class=1 - specificity  -  0.9904761904761905
Minkowski - k=6 - class=1 - fmeasure  -  0.9164349571246124
Minkowski - k=6 - class=2 - tp  -  47
Minkowski - k=6 - class=2 - tn  -  128
Minkowski - k=6 - class=2 - fp  -  2
Minkowski - k=6 - class=2 - fn  -  1
Minkowski - k=6 - class=2 - recall  -  0.9714285714285715
Minkowski - k=6 - class=2 - precision  -  0.9714285714285715
Minkowski - k=6 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=6 - class=2 - fmeasure  -  0.9633268692092221
Minkowski - k=7 - class=0 - tp  -  59
Minkowski - k=7 - class=0 - tn  -  110
Minkowski - k=7 - class=0 - fp  -  9
Minkowski - k=7 - class=0 - fn  -  0
Minkowski - k=7 - class=0 - recall  -  1.0
Minkowski - k=7 - class=0 - precision  -  1.0
Minkowski - k=7 - class=0 - specificity  -  0.9230389176041349
Minkowski - k=7 - class=0 - fmeasure  -  0.9314506957047792
Minkowski - k=7 - class=1 - tp  -  60
Minkowski - k=7 - class=1 - tn  -  107
Minkowski - k=7 - class=1 - fp  -  0
Minkowski - k=7 - class=1 - fn  -  11
Minkowski - k=7 - class=1 - recall  -  0.8411688311688312
Minkowski - k=7 - class=1 - precision  -  0.8411688311688312
Minkowski - k=7 - class=1 - specificity  -  1.0
Minkowski - k=7 - class=1 - fmeasure  -  0.9112599506428907
Minkowski - k=7 - class=2 - tp  -  48
Minkowski - k=7 - class=2 - tn  -  128
Minkowski - k=7 - class=2 - fp  -  2
Minkowski - k=7 - class=2 - fn  -  0
Minkowski - k=7 - class=2 - recall  -  1.0
Minkowski - k=7 - class=2 - precision  -  1.0
Minkowski - k=7 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=7 - class=2 - fmeasure  -  0.9787114845938376
Minkowski - k=8 - class=0 - tp  -  59
Minkowski - k=8 - class=0 - tn  -  110
Minkowski - k=8 - class=0 - fp  -  9
Minkowski - k=8 - class=0 - fn  -  0
Minkowski - k=8 - class=0 - recall  -  1.0
Minkowski - k=8 - class=0 - precision  -  1.0
Minkowski - k=8 - class=0 - specificity  -  0.9230389176041349
Minkowski - k=8 - class=0 - fmeasure  -  0.9314506957047792
Minkowski - k=8 - class=1 - tp  -  60
Minkowski - k=8 - class=1 - tn  -  107
Minkowski - k=8 - class=1 - fp  -  0
Minkowski - k=8 - class=1 - fn  -  11
Minkowski - k=8 - class=1 - recall  -  0.8411688311688312
Minkowski - k=8 - class=1 - precision  -  0.8411688311688312
Minkowski - k=8 - class=1 - specificity  -  1.0
Minkowski - k=8 - class=1 - fmeasure  -  0.9112599506428907
Minkowski - k=8 - class=2 - tp  -  48
Minkowski - k=8 - class=2 - tn  -  128
Minkowski - k=8 - class=2 - fp  -  2
Minkowski - k=8 - class=2 - fn  -  0
Minkowski - k=8 - class=2 - recall  -  1.0
Minkowski - k=8 - class=2 - precision  -  1.0
Minkowski - k=8 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=8 - class=2 - fmeasure  -  0.9787114845938376
Minkowski - k=9 - class=0 - tp  -  59
Minkowski - k=9 - class=0 - tn  -  108
Minkowski - k=9 - class=0 - fp  -  11
Minkowski - k=9 - class=0 - fn  -  0
Minkowski - k=9 - class=0 - recall  -  1.0
Minkowski - k=9 - class=0 - precision  -  1.0
Minkowski - k=9 - class=0 - specificity  -  0.9052523563393129
Minkowski - k=9 - class=0 - fmeasure  -  0.9194521788341822
Minkowski - k=9 - class=1 - tp  -  58
Minkowski - k=9 - class=1 - tn  -  107
Minkowski - k=9 - class=1 - fp  -  0
Minkowski - k=9 - class=1 - fn  -  13
Minkowski - k=9 - class=1 - recall  -  0.8096536796536796
Minkowski - k=9 - class=1 - precision  -  0.8096536796536796
Minkowski - k=9 - class=1 - specificity  -  1.0
Minkowski - k=9 - class=1 - fmeasure  -  0.8904579456303594
Minkowski - k=9 - class=2 - tp  -  48
Minkowski - k=9 - class=2 - tn  -  128
Minkowski - k=9 - class=2 - fp  -  2
Minkowski - k=9 - class=2 - fn  -  0
Minkowski - k=9 - class=2 - recall  -  1.0
Minkowski - k=9 - class=2 - precision  -  1.0
Minkowski - k=9 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=9 - class=2 - fmeasure  -  0.9787114845938376
Minkowski - k=10 - class=0 - tp  -  59
Minkowski - k=10 - class=0 - tn  -  110
Minkowski - k=10 - class=0 - fp  -  9
Minkowski - k=10 - class=0 - fn  -  0
Minkowski - k=10 - class=0 - recall  -  1.0
Minkowski - k=10 - class=0 - precision  -  1.0
Minkowski - k=10 - class=0 - specificity  -  0.9230389176041349
Minkowski - k=10 - class=0 - fmeasure  -  0.9314506957047792
Minkowski - k=10 - class=1 - tp  -  60
Minkowski - k=10 - class=1 - tn  -  107
Minkowski - k=10 - class=1 - fp  -  0
Minkowski - k=10 - class=1 - fn  -  11
Minkowski - k=10 - class=1 - recall  -  0.8411688311688312
Minkowski - k=10 - class=1 - precision  -  0.8411688311688312
Minkowski - k=10 - class=1 - specificity  -  1.0
Minkowski - k=10 - class=1 - fmeasure  -  0.9112599506428907
Minkowski - k=10 - class=2 - tp  -  48
Minkowski - k=10 - class=2 - tn  -  128
Minkowski - k=10 - class=2 - fp  -  2
Minkowski - k=10 - class=2 - fn  -  0
Minkowski - k=10 - class=2 - recall  -  1.0
Minkowski - k=10 - class=2 - precision  -  1.0
Minkowski - k=10 - class=2 - specificity  -  0.9849002849002849
Minkowski - k=10 - class=2 - fmeasure  -  0.9787114845938376
Cosine - k=1 - class=0 - tp  -  54
Cosine - k=1 - class=0 - tn  -  108
Cosine - k=1 - class=0 - fp  -  11
Cosine - k=1 - class=0 - fn  -  5
Cosine - k=1 - class=0 - recall  -  0.91991341991342
Cosine - k=1 - class=0 - precision  -  0.91991341991342
Cosine - k=1 - class=0 - specificity  -  0.9067675078544644
Cosine - k=1 - class=0 - fmeasure  -  0.8744978387998984
Cosine - k=1 - class=1 - tp  -  57
Cosine - k=1 - class=1 - tn  -  100
Cosine - k=1 - class=1 - fp  -  7
Cosine - k=1 - class=1 - fn  -  14
Cosine - k=1 - class=1 - recall  -  0.7926298701298701
Cosine - k=1 - class=1 - precision  -  0.7926298701298701
Cosine - k=1 - class=1 - specificity  -  0.9317179311916155
Cosine - k=1 - class=1 - fmeasure  -  0.8370991510034891
Cosine - k=1 - class=2 - tp  -  46
Cosine - k=1 - class=2 - tn  -  127
Cosine - k=1 - class=2 - fp  -  3
Cosine - k=1 - class=2 - fn  -  2
Cosine - k=1 - class=2 - recall  -  0.9568181818181818
Cosine - k=1 - class=2 - precision  -  0.9568181818181818
Cosine - k=1 - class=2 - specificity  -  0.9765669515669515
Cosine - k=1 - class=2 - fmeasure  -  0.9472943722943723
Cosine - k=2 - class=0 - tp  -  54
Cosine - k=2 - class=0 - tn  -  108
Cosine - k=2 - class=0 - fp  -  11
Cosine - k=2 - class=0 - fn  -  5
Cosine - k=2 - class=0 - recall  -  0.91991341991342
Cosine - k=2 - class=0 - precision  -  0.91991341991342
Cosine - k=2 - class=0 - specificity  -  0.9067675078544644
Cosine - k=2 - class=0 - fmeasure  -  0.8744978387998984
Cosine - k=2 - class=1 - tp  -  57
Cosine - k=2 - class=1 - tn  -  100
Cosine - k=2 - class=1 - fp  -  7
Cosine - k=2 - class=1 - fn  -  14
Cosine - k=2 - class=1 - recall  -  0.7926298701298701
Cosine - k=2 - class=1 - precision  -  0.7926298701298701
Cosine - k=2 - class=1 - specificity  -  0.9317179311916155
Cosine - k=2 - class=1 - fmeasure  -  0.8370991510034891
Cosine - k=2 - class=2 - tp  -  46
Cosine - k=2 - class=2 - tn  -  127
Cosine - k=2 - class=2 - fp  -  3
Cosine - k=2 - class=2 - fn  -  2
Cosine - k=2 - class=2 - recall  -  0.9568181818181818
Cosine - k=2 - class=2 - precision  -  0.9568181818181818
Cosine - k=2 - class=2 - specificity  -  0.9765669515669515
Cosine - k=2 - class=2 - fmeasure  -  0.9472943722943723
Cosine - k=3 - class=0 - tp  -  55
Cosine - k=3 - class=0 - tn  -  108
Cosine - k=3 - class=0 - fp  -  11
Cosine - k=3 - class=0 - fn  -  4
Cosine - k=3 - class=0 - recall  -  0.9326839826839827
Cosine - k=3 - class=0 - precision  -  0.9326839826839827
Cosine - k=3 - class=0 - specificity  -  0.9067675078544644
Cosine - k=3 - class=0 - fmeasure  -  0.8813884361252782
Cosine - k=3 - class=1 - tp  -  58
Cosine - k=3 - class=1 - tn  -  102
Cosine - k=3 - class=1 - fp  -  5
Cosine - k=3 - class=1 - fn  -  13
Cosine - k=3 - class=1 - recall  -  0.8059632034632035
Cosine - k=3 - class=1 - precision  -  0.8059632034632035
Cosine - k=3 - class=1 - specificity  -  0.9498063340168603
Cosine - k=3 - class=1 - fmeasure  -  0.8578256704980843
Cosine - k=3 - class=2 - tp  -  47
Cosine - k=3 - class=2 - tn  -  128
Cosine - k=3 - class=2 - fp  -  2
Cosine - k=3 - class=2 - fn  -  1
Cosine - k=3 - class=2 - recall  -  0.975
Cosine - k=3 - class=2 - precision  -  0.975
Cosine - k=3 - class=2 - specificity  -  0.9849002849002849
Cosine - k=3 - class=2 - fmeasure  -  0.9654761904761905
Cosine - k=4 - class=0 - tp  -  55
Cosine - k=4 - class=0 - tn  -  108
Cosine - k=4 - class=0 - fp  -  11
Cosine - k=4 - class=0 - fn  -  4
Cosine - k=4 - class=0 - recall  -  0.9326839826839827
Cosine - k=4 - class=0 - precision  -  0.9326839826839827
Cosine - k=4 - class=0 - specificity  -  0.9067675078544644
Cosine - k=4 - class=0 - fmeasure  -  0.8813884361252782
Cosine - k=4 - class=1 - tp  -  58
Cosine - k=4 - class=1 - tn  -  102
Cosine - k=4 - class=1 - fp  -  5
Cosine - k=4 - class=1 - fn  -  13
Cosine - k=4 - class=1 - recall  -  0.8059632034632035
Cosine - k=4 - class=1 - precision  -  0.8059632034632035
Cosine - k=4 - class=1 - specificity  -  0.9498063340168603
Cosine - k=4 - class=1 - fmeasure  -  0.8578256704980843
Cosine - k=4 - class=2 - tp  -  47
Cosine - k=4 - class=2 - tn  -  128
Cosine - k=4 - class=2 - fp  -  2
Cosine - k=4 - class=2 - fn  -  1
Cosine - k=4 - class=2 - recall  -  0.975
Cosine - k=4 - class=2 - precision  -  0.975
Cosine - k=4 - class=2 - specificity  -  0.9849002849002849
Cosine - k=4 - class=2 - fmeasure  -  0.9654761904761905
Cosine - k=5 - class=0 - tp  -  55
Cosine - k=5 - class=0 - tn  -  106
Cosine - k=5 - class=0 - fp  -  13
Cosine - k=5 - class=0 - fn  -  4
Cosine - k=5 - class=0 - recall  -  0.9326839826839827
Cosine - k=5 - class=0 - precision  -  0.9326839826839827
Cosine - k=5 - class=0 - specificity  -  0.8899842910712475
Cosine - k=5 - class=0 - fmeasure  -  0.8655108110280525
Cosine - k=5 - class=1 - tp  -  56
Cosine - k=5 - class=1 - tn  -  102
Cosine - k=5 - class=1 - fp  -  5
Cosine - k=5 - class=1 - fn  -  15
Cosine - k=5 - class=1 - recall  -  0.7792965367965368
Cosine - k=5 - class=1 - precision  -  0.7792965367965368
Cosine - k=5 - class=1 - specificity  -  0.9498063340168603
Cosine - k=5 - class=1 - fmeasure  -  0.8430801860974275
Cosine - k=5 - class=2 - tp  -  47
Cosine - k=5 - class=2 - tn  -  128
Cosine - k=5 - class=2 - fp  -  2
Cosine - k=5 - class=2 - fn  -  1
Cosine - k=5 - class=2 - recall  -  0.975
Cosine - k=5 - class=2 - precision  -  0.975
Cosine - k=5 - class=2 - specificity  -  0.9849002849002849
Cosine - k=5 - class=2 - fmeasure  -  0.9654761904761905
Cosine - k=6 - class=0 - tp  -  55
Cosine - k=6 - class=0 - tn  -  106
Cosine - k=6 - class=0 - fp  -  13
Cosine - k=6 - class=0 - fn  -  4
Cosine - k=6 - class=0 - recall  -  0.9326839826839827
Cosine - k=6 - class=0 - precision  -  0.9326839826839827
Cosine - k=6 - class=0 - specificity  -  0.8899842910712475
Cosine - k=6 - class=0 - fmeasure  -  0.8655108110280525
Cosine - k=6 - class=1 - tp  -  56
Cosine - k=6 - class=1 - tn  -  102
Cosine - k=6 - class=1 - fp  -  5
Cosine - k=6 - class=1 - fn  -  15
Cosine - k=6 - class=1 - recall  -  0.7792965367965368
Cosine - k=6 - class=1 - precision  -  0.7792965367965368
Cosine - k=6 - class=1 - specificity  -  0.9498063340168603
Cosine - k=6 - class=1 - fmeasure  -  0.8430801860974275
Cosine - k=6 - class=2 - tp  -  47
Cosine - k=6 - class=2 - tn  -  128
Cosine - k=6 - class=2 - fp  -  2
Cosine - k=6 - class=2 - fn  -  1
Cosine - k=6 - class=2 - recall  -  0.975
Cosine - k=6 - class=2 - precision  -  0.975
Cosine - k=6 - class=2 - specificity  -  0.9849002849002849
Cosine - k=6 - class=2 - fmeasure  -  0.9654761904761905
Cosine - k=7 - class=0 - tp  -  53
Cosine - k=7 - class=0 - tn  -  105
Cosine - k=7 - class=0 - fp  -  14
Cosine - k=7 - class=0 - fn  -  6
Cosine - k=7 - class=0 - recall  -  0.8991175491175492
Cosine - k=7 - class=0 - precision  -  0.8991175491175492
Cosine - k=7 - class=0 - specificity  -  0.8808933819803386
Cosine - k=7 - class=0 - fmeasure  -  0.8404622963243653
Cosine - k=7 - class=1 - tp  -  55
Cosine - k=7 - class=1 - tn  -  101
Cosine - k=7 - class=1 - fp  -  6
Cosine - k=7 - class=1 - fn  -  16
Cosine - k=7 - class=1 - recall  -  0.7659632034632035
Cosine - k=7 - class=1 - precision  -  0.7659632034632035
Cosine - k=7 - class=1 - specificity  -  0.9418063340168603
Cosine - k=7 - class=1 - fmeasure  -  0.8270112781954888
Cosine - k=7 - class=2 - tp  -  48
Cosine - k=7 - class=2 - tn  -  128
Cosine - k=7 - class=2 - fp  -  2
Cosine - k=7 - class=2 - fn  -  0
Cosine - k=7 - class=2 - recall  -  1.0
Cosine - k=7 - class=2 - precision  -  1.0
Cosine - k=7 - class=2 - specificity  -  0.9849002849002849
Cosine - k=7 - class=2 - fmeasure  -  0.9787114845938376
Cosine - k=8 - class=0 - tp  -  54
Cosine - k=8 - class=0 - tn  -  106
Cosine - k=8 - class=0 - fp  -  13
Cosine - k=8 - class=0 - fn  -  5
Cosine - k=8 - class=0 - recall  -  0.9145021645021645
Cosine - k=8 - class=0 - precision  -  0.9145021645021645
Cosine - k=8 - class=0 - specificity  -  0.8899842910712475
Cosine - k=8 - class=0 - fmeasure  -  0.8542553997726412
Cosine - k=8 - class=1 - tp  -  57
Cosine - k=8 - class=1 - tn  -  101
Cosine - k=8 - class=1 - fp  -  6
Cosine - k=8 - class=1 - fn  -  14
Cosine - k=8 - class=1 - recall  -  0.7917965367965368
Cosine - k=8 - class=1 - precision  -  0.7917965367965368
Cosine - k=8 - class=1 - specificity  -  0.9392800182273866
Cosine - k=8 - class=1 - fmeasure  -  0.8452860684503687
Cosine - k=8 - class=2 - tp  -  47
Cosine - k=8 - class=2 - tn  -  129
Cosine - k=8 - class=2 - fp  -  1
Cosine - k=8 - class=2 - fn  -  1
Cosine - k=8 - class=2 - recall  -  0.975
Cosine - k=8 - class=2 - precision  -  0.975
Cosine - k=8 - class=2 - specificity  -  0.9923076923076923
Cosine - k=8 - class=2 - fmeasure  -  0.9771428571428572
Cosine - k=9 - class=0 - tp  -  54
Cosine - k=9 - class=0 - tn  -  108
Cosine - k=9 - class=0 - fp  -  11
Cosine - k=9 - class=0 - fn  -  5
Cosine - k=9 - class=0 - recall  -  0.9172993672993673
Cosine - k=9 - class=0 - precision  -  0.9172993672993673
Cosine - k=9 - class=0 - specificity  -  0.9070132765784938
Cosine - k=9 - class=0 - fmeasure  -  0.8703752798925214
Cosine - k=9 - class=1 - tp  -  59
Cosine - k=9 - class=1 - tn  -  101
Cosine - k=9 - class=1 - fp  -  6
Cosine - k=9 - class=1 - fn  -  12
Cosine - k=9 - class=1 - recall  -  0.8242640692640691
Cosine - k=9 - class=1 - precision  -  0.8242640692640691
Cosine - k=9 - class=1 - specificity  -  0.9418063340168603
Cosine - k=9 - class=1 - fmeasure  -  0.863952369469611
Cosine - k=9 - class=2 - tp  -  47
Cosine - k=9 - class=2 - tn  -  129
Cosine - k=9 - class=2 - fp  -  1
Cosine - k=9 - class=2 - fn  -  1
Cosine - k=9 - class=2 - recall  -  0.975
Cosine - k=9 - class=2 - precision  -  0.975
Cosine - k=9 - class=2 - specificity  -  0.9923076923076923
Cosine - k=9 - class=2 - fmeasure  -  0.9771428571428572
Cosine - k=10 - class=0 - tp  -  55
Cosine - k=10 - class=0 - tn  -  108
Cosine - k=10 - class=0 - fp  -  11
Cosine - k=10 - class=0 - fn  -  4
Cosine - k=10 - class=0 - recall  -  0.9326839826839827
Cosine - k=10 - class=0 - precision  -  0.9326839826839827
Cosine - k=10 - class=0 - specificity  -  0.9070132765784938
Cosine - k=10 - class=0 - fmeasure  -  0.8782570532915361
Cosine - k=10 - class=1 - tp  -  59
Cosine - k=10 - class=1 - tn  -  102
Cosine - k=10 - class=1 - fp  -  5
Cosine - k=10 - class=1 - fn  -  12
Cosine - k=10 - class=1 - recall  -  0.8242640692640691
Cosine - k=10 - class=1 - precision  -  0.8242640692640691
Cosine - k=10 - class=1 - specificity  -  0.9498063340168603
Cosine - k=10 - class=1 - fmeasure  -  0.8723734221011898
Cosine - k=10 - class=2 - tp  -  47
Cosine - k=10 - class=2 - tn  -  129
Cosine - k=10 - class=2 - fp  -  1
Cosine - k=10 - class=2 - fn  -  1
Cosine - k=10 - class=2 - recall  -  0.975
Cosine - k=10 - class=2 - precision  -  0.975
Cosine - k=10 - class=2 - specificity  -  0.9923076923076923
Cosine - k=10 - class=2 - fmeasure  -  0.9771428571428572
EVALUATING NOISY DATA ==================
Euclidean | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     0    11     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 10 | TN - 23 | FP - 0 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 23 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 9 | TN - 24 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 1 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  89.66% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     1    10

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 8 | TN - 25 | FP - 1 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     1    11

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 10 | TN - 21 | FP - 2 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 22 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 3 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     1    12     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 22 | FP - 0 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     2     1
Actual Values: 1 -     0    14     1
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 0 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     1    12     1
Actual Values: 2 -     0     0    10

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 22 | FP - 0 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     2     1
Actual Values: 1 -     0    14     1
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 0 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     1     7

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 3 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 8 | TN - 25 | FP - 1 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0     7

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 10 | TN - 22 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 1 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     1    13     1
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 21 | FP - 1 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 19 | FP - 3 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0     7

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 19 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Manhattan | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 22 | FP - 1 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     1     0
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 22 | FP - 1 | FN - 1 |
  92.31% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     1     7

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 16 | FP - 3 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     7     2     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 91.43%
Error Rate: 8.57%

Class:  0
TP - 7 | TN - 25 | FP - 1 | FN - 2 |
  77.78% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 18 | FP - 2 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1    10

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 8 | TN - 24 | FP - 2 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  84.21% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 2 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  90.00% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 24 | FP - 0 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     0    11     0
Actual Values: 2 -     0     0    12

Accuracy: 94.44%
Error Rate: 5.56%

Class:  0
TP - 11 | TN - 23 | FP - 0 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 24 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  95.65% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     1     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 8 | TN - 25 | FP - 1 | FN - 1 |
  88.89% - Recall: TP / TP + FN
  88.89% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 19 | FP - 1 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  93.33% - Precision: TP / TP + FP
  95.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     1    15     0
Actual Values: 2 -     0     0     8

Accuracy: 94.29%
Error Rate: 5.71%

Class:  0
TP - 10 | TN - 23 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 15 | TN - 18 | FP - 1 | FN - 1 |
  93.75% - Recall: TP / TP + FN
  93.75% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  93.75% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     0    12

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 24 | FP - 1 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.00% - Specificity: TN / TN + FP
  90.91% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 12 | TN - 23 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  96.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 19 | FP - 2 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 10 | TN - 21 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 1 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  92.86% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    12     1
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 28 | FP - 1 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     1     6

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 2 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  90.91% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 18 | FP - 3 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     2    14     0
Actual Values: 2 -     0     0     8

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 9 | TN - 22 | FP - 2 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  81.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 2 | FN - 2 |
  87.50% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     0    13     1
Actual Values: 2 -     0     0    10

Accuracy: 97.22%
Error Rate: 2.78%

Class:  0
TP - 12 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 22 | FP - 0 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.30% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     1     6

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 19 | FP - 3 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.71% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 6 | TN - 29 | FP - 0 | FN - 1 |
  85.71% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 11 | TN - 22 | FP - 1 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 23 | FP - 2 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     3    13     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 9 | TN - 21 | FP - 3 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 2 | FN - 3 |
  81.25% - Recall: TP / TP + FN
  86.67% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Minkowski | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     0     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 97.14%
Error Rate: 2.86%

Class:  0
TP - 9 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  94.74% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 20 | FP - 0 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  96.55% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     3    10     2
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 19 | FP - 3 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     6    10     0
Actual Values: 2 -     0     1     7

Accuracy: 71.43%
Error Rate: 28.57%

Class:  0
TP - 8 | TN - 18 | FP - 6 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  57.14% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 15 | FP - 4 | FN - 6 |
  62.50% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  78.95% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 1 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     4     5     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 4 | TN - 25 | FP - 1 | FN - 5 |
  44.44% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  57.14% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 15 | FP - 5 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  73.68% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     3    10     2
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 19 | FP - 3 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  86.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     1    10     0
Actual Values: 2 -     0     1    11

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 10 | TN - 22 | FP - 1 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.65% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 3 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     6    10     0
Actual Values: 2 -     0     1     7

Accuracy: 71.43%
Error Rate: 28.57%

Class:  0
TP - 8 | TN - 18 | FP - 6 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  57.14% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 15 | FP - 4 | FN - 6 |
  62.50% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  78.95% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 0 | FN - 1 |
  87.50% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 2 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     4     5     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 4 | TN - 25 | FP - 1 | FN - 5 |
  44.44% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  57.14% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 15 | FP - 5 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  73.68% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  82.35% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     4     9     2
Actual Values: 2 -     0     0     7

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 13 | TN - 18 | FP - 4 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  81.82% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 20 | FP - 1 | FN - 6 |
  60.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  72.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     4     1
Actual Values: 1 -     2     9     0
Actual Values: 2 -     0     1    11

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 8 | TN - 21 | FP - 2 | FN - 5 |
  61.54% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  91.30% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 20 | FP - 5 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  64.29% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  72.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 8 | TN - 20 | FP - 4 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 3 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 3 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     6     3     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0    11

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 6 | TN - 23 | FP - 3 | FN - 3 |
  66.67% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  88.46% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 17 | FP - 3 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  85.00% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    14     0     0
Actual Values: 1 -     3    10     2
Actual Values: 2 -     0     0     7

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 14 | TN - 19 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  86.36% - Specificity: TN / TN + FP
  90.32% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 21 | FP - 0 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 27 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  93.10% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     3     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     0    11

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 9 | TN - 19 | FP - 4 | FN - 4 |
  69.23% - Recall: TP / TP + FN
  69.23% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  69.23% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 23 | FP - 1 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  91.67% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  91.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     5    11     0
Actual Values: 2 -     0     0     8

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 8 | TN - 19 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  79.17% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 16 | FP - 3 | FN - 5 |
  68.75% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  73.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 4 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     6     3     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 88.57%
Error Rate: 11.43%

Class:  0
TP - 6 | TN - 25 | FP - 1 | FN - 3 |
  66.67% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  75.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 17 | FP - 3 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  82.35% - Precision: TP / TP + FP
  85.00% - Specificity: TN / TN + FP
  87.50% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     0
Actual Values: 1 -     4     9     1
Actual Values: 2 -     0     0    10

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 11 | TN - 20 | FP - 4 | FN - 1 |
  91.67% - Recall: TP / TP + FN
  73.33% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  81.48% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 21 | FP - 1 | FN - 5 |
  64.29% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  95.45% - Specificity: TN / TN + FP
  75.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     5     9     1
Actual Values: 2 -     0     0     7

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 13 | TN - 17 | FP - 5 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  72.22% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 20 | FP - 1 | FN - 6 |
  60.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  72.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     4     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 72.22%
Error Rate: 27.78%

Class:  0
TP - 8 | TN - 19 | FP - 4 | FN - 5 |
  61.54% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 20 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     5    11     0
Actual Values: 2 -     0     0     8

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 8 | TN - 19 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  79.17% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 16 | FP - 3 | FN - 5 |
  68.75% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  73.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 5 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     6     3     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 6 | TN - 24 | FP - 2 | FN - 3 |
  66.67% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  70.59% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 17 | FP - 3 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  81.25% - Precision: TP / TP + FP
  85.00% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     1     0     9

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 9 | TN - 25 | FP - 1 | FN - 1 |
  90.00% - Recall: TP / TP + FN
  90.00% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  90.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     4    10     1
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 18 | FP - 4 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  76.47% - Precision: TP / TP + FP
  81.82% - Specificity: TN / TN + FP
  83.87% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    11     1     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 11 | TN - 19 | FP - 4 | FN - 2 |
  84.62% - Recall: TP / TP + FN
  73.33% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  78.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 23 | FP - 2 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  92.00% - Specificity: TN / TN + FP
  76.19% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     5    11     0
Actual Values: 2 -     0     0     8

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 8 | TN - 19 | FP - 5 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  61.54% - Precision: TP / TP + FP
  79.17% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 16 | FP - 3 | FN - 5 |
  68.75% - Recall: TP / TP + FN
  78.57% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  73.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 6 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     5     4     0
Actual Values: 1 -     1    14     0
Actual Values: 2 -     0     0    11

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 5 | TN - 25 | FP - 1 | FN - 4 |
  55.56% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  66.67% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 14 | TN - 16 | FP - 4 | FN - 1 |
  93.33% - Recall: TP / TP + FN
  77.78% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  84.85% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     2    11     1
Actual Values: 2 -     0     0    10

Accuracy: 91.67%
Error Rate: 8.33%

Class:  0
TP - 12 | TN - 22 | FP - 2 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  91.67% - Specificity: TN / TN + FP
  92.31% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 22 | FP - 0 | FN - 3 |
  78.57% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  88.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     5    10     0
Actual Values: 2 -     0     0     7

Accuracy: 80.56%
Error Rate: 19.44%

Class:  0
TP - 12 | TN - 17 | FP - 5 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  70.59% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 19 | FP - 2 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  83.33% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 10 | TN - 19 | FP - 4 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     6    10     0
Actual Values: 2 -     0     0     8

Accuracy: 74.29%
Error Rate: 25.71%

Class:  0
TP - 8 | TN - 18 | FP - 6 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  57.14% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  64.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 16 | FP - 3 | FN - 6 |
  62.50% - Recall: TP / TP + FN
  76.92% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  68.97% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 7 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     4     5     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 4 | TN - 24 | FP - 2 | FN - 5 |
  44.44% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  53.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 15 | FP - 5 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  72.22% - Precision: TP / TP + FP
  75.00% - Specificity: TN / TN + FP
  78.79% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     3    10     1
Actual Values: 2 -     0     0    10

Accuracy: 88.89%
Error Rate: 11.11%

Class:  0
TP - 12 | TN - 21 | FP - 3 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  87.50% - Specificity: TN / TN + FP
  88.89% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 22 | FP - 0 | FN - 4 |
  71.43% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  83.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     4    11     0
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 12 | TN - 18 | FP - 4 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  81.82% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 11 | TN - 19 | FP - 2 | FN - 4 |
  73.33% - Recall: TP / TP + FN
  84.62% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  78.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 10 | TN - 19 | FP - 4 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     8     3     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 8 | TN - 20 | FP - 4 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 3 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  80.00% - Precision: TP / TP + FP
  84.21% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 8 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     3     6     0
Actual Values: 1 -     2    13     0
Actual Values: 2 -     0     0    11

Accuracy: 77.14%
Error Rate: 22.86%

Class:  0
TP - 3 | TN - 24 | FP - 2 | FN - 6 |
  33.33% - Recall: TP / TP + FN
  60.00% - Precision: TP / TP + FP
  92.31% - Specificity: TN / TN + FP
  42.86% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 13 | TN - 14 | FP - 6 | FN - 2 |
  86.67% - Recall: TP / TP + FN
  68.42% - Precision: TP / TP + FP
  70.00% - Specificity: TN / TN + FP
  76.47% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     4     9     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 22 | FP - 0 | FN - 5 |
  64.29% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     2     0
Actual Values: 1 -     5     9     1
Actual Values: 2 -     0     0     7

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 12 | TN - 17 | FP - 5 | FN - 2 |
  85.71% - Recall: TP / TP + FN
  70.59% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 19 | FP - 2 | FN - 6 |
  60.00% - Recall: TP / TP + FN
  81.82% - Precision: TP / TP + FP
  90.48% - Specificity: TN / TN + FP
  69.23% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 28 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  87.50% - Precision: TP / TP + FP
  96.55% - Specificity: TN / TN + FP
  93.33% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     3     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 75.00%
Error Rate: 25.00%

Class:  0
TP - 9 | TN - 19 | FP - 4 | FN - 4 |
  69.23% - Recall: TP / TP + FN
  69.23% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  69.23% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 21 | FP - 4 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  66.67% - Precision: TP / TP + FP
  84.00% - Specificity: TN / TN + FP
  69.57% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     1     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 85.71%
Error Rate: 14.29%

Class:  0
TP - 10 | TN - 20 | FP - 4 | FN - 1 |
  90.91% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 18 | FP - 1 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  92.31% - Precision: TP / TP + FP
  94.74% - Specificity: TN / TN + FP
  82.76% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 9 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     5     4     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0    11

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 5 | TN - 23 | FP - 3 | FN - 4 |
  55.56% - Recall: TP / TP + FN
  62.50% - Precision: TP / TP + FP
  88.46% - Specificity: TN / TN + FP
  58.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 4 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 0  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    12     0     0
Actual Values: 1 -     4     9     1
Actual Values: 2 -     0     0    10

Accuracy: 86.11%
Error Rate: 13.89%

Class:  0
TP - 12 | TN - 20 | FP - 4 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  85.71% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 9 | TN - 22 | FP - 0 | FN - 5 |
  64.29% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  78.26% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 25 | FP - 1 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  96.15% - Specificity: TN / TN + FP
  95.24% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 1  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    13     1     0
Actual Values: 1 -     5    10     0
Actual Values: 2 -     0     0     7

Accuracy: 83.33%
Error Rate: 16.67%

Class:  0
TP - 13 | TN - 17 | FP - 5 | FN - 1 |
  92.86% - Recall: TP / TP + FN
  72.22% - Precision: TP / TP + FP
  77.27% - Specificity: TN / TN + FP
  81.25% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 10 | TN - 20 | FP - 1 | FN - 5 |
  66.67% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.24% - Specificity: TN / TN + FP
  76.92% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 7 | TN - 29 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 2  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -    10     2     1
Actual Values: 1 -     3     8     0
Actual Values: 2 -     1     1    10

Accuracy: 77.78%
Error Rate: 22.22%

Class:  0
TP - 10 | TN - 19 | FP - 4 | FN - 3 |
  76.92% - Recall: TP / TP + FN
  71.43% - Precision: TP / TP + FP
  82.61% - Specificity: TN / TN + FP
  74.07% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 8 | TN - 22 | FP - 3 | FN - 3 |
  72.73% - Recall: TP / TP + FN
  72.73% - Precision: TP / TP + FP
  88.00% - Specificity: TN / TN + FP
  72.73% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 10 | TN - 23 | FP - 1 | FN - 2 |
  83.33% - Recall: TP / TP + FN
  90.91% - Precision: TP / TP + FP
  95.83% - Specificity: TN / TN + FP
  86.96% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 3  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     9     2     0
Actual Values: 1 -     4    12     0
Actual Values: 2 -     0     0     8

Accuracy: 82.86%
Error Rate: 17.14%

Class:  0
TP - 9 | TN - 20 | FP - 4 | FN - 2 |
  81.82% - Recall: TP / TP + FN
  69.23% - Precision: TP / TP + FP
  83.33% - Specificity: TN / TN + FP
  75.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 17 | FP - 2 | FN - 4 |
  75.00% - Recall: TP / TP + FN
  85.71% - Precision: TP / TP + FP
  89.47% - Specificity: TN / TN + FP
  80.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 8 | TN - 27 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Cosine | K-Neighbours: 10 | Fold: 4  ================================================
Confusion Matrix ==========
Predicted Values:      0|    1|    2|
Actual Values: 0 -     5     4     0
Actual Values: 1 -     3    12     0
Actual Values: 2 -     0     0    11

Accuracy: 80.00%
Error Rate: 20.00%

Class:  0
TP - 5 | TN - 23 | FP - 3 | FN - 4 |
  55.56% - Recall: TP / TP + FN
  62.50% - Precision: TP / TP + FP
  88.46% - Specificity: TN / TN + FP
  58.82% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  1
TP - 12 | TN - 16 | FP - 4 | FN - 3 |
  80.00% - Recall: TP / TP + FN
  75.00% - Precision: TP / TP + FP
  80.00% - Specificity: TN / TN + FP
  77.42% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)


Class:  2
TP - 11 | TN - 24 | FP - 0 | FN - 0 |
  100.00% - Recall: TP / TP + FN
  100.00% - Precision: TP / TP + FP
  100.00% - Specificity: TN / TN + FP
  100.00% - Fmeasure:  2 * Recall * Precision / (Recall + Precision)

None
============================================================
Euclidean - k=1 - class=0 - tp  -  51
Euclidean - k=1 - class=0 - tn  -  112
Euclidean - k=1 - class=0 - fp  -  7
Euclidean - k=1 - class=0 - fn  -  8
Euclidean - k=1 - class=0 - recall  -  0.8598512598512599
Euclidean - k=1 - class=0 - precision  -  0.8598512598512599
Euclidean - k=1 - class=0 - specificity  -  0.9404302219519611
Euclidean - k=1 - class=0 - fmeasure  -  0.8686561929119474
Euclidean - k=1 - class=1 - tp  -  62
Euclidean - k=1 - class=1 - tn  -  98
Euclidean - k=1 - class=1 - fp  -  9
Euclidean - k=1 - class=1 - fn  -  9
Euclidean - k=1 - class=1 - recall  -  0.8766991341991343
Euclidean - k=1 - class=1 - precision  -  0.8766991341991343
Euclidean - k=1 - class=1 - specificity  -  0.9133734335839598
Euclidean - k=1 - class=1 - fmeasure  -  0.8751680387404864
Euclidean - k=1 - class=2 - tp  -  46
Euclidean - k=1 - class=2 - tn  -  127
Euclidean - k=1 - class=2 - fp  -  3
Euclidean - k=1 - class=2 - fn  -  2
Euclidean - k=1 - class=2 - recall  -  0.9583333333333333
Euclidean - k=1 - class=2 - precision  -  0.9583333333333333
Euclidean - k=1 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=1 - class=2 - fmeasure  -  0.9471428571428572
Euclidean - k=2 - class=0 - tp  -  51
Euclidean - k=2 - class=0 - tn  -  112
Euclidean - k=2 - class=0 - fp  -  7
Euclidean - k=2 - class=0 - fn  -  8
Euclidean - k=2 - class=0 - recall  -  0.8598512598512599
Euclidean - k=2 - class=0 - precision  -  0.8598512598512599
Euclidean - k=2 - class=0 - specificity  -  0.9404302219519611
Euclidean - k=2 - class=0 - fmeasure  -  0.8686561929119474
Euclidean - k=2 - class=1 - tp  -  62
Euclidean - k=2 - class=1 - tn  -  98
Euclidean - k=2 - class=1 - fp  -  9
Euclidean - k=2 - class=1 - fn  -  9
Euclidean - k=2 - class=1 - recall  -  0.8766991341991343
Euclidean - k=2 - class=1 - precision  -  0.8766991341991343
Euclidean - k=2 - class=1 - specificity  -  0.9133734335839598
Euclidean - k=2 - class=1 - fmeasure  -  0.8751680387404864
Euclidean - k=2 - class=2 - tp  -  46
Euclidean - k=2 - class=2 - tn  -  127
Euclidean - k=2 - class=2 - fp  -  3
Euclidean - k=2 - class=2 - fn  -  2
Euclidean - k=2 - class=2 - recall  -  0.9583333333333333
Euclidean - k=2 - class=2 - precision  -  0.9583333333333333
Euclidean - k=2 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=2 - class=2 - fmeasure  -  0.9471428571428572
Euclidean - k=3 - class=0 - tp  -  52
Euclidean - k=3 - class=0 - tn  -  112
Euclidean - k=3 - class=0 - fp  -  7
Euclidean - k=3 - class=0 - fn  -  7
Euclidean - k=3 - class=0 - recall  -  0.8889110889110888
Euclidean - k=3 - class=0 - precision  -  0.8889110889110888
Euclidean - k=3 - class=0 - specificity  -  0.9414335664335665
Euclidean - k=3 - class=0 - fmeasure  -  0.8818633540372671
Euclidean - k=3 - class=1 - tp  -  62
Euclidean - k=3 - class=1 - tn  -  100
Euclidean - k=3 - class=1 - fp  -  7
Euclidean - k=3 - class=1 - fn  -  9
Euclidean - k=3 - class=1 - recall  -  0.881547619047619
Euclidean - k=3 - class=1 - precision  -  0.881547619047619
Euclidean - k=3 - class=1 - specificity  -  0.9338997493734336
Euclidean - k=3 - class=1 - fmeasure  -  0.8884954476166935
Euclidean - k=3 - class=2 - tp  -  47
Euclidean - k=3 - class=2 - tn  -  127
Euclidean - k=3 - class=2 - fp  -  3
Euclidean - k=3 - class=2 - fn  -  1
Euclidean - k=3 - class=2 - recall  -  0.9818181818181818
Euclidean - k=3 - class=2 - precision  -  0.9818181818181818
Euclidean - k=3 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=3 - class=2 - fmeasure  -  0.9596190476190476
Euclidean - k=4 - class=0 - tp  -  52
Euclidean - k=4 - class=0 - tn  -  112
Euclidean - k=4 - class=0 - fp  -  7
Euclidean - k=4 - class=0 - fn  -  7
Euclidean - k=4 - class=0 - recall  -  0.882073482073482
Euclidean - k=4 - class=0 - precision  -  0.882073482073482
Euclidean - k=4 - class=0 - specificity  -  0.9404302219519611
Euclidean - k=4 - class=0 - fmeasure  -  0.881728088336784
Euclidean - k=4 - class=1 - tp  -  62
Euclidean - k=4 - class=1 - tn  -  100
Euclidean - k=4 - class=1 - fp  -  7
Euclidean - k=4 - class=1 - fn  -  9
Euclidean - k=4 - class=1 - recall  -  0.8766991341991343
Euclidean - k=4 - class=1 - precision  -  0.8766991341991343
Euclidean - k=4 - class=1 - specificity  -  0.9318997493734337
Euclidean - k=4 - class=1 - fmeasure  -  0.8883151125642783
Euclidean - k=4 - class=2 - tp  -  47
Euclidean - k=4 - class=2 - tn  -  127
Euclidean - k=4 - class=2 - fp  -  3
Euclidean - k=4 - class=2 - fn  -  1
Euclidean - k=4 - class=2 - recall  -  0.9818181818181818
Euclidean - k=4 - class=2 - precision  -  0.9818181818181818
Euclidean - k=4 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=4 - class=2 - fmeasure  -  0.9596190476190476
Euclidean - k=5 - class=0 - tp  -  52
Euclidean - k=5 - class=0 - tn  -  112
Euclidean - k=5 - class=0 - fp  -  7
Euclidean - k=5 - class=0 - fn  -  7
Euclidean - k=5 - class=0 - recall  -  0.8889110889110888
Euclidean - k=5 - class=0 - precision  -  0.8889110889110888
Euclidean - k=5 - class=0 - specificity  -  0.9404302219519611
Euclidean - k=5 - class=0 - fmeasure  -  0.8840906614361993
Euclidean - k=5 - class=1 - tp  -  62
Euclidean - k=5 - class=1 - tn  -  100
Euclidean - k=5 - class=1 - fp  -  7
Euclidean - k=5 - class=1 - fn  -  9
Euclidean - k=5 - class=1 - recall  -  0.8766991341991343
Euclidean - k=5 - class=1 - precision  -  0.8766991341991343
Euclidean - k=5 - class=1 - specificity  -  0.9358997493734336
Euclidean - k=5 - class=1 - fmeasure  -  0.8856218843983028
Euclidean - k=5 - class=2 - tp  -  47
Euclidean - k=5 - class=2 - tn  -  127
Euclidean - k=5 - class=2 - fp  -  3
Euclidean - k=5 - class=2 - fn  -  1
Euclidean - k=5 - class=2 - recall  -  0.9833333333333332
Euclidean - k=5 - class=2 - precision  -  0.9833333333333332
Euclidean - k=5 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=5 - class=2 - fmeasure  -  0.9604761904761905
Euclidean - k=6 - class=0 - tp  -  53
Euclidean - k=6 - class=0 - tn  -  112
Euclidean - k=6 - class=0 - fp  -  7
Euclidean - k=6 - class=0 - fn  -  6
Euclidean - k=6 - class=0 - recall  -  0.9042957042957044
Euclidean - k=6 - class=0 - precision  -  0.9042957042957044
Euclidean - k=6 - class=0 - specificity  -  0.9404302219519611
Euclidean - k=6 - class=0 - fmeasure  -  0.8934239947695325
Euclidean - k=6 - class=1 - tp  -  62
Euclidean - k=6 - class=1 - tn  -  102
Euclidean - k=6 - class=1 - fp  -  5
Euclidean - k=6 - class=1 - fn  -  9
Euclidean - k=6 - class=1 - recall  -  0.8766991341991343
Euclidean - k=6 - class=1 - precision  -  0.8766991341991343
Euclidean - k=6 - class=1 - specificity  -  0.9518997493734336
Euclidean - k=6 - class=1 - fmeasure  -  0.9007733995498178
Euclidean - k=6 - class=2 - tp  -  48
Euclidean - k=6 - class=2 - tn  -  127
Euclidean - k=6 - class=2 - fp  -  3
Euclidean - k=6 - class=2 - fn  -  0
Euclidean - k=6 - class=2 - recall  -  1.0
Euclidean - k=6 - class=2 - precision  -  1.0
Euclidean - k=6 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=6 - class=2 - fmeasure  -  0.9691428571428571
Euclidean - k=7 - class=0 - tp  -  53
Euclidean - k=7 - class=0 - tn  -  111
Euclidean - k=7 - class=0 - fp  -  8
Euclidean - k=7 - class=0 - fn  -  6
Euclidean - k=7 - class=0 - recall  -  0.9070929070929072
Euclidean - k=7 - class=0 - precision  -  0.9070929070929072
Euclidean - k=7 - class=0 - specificity  -  0.931734569778048
Euclidean - k=7 - class=0 - fmeasure  -  0.8875689223057645
Euclidean - k=7 - class=1 - tp  -  61
Euclidean - k=7 - class=1 - tn  -  101
Euclidean - k=7 - class=1 - fp  -  6
Euclidean - k=7 - class=1 - fn  -  10
Euclidean - k=7 - class=1 - recall  -  0.8585173160173161
Euclidean - k=7 - class=1 - precision  -  0.8585173160173161
Euclidean - k=7 - class=1 - specificity  -  0.9464260651629072
Euclidean - k=7 - class=1 - fmeasure  -  0.8810683547115332
Euclidean - k=7 - class=2 - tp  -  47
Euclidean - k=7 - class=2 - tn  -  127
Euclidean - k=7 - class=2 - fp  -  3
Euclidean - k=7 - class=2 - fn  -  1
Euclidean - k=7 - class=2 - recall  -  0.9833333333333332
Euclidean - k=7 - class=2 - precision  -  0.9833333333333332
Euclidean - k=7 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=7 - class=2 - fmeasure  -  0.9604761904761905
Euclidean - k=8 - class=0 - tp  -  52
Euclidean - k=8 - class=0 - tn  -  112
Euclidean - k=8 - class=0 - fp  -  7
Euclidean - k=8 - class=0 - fn  -  7
Euclidean - k=8 - class=0 - recall  -  0.8889110889110888
Euclidean - k=8 - class=0 - precision  -  0.8889110889110888
Euclidean - k=8 - class=0 - specificity  -  0.9404302219519611
Euclidean - k=8 - class=0 - fmeasure  -  0.8840906614361993
Euclidean - k=8 - class=1 - tp  -  62
Euclidean - k=8 - class=1 - tn  -  100
Euclidean - k=8 - class=1 - fp  -  7
Euclidean - k=8 - class=1 - fn  -  9
Euclidean - k=8 - class=1 - recall  -  0.8766991341991343
Euclidean - k=8 - class=1 - precision  -  0.8766991341991343
Euclidean - k=8 - class=1 - specificity  -  0.9358997493734336
Euclidean - k=8 - class=1 - fmeasure  -  0.8856218843983028
Euclidean - k=8 - class=2 - tp  -  47
Euclidean - k=8 - class=2 - tn  -  127
Euclidean - k=8 - class=2 - fp  -  3
Euclidean - k=8 - class=2 - fn  -  1
Euclidean - k=8 - class=2 - recall  -  0.9833333333333332
Euclidean - k=8 - class=2 - precision  -  0.9833333333333332
Euclidean - k=8 - class=2 - specificity  -  0.9770778072502211
Euclidean - k=8 - class=2 - fmeasure  -  0.9604761904761905
Euclidean - k=9 - class=0 - tp  -  53
Euclidean - k=9 - class=0 - tn  -  113
Euclidean - k=9 - class=0 - fp  -  6
Euclidean - k=9 - class=0 - fn  -  6
Euclidean - k=9 - class=0 - recall  -  0.9042957042957044
Euclidean - k=9 - class=0 - precision  -  0.9042957042957044
Euclidean - k=9 - class=0 - specificity  -  0.9487635552852943
Euclidean - k=9 - class=0 - fmeasure  -  0.9005386192754614
Euclidean - k=9 - class=1 - tp  -  64
Euclidean - k=9 - class=1 - tn  -  100
Euclidean - k=9 - class=1 - fp  -  7
Euclidean - k=9 - class=1 - fn  -  7
Euclidean - k=9 - class=1 - recall  -  0.9025324675324675
Euclidean - k=9 - class=1 - precision  -  0.9025324675324675
Euclidean - k=9 - class=1 - specificity  -  0.9343759398496241
Euclidean - k=9 - class=1 - fmeasure  -  0.9023510198305864
Euclidean - k=9 - class=2 - tp  -  46
Euclidean - k=9 - class=2 - tn  -  128
Euclidean - k=9 - class=2 - fp  -  2
Euclidean - k=9 - class=2 - fn  -  2
Euclidean - k=9 - class=2 - recall  -  0.9547619047619047
Euclidean - k=9 - class=2 - precision  -  0.9547619047619047
Euclidean - k=9 - class=2 - specificity  -  0.9839743589743591
Euclidean - k=9 - class=2 - fmeasure  -  0.9584249084249084
Euclidean - k=10 - class=0 - tp  -  53
Euclidean - k=10 - class=0 - tn  -  112
Euclidean - k=10 - class=0 - fp  -  7
Euclidean - k=10 - class=0 - fn  -  6
Euclidean - k=10 - class=0 - recall  -  0.9042957042957044
Euclidean - k=10 - class=0 - precision  -  0.9042957042957044
Euclidean - k=10 - class=0 - specificity  -  0.9404302219519611
Euclidean - k=10 - class=0 - fmeasure  -  0.8934239947695325
Euclidean - k=10 - class=1 - tp  -  63
Euclidean - k=10 - class=1 - tn  -  101
Euclidean - k=10 - class=1 - fp  -  6
Euclidean - k=10 - class=1 - fn  -  8
Euclidean - k=10 - class=1 - recall  -  0.8900324675324676
Euclidean - k=10 - class=1 - precision  -  0.8900324675324676
Euclidean - k=10 - class=1 - specificity  -  0.9438997493734336
Euclidean - k=10 - class=1 - fmeasure  -  0.9006843531639198
Euclidean - k=10 - class=2 - tp  -  47
Euclidean - k=10 - class=2 - tn  -  128
Euclidean - k=10 - class=2 - fp  -  2
Euclidean - k=10 - class=2 - fn  -  1
Euclidean - k=10 - class=2 - recall  -  0.9833333333333332
Euclidean - k=10 - class=2 - precision  -  0.9833333333333332
Euclidean - k=10 - class=2 - specificity  -  0.9839743589743591
Euclidean - k=10 - class=2 - fmeasure  -  0.9738095238095237
Manhattan - k=1 - class=0 - tp  -  49
Manhattan - k=1 - class=0 - tn  -  114
Manhattan - k=1 - class=0 - fp  -  5
Manhattan - k=1 - class=0 - fn  -  10
Manhattan - k=1 - class=0 - recall  -  0.8301809301809302
Manhattan - k=1 - class=0 - precision  -  0.8301809301809302
Manhattan - k=1 - class=0 - specificity  -  0.9586120401337792
Manhattan - k=1 - class=0 - fmeasure  -  0.8630089126559716
Manhattan - k=1 - class=1 - tp  -  64
Manhattan - k=1 - class=1 - tn  -  97
Manhattan - k=1 - class=1 - fp  -  10
Manhattan - k=1 - class=1 - fn  -  7
Manhattan - k=1 - class=1 - recall  -  0.9015800865800866
Manhattan - k=1 - class=1 - precision  -  0.9015800865800866
Manhattan - k=1 - class=1 - specificity  -  0.9053734335839598
Manhattan - k=1 - class=1 - fmeasure  -  0.8822693435596662
Manhattan - k=1 - class=2 - tp  -  46
Manhattan - k=1 - class=2 - tn  -  126
Manhattan - k=1 - class=2 - fp  -  4
Manhattan - k=1 - class=2 - fn  -  2
Manhattan - k=1 - class=2 - recall  -  0.9583333333333333
Manhattan - k=1 - class=2 - precision  -  0.9583333333333333
Manhattan - k=1 - class=2 - specificity  -  0.9701812555260831
Manhattan - k=1 - class=2 - fmeasure  -  0.9354761904761905
Manhattan - k=2 - class=0 - tp  -  49
Manhattan - k=2 - class=0 - tn  -  114
Manhattan - k=2 - class=0 - fp  -  5
Manhattan - k=2 - class=0 - fn  -  10
Manhattan - k=2 - class=0 - recall  -  0.8301809301809302
Manhattan - k=2 - class=0 - precision  -  0.8301809301809302
Manhattan - k=2 - class=0 - specificity  -  0.9586120401337792
Manhattan - k=2 - class=0 - fmeasure  -  0.8630089126559716
Manhattan - k=2 - class=1 - tp  -  64
Manhattan - k=2 - class=1 - tn  -  97
Manhattan - k=2 - class=1 - fp  -  10
Manhattan - k=2 - class=1 - fn  -  7
Manhattan - k=2 - class=1 - recall  -  0.9015800865800866
Manhattan - k=2 - class=1 - precision  -  0.9015800865800866
Manhattan - k=2 - class=1 - specificity  -  0.9053734335839598
Manhattan - k=2 - class=1 - fmeasure  -  0.8822693435596662
Manhattan - k=2 - class=2 - tp  -  46
Manhattan - k=2 - class=2 - tn  -  126
Manhattan - k=2 - class=2 - fp  -  4
Manhattan - k=2 - class=2 - fn  -  2
Manhattan - k=2 - class=2 - recall  -  0.9583333333333333
Manhattan - k=2 - class=2 - precision  -  0.9583333333333333
Manhattan - k=2 - class=2 - specificity  -  0.9701812555260831
Manhattan - k=2 - class=2 - fmeasure  -  0.9354761904761905
Manhattan - k=3 - class=0 - tp  -  52
Manhattan - k=3 - class=0 - tn  -  113
Manhattan - k=3 - class=0 - fp  -  6
Manhattan - k=3 - class=0 - fn  -  7
Manhattan - k=3 - class=0 - recall  -  0.8889110889110888
Manhattan - k=3 - class=0 - precision  -  0.8889110889110888
Manhattan - k=3 - class=0 - specificity  -  0.9495211310428703
Manhattan - k=3 - class=0 - fmeasure  -  0.8904398677854056
Manhattan - k=3 - class=1 - tp  -  64
Manhattan - k=3 - class=1 - tn  -  101
Manhattan - k=3 - class=1 - fp  -  6
Manhattan - k=3 - class=1 - fn  -  7
Manhattan - k=3 - class=1 - recall  -  0.9033658008658009
Manhattan - k=3 - class=1 - precision  -  0.9033658008658009
Manhattan - k=3 - class=1 - specificity  -  0.9438997493734336
Manhattan - k=3 - class=1 - fmeasure  -  0.907996181120909
Manhattan - k=3 - class=2 - tp  -  48
Manhattan - k=3 - class=2 - tn  -  128
Manhattan - k=3 - class=2 - fp  -  2
Manhattan - k=3 - class=2 - fn  -  0
Manhattan - k=3 - class=2 - recall  -  1.0
Manhattan - k=3 - class=2 - precision  -  1.0
Manhattan - k=3 - class=2 - specificity  -  0.9839743589743591
Manhattan - k=3 - class=2 - fmeasure  -  0.9824761904761905
Manhattan - k=4 - class=0 - tp  -  51
Manhattan - k=4 - class=0 - tn  -  113
Manhattan - k=4 - class=0 - fp  -  6
Manhattan - k=4 - class=0 - fn  -  8
Manhattan - k=4 - class=0 - recall  -  0.8666888666888667
Manhattan - k=4 - class=0 - precision  -  0.8666888666888667
Manhattan - k=4 - class=0 - specificity  -  0.9495211310428703
Manhattan - k=4 - class=0 - fmeasure  -  0.8787439613526569
Manhattan - k=4 - class=1 - tp  -  64
Manhattan - k=4 - class=1 - tn  -  99
Manhattan - k=4 - class=1 - fp  -  8
Manhattan - k=4 - class=1 - fn  -  7
Manhattan - k=4 - class=1 - recall  -  0.9033658008658009
Manhattan - k=4 - class=1 - precision  -  0.9033658008658009
Manhattan - k=4 - class=1 - specificity  -  0.9258997493734336
Manhattan - k=4 - class=1 - fmeasure  -  0.8943130227001195
Manhattan - k=4 - class=2 - tp  -  47
Manhattan - k=4 - class=2 - tn  -  128
Manhattan - k=4 - class=2 - fp  -  2
Manhattan - k=4 - class=2 - fn  -  1
Manhattan - k=4 - class=2 - recall  -  0.9833333333333332
Manhattan - k=4 - class=2 - precision  -  0.9833333333333332
Manhattan - k=4 - class=2 - specificity  -  0.9839743589743591
Manhattan - k=4 - class=2 - fmeasure  -  0.9738095238095237
Manhattan - k=5 - class=0 - tp  -  53
Manhattan - k=5 - class=0 - tn  -  112
Manhattan - k=5 - class=0 - fp  -  7
Manhattan - k=5 - class=0 - fn  -  6
Manhattan - k=5 - class=0 - recall  -  0.9042957042957044
Manhattan - k=5 - class=0 - precision  -  0.9042957042957044
Manhattan - k=5 - class=0 - specificity  -  0.9404302219519611
Manhattan - k=5 - class=0 - fmeasure  -  0.8934239947695325
Manhattan - k=5 - class=1 - tp  -  63
Manhattan - k=5 - class=1 - tn  -  101
Manhattan - k=5 - class=1 - fp  -  6
Manhattan - k=5 - class=1 - fn  -  8
Manhattan - k=5 - class=1 - recall  -  0.8900324675324676
Manhattan - k=5 - class=1 - precision  -  0.8900324675324676
Manhattan - k=5 - class=1 - specificity  -  0.9438997493734336
Manhattan - k=5 - class=1 - fmeasure  -  0.9006843531639198
Manhattan - k=5 - class=2 - tp  -  47
Manhattan - k=5 - class=2 - tn  -  128
Manhattan - k=5 - class=2 - fp  -  2
Manhattan - k=5 - class=2 - fn  -  1
Manhattan - k=5 - class=2 - recall  -  0.9833333333333332
Manhattan - k=5 - class=2 - precision  -  0.9833333333333332
Manhattan - k=5 - class=2 - specificity  -  0.9839743589743591
Manhattan - k=5 - class=2 - fmeasure  -  0.9738095238095237
Manhattan - k=6 - class=0 - tp  -  52
Manhattan - k=6 - class=0 - tn  -  114
Manhattan - k=6 - class=0 - fp  -  5
Manhattan - k=6 - class=0 - fn  -  7
Manhattan - k=6 - class=0 - recall  -  0.8889110889110888
Manhattan - k=6 - class=0 - precision  -  0.8889110889110888
Manhattan - k=6 - class=0 - specificity  -  0.9578544643762035
Manhattan - k=6 - class=0 - fmeasure  -  0.8975544922913345
Manhattan - k=6 - class=1 - tp  -  65
Manhattan - k=6 - class=1 - tn  -  100
Manhattan - k=6 - class=1 - fp  -  7
Manhattan - k=6 - class=1 - fn  -  6
Manhattan - k=6 - class=1 - recall  -  0.9158658008658008
Manhattan - k=6 - class=1 - precision  -  0.9158658008658008
Manhattan - k=6 - class=1 - specificity  -  0.9358997493734336
Manhattan - k=6 - class=1 - fmeasure  -  0.9080078688254438
Manhattan - k=6 - class=2 - tp  -  47
Manhattan - k=6 - class=2 - tn  -  128
Manhattan - k=6 - class=2 - fp  -  2
Manhattan - k=6 - class=2 - fn  -  1
Manhattan - k=6 - class=2 - recall  -  0.9833333333333332
Manhattan - k=6 - class=2 - precision  -  0.9833333333333332
Manhattan - k=6 - class=2 - specificity  -  0.9839743589743591
Manhattan - k=6 - class=2 - fmeasure  -  0.9738095238095237
Manhattan - k=7 - class=0 - tp  -  54
Manhattan - k=7 - class=0 - tn  -  113
Manhattan - k=7 - class=0 - fp  -  6
Manhattan - k=7 - class=0 - fn  -  5
Manhattan - k=7 - class=0 - recall  -  0.9224775224775226
Manhattan - k=7 - class=0 - precision  -  0.9224775224775226
Manhattan - k=7 - class=0 - specificity  -  0.9487635552852943
Manhattan - k=7 - class=0 - fmeasure  -  0.9108152991173586
Manhattan - k=7 - class=1 - tp  -  64
Manhattan - k=7 - class=1 - tn  -  102
Manhattan - k=7 - class=1 - fp  -  5
Manhattan - k=7 - class=1 - fn  -  7
Manhattan - k=7 - class=1 - recall  -  0.9025324675324675
Manhattan - k=7 - class=1 - precision  -  0.9025324675324675
Manhattan - k=7 - class=1 - specificity  -  0.9544260651629072
Manhattan - k=7 - class=1 - fmeasure  -  0.9135875789703715
Manhattan - k=7 - class=2 - tp  -  47
Manhattan - k=7 - class=2 - tn  -  128
Manhattan - k=7 - class=2 - fp  -  2
Manhattan - k=7 - class=2 - fn  -  1
Manhattan - k=7 - class=2 - recall  -  0.9833333333333332
Manhattan - k=7 - class=2 - precision  -  0.9833333333333332
Manhattan - k=7 - class=2 - specificity  -  0.9839743589743591
Manhattan - k=7 - class=2 - fmeasure  -  0.9738095238095237
Manhattan - k=8 - class=0 - tp  -  52
Manhattan - k=8 - class=0 - tn  -  114
Manhattan - k=8 - class=0 - fp  -  5
Manhattan - k=8 - class=0 - fn  -  7
Manhattan - k=8 - class=0 - recall  -  0.8889110889110888
Manhattan - k=8 - class=0 - precision  -  0.8889110889110888
Manhattan - k=8 - class=0 - specificity  -  0.9578544643762035
Manhattan - k=8 - class=0 - fmeasure  -  0.8975544922913345
Manhattan - k=8 - class=1 - tp  -  64
Manhattan - k=8 - class=1 - tn  -  100
Manhattan - k=8 - class=1 - fp  -  7
Manhattan - k=8 - class=1 - fn  -  7
Manhattan - k=8 - class=1 - recall  -  0.9025324675324675
Manhattan - k=8 - class=1 - precision  -  0.9025324675324675
Manhattan - k=8 - class=1 - specificity  -  0.9358997493734336
Manhattan - k=8 - class=1 - fmeasure  -  0.9006960408684547
Manhattan - k=8 - class=2 - tp  -  47
Manhattan - k=8 - class=2 - tn  -  127
Manhattan - k=8 - class=2 - fp  -  3
Manhattan - k=8 - class=2 - fn  -  1
Manhattan - k=8 - class=2 - recall  -  0.9833333333333332
Manhattan - k=8 - class=2 - precision  -  0.9833333333333332
Manhattan - k=8 - class=2 - specificity  -  0.9770778072502211
Manhattan - k=8 - class=2 - fmeasure  -  0.9604761904761905
Manhattan - k=9 - class=0 - tp  -  53
Manhattan - k=9 - class=0 - tn  -  112
Manhattan - k=9 - class=0 - fp  -  7
Manhattan - k=9 - class=0 - fn  -  6
Manhattan - k=9 - class=0 - recall  -  0.9042957042957044
Manhattan - k=9 - class=0 - precision  -  0.9042957042957044
Manhattan - k=9 - class=0 - specificity  -  0.9396726461943853
Manhattan - k=9 - class=0 - fmeasure  -  0.8946272892262004
Manhattan - k=9 - class=1 - tp  -  63
Manhattan - k=9 - class=1 - tn  -  101
Manhattan - k=9 - class=1 - fp  -  6
Manhattan - k=9 - class=1 - fn  -  8
Manhattan - k=9 - class=1 - recall  -  0.8891991341991343
Manhattan - k=9 - class=1 - precision  -  0.8891991341991343
Manhattan - k=9 - class=1 - specificity  -  0.9438997493734336
Manhattan - k=9 - class=1 - fmeasure  -  0.9001263257260259
Manhattan - k=9 - class=2 - tp  -  47
Manhattan - k=9 - class=2 - tn  -  128
Manhattan - k=9 - class=2 - fp  -  2
Manhattan - k=9 - class=2 - fn  -  1
Manhattan - k=9 - class=2 - recall  -  0.9833333333333332
Manhattan - k=9 - class=2 - precision  -  0.9833333333333332
Manhattan - k=9 - class=2 - specificity  -  0.9839743589743591
Manhattan - k=9 - class=2 - fmeasure  -  0.9738095238095237
Manhattan - k=10 - class=0 - tp  -  53
Manhattan - k=10 - class=0 - tn  -  113
Manhattan - k=10 - class=0 - fp  -  6
Manhattan - k=10 - class=0 - fn  -  6
Manhattan - k=10 - class=0 - recall  -  0.9042957042957044
Manhattan - k=10 - class=0 - precision  -  0.9042957042957044
Manhattan - k=10 - class=0 - specificity  -  0.9487635552852943
Manhattan - k=10 - class=0 - fmeasure  -  0.9005386192754614
Manhattan - k=10 - class=1 - tp  -  64
Manhattan - k=10 - class=1 - tn  -  101
Manhattan - k=10 - class=1 - fp  -  6
Manhattan - k=10 - class=1 - fn  -  7
Manhattan - k=10 - class=1 - recall  -  0.9025324675324675
Manhattan - k=10 - class=1 - precision  -  0.9025324675324675
Manhattan - k=10 - class=1 - specificity  -  0.9438997493734336
Manhattan - k=10 - class=1 - fmeasure  -  0.9079424176800488
Manhattan - k=10 - class=2 - tp  -  47
Manhattan - k=10 - class=2 - tn  -  128
Manhattan - k=10 - class=2 - fp  -  2
Manhattan - k=10 - class=2 - fn  -  1
Manhattan - k=10 - class=2 - recall  -  0.9833333333333332
Manhattan - k=10 - class=2 - precision  -  0.9833333333333332
Manhattan - k=10 - class=2 - specificity  -  0.9839743589743591
Manhattan - k=10 - class=2 - fmeasure  -  0.9738095238095237
Minkowski - k=1 - class=0 - tp  -  52
Minkowski - k=1 - class=0 - tn  -  112
Minkowski - k=1 - class=0 - fp  -  7
Minkowski - k=1 - class=0 - fn  -  7
Minkowski - k=1 - class=0 - recall  -  0.8752358752358752
Minkowski - k=1 - class=0 - precision  -  0.8752358752358752
Minkowski - k=1 - class=0 - specificity  -  0.9404302219519611
Minkowski - k=1 - class=0 - fmeasure  -  0.8772715775273319
Minkowski - k=1 - class=1 - tp  -  62
Minkowski - k=1 - class=1 - tn  -  97
Minkowski - k=1 - class=1 - fp  -  10
Minkowski - k=1 - class=1 - fn  -  9
Minkowski - k=1 - class=1 - recall  -  0.8766991341991343
Minkowski - k=1 - class=1 - precision  -  0.8766991341991343
Minkowski - k=1 - class=1 - specificity  -  0.9038496240601503
Minkowski - k=1 - class=1 - fmeasure  -  0.869650797361176
Minkowski - k=1 - class=2 - tp  -  45
Minkowski - k=1 - class=2 - tn  -  128
Minkowski - k=1 - class=2 - fp  -  2
Minkowski - k=1 - class=2 - fn  -  3
Minkowski - k=1 - class=2 - recall  -  0.9297619047619048
Minkowski - k=1 - class=2 - precision  -  0.9297619047619048
Minkowski - k=1 - class=2 - specificity  -  0.9854111405835544
Minkowski - k=1 - class=2 - fmeasure  -  0.9398757763975155
Minkowski - k=2 - class=0 - tp  -  52
Minkowski - k=2 - class=0 - tn  -  112
Minkowski - k=2 - class=0 - fp  -  7
Minkowski - k=2 - class=0 - fn  -  7
Minkowski - k=2 - class=0 - recall  -  0.8752358752358752
Minkowski - k=2 - class=0 - precision  -  0.8752358752358752
Minkowski - k=2 - class=0 - specificity  -  0.9404302219519611
Minkowski - k=2 - class=0 - fmeasure  -  0.8772715775273319
Minkowski - k=2 - class=1 - tp  -  62
Minkowski - k=2 - class=1 - tn  -  97
Minkowski - k=2 - class=1 - fp  -  10
Minkowski - k=2 - class=1 - fn  -  9
Minkowski - k=2 - class=1 - recall  -  0.8766991341991343
Minkowski - k=2 - class=1 - precision  -  0.8766991341991343
Minkowski - k=2 - class=1 - specificity  -  0.9038496240601503
Minkowski - k=2 - class=1 - fmeasure  -  0.869650797361176
Minkowski - k=2 - class=2 - tp  -  45
Minkowski - k=2 - class=2 - tn  -  128
Minkowski - k=2 - class=2 - fp  -  2
Minkowski - k=2 - class=2 - fn  -  3
Minkowski - k=2 - class=2 - recall  -  0.9297619047619048
Minkowski - k=2 - class=2 - precision  -  0.9297619047619048
Minkowski - k=2 - class=2 - specificity  -  0.9854111405835544
Minkowski - k=2 - class=2 - fmeasure  -  0.9398757763975155
Minkowski - k=3 - class=0 - tp  -  52
Minkowski - k=3 - class=0 - tn  -  111
Minkowski - k=3 - class=0 - fp  -  8
Minkowski - k=3 - class=0 - fn  -  7
Minkowski - k=3 - class=0 - recall  -  0.8848706848706849
Minkowski - k=3 - class=0 - precision  -  0.8848706848706849
Minkowski - k=3 - class=0 - specificity  -  0.9327379142596535
Minkowski - k=3 - class=0 - fmeasure  -  0.8731829573934837
Minkowski - k=3 - class=1 - tp  -  61
Minkowski - k=3 - class=1 - tn  -  100
Minkowski - k=3 - class=1 - fp  -  7
Minkowski - k=3 - class=1 - fn  -  10
Minkowski - k=3 - class=1 - recall  -  0.863365800865801
Minkowski - k=3 - class=1 - precision  -  0.863365800865801
Minkowski - k=3 - class=1 - specificity  -  0.9344260651629073
Minkowski - k=3 - class=1 - fmeasure  -  0.8786895441168305
Minkowski - k=3 - class=2 - tp  -  47
Minkowski - k=3 - class=2 - tn  -  127
Minkowski - k=3 - class=2 - fp  -  3
Minkowski - k=3 - class=2 - fn  -  1
Minkowski - k=3 - class=2 - recall  -  0.9818181818181818
Minkowski - k=3 - class=2 - precision  -  0.9818181818181818
Minkowski - k=3 - class=2 - specificity  -  0.9770778072502211
Minkowski - k=3 - class=2 - fmeasure  -  0.9596190476190476
Minkowski - k=4 - class=0 - tp  -  53
Minkowski - k=4 - class=0 - tn  -  113
Minkowski - k=4 - class=0 - fp  -  6
Minkowski - k=4 - class=0 - fn  -  6
Minkowski - k=4 - class=0 - recall  -  0.9002553002553004
Minkowski - k=4 - class=0 - precision  -  0.9002553002553004
Minkowski - k=4 - class=0 - specificity  -  0.9491258741258741
Minkowski - k=4 - class=0 - fmeasure  -  0.899206349206349
Minkowski - k=4 - class=1 - tp  -  63
Minkowski - k=4 - class=1 - tn  -  101
Minkowski - k=4 - class=1 - fp  -  6
Minkowski - k=4 - class=1 - fn  -  8
Minkowski - k=4 - class=1 - recall  -  0.8948809523809524
Minkowski - k=4 - class=1 - precision  -  0.8948809523809524
Minkowski - k=4 - class=1 - specificity  -  0.9429022556390978
Minkowski - k=4 - class=1 - fmeasure  -  0.9038969404186796
Minkowski - k=4 - class=2 - tp  -  47
Minkowski - k=4 - class=2 - tn  -  127
Minkowski - k=4 - class=2 - fp  -  3
Minkowski - k=4 - class=2 - fn  -  1
Minkowski - k=4 - class=2 - recall  -  0.9714285714285715
Minkowski - k=4 - class=2 - precision  -  0.9714285714285715
Minkowski - k=4 - class=2 - specificity  -  0.9770778072502211
Minkowski - k=4 - class=2 - fmeasure  -  0.9539047619047618
Minkowski - k=5 - class=0 - tp  -  54
Minkowski - k=5 - class=0 - tn  -  114
Minkowski - k=5 - class=0 - fp  -  5
Minkowski - k=5 - class=0 - fn  -  5
Minkowski - k=5 - class=0 - recall  -  0.9224775224775226
Minkowski - k=5 - class=0 - precision  -  0.9224775224775226
Minkowski - k=5 - class=0 - specificity  -  0.9570968886186277
Minkowski - k=5 - class=0 - fmeasure  -  0.9187204374572795
Minkowski - k=5 - class=1 - tp  -  64
Minkowski - k=5 - class=1 - tn  -  102
Minkowski - k=5 - class=1 - fp  -  5
Minkowski - k=5 - class=1 - fn  -  7
Minkowski - k=5 - class=1 - recall  -  0.9016991341991343
Minkowski - k=5 - class=1 - precision  -  0.9016991341991343
Minkowski - k=5 - class=1 - specificity  -  0.9529022556390977
Minkowski - k=5 - class=1 - fmeasure  -  0.9150142226866365
Minkowski - k=5 - class=2 - tp  -  47
Minkowski - k=5 - class=2 - tn  -  127
Minkowski - k=5 - class=2 - fp  -  3
Minkowski - k=5 - class=2 - fn  -  1
Minkowski - k=5 - class=2 - recall  -  0.9714285714285715
Minkowski - k=5 - class=2 - precision  -  0.9714285714285715
Minkowski - k=5 - class=2 - specificity  -  0.9770778072502211
Minkowski - k=5 - class=2 - fmeasure  -  0.9539047619047618
Minkowski - k=6 - class=0 - tp  -  54
Minkowski - k=6 - class=0 - tn  -  112
Minkowski - k=6 - class=0 - fp  -  7
Minkowski - k=6 - class=0 - fn  -  5
Minkowski - k=6 - class=0 - recall  -  0.9224775224775226
Minkowski - k=6 - class=0 - precision  -  0.9224775224775226
Minkowski - k=6 - class=0 - specificity  -  0.9404302219519611
Minkowski - k=6 - class=0 - fmeasure  -  0.9035689223057645
Minkowski - k=6 - class=1 - tp  -  62
Minkowski - k=6 - class=1 - tn  -  102
Minkowski - k=6 - class=1 - fp  -  5
Minkowski - k=6 - class=1 - fn  -  9
Minkowski - k=6 - class=1 - recall  -  0.8766991341991343
Minkowski - k=6 - class=1 - precision  -  0.8766991341991343
Minkowski - k=6 - class=1 - specificity  -  0.9529022556390977
Minkowski - k=6 - class=1 - fmeasure  -  0.9008475560199699
Minkowski - k=6 - class=2 - tp  -  47
Minkowski - k=6 - class=2 - tn  -  127
Minkowski - k=6 - class=2 - fp  -  3
Minkowski - k=6 - class=2 - fn  -  1
Minkowski - k=6 - class=2 - recall  -  0.9714285714285715
Minkowski - k=6 - class=2 - precision  -  0.9714285714285715
Minkowski - k=6 - class=2 - specificity  -  0.9770778072502211
Minkowski - k=6 - class=2 - fmeasure  -  0.9539047619047618
Minkowski - k=7 - class=0 - tp  -  53
Minkowski - k=7 - class=0 - tn  -  112
Minkowski - k=7 - class=0 - fp  -  7
Minkowski - k=7 - class=0 - fn  -  6
Minkowski - k=7 - class=0 - recall  -  0.9070929070929072
Minkowski - k=7 - class=0 - precision  -  0.9070929070929072
Minkowski - k=7 - class=0 - specificity  -  0.9404302219519611
Minkowski - k=7 - class=0 - fmeasure  -  0.8942355889724312
Minkowski - k=7 - class=1 - tp  -  62
Minkowski - k=7 - class=1 - tn  -  101
Minkowski - k=7 - class=1 - fp  -  6
Minkowski - k=7 - class=1 - fn  -  9
Minkowski - k=7 - class=1 - recall  -  0.8766991341991343
Minkowski - k=7 - class=1 - precision  -  0.8766991341991343
Minkowski - k=7 - class=1 - specificity  -  0.9464260651629072
Minkowski - k=7 - class=1 - fmeasure  -  0.891213282247765
Minkowski - k=7 - class=2 - tp  -  47
Minkowski - k=7 - class=2 - tn  -  127
Minkowski - k=7 - class=2 - fp  -  3
Minkowski - k=7 - class=2 - fn  -  1
Minkowski - k=7 - class=2 - recall  -  0.9833333333333332
Minkowski - k=7 - class=2 - precision  -  0.9833333333333332
Minkowski - k=7 - class=2 - specificity  -  0.9770778072502211
Minkowski - k=7 - class=2 - fmeasure  -  0.9604761904761905
Minkowski - k=8 - class=0 - tp  -  52
Minkowski - k=8 - class=0 - tn  -  112
Minkowski - k=8 - class=0 - fp  -  7
Minkowski - k=8 - class=0 - fn  -  7
Minkowski - k=8 - class=0 - recall  -  0.8889110889110888
Minkowski - k=8 - class=0 - precision  -  0.8889110889110888
Minkowski - k=8 - class=0 - specificity  -  0.9404302219519611
Minkowski - k=8 - class=0 - fmeasure  -  0.8840906614361993
Minkowski - k=8 - class=1 - tp  -  62
Minkowski - k=8 - class=1 - tn  -  99
Minkowski - k=8 - class=1 - fp  -  8
Minkowski - k=8 - class=1 - fn  -  9
Minkowski - k=8 - class=1 - recall  -  0.8766991341991343
Minkowski - k=8 - class=1 - precision  -  0.8766991341991343
Minkowski - k=8 - class=1 - specificity  -  0.9263759398496241
Minkowski - k=8 - class=1 - fmeasure  -  0.8801046430189924
Minkowski - k=8 - class=2 - tp  -  46
Minkowski - k=8 - class=2 - tn  -  127
Minkowski - k=8 - class=2 - fp  -  3
Minkowski - k=8 - class=2 - fn  -  2
Minkowski - k=8 - class=2 - recall  -  0.9547619047619047
Minkowski - k=8 - class=2 - precision  -  0.9547619047619047
Minkowski - k=8 - class=2 - specificity  -  0.9770778072502211
Minkowski - k=8 - class=2 - fmeasure  -  0.9452380952380952
Minkowski - k=9 - class=0 - tp  -  53
Minkowski - k=9 - class=0 - tn  -  113
Minkowski - k=9 - class=0 - fp  -  6
Minkowski - k=9 - class=0 - fn  -  6
Minkowski - k=9 - class=0 - recall  -  0.9042957042957044
Minkowski - k=9 - class=0 - precision  -  0.9042957042957044
Minkowski - k=9 - class=0 - specificity  -  0.9487635552852943
Minkowski - k=9 - class=0 - fmeasure  -  0.9005386192754614
Minkowski - k=9 - class=1 - tp  -  64
Minkowski - k=9 - class=1 - tn  -  100
Minkowski - k=9 - class=1 - fp  -  7
Minkowski - k=9 - class=1 - fn  -  7
Minkowski - k=9 - class=1 - recall  -  0.9025324675324675
Minkowski - k=9 - class=1 - precision  -  0.9025324675324675
Minkowski - k=9 - class=1 - specificity  -  0.9343759398496241
Minkowski - k=9 - class=1 - fmeasure  -  0.9023510198305864
Minkowski - k=9 - class=2 - tp  -  46
Minkowski - k=9 - class=2 - tn  -  128
Minkowski - k=9 - class=2 - fp  -  2
Minkowski - k=9 - class=2 - fn  -  2
Minkowski - k=9 - class=2 - recall  -  0.9547619047619047
Minkowski - k=9 - class=2 - precision  -  0.9547619047619047
Minkowski - k=9 - class=2 - specificity  -  0.9839743589743591
Minkowski - k=9 - class=2 - fmeasure  -  0.9584249084249084
Minkowski - k=10 - class=0 - tp  -  53
Minkowski - k=10 - class=0 - tn  -  111
Minkowski - k=10 - class=0 - fp  -  8
Minkowski - k=10 - class=0 - fn  -  6
Minkowski - k=10 - class=0 - recall  -  0.9042957042957044
Minkowski - k=10 - class=0 - precision  -  0.9042957042957044
Minkowski - k=10 - class=0 - specificity  -  0.9313393128610521
Minkowski - k=10 - class=0 - fmeasure  -  0.8875126647202715
Minkowski - k=10 - class=1 - tp  -  62
Minkowski - k=10 - class=1 - tn  -  100
Minkowski - k=10 - class=1 - fp  -  7
Minkowski - k=10 - class=1 - fn  -  9
Minkowski - k=10 - class=1 - recall  -  0.8766991341991343
Minkowski - k=10 - class=1 - precision  -  0.8766991341991343
Minkowski - k=10 - class=1 - specificity  -  0.9343759398496241
Minkowski - k=10 - class=1 - fmeasure  -  0.8873510198305865
Minkowski - k=10 - class=2 - tp  -  46
Minkowski - k=10 - class=2 - tn  -  128
Minkowski - k=10 - class=2 - fp  -  2
Minkowski - k=10 - class=2 - fn  -  2
Minkowski - k=10 - class=2 - recall  -  0.9547619047619047
Minkowski - k=10 - class=2 - precision  -  0.9547619047619047
Minkowski - k=10 - class=2 - specificity  -  0.9839743589743591
Minkowski - k=10 - class=2 - fmeasure  -  0.9584249084249084
Cosine - k=1 - class=0 - tp  -  47
Cosine - k=1 - class=0 - tn  -  104
Cosine - k=1 - class=0 - fp  -  15
Cosine - k=1 - class=0 - fn  -  12
Cosine - k=1 - class=0 - recall  -  0.773903873903874
Cosine - k=1 - class=0 - precision  -  0.773903873903874
Cosine - k=1 - class=0 - specificity  -  0.8730059795277187
Cosine - k=1 - class=0 - fmeasure  -  0.7537142857142858
Cosine - k=1 - class=1 - tp  -  54
Cosine - k=1 - class=1 - tn  -  94
Cosine - k=1 - class=1 - fp  -  13
Cosine - k=1 - class=1 - fn  -  17
Cosine - k=1 - class=1 - recall  -  0.7696753246753246
Cosine - k=1 - class=1 - precision  -  0.7696753246753246
Cosine - k=1 - class=1 - specificity  -  0.8743709273182958
Cosine - k=1 - class=1 - fmeasure  -  0.7852187028657616
Cosine - k=1 - class=2 - tp  -  45
Cosine - k=1 - class=2 - tn  -  126
Cosine - k=1 - class=2 - fp  -  4
Cosine - k=1 - class=2 - fn  -  3
Cosine - k=1 - class=2 - recall  -  0.9383333333333332
Cosine - k=1 - class=2 - precision  -  0.9383333333333332
Cosine - k=1 - class=2 - specificity  -  0.9701812555260831
Cosine - k=1 - class=2 - fmeasure  -  0.925
Cosine - k=2 - class=0 - tp  -  47
Cosine - k=2 - class=0 - tn  -  104
Cosine - k=2 - class=0 - fp  -  15
Cosine - k=2 - class=0 - fn  -  12
Cosine - k=2 - class=0 - recall  -  0.773903873903874
Cosine - k=2 - class=0 - precision  -  0.773903873903874
Cosine - k=2 - class=0 - specificity  -  0.8730059795277187
Cosine - k=2 - class=0 - fmeasure  -  0.7537142857142858
Cosine - k=2 - class=1 - tp  -  54
Cosine - k=2 - class=1 - tn  -  94
Cosine - k=2 - class=1 - fp  -  13
Cosine - k=2 - class=1 - fn  -  17
Cosine - k=2 - class=1 - recall  -  0.7696753246753246
Cosine - k=2 - class=1 - precision  -  0.7696753246753246
Cosine - k=2 - class=1 - specificity  -  0.8743709273182958
Cosine - k=2 - class=1 - fmeasure  -  0.7852187028657616
Cosine - k=2 - class=2 - tp  -  45
Cosine - k=2 - class=2 - tn  -  126
Cosine - k=2 - class=2 - fp  -  4
Cosine - k=2 - class=2 - fn  -  3
Cosine - k=2 - class=2 - recall  -  0.9383333333333332
Cosine - k=2 - class=2 - precision  -  0.9383333333333332
Cosine - k=2 - class=2 - specificity  -  0.9701812555260831
Cosine - k=2 - class=2 - fmeasure  -  0.925
Cosine - k=3 - class=0 - tp  -  47
Cosine - k=3 - class=0 - tn  -  103
Cosine - k=3 - class=0 - fp  -  16
Cosine - k=3 - class=0 - fn  -  12
Cosine - k=3 - class=0 - recall  -  0.7875790875790876
Cosine - k=3 - class=0 - precision  -  0.7875790875790876
Cosine - k=3 - class=0 - specificity  -  0.8648348028782813
Cosine - k=3 - class=0 - fmeasure  -  0.7571139161601994
Cosine - k=3 - class=1 - tp  -  52
Cosine - k=3 - class=1 - tn  -  95
Cosine - k=3 - class=1 - fp  -  12
Cosine - k=3 - class=1 - fn  -  19
Cosine - k=3 - class=1 - recall  -  0.7364935064935064
Cosine - k=3 - class=1 - precision  -  0.7364935064935064
Cosine - k=3 - class=1 - specificity  -  0.8888972431077693
Cosine - k=3 - class=1 - fmeasure  -  0.7695053763440861
Cosine - k=3 - class=2 - tp  -  47
Cosine - k=3 - class=2 - tn  -  126
Cosine - k=3 - class=2 - fp  -  4
Cosine - k=3 - class=2 - fn  -  1
Cosine - k=3 - class=2 - recall  -  0.9833333333333332
Cosine - k=3 - class=2 - precision  -  0.9833333333333332
Cosine - k=3 - class=2 - specificity  -  0.9701812555260831
Cosine - k=3 - class=2 - fmeasure  -  0.9488095238095238
Cosine - k=4 - class=0 - tp  -  49
Cosine - k=4 - class=0 - tn  -  102
Cosine - k=4 - class=0 - fp  -  17
Cosine - k=4 - class=0 - fn  -  10
Cosine - k=4 - class=0 - recall  -  0.8172494172494174
Cosine - k=4 - class=0 - precision  -  0.8172494172494174
Cosine - k=4 - class=0 - specificity  -  0.8552523563393128
Cosine - k=4 - class=0 - fmeasure  -  0.7738686045137658
Cosine - k=4 - class=1 - tp  -  53
Cosine - k=4 - class=1 - tn  -  98
Cosine - k=4 - class=1 - fp  -  9
Cosine - k=4 - class=1 - fn  -  18
Cosine - k=4 - class=1 - recall  -  0.7458116883116883
Cosine - k=4 - class=1 - precision  -  0.7458116883116883
Cosine - k=4 - class=1 - specificity  -  0.9144210526315788
Cosine - k=4 - class=1 - fmeasure  -  0.7937878787878787
Cosine - k=4 - class=2 - tp  -  46
Cosine - k=4 - class=2 - tn  -  126
Cosine - k=4 - class=2 - fp  -  4
Cosine - k=4 - class=2 - fn  -  2
Cosine - k=4 - class=2 - recall  -  0.9633333333333333
Cosine - k=4 - class=2 - precision  -  0.9633333333333333
Cosine - k=4 - class=2 - specificity  -  0.9701812555260831
Cosine - k=4 - class=2 - fmeasure  -  0.9383333333333332
Cosine - k=5 - class=0 - tp  -  46
Cosine - k=5 - class=0 - tn  -  99
Cosine - k=5 - class=0 - fp  -  20
Cosine - k=5 - class=0 - fn  -  13
Cosine - k=5 - class=0 - recall  -  0.770912420912421
Cosine - k=5 - class=0 - precision  -  0.770912420912421
Cosine - k=5 - class=0 - specificity  -  0.829378230465187
Cosine - k=5 - class=0 - fmeasure  -  0.7279727668845316
Cosine - k=5 - class=1 - tp  -  50
Cosine - k=5 - class=1 - tn  -  94
Cosine - k=5 - class=1 - fp  -  13
Cosine - k=5 - class=1 - fn  -  21
Cosine - k=5 - class=1 - recall  -  0.7048593073593075
Cosine - k=5 - class=1 - precision  -  0.7048593073593075
Cosine - k=5 - class=1 - specificity  -  0.8798063340168604
Cosine - k=5 - class=1 - fmeasure  -  0.741741935483871
Cosine - k=5 - class=2 - tp  -  46
Cosine - k=5 - class=2 - tn  -  127
Cosine - k=5 - class=2 - fp  -  3
Cosine - k=5 - class=2 - fn  -  2
Cosine - k=5 - class=2 - recall  -  0.9666666666666668
Cosine - k=5 - class=2 - precision  -  0.9666666666666668
Cosine - k=5 - class=2 - specificity  -  0.9770778072502211
Cosine - k=5 - class=2 - fmeasure  -  0.951055900621118
Cosine - k=6 - class=0 - tp  -  49
Cosine - k=6 - class=0 - tn  -  101
Cosine - k=6 - class=0 - fp  -  18
Cosine - k=6 - class=0 - fn  -  10
Cosine - k=6 - class=0 - recall  -  0.8115107115107115
Cosine - k=6 - class=0 - precision  -  0.8115107115107115
Cosine - k=6 - class=0 - specificity  -  0.8461614472484037
Cosine - k=6 - class=0 - fmeasure  -  0.7629800307219663
Cosine - k=6 - class=1 - tp  -  53
Cosine - k=6 - class=1 - tn  -  97
Cosine - k=6 - class=1 - fp  -  10
Cosine - k=6 - class=1 - fn  -  18
Cosine - k=6 - class=1 - recall  -  0.7458116883116883
Cosine - k=6 - class=1 - precision  -  0.7458116883116883
Cosine - k=6 - class=1 - specificity  -  0.9028972431077694
Cosine - k=6 - class=1 - fmeasure  -  0.7892574092574093
Cosine - k=6 - class=2 - tp  -  45
Cosine - k=6 - class=2 - tn  -  127
Cosine - k=6 - class=2 - fp  -  3
Cosine - k=6 - class=2 - fn  -  3
Cosine - k=6 - class=2 - recall  -  0.9466666666666667
Cosine - k=6 - class=2 - precision  -  0.9466666666666667
Cosine - k=6 - class=2 - specificity  -  0.9770778072502211
Cosine - k=6 - class=2 - fmeasure  -  0.9405797101449276
Cosine - k=7 - class=0 - tp  -  46
Cosine - k=7 - class=0 - tn  -  100
Cosine - k=7 - class=0 - fp  -  19
Cosine - k=7 - class=0 - fn  -  13
Cosine - k=7 - class=0 - recall  -  0.7596181596181596
Cosine - k=7 - class=0 - precision  -  0.7596181596181596
Cosine - k=7 - class=0 - specificity  -  0.8377115637985204
Cosine - k=7 - class=0 - fmeasure  -  0.7222689091076189
Cosine - k=7 - class=1 - tp  -  52
Cosine - k=7 - class=1 - tn  -  94
Cosine - k=7 - class=1 - fp  -  13
Cosine - k=7 - class=1 - fn  -  19
Cosine - k=7 - class=1 - recall  -  0.7342640692640693
Cosine - k=7 - class=1 - precision  -  0.7342640692640693
Cosine - k=7 - class=1 - specificity  -  0.8753734335839599
Cosine - k=7 - class=1 - fmeasure  -  0.7651094856612097
Cosine - k=7 - class=2 - tp  -  46
Cosine - k=7 - class=2 - tn  -  128
Cosine - k=7 - class=2 - fp  -  2
Cosine - k=7 - class=2 - fn  -  2
Cosine - k=7 - class=2 - recall  -  0.9666666666666668
Cosine - k=7 - class=2 - precision  -  0.9666666666666668
Cosine - k=7 - class=2 - specificity  -  0.9839743589743591
Cosine - k=7 - class=2 - fmeasure  -  0.9643892339544514
Cosine - k=8 - class=0 - tp  -  45
Cosine - k=8 - class=0 - tn  -  102
Cosine - k=8 - class=0 - fp  -  17
Cosine - k=8 - class=0 - fn  -  14
Cosine - k=8 - class=0 - recall  -  0.7373959373959373
Cosine - k=8 - class=0 - precision  -  0.7373959373959373
Cosine - k=8 - class=0 - specificity  -  0.8551358062227628
Cosine - k=8 - class=0 - fmeasure  -  0.7107706464228203
Cosine - k=8 - class=1 - tp  -  54
Cosine - k=8 - class=1 - tn  -  93
Cosine - k=8 - class=1 - fp  -  14
Cosine - k=8 - class=1 - fn  -  17
Cosine - k=8 - class=1 - recall  -  0.7583116883116883
Cosine - k=8 - class=1 - precision  -  0.7583116883116883
Cosine - k=8 - class=1 - specificity  -  0.8653734335839598
Cosine - k=8 - class=1 - fmeasure  -  0.7770439554120768
Cosine - k=8 - class=2 - tp  -  46
Cosine - k=8 - class=2 - tn  -  128
Cosine - k=8 - class=2 - fp  -  2
Cosine - k=8 - class=2 - fn  -  2
Cosine - k=8 - class=2 - recall  -  0.9666666666666668
Cosine - k=8 - class=2 - precision  -  0.9666666666666668
Cosine - k=8 - class=2 - specificity  -  0.9839743589743591
Cosine - k=8 - class=2 - fmeasure  -  0.9643892339544514
Cosine - k=9 - class=0 - tp  -  48
Cosine - k=9 - class=0 - tn  -  99
Cosine - k=9 - class=0 - fp  -  20
Cosine - k=9 - class=0 - fn  -  11
Cosine - k=9 - class=0 - recall  -  0.8028194028194028
Cosine - k=9 - class=0 - precision  -  0.8028194028194028
Cosine - k=9 - class=0 - specificity  -  0.8300192561062125
Cosine - k=9 - class=0 - fmeasure  -  0.7423758783910587
Cosine - k=9 - class=1 - tp  -  50
Cosine - k=9 - class=1 - tn  -  96
Cosine - k=9 - class=1 - fp  -  11
Cosine - k=9 - class=1 - fn  -  21
Cosine - k=9 - class=1 - recall  -  0.704025974025974
Cosine - k=9 - class=1 - precision  -  0.704025974025974
Cosine - k=9 - class=1 - specificity  -  0.8984260651629071
Cosine - k=9 - class=1 - fmeasure  -  0.7544696634313117
Cosine - k=9 - class=2 - tp  -  46
Cosine - k=9 - class=2 - tn  -  127
Cosine - k=9 - class=2 - fp  -  3
Cosine - k=9 - class=2 - fn  -  2
Cosine - k=9 - class=2 - recall  -  0.9666666666666668
Cosine - k=9 - class=2 - precision  -  0.9666666666666668
Cosine - k=9 - class=2 - specificity  -  0.9770778072502211
Cosine - k=9 - class=2 - fmeasure  -  0.951055900621118
Cosine - k=10 - class=0 - tp  -  49
Cosine - k=10 - class=0 - tn  -  99
Cosine - k=10 - class=0 - fp  -  20
Cosine - k=10 - class=0 - fn  -  10
Cosine - k=10 - class=0 - recall  -  0.8143079143079144
Cosine - k=10 - class=0 - precision  -  0.8143079143079144
Cosine - k=10 - class=0 - specificity  -  0.8300192561062125
Cosine - k=10 - class=0 - fmeasure  -  0.7497237784002491
Cosine - k=10 - class=1 - tp  -  51
Cosine - k=10 - class=1 - tn  -  97
Cosine - k=10 - class=1 - fp  -  10
Cosine - k=10 - class=1 - fn  -  20
Cosine - k=10 - class=1 - recall  -  0.7173593073593073
Cosine - k=10 - class=1 - precision  -  0.7173593073593073
Cosine - k=10 - class=1 - specificity  -  0.9054235588972432
Cosine - k=10 - class=1 - fmeasure  -  0.7706611481085535
Cosine - k=10 - class=2 - tp  -  46
Cosine - k=10 - class=2 - tn  -  128
Cosine - k=10 - class=2 - fp  -  2
Cosine - k=10 - class=2 - fn  -  2
Cosine - k=10 - class=2 - recall  -  0.9666666666666668
Cosine - k=10 - class=2 - precision  -  0.9666666666666668
Cosine - k=10 - class=2 - specificity  -  0.9839743589743591
Cosine - k=10 - class=2 - fmeasure  -  0.9643892339544514

6. More questions [9 pts]

Now answer the following questions as fully as you can. The answers should be based on your implementation above. Write your answers in the Markdown cells below each question.

Q3. Influence of noise

Do the best parameters change when noise is added to the data? Can you say that one parameter choice is better regardless of the data used?

Answer

Number of K - Clean Data

All parameters had an effect on the final result. For example, it can be seen that increasing k can increase accuracy. In the clean data, it is evident that a k value of 5 for the k-NN is the best pick. There is a trend where the accuracy peaks at k = 5. Only the cosine distance method functions better with a k value of 10.

figure = plt.subplots(2,2,figsize=(15,15))

plt.subplot(2,2,1)
x = [x for x in range(1,11)]
y = []
for i in cleanResults[0]:
    if "euclidean".upper() in i.upper():
        y.append(cleanResults[0][i])
plt.plot(x,y)
plt.axvline(x=5, color='red',ls = ':', linewidth=3)
plt.title("euclidean_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,2)
x = [x for x in range(1,11)]
y = []
for i in cleanResults[0]:
    if "manhattan".upper() in i.upper():
        y.append(cleanResults[0][i])
plt.plot(x,y)
plt.axvline(x=5, color='red',ls = ':', linewidth=3)
plt.title("manhattan_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,3)
x = [x for x in range(1,11)]
y = []
for i in cleanResults[0]:
    if "minkowski".upper() in i.upper():
        y.append(cleanResults[0][i])
plt.plot(x,y)
plt.axvline(x=5, color='red',ls = ':', linewidth=3)
plt.title("minkowski_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,4)
x = [x for x in range(1,11)]
y = []
for i in cleanResults[0]:
    if "cosine".upper() in i.upper():
        y.append(cleanResults[0][i])
plt.plot(x,y)
plt.axvline(x=10, color='red',ls = ':', linewidth=3)
plt.title("cosine_distance")
plt.ylabel("Accuracy (%)")

plt.show()

Number of K - Noisy data

For the noisy data, the optimal number of k was not as apparent. It seems that the optimal k could be outside of the scope of 1 to 10. This is because accuracy appears to increase along with the number of k, except for the cosine distance once again.

figure = plt.subplots(2,2,figsize=(15,15))

plt.subplot(2,2,1)
x = [x for x in range(1,11)]
y = []
for i in noisyResults[0]:
    if "euclidean".upper() in i.upper():
        y.append(noisyResults[0][i])
plt.plot(x,y)
plt.axvline(x=6, color='red',ls = ':', linewidth=3)
plt.axvline(x=9, color='red',ls = ':', linewidth=3)
plt.title("euclidean_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,2)
x = [x for x in range(1,11)]
y = []
for i in noisyResults[0]:
    if "manhattan".upper() in i.upper():
        y.append(noisyResults[0][i])
plt.plot(x,y)
plt.axvline(x=7, color='red',ls = ':', linewidth=3)
plt.title("manhattan_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,3)
x = [x for x in range(1,11)]
y = []
for i in noisyResults[0]:
    if "minkowski".upper() in i.upper():
        y.append(noisyResults[0][i])
plt.plot(x,y)
plt.axvline(x=5, color='red',ls = ':', linewidth=3)
plt.title("minkowski_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,4)
x = [x for x in range(1,11)]
y = []
for i in noisyResults[0]:
    if "cosine".upper() in i.upper():
        y.append(noisyResults[0][i])
plt.plot(x,y)
plt.axvline(x=4, color='red',ls = ':', linewidth=3)
plt.title("cosine_distance")
plt.ylabel("Accuracy (%)")

plt.show()

Comparison with K

Once we plot it with each other, we can see that the data with noise is also generally lower in overall accuracy. The orange is the data without noise and blue is the one with noise.

figure = plt.subplots(2,2,figsize=(15,15))

plt.subplot(2,2,1)
x = [x for x in range(1,11)]
y = []
y2 = []
for i in noisyResults[0]:
    if "euclidean".upper() in i.upper():
        y.append(noisyResults[0][i])
        y2.append(cleanResults[0][i])
plt.plot(x,y, label="noise")
plt.plot(x,y2, label="clean")
plt.title("euclidean_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,2)
x = [x for x in range(1,11)]
y = []
y2 = []
for i in noisyResults[0]:
    if "manhattan".upper() in i.upper():
        y.append(noisyResults[0][i])
        y2.append(cleanResults[0][i])
plt.plot(x,y, label="noise")
plt.plot(x,y2, label="clean")
plt.title("manhattan_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,3)
x = [x for x in range(1,11)]
y = []
y2 = []
for i in noisyResults[0]:
    if "minkowski".upper() in i.upper():
        y.append(noisyResults[0][i])
        y2.append(cleanResults[0][i])
plt.plot(x,y, label="noise")
plt.plot(x,y2, label="clean")
plt.title("minkowski_distance")
plt.ylabel("Accuracy (%)")

plt.subplot(2,2,4)
x = [x for x in range(1,11)]
y = []
y2 = []
for i in noisyResults[0]:
    if "cosine".upper() in i.upper():
        y.append(noisyResults[0][i])
        y2.append(cleanResults[0][i])
plt.plot(x,y, label="noise")
plt.plot(x,y2, label="clean")
plt.title("cosine_distance")
plt.ylabel("Accuracy (%)")

plt.legend(loc='center left', bbox_to_anchor=(1,2.3))

Looking for the Best Method

Based on this plot, we have plotted all the results of the accuracy between all the methods. These are plotted based on noisy data and clean data. As we can see here, the Minkowski and Manhattan methods are better in the noisy data. The Euclidean, Manhattan, and Minkowski methods can all get the job done and have a fair share of high accuracy. The only outlier is the cosine distance, which did not perform as well as the other methods regardless of the data.

figure = plt.subplots(1,2,figsize=(15,10))

# noise data
plt.subplot(1,2,1)
x = [x for x in range(1,11)]
y1 = []
y2 = []
y3 = []
y4 = []

for i in noisyResults[0]:
    if "euclidean".upper() in i.upper():
        y1.append(noisyResults[0][i])

    if "manhattan".upper() in i.upper():
        y2.append(noisyResults[0][i])

    if "minkowski".upper() in i.upper():
        y3.append(noisyResults[0][i])

    if "cosine".upper() in i.upper():
        y4.append(noisyResults[0][i])

plt.plot(x,y1, label="euclidean")
plt.plot(x,y2, label="manhattan")
plt.plot(x,y3, label="minkowski")
plt.plot(x,y4, label="cosine")
plt.ylabel("Accuracy (%)")
plt.xlabel("Noise Data")
plt.yticks([80,85,90,95])

# clean data
plt.subplot(1,2,2)
x = [x for x in range(1,11)]
y1 = []
y2 = []
y3 = []
y4 = []

for i in noisyResults[0]:
    if "euclidean".upper() in i.upper():
        y1.append(cleanResults[0][i])

    if "manhattan".upper() in i.upper():
        y2.append(cleanResults[0][i])

    if "minkowski".upper() in i.upper():
        y3.append(cleanResults[0][i])

    if "cosine".upper() in i.upper():
        y4.append(cleanResults[0][i])

plt.plot(x,y1, label="euclidean")
plt.plot(x,y2, label="manhattan")
plt.plot(x,y3, label="minkowski")
plt.plot(x,y4, label="cosine")
plt.ylabel("Accuracy (%)")
plt.xlabel("Clean Data")
plt.yticks([80,85,90,95])

plt.legend(loc='center left', bbox_to_anchor=(1.1,.95))
plt.show()

Q4. Tie break

Assume that you have selected the number of neighbours to be an even number, e.g., 2. For one of the neighbours, the suggested class is 1, and for the other neighbour the suggested class is 2. How would you break the tie? Write example pseudocode that does this.

Answer

The tiebreaker that was implemented in the decideValue function above uses distance as a determinant to decide the winner. It will try to pick the value of the shortest distance. If the distance between the two is the same, it will randomly pick between the two.

Pseudocode

If winner > 1:
    sort them in ascending order
    if firstValue's distance = secondValue's distance
        randomly pick one
    else
        pick firstValue's distance


# TIEBREAKER
# if final result consists of more than 1 value
if len(maxCountKey) > 1:

        # if the first and second values are not equal
        if nearestNeighbours[0] != nearestNeighbours[1]:
            return targetValues[nearestNeighbours[0]] # use the value with shortest distance

        # if the first and second values are equal
        else:
            return targetValues[nearestNeighbours[np.random.randint(2)]] # randomly select between the two
    else:
        # return the only value in the list
        return maxCountKey[0]

Q5. Beyond Wine

If you were to run your k-nn algorithm on a new dataset, what considerations would you need to take into account? Outline any changes that might be needed to your code.

Answer

Most likely, I would need to re-run the code to see if any changes are needed and check for any small errors. The part where I display the plots would need to be rewritten. This is because it is hard-coded to have a 4 x 4 plot. If more features are used for exploration, then the plot structure must be changed. Other than that, most of the functions should work as they were intended.

Back to Projects

Wine Classification using k Nearest Neighbour from Scratch

Table of Contents