lint

Author: MaryFllh

k_means_clustering.py

@@ -4,6 +4,7 @@
 from sklearn.datasets import make_blobs
 from utils import euclidean_distance
 
+
 class KMeans:
     def __init__(self, k: int, iter_nums=100):
         self.k = k
@@ -12,28 +13,30 @@ def __init__(self, k: int, iter_nums=100):
     def fit(self, X: np.array):
         self.X = X
         self.sample_nums, _ = self.X.shape
-        
+
         # initialise centroids
         random_idx = np.random.choice(self.sample_nums, self.k, replace=False)
         centroids = [self.X[idx] for idx in random_idx]
-        
+
         for _ in range(self.iter_nums):
             clusters = self._create_clusters(centroids)
             centroids_before_updates = centroids
-    
+
             self.plot(clusters, centroids)
-    
+
             centroids = self._update_centroids(clusters)
-            
+
             if self._has_converged(centroids_before_updates, centroids):
                 break
 
             self.plot(clusters, centroids)
-            
+
     def _create_clusters(self, centroids):
         clusters = [[] for _ in range(self.k)]
         for sample_idx in range(self.sample_nums):
-            distance_to_centroids = [euclidean_distance(self.X[sample_idx], c) for c in centroids]
+            distance_to_centroids = [
+                euclidean_distance(self.X[sample_idx], c) for c in centroids
+            ]
             clusters[np.argmin(distance_to_centroids)].append(sample_idx)
         return clusters
 
@@ -43,27 +46,31 @@ def _update_centroids(self, clusters):
             centroids.append(np.mean(self.X[point_idx], axis=0))
         print(centroids)
         return centroids
-    
+
     def plot(self, clusters, centroids):
         _, ax = plt.subplots()
 
         for _, idx in enumerate(clusters):
             points = self.X[idx].T
             ax.scatter(*points)
-        
+
         for c in centroids:
-            ax.scatter(*c, marker='x', color='black', linewidth=3)
+            ax.scatter(*c, marker="x", color="black", linewidth=3)
 
         plt.show()
-    
+
     def _has_converged(self, old_centroids, centroids):
-        distances = [euclidean_distance(old_centroids[i], centroids[i]) for i in range(self.k)]
+        distances = [
+            euclidean_distance(old_centroids[i], centroids[i]) for i in range(self.k)
+        ]
         return sum(distances) == 0
 
 
-if __name__=="__main__":
+if __name__ == "__main__":
     np.random.seed(42)
-    X, y = make_blobs(centers=3, n_samples=200, n_features=2, shuffle=True, random_state=40)
+    X, y = make_blobs(
+        centers=3, n_samples=200, n_features=2, shuffle=True, random_state=40
+    )
 
     k = KMeans(len(np.unique(y)))
     k.fit(X)

knn.py

@@ -6,10 +6,11 @@
 
 from utils import euclidean_distance
 
+
 class KNN:
     def __init__(self, k=5):
         self.k = k
-    
+
     def fit(self, X, Y):
         self.X_train = X
         self.Y_train = Y
@@ -19,14 +20,17 @@ def predict(self, X):
 
     def find_nearest_neighbors(self, x):
         distances = [euclidean_distance(x, x_train) for x_train in self.X_train]
-        nearest_neighbors_idx = np.argsort(distances)[:self.k]
+        nearest_neighbors_idx = np.argsort(distances)[: self.k]
         nearest_neighbors = [self.Y_train[i] for i in nearest_neighbors_idx]
         return Counter(nearest_neighbors).most_common()[0][0]
 
+
 def run():
     dataset = datasets.load_iris()
     X, y = dataset.data, dataset.target
-    X_train, X_test, Y_train, Y_test = train_test_split(X, y, test_size=.2, random_state=1)
+    X_train, X_test, Y_train, Y_test = train_test_split(
+        X, y, test_size=0.2, random_state=1
+    )
 
     knn = KNN()
     knn.fit(X_train, Y_train)
@@ -35,5 +39,6 @@ def run():
     accuracy = sum(preds == Y_test) / len(preds)
     print(accuracy)
 
+
 if __name__ == "__main__":
-    run()
+    run()

linear_regression.py

@@ -4,22 +4,23 @@
 from sklearn.model_selection import train_test_split
 from sklearn import datasets
 
+
 class LinearRegression:
-    def __init__(self, lr=.01, n_iter=1000):
+    def __init__(self, lr=0.01, n_iter=1000):
         self.lr = lr
         self.n_iter = n_iter
-    
+
     def fit(self, X, y):
         n_samples, n_features = X.shape
         self.weights = np.zeros(n_features)
         self.bias = 0
         for _ in range(self.n_iter):
             preds = np.dot(X, self.weights) + self.bias
-            dw = (2 / n_samples ) * np.dot(X.T, (preds - y))
+            dw = (2 / n_samples) * np.dot(X.T, (preds - y))
             db = (2 / n_samples) * sum(preds - y)
             self.weights -= self.lr * dw
-            self.bias -= self.lr * db 
-    
+            self.bias -= self.lr * db
+
     def predict(self, X):
         return np.dot(X, self.weights) + self.bias
 
@@ -30,13 +31,17 @@ def run():
     The mean square error is calculated and printed, the scatter plot of the
     test data points along with the fitted line are also plotted.
     """
-    X, y = datasets.make_regression(n_samples=1000, n_features=1, noise=10, random_state=1)
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2, random_state=1)
-    
+    X, y = datasets.make_regression(
+        n_samples=1000, n_features=1, noise=10, random_state=1
+    )
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=1
+    )
+
     lr = LinearRegression()
     lr.fit(X_train, y_train)
     preds = lr.predict(X_test)
-    
+
     mse = np.mean((preds - y_test) ** 2)
     print(mse)
 

logistic_regression.py

@@ -5,10 +5,10 @@
 
 
 class LogisticRegression:
-    def __init__(self, lr=.01, n_iter=1000):
+    def __init__(self, lr=0.01, n_iter=1000):
         self.lr = lr
         self.n_iter = n_iter
-    
+
     def sigmoid(self, x):
         return 1 / (1 + np.exp(-x))
 
@@ -21,19 +21,20 @@ def fit(self, X, y):
             preds = self.sigmoid(linear_preds)
 
             dw = (1 / n_samples) * np.dot(X.T, (preds - y))
-            db = (1 / n_samples) * np.sum(preds - y) 
+            db = (1 / n_samples) * np.sum(preds - y)
 
             self.weights -= self.lr * dw
             self.bias -= self.lr * db
-        
-    def predict(self, X, thresh=.5):
+
+    def predict(self, X, thresh=0.5):
         linear_preds = np.dot(X, self.weights) + self.bias
         preds = [1 if self.sigmoid(pred) > thresh else 0 for pred in linear_preds]
         return preds
-    
+
     def accuracy_score(self, y, preds):
         return sum(y == preds) / len(y)
 
+
 def run():
     """
     Creates a dataset, splits into train and test, fits LR and tests it.
@@ -42,12 +43,13 @@ def run():
     """
     dataset = datasets.load_breast_cancer()
     X, y = dataset.data, dataset.target
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2, random_state=1)
-    lr = LogisticRegression(lr=.001)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=1
+    )
+    lr = LogisticRegression(lr=0.001)
     lr.fit(X_train, y_train)
     preds = lr.predict(X_test)
     print(lr.accuracy_score(preds, y_test))
-    
 
 
 if __name__ == "__main__":

naive_bayes.py

@@ -3,10 +3,12 @@
 from sklearn.model_selection import train_test_split
 from sklearn import datasets
 
+
 def accuracy(y_true, y_pred):
     accuracy = np.sum(y_true == y_pred) / len(y_true)
     return accuracy
 
+
 class NaiveBayes:
     def fit(self, X, y):
         self.unique_classes = np.unique(y)
@@ -18,7 +20,7 @@ def fit(self, X, y):
         self._priors = np.zeros(classes_num, dtype=np.float64)
 
         for idx, c in enumerate(self.unique_classes):
-            X_c = X[y == c] # gives features of class c
+            X_c = X[y == c]  # gives features of class c
             self._mean[idx, :] = np.mean(X_c, axis=0)
             self._var[idx, :] = np.var(X_c, axis=0)
             self._priors[idx] = len(X_c) / samples_num
@@ -35,11 +37,11 @@ def _predict(self, x):
             posterior = prior + likelihood
             posteriors.append(posterior)
         return np.argmax(posteriors)
-    
+
     def _compute_likelihood(self, idx, x):
-        nominator = np.exp(-(x - self._mean[idx]) ** 2 / (2 * self._var[idx]))
+        nominator = np.exp(-((x - self._mean[idx]) ** 2) / (2 * self._var[idx]))
         denominator = np.sqrt(2 * np.pi * self._var[idx])
-        return  np.sum(np.log(nominator / denominator))
+        return np.sum(np.log(nominator / denominator))
 
 
 if __name__ == "__main__":
@@ -55,4 +57,4 @@ def _compute_likelihood(self, idx, x):
     nb.fit(X_train, y_train)
     predictions = nb.predict(X_test)
 
-    print("Naive Bayes classification accuracy", accuracy(y_test, predictions))
+    print("Naive Bayes classification accuracy", accuracy(y_test, predictions))

neural_net/activations.py

@@ -2,11 +2,12 @@
 
 from layers import Activation
 
+
 class ReLU(Activation):
     def __init__(self):
         def relu(X):
             return np.maximum(X, 0)
- 
+
         def relu_prime(X):
             return X > 0
 
@@ -23,12 +24,13 @@ def tanh_prime(X):
 
         super().__init__(tanh, tanh_prime)
 
+
 class Sigmoid(Activation):
     def __init__(self):
         def sigmoid(X):
             return 1 / (1 + np.exp(-X))
-        
+
         def sigmoid_prime(X):
             return sigmoid(X) * (1 - sigmoid(X))
 
-        super().__init__(sigmoid, sigmoid_prime)
+        super().__init__(sigmoid, sigmoid_prime)