ml2000 0.1.0__py3-none-any.whl

ml2000-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: ml2000
+Version: 0.1.0
+Summary: A CLI tool to generate machine learning experiment templates and datasets.
+Author-email: Your Name <your.email@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# ML Labs Generator
+
+This tool generates boilerplate code and datasets for standard Machine Learning experiments.
+
+## Installation
+
+```bash
+pipx install .
+```
+
+## Usage
+
+```bash
+# Generate the experiments and datasets
+ml-labs generate
+
+# Print the required packages
+ml-labs requirements
+```

ml2000-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+ml_labs/__init__.py,sha256=ZuMLGqQP5_DraPm_p4DUb-QSj_PFNP4YsRmKzSy-GNg,40
+ml_labs/cli.py,sha256=c-_oLZT7gJOo_QTiO6XAhCbrGBJePJICT-5GhV02Hrw,950
+ml_labs/generator.py,sha256=MyY_vrfCFIMSIo4xYLyLbi3bEb5AQ40yKqV7b09IzUQ,14125
+ml2000-0.1.0.dist-info/METADATA,sha256=w60Yzh89zI6dBl966O6c5eJzeXdh7jOT28Pq50Y7i4Y,662
+ml2000-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ml2000-0.1.0.dist-info/entry_points.txt,sha256=RheDcquRaEb6t9RZBNVb8OZb8okfE78lZEofN5nESMo,44
+ml2000-0.1.0.dist-info/top_level.txt,sha256=B1f-D4jn3FwXutJKX3R7MLLfY3VQ9tO8fjm87AjyXMQ,8
+ml2000-0.1.0.dist-info/RECORD,,

ml2000-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ml2000-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ml2000 = ml_labs.cli:main

ml2000-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ml_labs

ml_labs/__init__.py

@@ -0,0 +1,2 @@
+# ml_labs package
+__version__ = "0.1.0"

ml_labs/cli.py

@@ -0,0 +1,27 @@
+import argparse
+import sys
+from .generator import generate_experiments, print_requirements, interactive_menu
+
+def main():
+    parser = argparse.ArgumentParser(description="ML Labs Experiments Generator")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # generate command
+    gen_parser = subparsers.add_parser("generate", help="Generate all experiment scripts and datasets")
+    gen_parser.add_argument("--output-dir", default="ML_Experiments", help="Output directory name")
+
+    # requirements command
+    req_parser = subparsers.add_parser("requirements", help="Print required packages")
+
+    args = parser.parse_args()
+
+    if args.command == "generate":
+        generate_experiments(args.output_dir)
+    elif args.command == "requirements":
+        print_requirements()
+    else:
+        # If no arguments provided, run the interactive menu
+        interactive_menu()
+
+if __name__ == "__main__":
+    main()

ml_labs/generator.py

@@ -0,0 +1,420 @@
+import os
+import csv
+import random
+import math
+from pathlib import Path
+
+def print_requirements():
+    reqs = """numpy
+pandas
+matplotlib
+seaborn
+scikit-learn
+scipy
+"""
+    print(reqs)
+
+def generate_datasets(data_dir: Path):
+    data_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Classification Data (e.g. for Decision Tree, Random Forest, SVM, LR, KNN, NB)
+    # 2 features, 1 target (0 or 1)
+    with open(data_dir / "classification.csv", "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["feature1", "feature2", "target"])
+        for _ in range(200):
+            cls = random.choice([0, 1])
+            f1 = random.gauss(cls * 2, 1)
+            f2 = random.gauss(cls * 2, 1)
+            writer.writerow([f1, f2, cls])
+
+    # Regression Data (e.g. for Linear, Multiple, Polynomial Regression)
+    with open(data_dir / "regression.csv", "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["x1", "x2", "y"])
+        for _ in range(150):
+            x1 = random.uniform(-10, 10)
+            x2 = random.uniform(-10, 10)
+            y = 3.5 * x1 - 2.0 * x2 + 10 + random.gauss(0, 2)
+            writer.writerow([x1, x2, y])
+
+    # Clustering Data (e.g. for K-Means, Agglomerative)
+    with open(data_dir / "clustering.csv", "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["f1", "f2"])
+        for _ in range(300):
+            cluster = random.choice([(0,0), (5,5), (-5,5)])
+            f1 = random.gauss(cluster[0], 1)
+            f2 = random.gauss(cluster[1], 1)
+            writer.writerow([f1, f2])
+
+    # Recommendation Data (Collaborative Filtering) - Users, Items, Ratings
+    with open(data_dir / "ratings.csv", "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["user_id", "item_id", "rating"])
+        for u in range(1, 21): # 20 users
+            for i in range(1, 11): # 10 items
+                if random.random() > 0.3: # sparse matrix
+                    writer.writerow([u, i, random.randint(1, 5)])
+
+EXPERIMENTS = {
+    "expt_01_intro.py": '''"""
+Expt 01: Introduction to Python for Machine Learning
+Setting up Python environment, Basic Python syntax, data types, variables.
+Introduction to NumPy.
+"""
+import numpy as np
+
+# Python basics
+x = 10
+y = "Hello ML"
+print(f"Variables: x={x}, y='{y}'")
+
+# NumPy basics
+arr = np.array([1, 2, 3, 4, 5])
+print("NumPy Array:", arr)
+print("Mean:", np.mean(arr))
+print("Dot product:", np.dot(arr, arr))
+''',
+    
+    "expt_02_data.py": '''"""
+Expt 02: Data Manipulation & Visualization
+Pandas library for data manipulation, loading datasets, Data cleaning,
+Indexing, slicing, Data Visualization with Matplotlib and Seaborn.
+"""
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Load classification dataset
+df = pd.read_csv("datasets/classification.csv")
+
+# Data manipulation
+print(df.head())
+print(df.describe())
+filtered_df = df[df['feature1'] > 0]
+print(f"Filtered rows: {len(filtered_df)}")
+
+# Visualization
+sns.scatterplot(data=df, x='feature1', y='feature2', hue='target')
+plt.title("Classification Data Visualization")
+plt.savefig("expt_02_plot.png")
+print("Saved plot to expt_02_plot.png")
+''',
+
+    "expt_03_decision_tree.py": '''"""
+Expt 03: Decision Tree
+Implement and evaluate ID3 / C4.5 algorithm on given dataset.
+Using sklearn's DecisionTreeClassifier (uses optimized CART).
+"""
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier, plot_tree
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+
+df = pd.read_csv("datasets/classification.csv")
+X = df[['feature1', 'feature2']]
+y = df['target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Create and train Decision Tree (entropy for ID3/C4.5-like behavior)
+clf = DecisionTreeClassifier(criterion='entropy', max_depth=3, random_state=42)
+clf.fit(X_train, y_train)
+
+# Evaluate
+y_pred = clf.predict(X_test)
+print(f"Decision Tree Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+
+# Plot tree
+plt.figure(figsize=(10,6))
+plot_tree(clf, feature_names=['feature1', 'feature2'], class_names=['0', '1'], filled=True)
+plt.savefig("expt_03_tree.png")
+print("Decision tree visualized in expt_03_tree.png")
+''',
+
+    "expt_04_regression.py": '''"""
+Expt 04: Regression
+Implement and evaluate Linear, Multiple and Polynomial regression algorithms.
+"""
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.metrics import mean_squared_error, r2_score
+
+df = pd.read_csv("datasets/regression.csv")
+X = df[['x1', 'x2']]
+y = df['y']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Multiple Linear Regression
+model_mlr = LinearRegression()
+model_mlr.fit(X_train, y_train)
+y_pred_mlr = model_mlr.predict(X_test)
+print(f"Multiple Linear Regression MSE: {mean_squared_error(y_test, y_pred_mlr):.4f}")
+
+# Polynomial Regression (degree 2)
+poly = PolynomialFeatures(degree=2)
+X_train_poly = poly.fit_transform(X_train)
+X_test_poly = poly.transform(X_test)
+
+model_poly = LinearRegression()
+model_poly.fit(X_train_poly, y_train)
+y_pred_poly = model_poly.predict(X_test_poly)
+print(f"Polynomial Regression (d=2) MSE: {mean_squared_error(y_test, y_pred_poly):.4f}")
+''',
+
+    "expt_05_random_forest.py": '''"""
+Expt 05: Random Forest
+Implement and evaluate Random Forest algorithm on given dataset.
+"""
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, classification_report
+
+df = pd.read_csv("datasets/classification.csv")
+X = df[['feature1', 'feature2']]
+y = df['target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+clf = RandomForestClassifier(n_estimators=100, random_state=42)
+clf.fit(X_train, y_train)
+y_pred = clf.predict(X_test)
+
+print(f"Random Forest Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+print("Classification Report:")
+print(classification_report(y_test, y_pred))
+''',
+
+    "expt_06_svm.py": '''"""
+Expt 06: Support Vector Machine
+Implement and evaluate SVM algorithm on given dataset.
+"""
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC
+from sklearn.metrics import accuracy_score
+
+df = pd.read_csv("datasets/classification.csv")
+X = df[['feature1', 'feature2']]
+y = df['target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+clf = SVC(kernel='linear', C=1.0)
+clf.fit(X_train, y_train)
+y_pred = clf.predict(X_test)
+
+print(f"SVM (Linear Kernel) Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+''',
+
+    "expt_07_logistic_regression.py": '''"""
+Expt 07: Logistic Regression
+Implement and evaluate Logistic Regression algorithm on binary classification problem.
+"""
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, confusion_matrix
+
+df = pd.read_csv("datasets/classification.csv")
+X = df[['feature1', 'feature2']]
+y = df['target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+clf = LogisticRegression()
+clf.fit(X_train, y_train)
+y_pred = clf.predict(X_test)
+
+print(f"Logistic Regression Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))
+''',
+
+    "expt_08_knn.py": '''"""
+Expt 08: K-Nearest Neighbor
+Implement and visualize KNN clustering algorithm on given dataset.
+Note: KNN is traditionally for classification. K-Means is for clustering.
+We implement KNN Classifier here.
+"""
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import accuracy_score
+
+df = pd.read_csv("datasets/classification.csv")
+X = df[['feature1', 'feature2']]
+y = df['target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+knn = KNeighborsClassifier(n_neighbors=5)
+knn.fit(X_train, y_train)
+y_pred = knn.predict(X_test)
+
+print(f"KNN Classifier Accuracy (K=5): {accuracy_score(y_test, y_pred):.4f}")
+''',
+
+    "expt_09_naive_bayes.py": '''"""
+Expt 09: Naive Bayes
+Implement Naive Bayes Classifier.
+"""
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score
+
+df = pd.read_csv("datasets/classification.csv")
+X = df[['feature1', 'feature2']]
+y = df['target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+nb = GaussianNB()
+nb.fit(X_train, y_train)
+y_pred = nb.predict(X_test)
+
+print(f"Gaussian Naive Bayes Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+''',
+
+    "expt_10_kmeans_agglomerative.py": '''"""
+Expt 10: Unsupervised Learning
+Implement and apply suitable measuring parameters for K Means
+& Agglomerative clustering algorithms on given dataset.
+"""
+import pandas as pd
+from sklearn.cluster import KMeans, AgglomerativeClustering
+from sklearn.metrics import silhouette_score
+
+df = pd.read_csv("datasets/clustering.csv")
+X = df[['f1', 'f2']]
+
+# K-Means
+kmeans = KMeans(n_clusters=3, random_state=42, n_init='auto')
+labels_km = kmeans.fit_predict(X)
+sil_km = silhouette_score(X, labels_km)
+print(f"K-Means Silhouette Score (k=3): {sil_km:.4f}")
+
+# Agglomerative
+agglo = AgglomerativeClustering(n_clusters=3)
+labels_agg = agglo.fit_predict(X)
+sil_agg = silhouette_score(X, labels_agg)
+print(f"Agglomerative Silhouette Score (k=3): {sil_agg:.4f}")
+''',
+
+    "expt_11_recommendation.py": '''"""
+Expt 11: Recommendation System
+Implement a Collaborative Filtering Recommender System.
+Using simple Item-Item Collaborative Filtering via Cosine Similarity.
+"""
+import pandas as pd
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Load ratings dataset
+ratings = pd.read_csv("datasets/ratings.csv")
+
+# Create user-item matrix
+user_item_matrix = ratings.pivot_table(index='user_id', columns='item_id', values='rating').fillna(0)
+print("User-Item Matrix shape:", user_item_matrix.shape)
+
+# Calculate item similarity
+item_similarity = cosine_similarity(user_item_matrix.T)
+item_sim_df = pd.DataFrame(item_similarity, index=user_item_matrix.columns, columns=user_item_matrix.columns)
+
+# Get recommendations for item 1
+print("\\nSimilar items to Item 1:")
+similar_items = item_sim_df[1].sort_values(ascending=False)[1:4] # top 3 excluding itself
+print(similar_items)
+'''
+}
+
+def interactive_menu():
+    print("=" * 60)
+    print("              ML EXPERIMENTS CLI")
+    print("=" * 60)
+    print("Available Experiments:\\n")
+    
+    # Extract titles for the menu
+    titles = []
+    keys = list(EXPERIMENTS.keys())
+    for key in keys:
+        # Extract the first line of the docstring as title
+        content = EXPERIMENTS[key]
+        lines = content.splitlines()
+        first_line = key
+        for line in lines:
+            if "Expt " in line:
+                first_line = line.replace('Expt ', '').strip()
+                break
+        titles.append(first_line)
+        
+    for i, title in enumerate(titles, 1):
+        print(f"{i}. {title}")
+        
+    print("\\nEnter the number of the experiment to clone the code (or 'q' to quit):")
+    
+    while True:
+        try:
+            choice = input("> ").strip()
+            if choice.lower() == 'q':
+                print("Goodbye!")
+                break
+                
+            choice_idx = int(choice) - 1
+            if 0 <= choice_idx < len(keys):
+                filename = keys[choice_idx]
+                content = EXPERIMENTS[filename]
+                
+                # Write the file
+                out_path = Path.cwd()
+                (out_path / filename).write_text(content, encoding='utf-8')
+                print(f"\\n[+] Cloned '{filename}' into current directory.")
+                
+                # Generate datasets automatically
+                data_dir = out_path / "datasets"
+                if "datasets/classification.csv" in content and not (data_dir / "classification.csv").exists():
+                    generate_datasets(data_dir)
+                    print(f"[+] Generated required datasets in './datasets/' directory.")
+                elif "datasets/regression.csv" in content and not (data_dir / "regression.csv").exists():
+                    generate_datasets(data_dir)
+                    print(f"[+] Generated required datasets in './datasets/' directory.")
+                elif "datasets/clustering.csv" in content and not (data_dir / "clustering.csv").exists():
+                    generate_datasets(data_dir)
+                    print(f"[+] Generated required datasets in './datasets/' directory.")
+                elif "datasets/ratings.csv" in content and not (data_dir / "ratings.csv").exists():
+                    generate_datasets(data_dir)
+                    print(f"[+] Generated required datasets in './datasets/' directory.")
+                
+                print("=" * 60)
+                print("Enter another number to clone, or 'q' to quit:")
+            else:
+                print("Invalid number. Please try again.")
+        except ValueError:
+            print("Invalid input. Please enter a number or 'q'.")
+        except KeyboardInterrupt:
+            print("\\nGoodbye!")
+            break
+
+def generate_experiments(output_dir: str):
+    out_path = Path(output_dir)
+    print(f"Creating experiments in: {out_path.absolute()}")
+    
+    # 1. Create datasets
+    datasets_dir = out_path / "datasets"
+    generate_datasets(datasets_dir)
+    print("Generated datasets.")
+
+    # 2. Create python scripts
+    for filename, content in EXPERIMENTS.items():
+        script_path = out_path / filename
+        script_path.write_text(content, encoding='utf-8')
+        print(f"Generated {filename}")
+
+    print("\\nAll experiments generated successfully!")