mlgear 0.3__py3-none-any.whl → 0.5__py3-none-any.whl

mlgear/cv.py

@@ -3,8 +3,10 @@ import pandas as pd
 
 from sklearn.model_selection import KFold
 
+from mlgear.utils import print_step
 
-def run_cv_model(train, test=None, target=None, model_fn=None, params={}, eval_fn=None, label='model', n_folds=5, fold_splits=None, classes=1, stop_on_fold=None, train_on_full=False):
+
+def run_cv_model(train, test=None, target=None, model_fn=None, params={}, eval_fn=None, label='model', n_folds=5, fold_splits=None, classes=1, stop_on_fold=None, train_on_full=False, verbose=True):
     if target is None:
         raise ValueError('Target is needed.')
     if model_fn is None:
@@ -25,57 +27,64 @@ def run_cv_model(train, test=None, target=None, model_fn=None, params={}, eval_f
     feature_importance_df = pd.DataFrame()
     i = 1
     for dev_index, val_index in fold_splits:
-       print('Started ' + label + ' fold ' + str(i) + '/' + str(n_folds))
-       if isinstance(train, pd.DataFrame):
-           dev_X, val_X = train.iloc[dev_index], train.iloc[val_index]
-       else:
-           dev_X, val_X = train[dev_index], train[val_index]
-       dev_y, val_y = target[dev_index], target[val_index]
-       params2 = params.copy()
-       meta = {'dev_index': dev_index,
-               'val_index': val_index,
-               'fold': i,
-               'label': label}
-       pred_val_y, pred_test_y, importances, model = model_fn(dev_X, dev_y, val_X, val_y, test, params2, meta)
-       if test is not None:
-           pred_full_test = pred_full_test + pred_test_y
-       pred_train[val_index] = pred_val_y
-       if eval_fn is not None:
-           cv_score = eval_fn(val_y, pred_val_y)
-           cv_scores.append(cv_score)
-           print(label + ' cv score {}: {}'.format(i, cv_score))
-       models[i] = model
-       if importances is not None and isinstance(train, pd.DataFrame):
-           fold_importance_df = pd.DataFrame()
-           fold_importance_df['feature'] = train.columns.values
-           fold_importance_df['importance'] = importances
-           fold_importance_df['fold'] = i
-           feature_importance_df = pd.concat([feature_importance_df, fold_importance_df], axis=0)
-       if stop_on_fold and stop_on_fold == i:
-           results = {'label': label,
-                      'train': pred_train,
-                      'cv': cv_scores,
-                      'importance': feature_importance_df,
-                      'model': models}
-           if test is not None:
-               results['test'] = pred_full_test
-           return results
-       i += 1
+        if verbose:
+            print_step('Started ' + label + ' fold ' + str(i) + '/' + str(n_folds))
+        if isinstance(train, pd.DataFrame):
+            dev_X, val_X = train.iloc[dev_index], train.iloc[val_index]
+        else:
+            dev_X, val_X = train[dev_index], train[val_index]
+        dev_y, val_y = target[dev_index], target[val_index]
+        params2 = params.copy()
+        meta = {'dev_index': dev_index,
+                'val_index': val_index,
+                'fold': i,
+                'label': label}
+        pred_val_y, pred_test_y, importances, model = model_fn(dev_X, dev_y, val_X, val_y, test, params2, meta, verbose=verbose)
+        if test is not None:
+            pred_full_test = pred_full_test + pred_test_y
+        pred_train[val_index] = pred_val_y
+        if eval_fn is not None:
+            cv_score = eval_fn(val_y, pred_val_y)
+            cv_scores.append(cv_score)
+            if verbose:
+                print_step(label + ' cv score {}: {}'.format(i, cv_score))
+        models[i] = model
+        if importances is not None and isinstance(train, pd.DataFrame):
+            fold_importance_df = pd.DataFrame()
+            if params.get('group') is None:
+                fold_importance_df['feature'] = train.columns.values
+            else:
+                fold_importance_df['feature'] = [c for c in train.columns.values if c != params['group']]
+            fold_importance_df['importance'] = importances
+            fold_importance_df['fold'] = i
+            feature_importance_df = pd.concat([feature_importance_df, fold_importance_df], axis=0)
+        if stop_on_fold and stop_on_fold == i:
+            results = {'label': label,
+                       'train': pred_train,
+                       'cv': cv_scores,
+                       'importance': feature_importance_df,
+                       'model': models}
+            if test is not None:
+                results['test'] = pred_full_test
+            return results
+        i += 1
 
     if train_on_full:
-       print('## Training on full ##')
-       params2 = params.copy()
-       _, pred_full_test, importances, model = model_fn(train, target, None, None, test, params2)
-       models['full'] = model
+        if verbose:
+            print_step('## Training on full ##')
+        params2 = params.copy()
+        _, pred_full_test, importances, model = model_fn(train, target, None, None, test, params2, verbose=verbose)
+        models['full'] = model
     elif test is not None:
-       pred_full_test = pred_full_test / n_folds
+        pred_full_test = pred_full_test / n_folds
    
     final_cv = eval_fn(target, pred_train) if eval_fn else None
 
-    print('{} cv scores : {}'.format(label, cv_scores))
-    print('{} cv mean score : {}'.format(label, np.mean(cv_scores)))
-    print('{} cv total score : {}'.format(label, final_cv))
-    print('{} cv std score : {}'.format(label, np.std(cv_scores)))
+    if verbose:
+        print_step('{} cv scores : {}'.format(label, cv_scores))
+        print_step('{} cv mean score : {}'.format(label, np.mean(cv_scores)))
+        print_step('{} cv total score : {}'.format(label, final_cv))
+        print_step('{} cv std score : {}'.format(label, np.std(cv_scores)))
 
     results = {'label': label,
                'train': pred_train,
@@ -84,5 +93,5 @@ def run_cv_model(train, test=None, target=None, model_fn=None, params={}, eval_f
                'importance': feature_importance_df,
                'model': models}
     if test is not None:
-       results['test'] = pred_full_test
+        results['test'] = pred_full_test
     return results 

mlgear/models.py

@@ -8,17 +8,16 @@ from sklearn.preprocessing import StandardScaler
 from mlgear.utils import print_step
 
 
-def runLGB(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None):
-    print('Prep LGB')
-    d_train = lgb.Dataset(train_X, label=train_y)
-    if test_X is not None:
-        d_valid = lgb.Dataset(test_X, label=test_y)
-        watchlist = [d_train, d_valid]
+def runLGB(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None, verbose=True):
+    if verbose:
+        print_step('Prep LGB')
+
+    if params.get('group'):
+        group = params.pop('group')
     else:
-        watchlist = [d_train]
-    print('Train LGB')
+        group = None
+
     num_rounds = params.pop('num_rounds')
-    verbose_eval = params.pop('verbose_eval')
     early_stop = None
     if params.get('early_stop'):
         early_stop = params.pop('early_stop')
@@ -35,6 +34,31 @@ def runLGB(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={},
     else:
         feval = None
 
+    if group is None:
+        d_train = lgb.Dataset(train_X, label=train_y)
+    else:
+        d_train = lgb.Dataset(train_X.drop(group, axis=1),
+                              label=train_y,
+                              group=train_X.groupby(group).size().to_numpy())
+
+    if test_X is not None:
+        if group is None:
+            d_valid = lgb.Dataset(test_X, label=test_y)
+        else:
+            d_valid = lgb.Dataset(test_X.drop(group, axis=1),
+                                  label=test_y,
+                                  group=test_X.groupby(group).size().to_numpy()) 
+            test_X = test_X.drop(group, axis=1)
+        watchlist = [d_train, d_valid]
+    else:
+        watchlist = [d_train]
+
+    if test_X2 is not None and group is not None:
+        test_X2 = test_X2.drop(group, axis=1)
+
+    if verbose:
+        print_step('Train LGB')
+
     preds_test_y = []
     preds_test_y2 = []
     for b in range(nbag):
@@ -43,16 +67,16 @@ def runLGB(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={},
                           train_set=d_train,
                           num_boost_round=num_rounds,
                           valid_sets=watchlist,
-                          verbose_eval=verbose_eval,
-                          early_stopping_rounds=early_stop,
-                          categorical_feature=cat_cols,
+                          callbacks=[lgb.early_stopping(stopping_rounds=early_stop)] if early_stop else [],
                           feval=feval)
         if test_X is not None:
-            print('Predict 1/2')
+            if verbose:
+                print_step('Predict 1/2')
             pred_test_y = model.predict(test_X, num_iteration=model.best_iteration)
             preds_test_y += [pred_test_y]
         if test_X2 is not None:
-            print('Predict 2/2')
+            if verbose:
+                print_step('Predict 2/2')
             pred_test_y2 = model.predict(test_X2, num_iteration=model.best_iteration)
             preds_test_y2 += [pred_test_y2]
 
@@ -71,21 +95,22 @@ def get_lgb_feature_importance(train, target, params):
     train_d = lgb.Dataset(train, label=target)
     lgb_params2 = params.copy()
     rounds = lgb_params2.pop('num_rounds', 400)
-    verbose_eval = lgb_params2.pop('verbose_eval', 100)
-    model = lgb.train(lgb_params2, train_d, rounds, valid_sets = [train_d], verbose_eval=verbose_eval)
+    model = lgb.train(lgb_params2, train_d, rounds, valid_sets = [train_d])
     feature_df = pd.DataFrame(sorted(zip(model.feature_importance(), train.columns)),
                                columns=['Value', 'Feature']).sort_values('Value', ascending=False)
     return feature_df
 
 
-def runMLP(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None):
-    print('Define Model')
+def runMLP(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None, verbose=True):
+    if verbose:
+        print_step('Define Model')
     model = params['model'](params['input_size'])
     es = params['early_stopper']()
     es.set_model(model)
     metric = params['metric']
     metric = metric(model, [es], [(train_X, train_y), (test_X, test_y)])
-    print('Fit MLP')
+    if verbose:
+        print_step('Fit MLP')
     model.fit(train_X, train_y,
               verbose=params.get('model_verbose', 0),
               callbacks=[metric] + params['lr_scheduler'](),
@@ -93,12 +118,14 @@ def runMLP(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={},
               validation_data=(test_X, test_y),
               batch_size=params.get('batch_size', 128))
     if test_X is not None:
-        print('MLP Predict 1/2')
+        if verbose:
+            print_step('MLP Predict 1/2')
         pred_test_y = model.predict(test_X)
     else:
         pred_test_y = None
     if test_X2 is not None:
-        print('MLP Predict 2/2')
+        if verbose:
+            print_step('MLP Predict 2/2')
         pred_test_y2 = model.predict(test_X2)
     else:
         pred_test_y2 = None
@@ -106,10 +133,11 @@ def runMLP(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={},
     return pred_test_y, pred_test_y2, None, model
 
 
-def runLR(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None):
+def runLR(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None, verbose=True):
     params['random_state'] = 42
     if params.get('scale'):
-        print_step('Scale')
+        if verbose:
+            print_step('Scale')
         params.pop('scale')
         scaler = StandardScaler()
         scaler.fit(train_X.values)
@@ -119,33 +147,39 @@ def runLR(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, m
         if test_X2 is not None:
             test_X2 = scaler.transform(test_X2.values)
 
-    print_step('Train LR')
+    if verbose:
+        print_step('Train LR')
     model = LogisticRegression(**params)
     model.fit(train_X, train_y)
     if test_X is not None:
-        print_step('Predict 1/2')
+        if verbose:
+            print_step('Predict 1/2')
         pred_test_y = model.predict_proba(test_X)[:, 1]
     else:
         pred_test_y = None
     if test_X2 is not None:
-        print_step('Predict 2/2')
+        if verbose:
+            print_step('Predict 2/2')
         pred_test_y2 = model.predict_proba(test_X2)[:, 1]
     else:
         pred_test_y2 = None
     return pred_test_y, pred_test_y2, model.coef_, model
 
 
-def runRidge(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None):
+def runRidge(train_X, train_y, test_X=None, test_y=None, test_X2=None, params={}, meta=None, verbose=True):
     model = Ridge(**params)
-    print_step('Fit Ridge')
+    if verbose:
+        print_step('Fit Ridge')
     model.fit(train_X, train_y)
     if test_X is not None:
-        print_step('Ridge Predict 1/2')
+        if verbose:
+            print_step('Ridge Predict 1/2')
         pred_test_y = model.predict(test_X)
     else:
         pred_test_y = None
     if test_X2 is not None:
-        print_step('Ridge Predict 2/2')
+        if verbose:
+            print_step('Ridge Predict 2/2')
         pred_test_y2 = model.predict(test_X2)
     else:
         pred_test_y2 = None

mlgear/utils.py

@@ -14,7 +14,7 @@ def show(df, max_rows=10, max_cols=None, digits=6):
 
 
 def display_column(df, var):
-	if df[var].nunique() > 9 and (df[var].dtype == int or df[var].dtype == float):
+	if df[var].astype(str).nunique() > 9 and (df[var].dtype == int or df[var].dtype == float):
 		print('Mean: {} Median: {} SD: {}'.format(df[var].mean(), df[var].median(), df[var].std()))
 	else:
 		print(df[var].value_counts(normalize=True) * 100)
@@ -36,3 +36,7 @@ def chunk(l, n):
     for i in range(0, len(l), n):
         out.append(l[i:i + n])
     return out
+
+
+def min_max(dat):
+    return (min(dat), max(dat))

{mlgear-0.3.dist-info → mlgear-0.5.dist-info}/METADATA

@@ -1,23 +1,35 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: mlgear
-Version: 0.3
+Version: 0.5
 Summary: Utility scripts for machine learning
-Home-page: https://github.com/peterhurford/mlgear
+License: MIT
 Author: Peter Hurford
 Author-email: peter@peterhurford.com
-License: UNKNOWN
-Platform: UNKNOWN
+Requires-Python: >=3.7,<4.0
 Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+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: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: keras
+Requires-Dist: lightgbm
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Project-URL: Repository, https://github.com/peterhurford/mlgear
 Description-Content-Type: text/markdown
 
 ## MLGear
 
 Some utility functions to make ML with Python / Pandas / sklearn even easier
 
-#### Example Usage
+### Example Usage
 
 ```Python
 from mlgear.cv import run_cv_model
@@ -43,4 +55,25 @@ lgb_params = {'application': 'regression',
 results = run_cv_model(train, test, target, runLGB, lgb_params, rmse)
 ```
 
+### Installation
+
+```
+pip install mlgear
+```
+
+For development:
+
+```
+# Install poetry if you don't have it
+pip install poetry
+
+# Install dependencies
+poetry install
+
+# Build the package
+poetry build
+
+# Publish to PyPI
+poetry publish
+```
 

mlgear-0.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+mlgear/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mlgear/aggregators.py,sha256=k_GGL8zuBqpBKPYR_v14SqPcJyAUalHcQN2o7gjApiw,373
+mlgear/cv.py,sha256=Dk1ajLFITWgu5nQP-R1rpT-KQ9oYaQRhgSYqQi0IwX0,4009
+mlgear/encoders.py,sha256=_NRqTNSdCNhT04Odxa9xRQq7nrr9bTFRwskARx1rgnU,5044
+mlgear/lr_scheduler.py,sha256=S7DlTAWTzAUAQbmzm-yWIWI5r49Htz1jRBQ98IQHdgg,5272
+mlgear/metrics.py,sha256=_zQwjz4X3-vUQEqu2yIfq2w2XnuH8YUSD_M_u6szToo,1188
+mlgear/models.py,sha256=RtvmsjMFoecdce_ikj3fa9cukGdvQEj3Y72hz5Qw-fY,6249
+mlgear/tracker.py,sha256=U2OXm9tjAWSc5B5_-oTvj_YAJdpkU4nsmPE7tH8BSN4,447
+mlgear/utils.py,sha256=I72-qBgiisV1hcoUT5almb8GXwfmhTQgwvP6gl8kJEY,1096
+mlgear-0.5.dist-info/LICENSE.txt,sha256=qkKmWAzXQC3lYVyoucB3x4iW2xnGEmaORCB4ADTAik4,1081
+mlgear-0.5.dist-info/METADATA,sha256=sRhbP8yNadrRqDX3mY1wOKpjbWD2DPnLbwmibEFYvYc,1994
+mlgear-0.5.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+mlgear-0.5.dist-info/RECORD,,

{mlgear-0.3.dist-info → mlgear-0.5.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any
-

mlgear-0.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-mlgear/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mlgear/aggregators.py,sha256=k_GGL8zuBqpBKPYR_v14SqPcJyAUalHcQN2o7gjApiw,373
-mlgear/cv.py,sha256=m3BmiJ2evbyj1iCaIp6a4neiyLsFQKGnH51J48yXfBI,3567
-mlgear/encoders.py,sha256=_NRqTNSdCNhT04Odxa9xRQq7nrr9bTFRwskARx1rgnU,5044
-mlgear/lr_scheduler.py,sha256=S7DlTAWTzAUAQbmzm-yWIWI5r49Htz1jRBQ98IQHdgg,5272
-mlgear/metrics.py,sha256=_zQwjz4X3-vUQEqu2yIfq2w2XnuH8YUSD_M_u6szToo,1188
-mlgear/models.py,sha256=8zM44ti8vUpyotXpWj2QyVhPWVJrUjbN5l2jq2cKCHw,5300
-mlgear/tracker.py,sha256=U2OXm9tjAWSc5B5_-oTvj_YAJdpkU4nsmPE7tH8BSN4,447
-mlgear/utils.py,sha256=E8lb0gsTf4tun7PHUQ5GFxwwxY3ZRxwIMzNCTZCb1rM,1032
-mlgear-0.3.dist-info/LICENSE.txt,sha256=qkKmWAzXQC3lYVyoucB3x4iW2xnGEmaORCB4ADTAik4,1081
-mlgear-0.3.dist-info/METADATA,sha256=FSIlAsK1Zl1Ad268a_Ryd4NBXTv5EZ0JnB5_AgOGjWU,1269
-mlgear-0.3.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-mlgear-0.3.dist-info/top_level.txt,sha256=TM51_lbw1nIKS5TvY-qVQEBGw1tMrgBKGUcB5BISu-Y,7
-mlgear-0.3.dist-info/RECORD,,

mlgear-0.3.dist-info/top_level.txt

@@ -1 +0,0 @@
-mlgear