sklearnk 0.1.0__tar.gz

sklearnk-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: sklearnk
+Version: 0.1.0
+Summary: A collection of AI & ML lab programs
+Author-email: Antigravity <antigravity@example.com>
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+
+# sklearnk
+
+A collection of AI & ML lab programs extracted from the ScalarVerse project.
+
+## Installation
+
+```bash
+pip install .
+```
+
+### For Older Computers
+If `pip` is not working or if the computer is very old, you can use the traditional setup script:
+
+```bash
+python setup.py install
+```
+
+## Usage
+
+Each program is exposed as a function in the `sklearnk` package. You can run them sequentially:
+
+```python
+import sklearnk
+
+# Run Tic Tac Toe
+sklearnk.program1()
+
+# Run Alpha Beta Pruning
+sklearnk.program2()
+
+# Run 8 Puzzle (A* Algorithm)
+sklearnk.program3()
+
+# Run Hill Climbing
+sklearnk.program4()
+
+# Run Logistic Regression
+sklearnk.program5()
+
+# Run Naive Bayes
+sklearnk.program6()
+
+# Run K-Nearest Neighbors
+sklearnk.program7()
+
+# Run K-Means Clustering
+sklearnk.program8()
+
+# Run Logistic Regression (sklearn version)
+sklearnk.program9()
+
+# Run Naive Bayes (sklearn version)
+sklearnk.program10()
+
+# Run KNN (sklearn version)
+sklearnk.program11()
+
+# Run K-Means (sklearn version)
+sklearnk.program12()
+```
+
+## Programs Included
+
+1. **program1**: Tic Tac Toe (Minimax)
+2. **program2**: Alpha Beta Pruning
+3. **program3**: 8 Puzzle (A* Algorithm)
+4. **program4**: Hill Climbing
+5. **program5**: Logistic Regression (from scratch)
+6. **program6**: Naive Bayes (from scratch)
+7. **program7**: K-Nearest Neighbors (from scratch)
+8. **program8**: K-Means Clustering (from scratch)
+9. **program9**: Logistic Regression (using sklearn)
+10. **program10**: Naive Bayes (using sklearn)
+11. **program11**: KNN (using sklearn)
+12. **program12**: K-Means (using sklearn)

sklearnk-0.1.0/README.md

@@ -0,0 +1,75 @@
+# sklearnk
+
+A collection of AI & ML lab programs extracted from the ScalarVerse project.
+
+## Installation
+
+```bash
+pip install .
+```
+
+### For Older Computers
+If `pip` is not working or if the computer is very old, you can use the traditional setup script:
+
+```bash
+python setup.py install
+```
+
+## Usage
+
+Each program is exposed as a function in the `sklearnk` package. You can run them sequentially:
+
+```python
+import sklearnk
+
+# Run Tic Tac Toe
+sklearnk.program1()
+
+# Run Alpha Beta Pruning
+sklearnk.program2()
+
+# Run 8 Puzzle (A* Algorithm)
+sklearnk.program3()
+
+# Run Hill Climbing
+sklearnk.program4()
+
+# Run Logistic Regression
+sklearnk.program5()
+
+# Run Naive Bayes
+sklearnk.program6()
+
+# Run K-Nearest Neighbors
+sklearnk.program7()
+
+# Run K-Means Clustering
+sklearnk.program8()
+
+# Run Logistic Regression (sklearn version)
+sklearnk.program9()
+
+# Run Naive Bayes (sklearn version)
+sklearnk.program10()
+
+# Run KNN (sklearn version)
+sklearnk.program11()
+
+# Run K-Means (sklearn version)
+sklearnk.program12()
+```
+
+## Programs Included
+
+1. **program1**: Tic Tac Toe (Minimax)
+2. **program2**: Alpha Beta Pruning
+3. **program3**: 8 Puzzle (A* Algorithm)
+4. **program4**: Hill Climbing
+5. **program5**: Logistic Regression (from scratch)
+6. **program6**: Naive Bayes (from scratch)
+7. **program7**: K-Nearest Neighbors (from scratch)
+8. **program8**: K-Means Clustering (from scratch)
+9. **program9**: Logistic Regression (using sklearn)
+10. **program10**: Naive Bayes (using sklearn)
+11. **program11**: KNN (using sklearn)
+12. **program12**: K-Means (using sklearn)

sklearnk-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sklearnk"
+version = "0.1.0"
+description = "A collection of AI & ML lab programs"
+readme = "README.md"
+dependencies = [
+    "numpy",
+    "matplotlib",
+    "scikit-learn"
+]
+authors = [
+    { name = "Antigravity", email = "antigravity@example.com" }
+]
+
+[tool.setuptools]
+packages = ["sklearnk"]

sklearnk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sklearnk-0.1.0/sklearnk/__init__.py

@@ -0,0 +1,12 @@
+from .program1 import run as program1
+from .program2 import run as program2
+from .program3 import run as program3
+from .program4 import run as program4
+from .program5 import run as program5
+from .program6 import run as program6
+from .program7 import run as program7
+from .program8 import run as program8
+from .program9 import run as program9
+from .program10 import run as program10
+from .program11 import run as program11
+from .program12 import run as program12

sklearnk-0.1.0/sklearnk/program1.py

@@ -0,0 +1,81 @@
+def run():
+    class TicTacToe: 
+        def __init__(self): 
+            self.board = [[' ']*3 for _ in range(3)] 
+            self.player = 'X' 
+     
+        def print_board(self): 
+            for row in self.board: 
+                print(' | '.join(row)) 
+            print('-' * 5) 
+     
+        def is_winner(self, player): 
+            for row in self.board: 
+                if row.count(player) == 3: 
+                    return True 
+            for col in zip(*self.board): 
+                if list(col).count(player) == 3: 
+                    return True 
+            if all(self.board[i][i] == player for i in range(3)) or all(self.board[i][2-i] == player for i in 
+    range(3)): 
+                return True 
+            return False 
+     
+        def is_draw(self): 
+            return all(cell != ' ' for row in self.board for cell in row) 
+     
+        def dfs(self, player): 
+            winner = 'X' if self.is_winner('X') else ('O' if self.is_winner('O') else None) 
+            if winner: 
+                return {'score': 1 if winner == 'X' else -1} 
+            if self.is_draw(): 
+                return {'score': 0} 
+     
+            best = {'score': -float('inf')} if player == 'X' else {'score': float('inf')} 
+            for i in range(3): 
+                for j in range(3): 
+                    if self.board[i][j] == ' ': 
+                        self.board[i][j] = player 
+                        score = self.dfs('O' if player == 'X' else 'X') 
+                        self.board[i][j] = ' ' 
+                        score['row'], score['col'] = i, j 
+     
+                        if player == 'X' and score['score'] > best['score']: 
+                            best = score 
+                        elif player == 'O' and score['score'] < best['score']: 
+                            best = score 
+            return best 
+     
+        def play(self): 
+            while True: 
+                self.print_board() 
+                if self.is_winner('X'): 
+                    print("Player X wins!") 
+                    break 
+                if self.is_winner('O'): 
+                    print("Player O wins!") 
+                    break 
+                if self.is_draw(): 
+                    print("It's a draw!") 
+                    break 
+                if self.player == 'X': 
+                    best_move = self.dfs('X') 
+                    self.board[best_move['row']][best_move['col']] = 'X' 
+                else: 
+                    while True: 
+                        try: 
+                            i, j = map(int, input("Enter row and column (0-2): ").split()) 
+                            if self.board[i][j] == ' ': 
+                                self.board[i][j] = 'O' 
+                                break 
+                            else: 
+                                print("Invalid move. Try again.") 
+                        except (ValueError, IndexError): 
+                            print("Enter valid numbers between 0 and 2.") 
+                self.player = 'O' if self.player == 'X' else 'X' 
+     
+    game = TicTacToe() 
+    game.play()
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program10.py

@@ -0,0 +1,24 @@
+def run():
+    import numpy as np
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.naive_bayes import GaussianNB
+    from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+    
+    iris = load_iris()
+    X, y = iris.data, iris.target
+    
+    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=1)
+    
+    nb = GaussianNB()
+    nb.fit(Xtr, ytr)
+    
+    y_pred = nb.predict(Xte)
+    
+    print("Accuracy: %.4f" % accuracy_score(yte, y_pred))
+    print("Predictions:", iris.target_names[y_pred])
+    print("\nConfusion Matrix:\n", confusion_matrix(yte, y_pred))
+    print("\nClassification Report:\n", classification_report(yte, y_pred, target_names=iris.target_names))
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program11.py

@@ -0,0 +1,25 @@
+def run():
+    import numpy as np
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.neighbors import KNeighborsClassifier
+    from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+    
+    iris = load_iris()
+    X, y = iris.data, iris.target
+    class_names = iris.target_names
+    
+    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=1)
+    
+    knn = KNeighborsClassifier(n_neighbors=3)
+    knn.fit(Xtr, ytr)
+    
+    y_pred = knn.predict(Xte)
+    
+    print("Accuracy: %.4f" % accuracy_score(yte, y_pred))
+    print("Predictions:", class_names[y_pred])
+    print("\nConfusion Matrix:\n", confusion_matrix(yte, y_pred))
+    print("\nClassification Report:\n", classification_report(yte, y_pred, target_names=class_names))
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program12.py

@@ -0,0 +1,22 @@
+def run():
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from sklearn.datasets import load_iris
+    from sklearn.cluster import KMeans
+    
+    iris = load_iris()
+    X = iris.data
+    
+    kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
+    labels = kmeans.fit_predict(X)
+    centroids = kmeans.cluster_centers_
+    
+    colors = ['r','g','b']
+    
+    for i in range(3): plt.scatter(X[labels==i,0], X[labels==i,1], c=colors[i], label=f'Cluster {i+1}')
+    plt.scatter(centroids[:,0], centroids[:,1], c='black', marker='x', s=100, label='Centroids')
+    plt.xlabel('Sepal Length'); plt.ylabel('Sepal Width'); plt.title('K-Means Clustering on Iris Dataset')
+    plt.legend(); plt.show()
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program2.py

@@ -0,0 +1,40 @@
+def run():
+    INF = 1000
+    
+    def minimax(depth, index, is_max, values, alpha, beta):
+        # Leaf node
+        if depth == 3:
+            return values[index]
+    
+        # MAX player's turn
+        if is_max:
+            best = -INF
+            for child in range(2):
+                value = minimax(depth + 1, index * 2 + child,
+                                False, values, alpha, beta)
+                best = max(best, value)
+                alpha = max(alpha, best)
+    
+                if beta <= alpha:   # pruning
+                    break
+            return best
+    
+        # MIN player's turn
+        else:
+            best = INF
+            for child in range(2):
+                value = minimax(depth + 1, index * 2 + child,
+                                True, values, alpha, beta)
+                best = min(best, value)
+                beta = min(beta, best)
+    
+                if beta <= alpha:   # pruning
+                    break
+            return best
+    
+    
+    values = [3, 5, 6, 9, 1, 2, 0, -1]
+    print("Optimal value:", minimax(0, 0, True, values, -INF, INF))
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program3.py

@@ -0,0 +1,108 @@
+def run():
+    import heapq
+    
+    # Possible moves: up, down, left, right
+    MOVES = [(-1,0), (1,0), (0,-1), (0,1)]
+    
+    
+    def print_state(state):
+        for row in state:
+            print(" ".join(map(str, row)))
+        print()
+    
+    
+    def heuristic(state, goal):
+        # Misplaced tiles heuristic (ignore blank = 0)
+        count = 0
+        for i in range(3):
+            for j in range(3):
+                if state[i][j] != 0:
+                    if state[i][j] != goal[i][j]:
+                        count += 1
+        return count
+    
+    
+    def find_blank(state):
+        for i in range(3):
+            for j in range(3):
+                if state[i][j] == 0:
+                    return i, j
+    
+    
+    def get_neighbors(state):
+        x, y = find_blank(state)
+        neighbors = []
+    
+        for dx, dy in MOVES:
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < 3 and 0 <= ny < 3:
+                new_state = [list(row) for row in state]
+                new_state[x][y], new_state[nx][ny] = new_state[nx][ny], new_state[x][y]
+                neighbors.append(tuple(tuple(row) for row in new_state))
+    
+        return neighbors
+    
+    
+    def a_star(start, goal):
+        start = tuple(tuple(row) for row in start)
+        goal = tuple(tuple(row) for row in goal)
+    
+        open_list = []
+        heapq.heappush(open_list, (heuristic(start, goal), 0, start))
+        closed = set()
+    
+        parent = {start: None}
+        g_score = {start: 0}  # Track g-scores separately
+    
+        while open_list:
+            f, g, current = heapq.heappop(open_list)
+    
+            if current == goal:
+                # Reconstruct path
+                path = []
+                while current:
+                    path.append(current)
+                    current = parent[current]
+                path.reverse()
+    
+                print("Solution path:\n")
+                for step in path:
+                    print_state(step)
+    
+                print("Total moves:", len(path) - 1)
+                return
+    
+            closed.add(current)
+    
+            for neighbor in get_neighbors(current):
+                if neighbor in closed:
+                    continue
+    
+                g_new = g + 1
+    
+                # If we found a better path to this neighbor
+                if neighbor not in g_score or g_new < g_score[neighbor]:
+                    parent[neighbor] = current
+                    g_score[neighbor] = g_new
+                    f_new = g_new + heuristic(neighbor, goal)
+                    heapq.heappush(open_list, (f_new, g_new, neighbor))
+    
+        print("No solution found")
+    
+    
+    initial_state = [
+        [1, 2, 3],
+        [8, 0, 4],
+        [7, 6, 5]
+    ]
+    
+    goal_state = [
+        [2, 8, 1],
+        [0, 4, 3],
+        [7, 6, 5]
+    ]
+    
+    a_star(initial_state, goal_state)
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program4.py

@@ -0,0 +1,43 @@
+def run():
+    def hill_climbing(func, start, step=0.01, max_iter=1000):
+        x = start
+    
+        for _ in range(max_iter):
+            f_x = func(x)
+            f_right = func(x + step)
+            f_left = func(x - step)
+    
+            if f_right > f_x and f_right >= f_left:
+                x += step
+            elif f_left > f_x:
+                x -= step
+            else:
+                break
+    
+        return x, func(x)
+    
+    
+    # ---- User input ----
+    while True:
+        try:
+            func_str = input("\nEnter a function of x: ")
+            func = lambda x: eval(func_str)
+            func(0)   # test
+            break
+        except:
+            print("Invalid function. Try again.")
+    
+    while True:
+        try:
+            start = float(input("\nEnter starting value: "))
+            break
+        except:
+            print("Enter a valid number.")
+    
+    maxima, max_value = hill_climbing(func, start)
+    
+    print("The maxima is at x =", maxima)
+    print("The maximum value obtained is", max_value)
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program5.py

@@ -0,0 +1,55 @@
+def run():
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.preprocessing import StandardScaler
+    
+    
+    # Sigmoid
+    def sigmoid(z):
+        return 1 / (1 + np.exp(-z))
+    
+    
+    # Logistic Regression
+    def train(X, y, lr=0.001, iters=200):
+        w = np.zeros(X.shape[1])
+        for _ in range(iters):
+            w -= lr * (X.T @ (sigmoid(X @ w) - y)) / len(y)
+        return w
+    
+    
+    # Load data
+    iris = load_iris()
+    X = iris.data[:, :2]    
+    y = (iris.target != 0).astype(int)
+    
+    # Split & scale
+    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.4, random_state=9)
+    sc = StandardScaler()
+    Xtr = sc.fit_transform(Xtr)
+    Xte = sc.transform(Xte)
+    
+    # Train
+    w = train(Xtr, ytr)
+    
+    # Accuracy
+    pred = sigmoid(Xte @ w) > 0.5
+    print("Accuracy:", np.mean(pred == yte))
+    
+    # Plot decision boundary
+    xx, yy = np.meshgrid(
+        np.arange(Xtr[:,0].min()-1, Xtr[:,0].max()+1, 0.1),
+        np.arange(Xtr[:,1].min()-1, Xtr[:,1].max()+1, 0.1)
+    )
+    
+    Z = sigmoid(np.c_[xx.ravel(), yy.ravel()] @ w) > 0.5
+    plt.contourf(xx, yy, Z.reshape(xx.shape), alpha=0.4)
+    plt.scatter(Xtr[:,0], Xtr[:,1], c=ytr)
+    plt.xlabel("Sepal length")
+    plt.ylabel("Sepal width")
+    plt.title("Logistic Regression")
+    plt.show()
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program6.py

@@ -0,0 +1,44 @@
+def run():
+    import numpy as np
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.metrics import confusion_matrix, classification_report
+    
+    iris = load_iris()
+    X, y = iris.data, iris.target
+    
+    class NaiveBayes:
+        def fit(self, X, y):
+            self.classes = np.unique(y)
+            self.mean = np.array([X[y == c].mean(0) for c in self.classes])
+            self.var = np.array([X[y == c].var(0) for c in self.classes])
+            self.priors = np.array([np.mean(y == c) for c in self.classes])
+    
+        def predict(self, X):
+            return np.array([self._predict(x) for x in X])
+    
+        def _predict(self, x):
+            probs = []
+            for i in range(len(self.classes)):
+                likelihood = -0.5 * np.sum(np.log(2 * np.pi * self.var[i]))
+                likelihood -= np.sum((x - self.mean[i]) ** 2 / (2 * self.var[i]))
+                probs.append(np.log(self.priors[i]) + likelihood)
+            return self.classes[np.argmax(probs)]
+    
+    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=1)
+    
+    nb = NaiveBayes()
+    nb.fit(Xtr, ytr)
+    
+    y_pred = nb.predict(Xte)
+    
+    print("Accuracy: %.4f" % np.mean(y_pred == yte))
+    print("Predictions:", iris.target_names[y_pred])
+    print("\nConfusion Matrix:")
+    print(confusion_matrix(yte, y_pred))
+    print("\nClassification Report:")
+    print(classification_report(yte, y_pred, target_names=iris.target_names))
+        
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program7.py

@@ -0,0 +1,32 @@
+def run():
+    import numpy as np
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.metrics import confusion_matrix, classification_report
+    from collections import Counter
+    
+    iris = load_iris()
+    X, y = iris.data, iris.target
+    class_names = iris.target_names
+    
+    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=1)
+    
+    def knn_predict(Xtr, ytr, Xte, k=3):
+        preds = []
+        for x in Xte:
+            dists = np.linalg.norm(Xtr - x, axis=1)
+            k_labels = ytr[np.argsort(dists)[:k]]
+            preds.append(Counter(k_labels).most_common(1)[0][0])
+        return np.array(preds)
+    
+    y_pred = knn_predict(Xtr, ytr, Xte, k=3)
+    
+    print("Accuracy: %.4f" % np.mean(y_pred == yte))
+    print("Predictions:", class_names[y_pred])
+    print("\nConfusion Matrix:")
+    print(confusion_matrix(yte, y_pred))
+    print("\nClassification Report:")
+    print(classification_report(yte, y_pred))
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program8.py

@@ -0,0 +1,36 @@
+def run():
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from sklearn.datasets import load_iris
+    
+    iris = load_iris()
+    X = iris.data
+    
+    def kmeans(X, k):
+        centroids = X[np.random.choice(X.shape[0], k, replace=False)]
+    
+        for _ in range(100):
+            distances = np.linalg.norm(X[:, None] - centroids, axis=2)
+            labels = np.argmin(distances, axis=1)
+            centroids = np.array([X[labels == i].mean(axis=0) for i in range(k)])
+    
+        return centroids, labels
+    
+    k = 3
+    centroids, labels = kmeans(X, k)
+    
+    colors = ['r', 'g', 'b']
+    
+    for i in range(k):
+        plt.scatter(X[labels == i, 0], X[labels == i, 1], c=colors[i], label=f'Cluster {i+1}')
+    
+    plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', c='black', label='Centroids')
+    
+    plt.title('K-Means Clustering on Iris Dataset')
+    plt.xlabel('Sepal Length')
+    plt.ylabel('Sepal Width')
+    plt.legend()
+    plt.show()
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk/program9.py

@@ -0,0 +1,41 @@
+def run():
+    import numpy as np
+    import matplotlib.pyplot as plt
+    
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.inspection import DecisionBoundaryDisplay
+    
+    
+    # Load data
+    iris = load_iris()
+    X = iris.data[:, :2]
+    y = (iris.target != 0).astype(int)
+    
+    # Split
+    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.4, random_state=9)
+    
+    # Scale
+    sc = StandardScaler()
+    Xtr = sc.fit_transform(Xtr)
+    Xte = sc.transform(Xte)
+    
+    # Train
+    lr = LogisticRegression()
+    lr.fit(Xtr, ytr)
+    
+    # Accuracy
+    print("Accuracy:", np.mean(lr.predict(Xte) == yte))
+    
+    # Plot decision boundary
+    DecisionBoundaryDisplay.from_estimator(lr, Xtr, response_method="predict", alpha=0.3)
+    plt.scatter(Xtr[:,0], Xtr[:,1], c=ytr, edgecolor="k")
+    plt.xlabel("Sepal Length (scaled)")
+    plt.ylabel("Sepal Width (scaled)")
+    plt.title("Logistic Regression Decision Boundary")
+    plt.show()
+
+if __name__ == '__main__':
+    run()

sklearnk-0.1.0/sklearnk.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: sklearnk
+Version: 0.1.0
+Summary: A collection of AI & ML lab programs
+Author-email: Antigravity <antigravity@example.com>
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+
+# sklearnk
+
+A collection of AI & ML lab programs extracted from the ScalarVerse project.
+
+## Installation
+
+```bash
+pip install .
+```
+
+### For Older Computers
+If `pip` is not working or if the computer is very old, you can use the traditional setup script:
+
+```bash
+python setup.py install
+```
+
+## Usage
+
+Each program is exposed as a function in the `sklearnk` package. You can run them sequentially:
+
+```python
+import sklearnk
+
+# Run Tic Tac Toe
+sklearnk.program1()
+
+# Run Alpha Beta Pruning
+sklearnk.program2()
+
+# Run 8 Puzzle (A* Algorithm)
+sklearnk.program3()
+
+# Run Hill Climbing
+sklearnk.program4()
+
+# Run Logistic Regression
+sklearnk.program5()
+
+# Run Naive Bayes
+sklearnk.program6()
+
+# Run K-Nearest Neighbors
+sklearnk.program7()
+
+# Run K-Means Clustering
+sklearnk.program8()
+
+# Run Logistic Regression (sklearn version)
+sklearnk.program9()
+
+# Run Naive Bayes (sklearn version)
+sklearnk.program10()
+
+# Run KNN (sklearn version)
+sklearnk.program11()
+
+# Run K-Means (sklearn version)
+sklearnk.program12()
+```
+
+## Programs Included
+
+1. **program1**: Tic Tac Toe (Minimax)
+2. **program2**: Alpha Beta Pruning
+3. **program3**: 8 Puzzle (A* Algorithm)
+4. **program4**: Hill Climbing
+5. **program5**: Logistic Regression (from scratch)
+6. **program6**: Naive Bayes (from scratch)
+7. **program7**: K-Nearest Neighbors (from scratch)
+8. **program8**: K-Means Clustering (from scratch)
+9. **program9**: Logistic Regression (using sklearn)
+10. **program10**: Naive Bayes (using sklearn)
+11. **program11**: KNN (using sklearn)
+12. **program12**: K-Means (using sklearn)

sklearnk-0.1.0/sklearnk.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+sklearnk/__init__.py
+sklearnk/program1.py
+sklearnk/program10.py
+sklearnk/program11.py
+sklearnk/program12.py
+sklearnk/program2.py
+sklearnk/program3.py
+sklearnk/program4.py
+sklearnk/program5.py
+sklearnk/program6.py
+sklearnk/program7.py
+sklearnk/program8.py
+sklearnk/program9.py
+sklearnk.egg-info/PKG-INFO
+sklearnk.egg-info/SOURCES.txt
+sklearnk.egg-info/dependency_links.txt
+sklearnk.egg-info/requires.txt
+sklearnk.egg-info/top_level.txt

sklearnk-0.1.0/sklearnk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sklearnk-0.1.0/sklearnk.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+matplotlib
+scikit-learn

sklearnk-0.1.0/sklearnk.egg-info/top_level.txt

@@ -0,0 +1 @@
+sklearnk