mlba 1.9.10__tar.gz

mlba-1.9.10/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Galit Shmueli, Peter C. Bruce, Peter Gedeck 
+
+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.

mlba-1.9.10/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: mlba
+Version: 1.9.10
+Summary: Utility functions for 'Data Mining for Business Analytics: Concepts, Techniques, and Applications in Python'
+Home-page: https://github.com/gedeck/mlba-python
+Author: Peter Gedeck
+Author-email: mail@petergedeck.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Data Mining for Business Analytics: Concepts, Techniques, and  Applications in Python
+
+Collection of utility functions used in the book
+
+> _Data Mining for Business Analytics: Concepts, Techniques, and Applications in Python_ (First Edition) 
+> Galit Shmueli, Peter C. Bruce, Peter Gedeck, and Nitin R. Patel
+> (c) 2019 John Wiley & Sons, Inc. 
+
+Code for the book and the used datasets are available on https://www.dataminingbook.com/book/python-edition.
+
+
+## Installation
+Use `pip` to install the `dmba` package from pypi (https://pypi.org/project/dmba/).
+```
+pip install dmba
+```
+Should this not work, for example when you are behind a firewall, download the package from pypi and install from file, e.g.
+```
+pip install dmba-0.0.14.tar.gz 
+```

mlba-1.9.10/README.md

@@ -0,0 +1,20 @@
+# Data Mining for Business Analytics: Concepts, Techniques, and  Applications in Python
+
+Collection of utility functions used in the book
+
+> _Data Mining for Business Analytics: Concepts, Techniques, and Applications in Python_ (First Edition) 
+> Galit Shmueli, Peter C. Bruce, Peter Gedeck, and Nitin R. Patel
+> (c) 2019 John Wiley & Sons, Inc. 
+
+Code for the book and the used datasets are available on https://www.dataminingbook.com/book/python-edition.
+
+
+## Installation
+Use `pip` to install the `dmba` package from pypi (https://pypi.org/project/dmba/).
+```
+pip install dmba
+```
+Should this not work, for example when you are behind a firewall, download the package from pypi and install from file, e.g.
+```
+pip install dmba-0.0.14.tar.gz 
+```

mlba-1.9.10/setup.cfg

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

mlba-1.9.10/setup.py

@@ -0,0 +1,47 @@
+'''
+Utility functions for "Data Mining for Business Analytics: Concepts, Techniques, and 
+Applications in Python"
+
+(c) 2019, 2024 Galit Shmueli, Peter C. Bruce, Peter Gedeck 
+'''
+from pathlib import Path
+
+import setuptools
+
+
+def getVersion():
+    f = Path(__file__).parent / 'src' / 'mlba' / 'version.py'
+    lines = f.read_text().split('\n')
+    version = [s for s in lines if '__version__' in s][0]
+    version = version.split('=')[1].strip().strip("'")
+    return version
+
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="mlba",
+    version=getVersion(),
+    author="Peter Gedeck",
+    author_email="mail@petergedeck.com",
+    description="Utility functions for 'Data Mining for Business Analytics: Concepts, Techniques, and Applications in Python'",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/gedeck/mlba-python",
+    packages=setuptools.find_packages("src"),
+    package_dir={'': 'src'},
+    package_data={
+        "mlba": ["csvFiles/*.csv.gz", "csvFiles/*.zip"],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+
+    test_suite='nose.collector',
+    tests_require=['nose'],
+)

mlba-1.9.10/src/mlba/__init__.py

@@ -0,0 +1,20 @@
+'''
+Utility functions for "Data Mining for Business Analytics: Concepts, Techniques, and 
+Applications in Python"
+
+(c) 2019, 2024 Galit Shmueli, Peter C. Bruce, Peter Gedeck 
+'''
+import os
+import matplotlib as mpl
+from .version import __version__
+
+if os.environ.get('DISPLAY', '') == '' and os.name != 'nt':
+    print('no display found. Using non-interactive Agg backend')
+    mpl.use('Agg')
+
+from .featureSelection import exhaustive_search, forward_selection, backward_elimination, stepwise_selection
+from .graphs import plotDecisionTree, liftChart, gainsChart, textDecisionTree
+from .metric import regressionSummary, classificationSummary
+from .metric import AIC_score, BIC_score, adjusted_r2_score
+from .textMining import printTermDocumentMatrix
+from .data import load_data, get_data_file

mlba-1.9.10/src/mlba/data.py

@@ -0,0 +1,32 @@
+'''
+Created on Jun 12, 2020
+
+@author: gedeck
+'''
+from pathlib import Path
+
+import pandas as pd
+
+
+DATA_DIR = Path(__file__).parent / 'csvFiles'
+
+
+def load_data(name, **kwargs):
+    """ Returns the data either as a Pandas data frame or series """
+    data_file = get_data_file(name)
+    if not data_file.exists():
+        raise ValueError('Data file {name} not found')
+    data = pd.read_csv(data_file, **kwargs)
+    if data.shape[1] == 1:
+        return data[data.columns[0]]
+    return data
+
+
+def get_data_file(name):
+    if name.endswith('.zip'):
+        return DATA_DIR / name
+    if name.endswith('.gz'):
+        name = name[:-3]
+    if name.endswith('.csv'):
+        name = name[:-4]
+    return DATA_DIR / f'{name}.csv.gz'

mlba-1.9.10/src/mlba/featureSelection.py

@@ -0,0 +1,191 @@
+'''
+Utility functions for "Data Mining for Business Analytics: Concepts, Techniques, and 
+Applications in Python"
+
+(c) 2019, 2024 Galit Shmueli, Peter C. Bruce, Peter Gedeck 
+'''
+import itertools
+
+
+def exhaustive_search(variables, train_model, score_model):
+    """ Variable selection using backward elimination 
+
+    Input:
+        variables: complete list of variables to consider in model building
+        train_model: function that returns a fitted model for a given set of variables
+        score_model: function that returns the score of a model; better models have lower scores
+
+    Returns:
+        List of best subset models for increasing number of variables
+    """
+    # create models of increasing size and determine the best models in each case
+    result = []
+    for nvariables in range(1, len(variables) + 1):
+        best_subset = None
+        best_score = None
+        best_model = None
+        for subset in itertools.combinations(variables, nvariables):
+            subset = list(subset)
+            subset_model = train_model(subset)
+            subset_score = score_model(subset_model, subset)
+            if best_subset is None or best_score > subset_score:
+                best_subset = subset
+                best_score = subset_score
+                best_model = subset_model
+        result.append({
+            'n': nvariables,
+            'variables': best_subset,
+            'score': best_score,
+            'model': best_model,
+        })
+    return result
+
+
+def backward_elimination(variables, train_model, score_model, verbose=False):
+    """ Variable selection using backward elimination 
+
+    Input:
+        variables: complete list of variables to consider in model building
+        train_model: function that returns a fitted model for a given set of variables
+        score_model: function that returns the score of a model; better models have lower scores
+
+    Returns:
+        (best_model, best_variables) 
+    """
+    # we start with a model that contains all variables
+    best_variables = list(variables)
+    best_model = train_model(best_variables)
+    best_score = score_model(best_model, best_variables)
+    if verbose:
+        print('Variables: ' + ', '.join(variables))
+        print('Start: score={:.2f}'.format(best_score))
+
+    while len(best_variables) > 1:
+        step = [(best_score, None, best_model)]
+        for removeVar in best_variables:
+            step_var = list(best_variables)
+            step_var.remove(removeVar)
+            step_model = train_model(step_var)
+            step_score = score_model(step_model, step_var)
+            step.append((step_score, removeVar, step_model))
+
+        # sort by ascending score
+        step.sort(key=lambda x: x[0])
+
+        # the first entry is the model with the lowest score
+        best_score, removed_step, best_model = step[0]
+        if verbose:
+            print('Step: score={:.2f}, remove {}'.format(
+                best_score, removed_step))
+        if removed_step is None:
+            # step here, as removing more variables is detrimental to performance
+            break
+        best_variables.remove(removed_step)
+    return best_model, best_variables
+
+
+def forward_selection(variables, train_model, score_model, verbose=True):
+    """ Variable selection using forward selection 
+
+    Input:
+        variables: complete list of variables to consider in model building
+        train_model: function that returns a fitted model for a given set of variables
+        score_model: function that returns the score of a model; better models have lower scores
+
+    Returns:
+        (best_model, best_variables) 
+    """
+    # we start with a model that contains no variables
+    best_variables = []
+    best_model = train_model(best_variables)
+    best_score = score_model(best_model, best_variables)
+    if verbose:
+        print('Variables: ' + ', '.join(variables))
+        print('Start: score={:.2f}, constant'.format(best_score))
+    while True:
+        step = [(best_score, None, best_model)]
+        for addVar in variables:
+            if addVar in best_variables:
+                continue
+            step_var = list(best_variables)
+            step_var.append(addVar)
+            step_model = train_model(step_var)
+            step_score = score_model(step_model, step_var)
+            step.append((step_score, addVar, step_model))
+        step.sort(key=lambda x: x[0])
+
+        # the first entry in step is now the model that improved most
+        best_score, added_step, best_model = step[0]
+        if verbose:
+            print('Step: score={:.2f}, add {}'.format(best_score, added_step))
+        if added_step is None:
+            # stop here, as adding more variables is detrimental to performance
+            break
+        best_variables.append(added_step)
+    return best_model, best_variables
+
+
+def stepwise_selection(variables, train_model, score_model, direction='both', verbose=True):
+    """ Variable selection using forward and/or backward selection 
+
+    Input:
+        variables: complete list of variables to consider in model building
+        train_model: function that returns a fitted model for a given set of variables
+        score_model: function that returns the score of a model; better models have lower scores
+        direction: use it to limit stepwise selection to either 'forward' or 'backward'
+
+    Returns:
+        (best_model, best_variables) 
+    """
+    FORWARD = 'forward'
+    BACKWARD = 'backward'
+    directions = [FORWARD, BACKWARD]
+    if direction.lower() == FORWARD:
+        directions = [FORWARD]
+    if direction.lower() == BACKWARD:
+        directions = [BACKWARD]
+
+    # we start with a model that contains no variables
+    best_variables = [] if 'forward' in directions else list(variables)
+    best_model = train_model(best_variables)
+    best_score = score_model(best_model, best_variables)
+    if verbose:
+        print('Variables: ' + ', '.join(variables))
+        print('Start: score={:.2f}, constant'.format(best_score))
+
+    while True:
+        step = [(best_score, None, best_model, 'unchanged')]
+        if FORWARD in directions:
+            for variable in variables:
+                if variable in best_variables:
+                    continue
+                step_var = list(best_variables)
+                step_var.append(variable)
+                step_model = train_model(step_var)
+                step_score = score_model(step_model, step_var)
+                step.append((step_score, variable, step_model, 'add'))
+
+        if 'backward' in directions:
+            for variable in best_variables:
+                step_var = list(best_variables)
+                step_var.remove(variable)
+                step_model = train_model(step_var)
+                step_score = score_model(step_model, step_var)
+                step.append((step_score, variable, step_model, 'remove'))
+
+        # sort by ascending score
+        step.sort(key=lambda x: x[0])
+
+        # the first entry is the model with the lowest score
+        best_score, chosen_variable, best_model, direction = step[0]
+        if verbose:
+            print('Step: score={:.2f}, {} {}'.format(
+                best_score, direction, chosen_variable))
+        if chosen_variable is None:
+            # step here, as adding or removing more variables is detrimental to performance
+            break
+        if direction == 'add':
+            best_variables.append(chosen_variable)
+        else:
+            best_variables.remove(chosen_variable)
+    return best_model, best_variables