Merge pull request #39 from param087/linearRegression

added Least Squares Linear Regression algorithm

Author: param087

Notebooks/Least Squares Linear Regression.ipynb

@@ -47,8 +47,6 @@ public class BernoulliNB {
         // Find unique classes in target values.
         (self.classes, self.indices) = Raw.unique(labels.flattened())
 
-        precondition(self.classes.shape[0] == 2, "Labels must have only two classes.")
-
         // Initialize the classLogPrior and featureLogProb based on feature count and sample count.
         var separated = [[Tensor<Float>]]()
         self.classLogPrior = Tensor<Float>(zeros: [self.classes.shape[0]])

Sources/swiftML/BernoulliNB.swift

@@ -100,9 +100,9 @@ public class KNeighborsClassifier {
     /// - Returns: Predicted classification.
     internal func predictSingleSample(_ test: Tensor<Float>) -> Tensor<Int32> {
         var distances = Tensor<Float>(zeros: [self.data.shape[0]])
-        var maxLabel = Tensor<Int32>(zeros: [self.neighborCount])
-        var maxDistances: Tensor<Float>
-        var maxIndex: Tensor<Int32>
+        var minDistanceLabels = Tensor<Int32>(zeros: [self.neighborCount])
+        var minDistances: Tensor<Float>
+        var minDistanceIndex: Tensor<Int32>
         var classes: Tensor<Int32>
         var indices: Tensor<Int32>
 
@@ -112,27 +112,27 @@ public class KNeighborsClassifier {
         }
 
         // Find the top neighbor with minimum distance.
-        (maxDistances, maxIndex) =
+        (minDistances, minDistanceIndex) =
             Raw.topKV2(distances, k: Tensor<Int32>(Int32(data.shape[0])), sorted: true)
-        maxDistances = Raw.reverse(maxDistances, dims: Tensor<Bool>([true]))
-        maxDistances = maxDistances
+        minDistances = Raw.reverse(minDistances, dims: Tensor<Bool>([true]))
+        minDistances = minDistances
             .slice(lowerBounds: Tensor<Int32>([0]),
                 sizes: Tensor<Int32>([Int32(self.neighborCount)]))
 
-        maxIndex = Raw.reverse(maxIndex, dims: Tensor<Bool>([true]))
-        maxIndex = maxIndex
+        minDistanceIndex = Raw.reverse(minDistanceIndex, dims: Tensor<Bool>([true]))
+        minDistanceIndex = minDistanceIndex
             .slice(lowerBounds: Tensor<Int32>([0]),
                 sizes: Tensor<Int32>([Int32(self.neighborCount)]))
 
         for i in 0..<self.neighborCount {
-            maxLabel[i] = self.labels[Int(maxIndex[i].scalarized())]
+            minDistanceLabels[i] = self.labels[Int(minDistanceIndex[i].scalarized())]
         }
 
         // Weights the neighbors based on their weighing method.
         let labelsAndWeightsTensor = computeWeights(
-            distances: maxDistances, labels: Tensor<Float>(maxLabel))
+            distances: minDistances, labels: Tensor<Float>(minDistanceLabels))
 
-        (classes, indices) = Raw.unique(Tensor<Int32>(maxLabel))
+        (classes, indices) = Raw.unique(Tensor<Int32>(minDistanceLabels))
 
         var kClasses = Tensor<Int32>(zeros: [classes.shape[0]])
         var kWeights = Tensor<Float>(zeros: [classes.shape[0]])

Sources/swiftML/KNeighborsClassifier.swift

@@ -97,34 +97,34 @@ public class KNeighborsRegressor {
     /// - Returns: Predicted target value.
     internal func predictSingleSample(_ test: Tensor<Float>) -> Tensor<Float> {
         var distances = Tensor<Float>(zeros: [self.data.shape[0]])
-        var maxLabel = Tensor<Float>(zeros: [self.neighborCount])
-        var maxDistances: Tensor<Float>
-        var maxIndex: Tensor<Int32>
+        var minDistanceLabels = Tensor<Float>(zeros: [self.neighborCount])
+        var minDistances: Tensor<Float>
+        var minDistanceIndex: Tensor<Int32>
 
         // Calculate the distance between test and all data points.
         for i in 0..<self.data.shape[0] {
             distances[i] = minkowskiDistance(self.data[i], test, p: self.p)
         }
 
         // Find the top neighbors with minimum distance.
-        (maxDistances, maxIndex) =
+        (minDistances, minDistanceIndex) =
             Raw.topKV2(distances, k: Tensor<Int32>(Int32(data.shape[0])), sorted: true)
-        maxDistances = Raw.reverse(maxDistances, dims: Tensor<Bool>([true]))
-        maxDistances = maxDistances
+        minDistances = Raw.reverse(minDistances, dims: Tensor<Bool>([true]))
+        minDistances = minDistances
             .slice(lowerBounds: Tensor<Int32>([0]),
                 sizes: Tensor<Int32>([Int32(self.neighborCount)]))
 
-        maxIndex = Raw.reverse(maxIndex, dims: Tensor<Bool>([true]))
-        maxIndex = maxIndex
+        minDistanceIndex = Raw.reverse(minDistanceIndex, dims: Tensor<Bool>([true]))
+        minDistanceIndex = minDistanceIndex
             .slice(lowerBounds: Tensor<Int32>([0]),
                 sizes: Tensor<Int32>([Int32(self.neighborCount)]))
 
         for i in 0..<self.neighborCount {
-            maxLabel[i] = self.labels[Int(maxIndex[i].scalarized())]
+            minDistanceLabels[i] = self.labels[Int(minDistanceIndex[i].scalarized())]
         }
 
         // Average weight based on neighbors weights.
-        let avgWeight = computeWeights(distances: maxDistances, labels: maxLabel)
+        let avgWeight = computeWeights(distances: minDistances, labels: minDistanceLabels)
         return avgWeight
     }
 

Sources/swiftML/KNeighborsRegressor.swift

@@ -0,0 +1,50 @@
+import TensorFlow
+
+/// Least Squares linear regression.
+///
+/// Reference: ["Least Squares linear regression"](
+/// https://en.wikipedia.org/wiki/Linear_regression)
+public class LeastSquaresLinearRegression: LinearRegression {
+    /// Whether to calculate the intercept for this model.
+    public var fitIntercept: Bool
+    /// The weights of the model.
+    public var weights: Tensor<Float>
+    
+    /// Creates a linear regression model.
+    ///
+    /// - Parameters:
+    ///   - fitIntercept: Whether to calculate the intercept for this model. If `false`, no
+    ///     intercept will be used in calculations. The default is `true`.
+    public init(
+        fitIntercept: Bool = true
+    ) {
+        self.fitIntercept = fitIntercept
+        self.weights = Tensor<Float>(0)
+    }
+
+    /// Fit a linear model.
+    ///
+    /// - Parameters:
+    ///   - data: Training data with shape `[sample count, feature count]`.
+    ///   - labels: Target value with shape `[sample count, target count]`.
+    public func fit(data: Tensor<Float>, labels: Tensor<Float>) {
+        precondition(data.shape[0] > 0, "Data must have a positive sample count.")
+        precondition(data.shape[1] >= 1,
+            "Data must have feature count greater than or equal to one.")
+        precondition(labels.shape[0] > 0, "Labels must have a positive sample count.")
+        precondition(labels.shape[1] >= 1,
+            "Labels must have target feature count greater than or equal to one.")
+        precondition(data.shape[0] == labels.shape[0],
+            "Data and labels must have the same sample count.")
+
+        var data: Tensor<Float> = data
+        if self.fitIntercept {
+            let ones = Tensor<Float>(ones: [data.shape[0], 1])
+            data = ones.concatenated(with: data, alongAxis: -1)
+        }   
+
+        // weights = (X^T.X)^-1.X^T.y
+        self.weights = matmul(matmul(Raw.matrixInverse(matmul(data.transposed(), data)),
+            data.transposed()), labels)
+    }
+}