breezeml 0.1.1__tar.gz

breezeml-0.1.1/LICENSE

@@ -0,0 +1,2 @@
+MIT License
+Copyright (c) 2025 Akash

breezeml-0.1.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+recursive-include examples *

breezeml-0.1.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: breezeml
+Version: 0.1.1
+Summary: Beginner-friendly wrapper around scikit-learn: train, evaluate, explain, and compare ML models in one line.
+Author-email: Akash Anipakalu Giridhar <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/your-username/breezeml
+Project-URL: Repository, https://github.com/your-username/breezeml
+Project-URL: Documentation, https://github.com/your-username/breezeml#readme
+Keywords: machine-learning,scikit-learn,beginners,data-science,education
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3
+Requires-Dist: numpy>=1.21
+Requires-Dist: scikit-learn>=1.1
+Requires-Dist: joblib>=1.1
+Requires-Dist: matplotlib>=3.5
+Dynamic: license-file
+
+# BreezeML v0.1.0
+
+If you can load a CSV, you can train a model.
+
+Quickstart:
+```python
+from breezeml import datasets, fit, predict, creator
+print(creator())
+df = datasets.iris()
+model = fit(df, "species")
+print(predict(model, df.drop(columns=["species"]))[:5])
+```

breezeml-0.1.1/README.md

@@ -0,0 +1,12 @@
+# BreezeML v0.1.0
+
+If you can load a CSV, you can train a model.
+
+Quickstart:
+```python
+from breezeml import datasets, fit, predict, creator
+print(creator())
+df = datasets.iris()
+model = fit(df, "species")
+print(predict(model, df.drop(columns=["species"]))[:5])
+```

breezeml-0.1.1/breezeml/__init__.py

@@ -0,0 +1,7 @@
+from .breezeml import (
+    EasyModel, classify, regress, auto,
+    fit, predict, from_csv, report, load,
+    save, creator, datasets
+)
+
+__version__ = "0.1.1"

breezeml-0.1.1/breezeml/breezeml.py

@@ -0,0 +1,219 @@
+"""
+BreezeML: Beginner-friendly wrapper around scikit-learn
+
+Created by Akash Anipakalu Giridhar 🔥✨
+(PATCH: compute RMSE via sqrt(MSE) to support older scikit-learn versions without 'squared' kwarg)
+"""
+import pandas as pd
+import numpy as np
+import joblib
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.impute import SimpleImputer
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.linear_model import LogisticRegression, LinearRegression
+from sklearn.metrics import (
+    accuracy_score, f1_score,
+    r2_score, mean_absolute_error, mean_squared_error
+)
+from sklearn import datasets as skdatasets
+
+__all__ = [
+    "classify", "regress", "fit", "predict", "from_csv",
+    "report", "save", "load", "auto", "creator", "datasets"
+]
+
+
+class EasyModel:
+    def __init__(self, pipeline, target, task):
+        self.pipeline = pipeline
+        self.target = target
+        self.task = task
+
+    def predict(self, X):
+        return self.pipeline.predict(X)
+
+    def save(self, path):
+        joblib.dump(self, path)
+
+    @staticmethod
+    def load(path):
+        return joblib.load(path)
+
+
+def _detect_types(df, target):
+    X = df.drop(columns=[target])
+    numeric = X.select_dtypes(include=[np.number]).columns
+    categorical = X.select_dtypes(exclude=[np.number]).columns
+    return list(numeric), list(categorical)
+
+
+def _build_preprocessor(numeric, categorical):
+    num_pipe = Pipeline([
+        ("imputer", SimpleImputer(strategy="median")),
+        ("scaler", StandardScaler())
+    ])
+    cat_pipe = Pipeline([
+        ("imputer", SimpleImputer(strategy="most_frequent")),
+        ("onehot", OneHotEncoder(handle_unknown="ignore"))
+    ])
+    return ColumnTransformer([
+        ("num", num_pipe, numeric),
+        ("cat", cat_pipe, categorical)
+    ])
+
+
+def classify(df, target, algo="forest", return_report=True):
+    X = df.drop(columns=[target])
+    y = df[target]
+    numeric, categorical = _detect_types(df, target)
+    pre = _build_preprocessor(numeric, categorical)
+
+    model = RandomForestClassifier(random_state=42) if algo == "forest" else LogisticRegression(max_iter=200)
+    pipe = Pipeline([("pre", pre), ("model", model)])
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.2, random_state=42)
+    pipe.fit(X_train, y_train)
+
+    em = EasyModel(pipe, target, "classification")
+
+    if not return_report:
+        return em
+    preds = pipe.predict(X_test)
+    report = {
+        "accuracy": float(accuracy_score(y_test, preds)),
+        "f1": float(f1_score(y_test, preds, average="weighted"))
+    }
+    return em, report
+
+
+def regress(df, target, algo="forest", return_report=True):
+    X = df.drop(columns=[target])
+    y = df[target]
+    numeric, categorical = _detect_types(df, target)
+    pre = _build_preprocessor(numeric, categorical)
+
+    model = RandomForestRegressor(random_state=42) if algo == "forest" else LinearRegression()
+    pipe = Pipeline([("pre", pre), ("model", model)])
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    pipe.fit(X_train, y_train)
+
+    em = EasyModel(pipe, target, "regression")
+
+    if not return_report:
+        return em
+    preds = pipe.predict(X_test)
+    mse = mean_squared_error(y_test, preds)  # avoid 'squared' kwarg for compatibility
+    rmse = float(np.sqrt(mse))
+    report = {
+        "r2": float(r2_score(y_test, preds)),
+        "mae": float(mean_absolute_error(y_test, preds)),
+        "rmse": rmse
+    }
+    return em, report
+
+
+def fit(df, target):
+    y = df[target]
+    if y.dtype == "object" or y.nunique() < 20:
+        m, _ = classify(df, target)
+    else:
+        m, _ = regress(df, target)
+    return m
+
+
+def predict(model, X):
+    return model.predict(X)
+
+
+def from_csv(path, target):
+    df = pd.read_csv(path)
+    model = fit(df, target)
+    y = df[target]
+    preds = model.predict(df.drop(columns=[target]))
+
+    if model.task == "classification":
+        return model, {
+            "accuracy": float(accuracy_score(y, preds)),
+            "f1": float(f1_score(y, preds, average="weighted"))
+        }
+    else:
+        mse = mean_squared_error(y, preds)
+        rmse = float(np.sqrt(mse))
+        return model, {
+            "r2": float(r2_score(y, preds)),
+            "mae": float(mean_absolute_error(y, preds)),
+            "rmse": rmse
+        }
+
+
+def report(model, df):
+    y = df[model.target]
+    preds = model.predict(df.drop(columns=[model.target]))
+    if model.task == "classification":
+        return {
+            "accuracy": float(accuracy_score(y, preds)),
+            "f1": float(f1_score(y, preds, average="weighted"))
+        }
+    else:
+        mse = mean_squared_error(y, preds)
+        rmse = float(np.sqrt(mse))
+        return {
+            "r2": float(r2_score(y, preds)),
+            "mae": float(mean_absolute_error(y, preds)),
+            "rmse": rmse
+        }
+
+
+def save(model, path):
+    model.save(path)
+
+
+def load(path):
+    return EasyModel.load(path)
+
+
+def auto(df, target):
+    """Automatically pick classification or regression based on target."""
+    y = df[target]
+    if y.dtype == "object" or y.nunique() < 20:
+        return classify(df, target)
+    else:
+        return regress(df, target)
+
+
+def creator():
+    return "Created by Akash Anipakalu Giridhar 🔥✨"
+
+
+class datasets:
+    @staticmethod
+    def iris():
+        data = skdatasets.load_iris(as_frame=True)
+        df = data.frame.copy()
+        df.rename(columns={"target": "species"}, inplace=True)
+        return df
+
+    @staticmethod
+    def breast_cancer():
+        data = skdatasets.load_breast_cancer(as_frame=True)
+        df = data.frame.copy()
+        df.rename(columns={"target": "label"}, inplace=True)
+        return df
+
+    @staticmethod
+    def wine():
+        data = skdatasets.load_wine(as_frame=True)
+        df = data.frame.copy()
+        df.rename(columns={"target": "class"}, inplace=True)
+        return df
+
+    @staticmethod
+    def diabetes():
+        data = skdatasets.load_diabetes(as_frame=True)
+        df = data.frame.copy()
+        return df

breezeml-0.1.1/breezeml.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: breezeml
+Version: 0.1.1
+Summary: Beginner-friendly wrapper around scikit-learn: train, evaluate, explain, and compare ML models in one line.
+Author-email: Akash Anipakalu Giridhar <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/your-username/breezeml
+Project-URL: Repository, https://github.com/your-username/breezeml
+Project-URL: Documentation, https://github.com/your-username/breezeml#readme
+Keywords: machine-learning,scikit-learn,beginners,data-science,education
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3
+Requires-Dist: numpy>=1.21
+Requires-Dist: scikit-learn>=1.1
+Requires-Dist: joblib>=1.1
+Requires-Dist: matplotlib>=3.5
+Dynamic: license-file
+
+# BreezeML v0.1.0
+
+If you can load a CSV, you can train a model.
+
+Quickstart:
+```python
+from breezeml import datasets, fit, predict, creator
+print(creator())
+df = datasets.iris()
+model = fit(df, "species")
+print(predict(model, df.drop(columns=["species"]))[:5])
+```

breezeml-0.1.1/breezeml.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+breezeml/__init__.py
+breezeml/breezeml.py
+breezeml.egg-info/PKG-INFO
+breezeml.egg-info/SOURCES.txt
+breezeml.egg-info/dependency_links.txt
+breezeml.egg-info/requires.txt
+breezeml.egg-info/top_level.txt
+examples/test_classification.py
+examples/test_regression.py
+examples/test_save_load.py

breezeml-0.1.1/breezeml.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

breezeml-0.1.1/breezeml.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pandas>=1.3
+numpy>=1.21
+scikit-learn>=1.1
+joblib>=1.1
+matplotlib>=3.5

breezeml-0.1.1/breezeml.egg-info/top_level.txt

@@ -0,0 +1 @@
+breezeml

breezeml-0.1.1/examples/test_classification.py

@@ -0,0 +1,7 @@
+from breezeml import datasets, fit, predict, creator
+
+print("Easter Egg:", creator())
+df = datasets.iris()
+model = fit(df, "species")
+yhat = predict(model, df.drop(columns=["species"]))
+print("First 10 predictions:", yhat[:10])

breezeml-0.1.1/examples/test_regression.py

@@ -0,0 +1,7 @@
+from breezeml import datasets, fit, predict
+
+print("Running regression test...")
+df = datasets.diabetes()
+model = fit(df, "target")
+yhat = predict(model, df.drop(columns=["target"]))
+print("First 10 predictions:", yhat[:10])

breezeml-0.1.1/examples/test_save_load.py

@@ -0,0 +1,28 @@
+from breezeml import datasets, fit, save, load, predict
+
+print("Running save/load test...")
+
+# Train a simple model on Iris
+df = datasets.iris()
+model = fit(df, "species")
+
+# Save to disk
+model_path = "iris_model.joblib"
+save(model, model_path)
+print(f"Model saved to: {model_path}")
+
+# Load back
+loaded = load(model_path)
+print("Model loaded.")
+
+# Sanity check: predictions should match (on same data)
+X = df.drop(columns=["species"])
+orig_pred = predict(model, X)[:10]
+loaded_pred = predict(loaded, X)[:10]
+
+print("Original preds (first 10):", orig_pred)
+print("Loaded   preds (first 10):", loaded_pred)
+
+# Optional: assert equality for the first 50 rows
+same = (orig_pred[:50] == loaded_pred[:50]).all()
+print("Do first 50 predictions match?", bool(same))

breezeml-0.1.1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "breezeml"
+version = "0.1.1"
+description = "Beginner-friendly wrapper around scikit-learn: train, evaluate, explain, and compare ML models in one line."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+  {name = "Akash Anipakalu Giridhar", email = "your.email@example.com"}
+]
+keywords = ["machine-learning", "scikit-learn", "beginners", "data-science", "education"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Education",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+  "pandas>=1.3",
+  "numpy>=1.21",
+  "scikit-learn>=1.1",
+  "joblib>=1.1",
+  "matplotlib>=3.5"
+]
+
+[project.urls]
+Homepage = "https://github.com/your-username/breezeml"
+Repository = "https://github.com/your-username/breezeml"
+Documentation = "https://github.com/your-username/breezeml#readme"
+
+[tool.setuptools.packages.find]
+where = [""]
+include = ["breezeml*"]

breezeml-0.1.1/setup.cfg

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