implemented PLA initalized by linear regression

Author: Chetanfs

HW1 - PLA Implementation/.idea/workspace.xml

@@ -80,8 +80,8 @@ public static void main(String[] args) {
                     /estimGError.size());
         }
         System.out.println(counters);
-        System.out.println(counters.stream().mapToInt(Integer::intValue).average().getAsDouble());
-        System.out.println(propDiffs.stream().mapToDouble(Double::doubleValue).average().getAsDouble());
+        System.out.println("Average iterations to convergence: " + counters.stream().mapToInt(Integer::intValue).average().getAsDouble());
+        System.out.println("Average probability that convergence hypothesis and real function differ: " + propDiffs.stream().mapToDouble(Double::doubleValue).average().getAsDouble());
     }
 
     public static Point genRanPoint() {

HW1 - PLA Implementation/src/PLA.java

@@ -34,6 +34,10 @@ public static void main(String[] args) {
             Matrix output = Matrix.constructWithCopy(realClasses);
             Matrix weights = inputs.inverse().times(output);
 
+            // How to estimate parameters without .inverse() pseudoinverse shortcut
+//            Matrix inputsT = inputs.transpose();
+//            Matrix weights = inputsT.times(inputs).inverse().times(inputsT).times(output);
+
             // Estimating error in training/test set
             propIncorrectTrain.add(evaluate(inputs, realClasses, weights));
             Matrix inputTest = Matrix.constructWithCopy(testData);
@@ -47,10 +51,9 @@ public static void main(String[] args) {
     public static double[][] genRandomPoints(int n, int cols) {
         double[][] inputs =  new double [n][cols+1];
         for (int i = 0; i < n; i++) {
-            double[] newPoint = {Math.random() * 2 - 1, Math.random() * 2 - 1};
-            inputs[i][0] = 1;
-            inputs[i][1] = newPoint[0];
-            inputs[i][2] = newPoint[1];
+            inputs[i][0] = 1; // added so we can treat threshold as w_0
+            inputs[i][1] = Math.random() * 2 - 1;
+            inputs[i][2] = Math.random() * 2 - 1;
         }
         return inputs;
     }
@@ -70,9 +73,13 @@ public static double[] genRandomLine() {
         return new double [] {m, b};
     }
 
-    public static double evaluate(Matrix input, double[][] realClasses, Matrix weights) {
+    public static double[] predict(Matrix input, Matrix weights) {
         double scores[][] = input.times(weights).getArray();
-        double estimClass[] = Arrays.stream(scores).map(n -> n[0] > 0 ? 1.0 : 0.0).mapToDouble(Double::doubleValue).toArray();
+        return Arrays.stream(scores).map(n -> n[0] > 0 ? 1.0 : 0.0).mapToDouble(Double::doubleValue).toArray();
+    }
+
+    public static double evaluate(Matrix input, double[][] realClasses, Matrix weights) {
+        double estimClass[] = predict(input, weights);
         int numIncorrect = 0;
         for (int i = 0; i < estimClass.length; i++)
             if (estimClass[i] != realClasses[i][0])

The Learning Problem HW2.docx

@@ -0,0 +1,72 @@
+import Jama.Matrix;
+
+import java.util.ArrayList;
+
+/**
+ * Created by cheta_000 on 5/22/2015.
+ * Implements the PLA algorithm with weights initialized by linear regression
+ */
+
+public class PLA {
+
+    public static void main(String[] args) {
+        int N = 10;
+        ArrayList<Double> errorRatesInitially = new ArrayList<>();
+        ArrayList<Integer> iterations = new ArrayList<>();
+        for (int j = 0; j < 1000; j++) {
+            // Generate f(x)
+            double[] realLine = LinRegImplementation.genRandomLine();
+
+            // Generate training data
+            double[][] training = LinRegImplementation.genRandomPoints(N, 2);
+            double[][] trainingClass = LinRegImplementation.getPointClasses(training, realLine);
+
+            // Initialize weights
+            Matrix inputs = Matrix.constructWithCopy(training);
+            Matrix output = Matrix.constructWithCopy(trainingClass);
+            Matrix weights = inputs.inverse().times(output);
+
+//            System.out.println("Initial error: " + LinRegImplementation.evaluate(inputs, trainingClass, weights) + ", ");
+            errorRatesInitially.add(LinRegImplementation.evaluate(inputs, trainingClass, weights));
+
+            // Get error and start iterations
+            double[] error = getErrorArray(weights, inputs, output);
+            int wrongIndex = findWrongIndex(error);
+            int counter = 0;
+            while(wrongIndex != -1) {
+                counter++;
+                weights.getArray()[0][0] += error[wrongIndex]*inputs.getArray()[wrongIndex][0];
+                weights.getArray()[1][0] += error[wrongIndex]*inputs.getArray()[wrongIndex][1];
+                weights.getArray()[2][0] += error[wrongIndex]*inputs.getArray()[wrongIndex][2];
+                error = getErrorArray(weights, inputs, output);
+                wrongIndex = findWrongIndex(error);
+            }
+            iterations.add(counter);
+//            System.out.println("Iterations for PLA to perfect: " + counter);
+        }
+        System.out.println("Average initial error: " + errorRatesInitially.stream().mapToDouble(Double::doubleValue).average().getAsDouble());
+        System.out.println("Average num of iterations: " + iterations.stream().mapToInt(Integer::intValue).average().getAsDouble());
+
+    }
+
+    public static double[] getErrorArray(Matrix weights, Matrix inputs, Matrix outputs) {
+        double[][] realClass = outputs.getArray();
+        double[] estimOutput = LinRegImplementation.predict(inputs, weights);
+        double[] error = new double[realClass.length];
+        for (int i = 0; i < realClass.length; i++) {
+            error[i] = realClass[i][0] - estimOutput[i];
+        }
+        return error;
+    }
+
+    public static int findWrongIndex(double[] error) {
+        for (int i = 0; i < error.length; i++) {
+            if (error[i] != 0) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+
+}