KL-Py 0.0.4__tar.gz → 0.0.5__tar.gz

{kl_py-0.0.4/src/KL_Py.egg-info → kl_py-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KL_Py
-Version: 0.0.4
+Version: 0.0.5
 Summary: A Python simplification module
 Author-email: Abbaskhurram255 <abbaskhurram255@gmail.com>
 Classifier: Programming Language :: Python :: 3

{kl_py-0.0.4 → kl_py-0.0.5}/pyproject.toml

@@ -12,13 +12,14 @@ requires = [
 	"PySimpleGUI",
 	"FreeSimpleGUI",
 	"pyinstaller",
-	"auto-py-to-exe"
+	"auto-py-to-exe",
+	"joblib"
 ]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "KL_Py"
-version = "0.0.4"
+version = "0.0.5"
 authors = [
   { name="Abbaskhurram255", email="abbaskhurram255@gmail.com" },
 ]

{kl_py-0.0.4 → kl_py-0.0.5}/src/KL_Py/__init__.py

@@ -3,6 +3,7 @@ from ._custom_turtle import *
 from ._custom_sqlite import *
 from ._custom_pandas import *
 from ._klang_builtins import *
+from .automl import *
 from KL_Py import FreeSimpleGUI
 from KL_Py import dnd
 from KL_Py import drag_and_drop

kl_py-0.0.5/src/KL_Py/automl.py

@@ -0,0 +1,214 @@
+import pandas as pd
+import numpy as np
+import joblib
+from sklearn.model_selection import train_test_split, RepeatedKFold, cross_val_score
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import OneHotEncoder
+from sklearn.ensemble import HistGradientBoostingRegressor, HistGradientBoostingClassifier
+from sklearn.metrics import mean_absolute_error, accuracy_score, r2_score
+from sklearn.inspection import permutation_importance
+import matplotlib.pyplot as plt
+import time
+
+def auto_ml_train(
+    df: pd.DataFrame,
+    target_col: str,
+    problem_type: str = 'auto', # 'regression', 'classification', or 'auto'
+    test_size: float = 0.2,
+    save_path: str = 'model.pkl',
+    verbose: bool = True
+):
+    """
+    Trains a pipeline that handles missing values, categoricals, and auto-tunes HGB.
+    Works on 50 rows or 500k rows. Returns trained pipeline + metrics.
+
+    Usage:
+        model, metrics = auto_ml_train(df, target_col='price')
+        preds = model.predict(new_df)
+    """
+    if not isinstance(df, pd.DataFrame):
+    	try:
+    		df = pd.DataFrame(df)
+    	except Exception:
+    		return
+    start_time = time.time()
+    X = df.drop(target_col, axis=1)
+    y = df[target_col]
+    n_samples = X.shape[0]
+    # 1. Auto-detect problem type
+    if problem_type == 'auto':
+        if y.nunique() <= 20 and y.dtype in ['object', 'bool'] or y.nunique() == 2:
+            problem_type = 'classification'
+        else:
+            problem_type = 'regression'
+    # 2. Auto-detect column types
+    numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns.tolist()
+    categorical_cols = X.select_dtypes(include=['object', 'category', 'bool']).columns.tolist()
+    if verbose:
+        print(f"Problem: {problem_type} | Rows: {n_samples}")
+        print(f"Numeric: {len(numeric_cols)} | Categorical: {len(categorical_cols)}")
+    # 3. Preprocessing
+    numeric_transformer = Pipeline(steps=[
+        ('imputer', SimpleImputer(strategy='median'))
+    ])
+    categorical_transformer = Pipeline(steps=[
+        ('imputer', SimpleImputer(strategy='most_frequent')),
+        ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
+    ])
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ('num', numeric_transformer, numeric_cols),
+            ('cat', categorical_transformer, categorical_cols)
+        ],
+        remainder='drop'
+    )
+    # 4. Auto-tune HGB based on data size - FIXED FOR SPEED
+    if problem_type == 'regression':
+        Model = HistGradientBoostingRegressor
+        scoring = 'neg_mean_absolute_error'
+        metric_fn = mean_absolute_error
+        metric_name = 'MAE'
+    else:
+        Model = HistGradientBoostingClassifier
+        scoring = 'accuracy'
+        metric_fn = accuracy_score
+        metric_name = 'Accuracy'
+
+    if n_samples < 500: # Small data mode
+        model_params = dict(
+            max_depth=3, max_leaf_nodes=15, min_samples_leaf=20,
+            learning_rate=0.01, max_iter=100, l2_regularization=1.0,
+            max_features=0.8, early_stopping=True, validation_fraction=0.2,
+            n_iter_no_change=5, random_state=432
+        )
+    elif n_samples < 5000: # Medium data
+        model_params = dict(
+            max_depth=5, max_leaf_nodes=31, learning_rate=0.05,
+            max_iter=200, early_stopping=True, validation_fraction=0.1,
+            n_iter_no_change=10, random_state=432
+        )
+    else: # Big data - NO EARLY STOPPING to avoid hanging
+        model_params = dict(
+            learning_rate=0.1,
+            max_iter=100,
+            early_stopping=False,
+            random_state=432
+        )
+    # 5. Full pipeline
+    pipe = Pipeline(steps=[
+        ('preprocessor', preprocessor),
+        ('model', Model(**model_params))
+    ])
+    # 6. Train/test split
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=432
+    )
+    # 7. Fit
+    if verbose: print("Training...")
+    pipe.fit(X_train, y_train)
+    # 8. Test metrics
+    preds = pipe.predict(X_test)
+    test_score = metric_fn(y_test, preds)
+    # 9. Cross-val for honest score - fewer repeats on big data
+    n_repeats = 3 if n_samples < 10000 else 1
+    cv = RepeatedKFold(n_splits=5, n_repeats=n_repeats, random_state=432)
+    cv_scores = cross_val_score(pipe, X, y, cv=cv, scoring=scoring, n_jobs=-1)
+    cv_mean = -cv_scores.mean() if problem_type == 'regression' else cv_scores.mean()
+    cv_std = cv_scores.std()
+    metrics: dict[str, ] = {
+        f'test_{metric_name}': test_score,
+        f'cv_{metric_name}_mean': cv_mean,
+        f'cv_{metric_name}_std': cv_std,
+        'n_samples': n_samples,
+        'problem_type': problem_type,
+        'train_time_sec': round(time.time() - start_time, 2)
+    }
+    if problem_type == 'regression':
+        metrics['test_R2'] = r2_score(y_test, preds)
+    if verbose:
+        print(f"\nTest {metric_name}: {test_score:.4f}")
+        if problem_type == 'regression':
+            print(f"Test R2: {metrics['test_R2']:.4f}")
+        print(f"CV {metric_name}: {cv_mean:.4f} +/- {cv_std:.4f}")
+        print(f"Train time: {metrics['train_time_sec']} sec")
+    # 10. Save
+    joblib.dump(pipe, save_path)
+    if verbose: print(f"\nModel saved to {save_path}")
+    return pipe, metrics
+auto_train = auto_ml_train
+def auto_ml_predict(model_path: str, df_new: pd.DataFrame):
+    if not isinstance(df_new, pd.DataFrame):
+    	try:
+    		df_new = pd.DataFrame(df_new)
+    	except Exception:
+    		return
+    pipe = joblib.load(model_path)
+    return pipe.predict(df_new)
+auto_predict = auto_ml_predict
+def get_feature_importance(
+    model_path: str,
+    df_sample: pd.DataFrame,
+    target_col: str,
+    top_n: int = 10,
+    plot: bool = True
+):
+    """
+    Loads a saved pipeline and returns permutation importance.
+
+    Usage:
+        top_features = get_feature_importance('model.pkl', df.sample(300), 'MedHouseVal')
+    """
+    if not isinstance(df_sample, pd.DataFrame):
+    	try:
+    		df_sample = pd.DataFrame(df_sample)
+    	except Exception:
+    		return
+    pipe = joblib.load(model_path)
+    X = df_sample.drop(target_col, axis=1)
+    y = df_sample[target_col]
+    # Get feature names after preprocessing
+    preprocessor = pipe.named_steps['preprocessor']
+    num_cols = preprocessor.transformers_[0][2]
+    # Check if we have categorical columns
+    cat_cols_list = preprocessor.transformers_[1][2]
+    if len(cat_cols_list) > 0:
+        cat_transformer = preprocessor.transformers_[1][1]
+        cat_cols = cat_transformer.named_steps['onehot'].get_feature_names_out(cat_cols_list)
+        feature_names = list(num_cols) + list(cat_cols)
+    else:
+        feature_names = list(num_cols)
+    n_repeats = 5 if X.shape[0] < 5000 else 2
+    r = permutation_importance(
+        pipe, X, y, n_repeats=n_repeats, random_state=432, n_jobs=-1
+    )
+    importances = pd.Series(r.importances_mean, index=feature_names)
+    importances = importances.sort_values(ascending=False).head(top_n)
+    if plot:
+        plt.figure(figsize=(8, 6))
+        importances.plot(kind='barh')
+        plt.title(f'Top {top_n} Feature Importances')
+        plt.xlabel('Mean decrease in score')
+        plt.gca().invert_yaxis()
+        plt.tight_layout()
+        plt.show()
+    return importances.round(4)
+feature_importance = get_feature_importance
+def explain_model_simple(model_path, df_sample, target_col, business_metric="price"):
+    importances = get_feature_importance(model_path, df_sample, target_col, top_n=3, plot=False)
+    total = importances.sum()
+    top1, top2, top3 = importances.index[0], importances.index[1], importances.index[2]
+    pct1, pct2, pct3 = importances.iloc / total * 100
+
+    explanation = f"""
+    What drives your {business_metric}:
+    1. {top1}: Drives {pct1.iloc[0]:.0f}% of the decision
+    2. {top2}: Drives {pct2.iloc[1]:.0f}% of the decision  
+    3. {top3}: Drives {pct3.iloc[2]:.0f}% of the decision
+    
+    Everything else combined is less important than {top3}.
+    """
+    return explanation
+#Usage:
+#print(explain_model_simple('model.pkl', df, 'MedHouseVal', 'house price'))

{kl_py-0.0.4 → kl_py-0.0.5/src/KL_Py.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KL_Py
-Version: 0.0.4
+Version: 0.0.5
 Summary: A Python simplification module
 Author-email: Abbaskhurram255 <abbaskhurram255@gmail.com>
 Classifier: Programming Language :: Python :: 3

{kl_py-0.0.4 → kl_py-0.0.5}/src/KL_Py.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/KL_Py/_custom_turtle.py
 src/KL_Py/_error_classes.py
 src/KL_Py/_klang_builtins.py
 src/KL_Py/_translate.py
+src/KL_Py/automl.py
 src/KL_Py/when.py
 src/KL_Py.egg-info/PKG-INFO
 src/KL_Py.egg-info/SOURCES.txt