mymllibrary 0.1.0__tar.gz

mymllibrary-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: mymllibrary
+Version: 0.1.0
+Summary: A beginner-friendly Python machine learning library implemented from scratch.
+Author: Ayush Kumar Gour
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+
+# MyMLLibrary
+
+A simple Python Machine Learning library containing machine learning algorithms implemented from scratch for learning and educational purposes.
+
+## Features
+
+- Machine Learning algorithms implemented from scratch
+- Simple and beginner-friendly implementations
+- No automatic dataset loading
+- No automatic model training or prediction
+- Source code of each algorithm can be displayed directly
+- Designed for learning how ML algorithms work internally
+
+## Algorithms
+
+Currently available:
+
+1. Perceptron Learning Algorithm (PLA)=
+2. Linear Regression
+3. Logistic Regression
+4. K-Nearest Neighbors (KNN)
+5. Naive Bayes
+6. K-Means Clustering
+7. DBSCAN
+8. Single Layer Perceptron (SLP)
+9. Performance matrix
+10. Multilayer Perceptron (MLP)
+
+### Supporting Modules
+
+- Performance Metrics
+- Code Viewer
+
+> More algorithms will be added in future versions.
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/AYUSHKUMAR0401/MyMLLibrary.git

mymllibrary-0.1.0/README.md

@@ -0,0 +1,41 @@
+# MyMLLibrary
+
+A simple Python Machine Learning library containing machine learning algorithms implemented from scratch for learning and educational purposes.
+
+## Features
+
+- Machine Learning algorithms implemented from scratch
+- Simple and beginner-friendly implementations
+- No automatic dataset loading
+- No automatic model training or prediction
+- Source code of each algorithm can be displayed directly
+- Designed for learning how ML algorithms work internally
+
+## Algorithms
+
+Currently available:
+
+1. Perceptron Learning Algorithm (PLA)=
+2. Linear Regression
+3. Logistic Regression
+4. K-Nearest Neighbors (KNN)
+5. Naive Bayes
+6. K-Means Clustering
+7. DBSCAN
+8. Single Layer Perceptron (SLP)
+9. Performance matrix
+10. Multilayer Perceptron (MLP)
+
+### Supporting Modules
+
+- Performance Metrics
+- Code Viewer
+
+> More algorithms will be added in future versions.
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/AYUSHKUMAR0401/MyMLLibrary.git

mymllibrary-0.1.0/myml/Dbscan_clustering.py

@@ -0,0 +1,213 @@
+import math
+import matplotlib.pyplot as plt
+
+
+# --------------------------------------------------
+# Function 1: Calculate Euclidean Distance
+# --------------------------------------------------
+
+def distance(p1, p2):
+
+    x1, y1 = p1
+    x2, y2 = p2
+
+    return math.sqrt(
+        (x1 - x2) ** 2 +
+        (y1 - y2) ** 2
+    )
+
+
+# --------------------------------------------------
+# Function 2: Find Neighbors of a Point
+# --------------------------------------------------
+
+def get_neighbors(points, point, eps):
+
+    neighbors = []
+
+    for p in points:
+
+        if p != point:
+
+            if distance(
+                points[point],
+                points[p]
+            ) <= eps:
+
+                neighbors.append(p)
+
+    return neighbors
+
+
+# --------------------------------------------------
+# Function 3: DBSCAN Algorithm
+# --------------------------------------------------
+
+def dbscan(points, eps, minPts):
+
+    visited = set()
+
+    clusters = []
+
+    noise = []
+
+    for point in points:
+
+        if point in visited:
+            continue
+
+        visited.add(point)
+
+        neighbors = get_neighbors(
+            points,
+            point,
+            eps
+        )
+
+        # Include the point itself
+        # when checking MinPts
+        if len(neighbors) + 1 < minPts:
+
+            noise.append(point)
+
+            continue
+
+        # Start a new cluster
+        cluster = [point]
+
+        # Expand cluster
+        i = 0
+
+        while i < len(neighbors):
+
+            current = neighbors[i]
+
+            if current not in visited:
+
+                visited.add(current)
+
+                current_neighbors = get_neighbors(
+                    points,
+                    current,
+                    eps
+                )
+
+                if len(current_neighbors) + 1 >= minPts:
+
+                    for n in current_neighbors:
+
+                        if n not in neighbors:
+                            neighbors.append(n)
+
+            # Add point to cluster
+            if current not in cluster:
+
+                cluster.append(current)
+
+            i += 1
+
+        clusters.append(cluster)
+
+    return clusters, noise
+
+
+# --------------------------------------------------
+# Function 4: Plot DBSCAN Clusters
+# --------------------------------------------------
+
+def plot_dbscan(points, clusters, noise):
+
+    # Plot clusters
+    for i, cluster in enumerate(clusters):
+
+        x = [
+            points[p][0]
+            for p in cluster
+        ]
+
+        y = [
+            points[p][1]
+            for p in cluster
+        ]
+
+        plt.scatter(
+            x,
+            y,
+            label="Cluster " + str(i + 1)
+        )
+
+    # Plot noise / outliers
+    if len(noise) > 0:
+
+        x = [
+            points[p][0]
+            for p in noise
+        ]
+
+        y = [
+            points[p][1]
+            for p in noise
+        ]
+
+        plt.scatter(
+            x,
+            y,
+            label="Noise / Outlier"
+        )
+
+    # Display point names
+    for p, (x, y) in points.items():
+
+        plt.text(
+            x + 0.3,
+            y + 0.3,
+            p
+        )
+
+    plt.xlabel("X")
+    plt.ylabel("Y")
+
+    plt.title("DBSCAN Clustering")
+
+    plt.legend()
+
+    plt.grid(True)
+
+    plt.show()
+
+
+# --------------------------------------------------
+# Function 5: Display DBSCAN Results
+# --------------------------------------------------
+
+def display_clusters(clusters, noise):
+
+    print("Clusters:")
+
+    for i in range(len(clusters)):
+
+        print(
+            "Cluster",
+            i + 1,
+            ":",
+            clusters[i]
+        )
+
+    print(
+        "Noise / Outliers:",
+        noise
+    )
+
+
+# --------------------------------------------------
+# Function 6: Display DBSCAN Source Code
+# --------------------------------------------------
+
+def show_dbscan_code():
+
+    import sys
+    from .code_viewer import show_code7
+
+    module = sys.modules[__name__]
+
+    show_code7(module)

mymllibrary-0.1.0/myml/K_mean_clustering.py

@@ -0,0 +1,187 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+# --------------------------------------------------
+# Function 1: Calculate Euclidean Distance
+# --------------------------------------------------
+
+def distance(point, centroid):
+
+    return np.sqrt(
+        np.sum((point - centroid) ** 2)
+    )
+
+
+# --------------------------------------------------
+# Function 2: Assign each point to nearest centroid
+# --------------------------------------------------
+
+def assign_clusters(data, centroids):
+
+    clusters = []
+
+    for point in data:
+
+        distances = []
+
+        for centroid in centroids:
+
+            distances.append(
+                distance(point, centroid)
+            )
+
+        # Get index of minimum distance
+        cluster = np.argmin(distances)
+
+        clusters.append(cluster)
+
+    return np.array(clusters, dtype=int)
+
+
+# --------------------------------------------------
+# Function 3: Calculate new centroids
+# --------------------------------------------------
+
+def calculate_centroids(data, clusters, k):
+
+    new_centroids = []
+
+    for i in range(k):
+
+        cluster_points = data[clusters == i]
+
+        centroid = np.mean(
+            cluster_points,
+            axis=0
+        )
+
+        new_centroids.append(centroid)
+
+    return np.array(new_centroids)
+
+
+# --------------------------------------------------
+# Function 4: K-Means Algorithm
+# --------------------------------------------------
+
+def kmeans(data, k):
+
+    # Initial centroids = first k points
+    centroids = data[:k].copy()
+
+    while True:
+
+        # Assign clusters
+        clusters = assign_clusters(
+            data,
+            centroids
+        )
+
+        # Calculate new centroids
+        new_centroids = calculate_centroids(
+            data,
+            clusters,
+            k
+        )
+
+        # Check convergence
+        if np.allclose(
+            centroids,
+            new_centroids
+        ):
+            break
+
+        centroids = new_centroids
+
+    return clusters, centroids
+
+
+# --------------------------------------------------
+# Function 5: Display Final Clusters
+# --------------------------------------------------
+
+def display_clusters(
+    names,
+    data,
+    clusters,
+    centroids
+):
+
+    print("\n----- FINAL CLUSTERS -----")
+
+    for i in range(len(centroids)):
+
+        print("\nCluster", i + 1)
+
+        for j in range(len(data)):
+
+            if clusters[j] == i:
+
+                print(
+                    names[j],
+                    "->",
+                    data[j]
+                )
+
+        print(
+            "Centroid =",
+            centroids[i]
+        )
+
+
+# --------------------------------------------------
+# Function 6: Plot Graph
+# --------------------------------------------------
+
+def plot_graph(
+    data,
+    clusters,
+    centroids,
+    names
+):
+
+    for i in range(len(centroids)):
+
+        points = data[clusters == i]
+
+        plt.scatter(
+            points[:, 0],
+            points[:, 1],
+            label="Cluster " + str(i + 1)
+        )
+
+    # Display point names
+    for i in range(len(data)):
+
+        plt.annotate(
+            names[i],
+            (data[i][0], data[i][1])
+        )
+
+    # Display centroids
+    plt.scatter(
+        centroids[:, 0],
+        centroids[:, 1],
+        marker="X",
+        s=200,
+        label="Centroids"
+    )
+
+    plt.xlabel("X")
+    plt.ylabel("Y")
+    plt.title("K-Means Clustering")
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+
+# --------------------------------------------------
+# Function 7: Display K-Means Source Code
+# --------------------------------------------------
+
+def show_kmeans_code():
+    import sys
+    from .code_viewer import show_code6
+    module = sys.modules[__name__]
+    show_code6(module)

mymllibrary-0.1.0/myml/Knn.py

@@ -0,0 +1,67 @@
+import math
+from collections import Counter
+
+def calculate_distance(x1, y1, x2, y2):
+    distance = math.sqrt(
+        (x1 - x2) ** 2 +
+        (y1 - y2) ** 2
+    )
+    return distance
+
+
+# --------------------------------------------------
+# Function 2: Calculate distances from test point
+# --------------------------------------------------
+
+def calculate_distances(data, test_x, test_y):
+
+    distances = []
+
+    for index, row in data.iterrows():
+
+        distance = calculate_distance(
+            test_x,
+            test_y,
+            row["X"],
+            row["Y"]
+        )
+
+        distances.append(
+            (row["ID"], distance, row["Label"])
+        )
+
+    return distances
+
+
+# --------------------------------------------------
+# Function 3: KNN Classification
+# --------------------------------------------------
+
+def knn_classification(data, test_x, test_y, k):
+
+    distances = calculate_distances(
+        data,
+        test_x,
+        test_y
+    )
+
+    # Sort according to distance
+    distances.sort(key=lambda x: x[1])
+
+    # Select k nearest neighbours
+    nearest = distances[:k]
+
+    # Get labels
+    labels = [item[2] for item in nearest]
+
+    count = Counter(labels)
+    prediction = count.most_common(1)[0][0]
+    return prediction
+def show_knn_code():
+
+    import sys
+    from .code_viewer import show_code4
+
+    module = sys.modules[__name__]
+
+    show_code4(module)

mymllibrary-0.1.0/myml/Linear_regression.py

@@ -0,0 +1,48 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from .code_viewer import show_code2
+
+
+def linear_regression(X, Y):
+    x_mean = np.mean(X)
+    y_mean = np.mean(Y)
+
+    numerator = np.sum((X - x_mean) * (Y - y_mean))
+    denominator = np.sum((X - x_mean) ** 2)
+
+    slope = numerator / denominator
+    intercept = y_mean - slope * x_mean
+
+    Y_pred = intercept + slope * X
+
+    return intercept, slope, Y_pred
+
+
+def error_metrics(Y, Y_pred):
+    MSE = np.mean((Y - Y_pred) ** 2)
+    RMSE = np.sqrt(MSE)
+    MAE = np.mean(np.abs(Y - Y_pred))
+
+    SS_res = np.sum((Y - Y_pred) ** 2)
+    SS_tot = np.sum((Y - np.mean(Y)) ** 2)
+
+    R2 = 1 - (SS_res / SS_tot)
+
+    return MSE, RMSE, MAE, R2
+
+
+def plot_regression(X, Y, Y_pred):
+    plt.scatter(X, Y, label="Actual Data")
+    plt.plot(X, Y_pred, label="Regression Line")
+
+    plt.xlabel("Class_Test_Marks")
+    plt.ylabel("Semester_Marks")
+    plt.title("Linear Regression")
+
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+
+def show_linear_regression_code():
+    show_code2(__import__(__name__, fromlist=["*"]))

mymllibrary-0.1.0/myml/Logistic_regression.py

@@ -0,0 +1,71 @@
+import numpy as np
+from .code_viewer import show_code3
+
+def sigmoid(z):
+    return 1 / (1 + np.exp(-z))
+
+
+def hypothesis(X, w, b):
+    z = w * X + b
+    return sigmoid(z)
+
+
+def cost_function(X, y, w, b):
+    m = len(X)
+
+    h = hypothesis(X, w, b)
+
+    h = np.clip(h, 1e-10, 1 - 1e-10)
+
+    cost = (-1 / m) * np.sum(
+        y * np.log(h) + (1 - y) * np.log(1 - h)
+    )
+
+    return cost
+
+
+def gradient_descent(X, y, w, b, learning_rate, iterations):
+    m = len(X)
+
+    for i in range(iterations):
+
+        h = hypothesis(X, w, b)
+
+        dw = (1 / m) * np.dot(X.T, (h - y))
+
+        db = (1 / m) * np.sum(h - y)
+
+        w -= learning_rate * dw
+        b -= learning_rate * db
+
+    return w, b
+
+
+def logistic_regression(
+    X,
+    y,
+    learning_rate=0.0001,
+    iterations=100000
+):
+
+    w = 0.0
+    b = 0.0
+
+    w, b = gradient_descent(
+        X,
+        y,
+        w,
+        b,
+        learning_rate,
+        iterations
+    )
+
+    return w, b
+
+def show_logistic_regression_code():
+    import sys
+    from .code_viewer import show_code2
+
+    module = sys.modules[__name__]
+
+    show_code3(module)