mlhitk 0.1.0__tar.gz

mlhitk-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: mlhitk
+Version: 0.1.0
+Summary: A library for printing ML code snippets
+Home-page: https://github.com/ayush/mlhitk
+Author: Ayush
+Author-email: ayush@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary

mlhitk-0.1.0/mlhitk/__init__.py

@@ -0,0 +1,333 @@
+
+def show_pla():
+    print(r"""import numpy as np
+import pandas as pd
+
+df = pd.read_csv('demo.csv')
+X = df.iloc[:, :-1].values
+y = df.iloc[:, -1].values
+
+w = np.zeros(X.shape[1])
+b = 0
+lr = 1
+
+while True:
+    errors = 0
+    for i in range(len(X)):
+        if y[i] * (np.dot(X[i], w) + b) <= 0:
+            w += lr * y[i] * X[i]
+            b += lr * y[i]
+            errors += 1
+    if errors == 0:
+        break
+
+print(f"Final weights: {w}, bias: {b}")
+""")
+
+def show_lr():
+    print(r"""import numpy as np
+import pandas as pd
+
+df = pd.read_csv('demo.csv')
+# Assuming format from image: Sl No, Marks in Class test, Marks in Semester
+X = df.iloc[:, 1].values  
+Y = df.iloc[:, 2].values  
+
+n = len(X)
+m = (n * np.sum(X*Y) - np.sum(X)*np.sum(Y)) / (n * np.sum(X**2) - np.sum(X)**2)
+c = (np.sum(Y) - m * np.sum(X)) / n
+
+pred_20 = m * 20 + c
+print(f"Estimated marks for 20 in class test: {pred_20}")
+
+Y_pred = m * X + c
+mae = np.mean(np.abs(Y - Y_pred))
+mse = np.mean((Y - Y_pred)**2)
+rmse = np.sqrt(mse)
+ss_tot = np.sum((Y - np.mean(Y))**2)
+ss_res = np.sum((Y - Y_pred)**2)
+r2 = 1 - (ss_res / ss_tot)
+
+print(f"MAE: {mae}, MSE: {mse}, RMSE: {rmse}, R2: {r2}")
+""")
+
+def show_logr():
+    print(r"""import numpy as np
+import pandas as pd
+
+df = pd.read_csv('demo.csv')
+X = df.iloc[:, 1].values
+y = df.iloc[:, 2].values
+y = np.where(y == np.min(y), 0, 1)
+
+mean_X = np.mean(X)
+std_X = np.std(X)
+X = (X - mean_X) / std_X
+
+def sigmoid(z):
+    return 1 / (1 + np.exp(-z))
+
+def cost_function(X, y, w, b):
+    m = len(y)
+    h = sigmoid(X * w + b)
+    return -1/m * np.sum(y * np.log(h + 1e-15) + (1-y) * np.log(1-h + 1e-15))
+
+w, b = 0.0, 0.0
+lr, epochs = 0.1, 10000
+
+for _ in range(epochs):
+    h = sigmoid(X * w + b)
+    w -= lr * np.mean((h - y) * X)
+    b -= lr * np.mean(h - y)
+
+x_test = (20 - mean_X) / std_X
+prob = sigmoid(w * x_test + b)
+print(f"Weights: w={w}, b={b}")
+print(f"Probability of passing for 20 marks: {prob}")
+print("Pass" if prob >= 0.5 else "Fail")
+""")
+
+def show_knn():
+    print(r"""import numpy as np
+import pandas as pd
+
+df = pd.read_csv('demo.csv')
+# Assuming features and then label as last column
+X = df.iloc[:, 1:-1].values
+y = df.iloc[:, -1].values
+
+def knn(X_train, y_train, x_query, k=3):
+    distances = np.sqrt(np.sum((X_train - x_query)**2, axis=1))
+    nearest_idx = np.argsort(distances)[:k]
+    nearest_labels = y_train[nearest_idx]
+    values, counts = np.unique(nearest_labels, return_counts=True)
+    return values[np.argmax(counts)]
+
+print("KNN Predictions on the training set (k=3):")
+for i, x_q in enumerate(X):
+    print(f"Sample {i} Prediction:", knn(X, y, x_q, k=3))
+""")
+
+def show_nbc():
+    print(r"""import pandas as pd
+import numpy as np
+
+df = pd.read_csv('demo.csv')
+X = df.iloc[:, 1:-1].values
+y = df.iloc[:, -1].values
+
+class NaiveBayes:
+    def fit(self, X, y):
+        self.classes = np.unique(y)
+        self.mean = np.zeros((len(self.classes), X.shape[1]))
+        self.var = np.zeros((len(self.classes), X.shape[1]))
+        self.priors = np.zeros(len(self.classes))
+        for idx, c in enumerate(self.classes):
+            X_c = X[y == c]
+            self.mean[idx, :] = X_c.mean(axis=0)
+            self.var[idx, :] = X_c.var(axis=0) + 1e-6
+            self.priors[idx] = X_c.shape[0] / float(X.shape[0])
+            
+    def predict(self, X):
+        return np.array([self._predict(x) for x in X])
+        
+    def _predict(self, x):
+        posteriors = []
+        for idx, c in enumerate(self.classes):
+            prior = np.log(self.priors[idx])
+            num = np.exp(-((x - self.mean[idx])**2) / (2 * self.var[idx]))
+            den = np.sqrt(2 * np.pi * self.var[idx])
+            posterior = np.sum(np.log(num / den))
+            posteriors.append(prior + posterior)
+        return self.classes[np.argmax(posteriors)]
+
+nb = NaiveBayes()
+nb.fit(X, y)
+print("Naive Bayes predictions:", nb.predict(X))
+""")
+
+def show_dbscan():
+    print(r"""import numpy as np
+import pandas as pd
+
+df = pd.read_csv('demo.csv')
+X = df.iloc[:, 1:3].values
+epsilon = 2
+min_pts = 2
+
+labels = np.full(X.shape[0], -1)
+cluster_id = 0
+
+def region_query(p_idx):
+    return np.where(np.linalg.norm(X - X[p_idx], axis=1) <= epsilon)[0]
+
+for p in range(X.shape[0]):
+    if labels[p] != -1:
+        continue
+    neighbors = region_query(p)
+    if len(neighbors) < min_pts:
+        labels[p] = -1 # Noise
+    else:
+        labels[p] = cluster_id
+        i = 0
+        while i < len(neighbors):
+            pn = neighbors[i]
+            if labels[pn] == -1:
+                labels[pn] = cluster_id
+            elif labels[pn] < 0:
+                labels[pn] = cluster_id
+                pn_neighbors = region_query(pn)
+                if len(pn_neighbors) >= min_pts:
+                    neighbors = np.append(neighbors, pn_neighbors)
+            i += 1
+        cluster_id += 1
+
+print("DBSCAN Labels (-1 is noise):", labels)
+""")
+
+def show_kmeans():
+    print(r"""import numpy as np
+import pandas as pd
+
+df = pd.read_csv('demo.csv')
+X = df.iloc[:, 1:3].values
+K = 3
+
+np.random.seed(42)
+centroids = X[np.random.choice(X.shape[0], K, replace=False)]
+
+while True:
+    distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
+    labels = np.argmin(distances, axis=1)
+    new_centroids = np.array([X[labels == k].mean(axis=0) if np.any(labels == k) else centroids[k] for k in range(K)])
+    if np.all(centroids == new_centroids):
+        break
+    centroids = new_centroids
+
+print("Final centroids:\n", centroids)
+print("Labels:", labels)
+""")
+
+def show_pm():
+    print(r"""import numpy as np
+
+y_actual = np.array([0]*900 + [1]*100)
+np.random.shuffle(y_actual)
+
+y_pred = np.array([0]*900 + [1]*100)
+np.random.shuffle(y_pred)
+
+TP = np.sum((y_actual == 1) & (y_pred == 1))
+TN = np.sum((y_actual == 0) & (y_pred == 0))
+FP = np.sum((y_actual == 0) & (y_pred == 1))
+FN = np.sum((y_actual == 1) & (y_pred == 0))
+
+print(f"Confusion Matrix:\n[[{TN}, {FP}]\n [{FN}, {TP}]]")
+
+print("Decision: Precision is used when FP is costly, Recall is used when FN is costly.")
+
+priority = np.random.choice(['FP', 'FN'])
+beta = 0.5 if priority == 'FP' else 2
+print(f"Randomly assigned priority to: {priority} => Beta = {beta}")
+
+precision = TP / (TP + FP) if (TP + FP) else 0
+recall = TP / (TP + FN) if (TP + FN) else 0
+
+f_beta = (1 + beta**2) * (precision * recall) / ((beta**2 * precision) + recall) if (precision + recall) else 0
+print(f"Precision: {precision:.4f}, Recall: {recall:.4f}")
+print(f"F-beta Score: {f_beta:.4f}")
+""")
+
+def show_slp():
+    print(r"""import numpy as np
+
+def train_slp():
+    # Logical AND gate
+    X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
+    y = np.array([0, 0, 0, 1])
+    
+    w = np.zeros(2)
+    b = 0
+    lr = 0.1
+    
+    while True:
+        errors = 0
+        for i in range(4):
+            y_pred = 1 if (np.dot(X[i], w) + b) >= 0 else 0
+            if y[i] != y_pred:
+                w += lr * (y[i] - y_pred) * X[i]
+                b += lr * (y[i] - y_pred)
+                errors += 1
+        if errors == 0:
+            break
+    return w, b
+
+w, b = train_slp()
+print(f"Trained SLP for AND gate. Weights: {w}, Bias: {b}")
+
+print("Testing the trained perceptron:")
+for x in [[0,0], [0,1], [1,0], [1,1]]:
+    pred = 1 if (np.dot(x, w) + b) >= 0 else 0
+    print(f"Input {x} -> Prediction {pred}")
+""")
+
+def show_mlp():
+    print(r"""import numpy as np
+import pandas as pd
+
+df = pd.read_csv('demo.csv')
+X = df.iloc[:, :-1].values
+y = df.iloc[:, -1].values
+
+labels, y_int = np.unique(y, return_inverse=True)
+y_onehot = np.zeros((y_int.size, y_int.max() + 1))
+y_onehot[np.arange(y_int.size), y_int] = 1
+
+X = (X - X.mean(axis=0)) / X.std(axis=0)
+
+def sigmoid(z): return 1 / (1 + np.exp(-z))
+def sigmoid_deriv(z): return z * (1 - z)
+
+np.random.seed(42)
+input_dim = X.shape[1]
+hidden_dim = 5
+output_dim = y_onehot.shape[1]
+
+W1 = np.random.randn(input_dim, hidden_dim)
+b1 = np.zeros((1, hidden_dim))
+W2 = np.random.randn(hidden_dim, output_dim)
+b2 = np.zeros((1, output_dim))
+
+lr = 0.1
+epochs = 100
+
+for epoch in range(1, epochs + 1):
+    # Forward
+    z1 = np.dot(X, W1) + b1
+    a1 = sigmoid(z1)
+    z2 = np.dot(a1, W2) + b2
+    a2 = sigmoid(z2)
+    
+    loss = np.mean((y_onehot - a2)**2)
+    
+    # Backprop
+    d2 = (a2 - y_onehot) * sigmoid_deriv(a2)
+    dW2 = np.dot(a1.T, d2)
+    db2 = np.sum(d2, axis=0, keepdims=True)
+    
+    d1 = np.dot(d2, W2.T) * sigmoid_deriv(a1)
+    dW1 = np.dot(X.T, d1)
+    db1 = np.sum(d1, axis=0, keepdims=True)
+    
+    W1 -= lr * dW1 / X.shape[0]
+    b1 -= lr * db1 / X.shape[0]
+    W2 -= lr * dW2 / X.shape[0]
+    b2 -= lr * db2 / X.shape[0]
+    
+    if epoch % 10 == 0 or epoch == 1:
+        print(f"Epoch {epoch}, Loss: {loss:.4f}")
+
+predictions = np.argmax(a2, axis=1)
+accuracy = np.mean(predictions == y_int)
+print(f"\nFinal Accuracy: {accuracy * 100:.2f}%")
+""")

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

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: mlhitk
+Version: 0.1.0
+Summary: A library for printing ML code snippets
+Home-page: https://github.com/ayush/mlhitk
+Author: Ayush
+Author-email: ayush@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary

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

@@ -0,0 +1,6 @@
+setup.py
+mlhitk/__init__.py
+mlhitk.egg-info/PKG-INFO
+mlhitk.egg-info/SOURCES.txt
+mlhitk.egg-info/dependency_links.txt
+mlhitk.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+mlhitk

mlhitk-0.1.0/setup.cfg

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

mlhitk-0.1.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='mlhitk',
+    version='0.1.0',
+    packages=find_packages(),
+    description='A library for printing ML code snippets',
+    author='Ayush',
+    author_email='ayush@example.com',
+    url='https://github.com/ayush/mlhitk',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.6',
+)
+