Merge pull request #15 from max-acc/4-code-cleanup

4 code cleanup

Author: max-acc

Dry_Bean_Dataset.csv

@@ -13,17 +13,44 @@
 ### Installing
 
 
-### Executing program
-
-
-### Error Codes
+### Executing the program
+#### Setting up the classification model
+Firstly you have to import a package called "classification" that contains all important functions for classifying a 
+dataset consisting of float values:   
+```import classification.ClassificationOfFloatValues;```<br>  
+The next step is to create an object for this classification (ob is used as a default name for an object):  
+```ClassificationOfFloatValues ob = new ClassificationOfFloatValues(dataset);```  
+The ```dataset``` variable should contain the name of the dataset that should be classified as a string. 
+The dataset has to be in the same folder as the main file.<br>  
+If the dataset has an index or a header (or both), it has to be indecaded by the user.  
+If there is a header you have to call ```ob.setIndex(true);``` or/and ```ob.setHeader(true);```.  
+The default value for these is ```false``` because it is expected that the dataset does not have an index or header.  
+Most datasets do have a header and an index so make sure, if your dataset has a header or an index, to include this part in your program.
+<br><br>
+
+#### Processing the data
+The following functions are required for classifying the data.  
+Firstly you have to call ```ob.dataProcessing();```  
+```ob.dataSubdivision();```  
+```ob.distanceClassification();```
+<br><br>
+
+#### Evaluating the Results
+For evaluating the predicted results you can call ```ob.evaluateResults();```.
+There are multiple ways to show how the results should be displayed.  
+The ```ob.setEvaluation(model)``` functions sets the evaluation models which are going to be calculated and printed.
+```model``` should contain one of the names below as a string.<br>  
+**Confusion Matrix**: Printing a normal confusion matrix for every class (size: class x class).  
+**Simple Confusion Matrix**: Printing a simplified confusion matrix for every class with true positives and false positives (size: class x 2).  
+**NormalizedConfusion Matrix**: Printing a normalized confusion matrix with the format of the confusion matrix as explained
+above. The values that are displayed a normalized (values between 0 and 1).
 
 
 ## Scripts
-
-
+There is a script that explains the programs function and also explains the data manipulation in detail.  
+You can find the description here.
 ## Help
-
+If you need help if applying the algorithm to your projects, feel free to ask.
 
 ## Authors
 
@@ -33,6 +60,10 @@ Contributors names and contact info
 	* [@max-acc](https://github.com/max-acc)
 
 ## Version History
+### Built v-0.1  
+The current built is v-0.1.  
+It is possible to classify a dataset which contains only float values.
+It is important to consider that the weight for every class is the same.
 
 
 ## License

README.md

@@ -7,22 +7,26 @@ public class Main {
     public static void main (String[] args) throws Exception {
         // Creating of instance of second class present
         // in the same project
-        boolean index = true;
-        boolean header = true;
         String dataset = "Iris_unordered_2.csv";
+        dataset = "Dry_Bean_Dataset.csv";
+
+
 
         ClassificationOfFloatValues ob = new ClassificationOfFloatValues(dataset);
         ob.setIndex(true);
         ob.setHeader(true);
 
-        // traingingData = percentage of training data <1
+        // trainingData = percentage of training data <1
         ob.dataValidation(0.7f);
         ob.dataProcessing();
         ob.dataSubdivision();
-        //System.out.println(ob.feedback()[0][2]);
+
         ob.distanceClassification();
 
+        ob.setEvaluation("Confusion Matrix");
+        ob.setEvaluation("Simple Confusion Matrix");
+        ob.setEvaluation("Normalized Confusion Matrix");
+
         ob.evaluateResults();
     }
-
 }

script/Dokumentation.pdf

@@ -68,6 +68,7 @@ static float[] getRecordFromLine (String line, boolean index, int rowCount) {
             // Using , as a delimiter for separating the line input
             rowScanner.useDelimiter(",");
             for (int i = 0; rowScanner.hasNext(); i++) {
+                //System.out.println(rowScanner);
                 // Skip if there is an index
                 if ((index == true && skip == true) || i == rowCount) {
                     skip = false;
@@ -77,7 +78,10 @@ static float[] getRecordFromLine (String line, boolean index, int rowCount) {
                     if (i == rowCount) {
                         break;
                     }
-                }values[i] = Float.parseFloat(rowScanner.next());
+                }
+                String tempVar = rowScanner.next();
+                //System.out.println(tempVar);
+                values[i] = Float.parseFloat(tempVar);
             }
         }
         return values;

src/Dry_Bean_Dataset.csv

@@ -32,6 +32,8 @@ public class ClassificationOfFloatValues {
     private int[][] sortedProbability;
     private int numberOfClasses;
 
+    private boolean[] validationModel = {false, false, false};
+
 
     // Function to add the members of the class
     public float[][] output() { return this.predictorData; }
@@ -47,12 +49,12 @@ public ClassificationOfFloatValues(String dataset) throws Exception {
         this.datasetName = dataset;
     }
 
-    // --- Function for creating
+    // --- Function for processing the data (reading and writing the data to an array)
     public void dataProcessing() throws Exception {
+        // Get row and column count
         this.rowCount = CSVread.calcRowCount(this.datasetName, this.index);
         this.columnCount = CSVread.calcColumnCount(this.datasetName, this.index);
-        //System.out.println(this.rowCount);
-        //System.out.println(this.columnCount);
+        // Get predictor and result data
         this.predictorData = CSVread.transformPredictorData(this.datasetName, this.index, this.header, this.columnCount, this.rowCount);
         this.resultData = CSVread.transformResultData(this.datasetName, this.index, this.header, this.columnCount, this.rowCount);
         this.dataProcessingBool = true;
@@ -77,56 +79,85 @@ public void dataSubdivision () {
 
 
     // --- Functions for additional user control -----------------------------------------------------------------------
-    // --- Function for changing the ratio between training and testing data
+    // --- Functions for setting the index and header data
     public void setIndex (boolean index) { this.index = index; }
+
     public void setHeader (boolean header) { this.header = header; }
+
+    // --- Function for changing the data density to clear extreme values | Not working
     public void setDensity (float density) {this.density = density;}
+
+    // --- Function for changing the ratio between training and testing data
     public void dataValidation (float trainingData) {
         this.validation[0] = trainingData;
         this.validation[1] = 1- trainingData;
     }
+    // --- Function for setting the validation model
+    public void setEvaluation(String evaluationName) {
+        if (evaluationName.equals("Confusion Matrix")) {
+            this.validationModel[0] = true;
+        }else if (evaluationName.equals("Simple Confusion Matrix")) {
+            this.validationModel[1] = true;
+        }else if (evaluationName.equals("Normalized Confusion Matrix")) {
+            this.validationModel[2] = true;
+        }
+    }
 
 
     // --- Functions for evaluating the machine learning results -------------------------------------------------------
+    // --- Function for printing confusion matrices
     public void evaluateResults() {
+        // Creating an object to calculate confusion matrices
         DATA_evaluation evaluationObject    = new DATA_evaluation(this.testDataResults,
                 this.columnCount - this.numberOfTrainingData,
                 this.predictedTestData,
                 this.sortedProbability,
                 this.numberOfClasses);
-        int[][] asdf = evaluationObject.getConfusionMatrixSimple();
-        evaluationObject.getConfusionMatrixNormalized();
-    }
-    public void confusionMatrix() {
-        if (this.MLAlgorithm == "DistanceClassification") {
-            System.out.println("nice confusion");
+
+        // Printing a basic confusion matrix
+        if (this.validationModel[0] == true) {
+            System.out.println("\nConfusion Matrix");
+            evaluationObject.getConfusionMatrix();
+        }
+        // Printing a simplified confusion matrix
+        if (this.validationModel[1] == true) {
+            System.out.println("\nSimple Confusion Matrix");
+            evaluationObject.getConfusionMatrixSimple();
         }
-        else {
-            System.out.println("There is no algorithm");
+        // Printing a normalized confusion matrix
+        if (this.validationModel[2] == true) {
+            System.out.println("\nNormalized Confusion Matrix");
+            evaluationObject.getConfusionMatrixNormalized();
         }
+
     }
 
 
     // --- Functions for private calculations --------------------------------------------------------------------------
     // --- Function for returning usable index data
     private int returnIndex() {
         // If there is an index it returns -1 because the usable data of the processed data has one element less
+        // The index does not belong to the important data
         if (this.index == true) { return -1; } else { return 0; }
     }
 
-    //
+    // --- Function for checking if all required processes have been completed successful before starting the
+    // classification algorithms
     private boolean checkRequiredProcesses () {
+        // dataProcessingBool:  Process the CSV data (reading)
+        // dataSubdivisionBool: Dividing the data into training and testing data
         if (this.dataProcessingBool == true &&
             this.dataSubdivisionBool == true) {
             return true;
+        }else {
+            if (this.dataProcessingBool == false) {
+                System.out.println("Error 310 | The data has not been divided into training and testing data!");
+            }
+            if (this.dataSubdivisionBool == false) {
+                System.out.println("Error 311 | The data has not been divided into training and testing data!");
+            }
+            return false;
         }
-        if (this.dataProcessingBool == false) {
-            System.out.println("Error 310 | The data has not been divided into training and testing data!");
-        }
-        if (this.dataSubdivisionBool == false) {
-            System.out.println("Error 311 | The data has not been divided into training and testing data!");
-        }
-        return false;
     }
 
 
@@ -149,9 +180,10 @@ public void distanceClassification (){
             classificationObject.setTestData(this.testDataPredictors, this.testDataResults, this.rowCount, this.columnCount - this.numberOfTrainingData);
             classificationObject.testModel();
 
+            // Return the number of found classes
             this.numberOfClasses = classificationObject.getNumberOfClasses();
 
-            // Get the test data
+            // Get the predicted text data
             this.predictedTestData  = classificationObject.getPredictedTestData();
             this.sortedProbability  = classificationObject.getSortedProbability();
         }