mlgear 0.3__tar.gz → 0.5__tar.gz

mlgear-0.5/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020- Peter Hurford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

mlgear-0.5/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.3
+Name: mlgear
+Version: 0.5
+Summary: Utility scripts for machine learning
+License: MIT
+Author: Peter Hurford
+Author-email: peter@peterhurford.com
+Requires-Python: >=3.7,<4.0
+Classifier: Development Status :: 3 - Alpha
+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
+
+```Python
+from mlgear.cv import run_cv_model
+from mlgear.models import runLGB
+from mlgear.metrics import rmse
+
+lgb_params = {'application': 'regression',
+              'boosting': 'gbdt',
+              'metric': 'rmse',
+              'num_leaves': 15,
+              'learning_rate': 0.01,
+              'bagging_fraction': 0.9,
+              'feature_fraction': 0.9,
+              'verbosity': -1,
+              'seed': 1,
+              'lambda_l1': 1,
+              'lambda_l2': 1,
+              'early_stop': 20,
+              'verbose_eval': 10,
+              'num_rounds': 500,
+              'num_threads': 3}
+
+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.3 → mlgear-0.5}/README.md

@@ -2,7 +2,7 @@
 
 Some utility functions to make ML with Python / Pandas / sklearn even easier
 
-#### Example Usage
+### Example Usage
 
 ```Python
 from mlgear.cv import run_cv_model
@@ -27,3 +27,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/mlgear/cv.py

@@ -0,0 +1,97 @@
+import numpy as np
+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, verbose=True):
+    if target is None:
+        raise ValueError('Target is needed.')
+    if model_fn is None:
+        raise ValueError('model function is needed.')
+    if not fold_splits:
+        kf = KFold(n_splits=n_folds, random_state=42, shuffle=True)
+        fold_splits = kf.split(train)
+    cv_scores = []
+    models = {}
+    if classes > 1 and test is not None:
+       pred_full_test = np.zeros((test.shape[0], classes))
+    else:
+       pred_full_test = 0
+    if classes > 1:
+       pred_train = np.zeros((train.shape[0], classes))
+    else:
+       pred_train = np.zeros(train.shape[0])
+    feature_importance_df = pd.DataFrame()
+    i = 1
+    for dev_index, val_index in fold_splits:
+        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:
+        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
+   
+    final_cv = eval_fn(target, pred_train) if eval_fn else None
+
+    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,
+               'cv': cv_scores,
+               'final_cv': final_cv,
+               'importance': feature_importance_df,
+               'model': models}
+    if test is not None:
+        results['test'] = pred_full_test
+    return results 

{mlgear-0.3 → mlgear-0.5}/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-0.3 → mlgear-0.5}/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.5/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "mlgear"
+version = "0.5"
+description = "Utility scripts for machine learning"
+authors = ["Peter Hurford <peter@peterhurford.com>"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/peterhurford/mlgear"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.poetry.dependencies]
+python = "^3.7"
+keras = "*"
+lightgbm = "*"
+numpy = "*"
+pandas = "*"
+scikit-learn = "*"
+
+[tool.poetry.group.dev.dependencies]
+flake8 = "*"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

mlgear-0.3/PKG-INFO

@@ -1,44 +0,0 @@
-Metadata-Version: 2.1
-Name: mlgear
-Version: 0.3
-Summary: Utility scripts for machine learning
-Home-page: https://github.com/peterhurford/mlgear
-Author: Peter Hurford
-Author-email: peter@peterhurford.com
-License: UNKNOWN
-Description: ## MLGear
-        
-        Some utility functions to make ML with Python / Pandas / sklearn even easier
-        
-        #### Example Usage
-        
-        ```Python
-        from mlgear.cv import run_cv_model
-        from mlgear.models import runLGB
-        from mlgear.metrics import rmse
-        
-        lgb_params = {'application': 'regression',
-                      'boosting': 'gbdt',
-                      'metric': 'rmse',
-                      'num_leaves': 15,
-                      'learning_rate': 0.01,
-                      'bagging_fraction': 0.9,
-                      'feature_fraction': 0.9,
-                      'verbosity': -1,
-                      'seed': 1,
-                      'lambda_l1': 1,
-                      'lambda_l2': 1,
-                      'early_stop': 20,
-                      'verbose_eval': 10,
-                      'num_rounds': 500,
-                      'num_threads': 3}
-        
-        results = run_cv_model(train, test, target, runLGB, lgb_params, rmse)
-        ```
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown

mlgear-0.3/mlgear/cv.py

@@ -1,88 +0,0 @@
-import numpy as np
-import pandas as pd
-
-from sklearn.model_selection import KFold
-
-
-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):
-    if target is None:
-        raise ValueError('Target is needed.')
-    if model_fn is None:
-        raise ValueError('model function is needed.')
-    if not fold_splits:
-        kf = KFold(n_splits=n_folds, random_state=42, shuffle=True)
-        fold_splits = kf.split(train)
-    cv_scores = []
-    models = {}
-    if classes > 1 and test is not None:
-       pred_full_test = np.zeros((test.shape[0], classes))
-    else:
-       pred_full_test = 0
-    if classes > 1:
-       pred_train = np.zeros((train.shape[0], classes))
-    else:
-       pred_train = np.zeros(train.shape[0])
-    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 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
-    elif test is not None:
-       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)))
-
-    results = {'label': label,
-               'train': pred_train,
-               'cv': cv_scores,
-               'final_cv': final_cv,
-               'importance': feature_importance_df,
-               'model': models}
-    if test is not None:
-       results['test'] = pred_full_test
-    return results 

mlgear-0.3/mlgear.egg-info/PKG-INFO

@@ -1,44 +0,0 @@
-Metadata-Version: 2.1
-Name: mlgear
-Version: 0.3
-Summary: Utility scripts for machine learning
-Home-page: https://github.com/peterhurford/mlgear
-Author: Peter Hurford
-Author-email: peter@peterhurford.com
-License: UNKNOWN
-Description: ## MLGear
-        
-        Some utility functions to make ML with Python / Pandas / sklearn even easier
-        
-        #### Example Usage
-        
-        ```Python
-        from mlgear.cv import run_cv_model
-        from mlgear.models import runLGB
-        from mlgear.metrics import rmse
-        
-        lgb_params = {'application': 'regression',
-                      'boosting': 'gbdt',
-                      'metric': 'rmse',
-                      'num_leaves': 15,
-                      'learning_rate': 0.01,
-                      'bagging_fraction': 0.9,
-                      'feature_fraction': 0.9,
-                      'verbosity': -1,
-                      'seed': 1,
-                      'lambda_l1': 1,
-                      'lambda_l2': 1,
-                      'early_stop': 20,
-                      'verbose_eval': 10,
-                      'num_rounds': 500,
-                      'num_threads': 3}
-        
-        results = run_cv_model(train, test, target, runLGB, lgb_params, rmse)
-        ```
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown

mlgear-0.3/mlgear.egg-info/SOURCES.txt

@@ -1,16 +0,0 @@
-README.md
-setup.cfg
-setup.py
-mlgear/__init__.py
-mlgear/aggregators.py
-mlgear/cv.py
-mlgear/encoders.py
-mlgear/lr_scheduler.py
-mlgear/metrics.py
-mlgear/models.py
-mlgear/tracker.py
-mlgear/utils.py
-mlgear.egg-info/PKG-INFO
-mlgear.egg-info/SOURCES.txt
-mlgear.egg-info/dependency_links.txt
-mlgear.egg-info/top_level.txt

mlgear-0.3/mlgear.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

mlgear-0.3/mlgear.egg-info/top_level.txt

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

mlgear-0.3/setup.cfg

@@ -1,7 +0,0 @@
-[flake8]
-max-line-length = 100
-
-[egg_info]
-tag_build = 
-tag_date = 0
-

mlgear-0.3/setup.py

@@ -1,22 +0,0 @@
-import setuptools
-
-with open('README.md', 'r') as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-     name='mlgear',  
-     version='0.3',
-     author='Peter Hurford',
-     author_email='peter@peterhurford.com',
-     description='Utility scripts for machine learning',
-     long_description=long_description,
-	 long_description_content_type='text/markdown',
-     url='https://github.com/peterhurford/mlgear',
-     packages=setuptools.find_packages(),
-     classifiers=[
-         'Development Status :: 3 - Alpha',
-         'Programming Language :: Python :: 3',
-         'License :: OSI Approved :: MIT License',
-         'Operating System :: OS Independent',
-     ],
- )