implemented non-linear lin reg and lin reg with transformations.

Author: Chetanfs

HW1 - PLA Implementation/.idea/workspace.xml

@@ -28,3 +28,17 @@ mean(unlist(lapply(1:1000, function(i) {
   lm2 <- lm(data=test, c2 ~ x + y)
   summary(lm2)$sigma
 })))
+
+
+## Prob 9/10 Test 
+
+weigths <- matrix(unlist(lapply(1:100, function(i) {
+  test2 <- data.table(x=runif(100, -1, 1), y=runif(100, -1, 1))
+  test2[,x2:=x^2]
+  test2[,y2:=y^2]
+  test2[,xy:=x*y]
+  test2[,cls:=ifelse(x2+y2-0.6 >=0, 1, -1)]
+  coef(lm(cls ~ x + y + x2 + y2 + xy, data=test2))
+}), recursive=F), ncol=6, nrow=100, byrow=T)
+
+apply(weigths, 2, mean)

HW2 - Linear Regression Verification.R

@@ -29,11 +29,21 @@ public static void main(String[] args) {
             double[][] testData = genRandomPoints(Ntest, 2);
             double[][] testClass = getPointClasses(testData, realLine);
 
+            // Insert output noise
+            for (int i = 0; i < N/10; i++) {
+                int randIndex = (int)(Math.random()*N);
+                if (realClasses[randIndex][0] == 0)
+                    realClasses[randIndex][0] = 1;
+                else
+                    realClasses[randIndex][0] = 0;
+            }
+
             // Estimate parameters, note: .inverse() calculates pseudoinverse if inverse isn't possible
             Matrix inputs = Matrix.constructWithCopy(randPoints);
             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);

The Learning Problem HW2.docx

@@ -0,0 +1,32 @@
+import Jama.Matrix;
+
+import java.util.ArrayList;
+
+/**
+ * Created by cheta_000 on 5/22/2015.
+ */
+public class LinRegNonLinear {
+
+    public static void main(String[] args) {
+        int N = 1000;
+        int iters = 1000;
+        ArrayList<Double> props = new ArrayList<>();
+        for (int j = 0; j < iters; j++) {
+            // Generate training data set
+            double[][] train = LinRegImplementation.genRandomPoints(N, 2);
+            double[][] trainCls = LinRegTransformed.assignClassWithNoise(train, N);
+
+            // Fit parameters
+            Matrix inputs = Matrix.constructWithCopy(train);
+            Matrix outputs = Matrix.constructWithCopy(trainCls);
+            Matrix weights = inputs.inverse().times(outputs);
+
+            // Assess probability
+            props.add(LinRegImplementation.evaluate(inputs, trainCls, weights));
+        }
+        System.out.println(props.stream().mapToDouble(Double::doubleValue).average().getAsDouble());
+
+
+    }
+
+}

hw2Programs/.idea/workspace.xml

@@ -0,0 +1,87 @@
+import Jama.Matrix;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
+/**
+ * Created by cheta_000 on 5/22/2015.
+ */
+public class LinRegTransformed {
+
+    public static void main(String[] args) {
+        int N =1000;
+        int iters = 1000;
+        double[][] weightArr = new double[6][iters];
+        ArrayList<Double> normalReg = new ArrayList<>();
+        for (int j = 0; j < iters; j++) {
+            // Generate training/test set and assign classes
+            double[][] training = LinRegImplementation.genRandomPoints(N, 2);
+            double[][] realClass = assignClassWithNoise(training, N);
+            double[][] test = LinRegImplementation.genRandomPoints(N, 2);
+            double[][] testClass = assignClassWithNoise(test, N);
+
+            // Expand training/test vector into nonlinear transformed feature vector
+            double[][] expandedTraining = nonlinearTransform(training, N);
+            double[][] expandedTest = nonlinearTransform(test, N);
+
+            // Fit parameters
+            Matrix inputs = Matrix.constructWithCopy(expandedTraining);
+            Matrix outputs = Matrix.constructWithCopy(realClass);
+            Matrix weights = inputs.inverse().times(outputs);
+            for (int i = 0; i < 6; i++) {
+                weightArr[i][j] = weights.getArray()[i][0];
+            }
+        }
+        double[] avgWeights = Arrays.stream(weightArr).mapToDouble(w -> Arrays.stream(w).average().getAsDouble()).toArray();
+        printArr(avgWeights);
+    }
+
+    public static double[][] assignClassWithNoise(double[][] training, int N) {
+        double[][] realClass = new double[N][1];
+        for (int i = 0; i < N; i++) {
+            realClass[i][0] = Math.pow(training[i][1], 2) + Math.pow(training[i][2], 2) - 0.6;
+            realClass[i][0] = realClass[i][0] >= 0 ? 1 : -1;
+
+            if (i % 10 == 0) { // Inducing noise in 10% of cases
+                realClass[i][0] = realClass[i][0]*-1;
+            }
+        }
+        return realClass;
+    }
+
+    public static double[][] nonlinearTransform(double[][] data, int N) {
+        double[][] expandedTraining = new double[N][6];
+        for(int i = 0; i < N; i++) {
+            expandedTraining[i][0] = data[i][0];
+            expandedTraining[i][1] = data[i][1];
+            expandedTraining[i][2] = data[i][2];
+            expandedTraining[i][3] = data[i][1]*data[i][2];
+            expandedTraining[i][4] = Math.pow(data[i][1], 2);
+            expandedTraining[i][5] = Math.pow(data[i][2], 2);
+        }
+        return expandedTraining;
+    }
+
+    public static void printArr(double[][] myData, int numRows, int numCols)
+    {
+        for(int i = 0; i < numRows; i++)
+        {
+            for(int j = 0; j < numCols; j++)
+            {
+                System.out.print(myData[i][j] + "\t");
+            }
+            System.out.println();
+        }
+    }
+
+    public static void printArr(double[] myData)
+    {
+        for(int j = 0; j < myData.length; j++)
+        {
+            System.out.print(myData[j] + "\t");
+        }
+        System.out.println();
+    }
+
+}

hw2Programs/out/production/hw2Programs/LinRegImplementation.class

@@ -9,6 +9,10 @@ public static void main(String[] args) {
         double test [][] = {{1, 2}, {3, 4}};
         Arrays.stream(test).forEach(p -> System.out.println(p[0] + "" + p[1]));
 //        test[0]={5, 6} confirmed hat this doesn't work
+
+        System.out.println(Math.pow(3, 4));
+
+        System.out.println(test[1]);
     }
 
 }