metacountregressor 0.1.96__tar.gz → 0.1.103__tar.gz

{metacountregressor-0.1.96 → metacountregressor-0.1.103}/PKG-INFO

@@ -1,17 +1,31 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: metacountregressor
-Version: 0.1.96
-Summary: Extensions for a Python package for estimation of count models.
+Version: 0.1.103
+Summary: Extensive Testing for Estimation of Data Count Models
 Home-page: https://github.com/zahern/CountDataEstimation
 Author: Zeke Ahern
-Author-email: zeke.ahern@hdr.qut.edu.au
-License: QUT
+Author-email: z.ahern@qut.edu.au
+License: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy>=1.13.1
 Requires-Dist: scipy>=1.0.0
 Requires-Dist: requests
+Requires-Dist: latextable
+Requires-Dist: pandas
+Requires-Dist: scikit_learn>=1.4.1.post1
+Requires-Dist: statsmodels
+Requires-Dist: psutil
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <div style="display: flex; align-items: center;">
     <img src="https://github.com/zahern/data/raw/main/m.png" alt="My Image" style="width: 100px; margin-right: 20px;">
@@ -23,10 +37,24 @@ Requires-Dist: requests
 
 The tutorial provides more extensive examples on how to run the code and perform experiments. Further documentation is currently in development.
 
-##### Quick Setup
+# For an Application Setup Download the following GUI
+[Download Application](https://github.com/zahern/MetaCount/tree/master/metacountregressor/application_gui/dist/meta_app)
+
+The application involves setting up a problem instance to run the models.
+
+### Entire [Git Repository](https://github.com/zahern/MetaCount.git) is available to clone.
+#### Steps
+1. Clone Project
+2. Navigate to "metacountregressor/application_gui/dist/meta_app"
+3. Run meta_app.exe
+4. Navigate to metacountregressor/app_main.py
+5. Run app_main.py
+
+
+## Setup For Python Package Approach
 The Below code demonstrates how to set up automatic optimization assisted by the harmony search algorithm. References to the Differential Evolution and Simulated Annealing has been mentioned (change accordingly)
 
-## Quick install: Requires Python 3.10
+## Install: Requires Python 3.10
 
 Install `metacountregressor` using pip as follows:
 

{metacountregressor-0.1.96 → metacountregressor-0.1.103}/README.rst

@@ -14,16 +14,37 @@ Notebook <https://github.com/zahern/CountDataEstimation/blob/main/Tutorial.ipynb
 The tutorial provides more extensive examples on how to run the code and
 perform experiments. Further documentation is currently in development.
 
-Quick Setup
-'''''''''''
+For an Application Setup Download the following GUI
+===================================================
+
+`Download
+Application <https://github.com/zahern/MetaCount/tree/master/metacountregressor/application_gui/dist/meta_app>`__
+
+The application involves setting up a problem instance to run the
+models.
+
+Entire `Git Repository <https://github.com/zahern/MetaCount.git>`__ is available to clone.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Steps
+^^^^^
+
+1. Clone Project
+2. Navigate to �metacountregressor/application_gui/dist/meta_app�
+3. Run meta_app.exe
+4. Navigate to metacountregressor/app_main.py
+5. Run app_main.py
+
+Setup For Python Package Approach
+---------------------------------
 
 The Below code demonstrates how to set up automatic optimization
 assisted by the harmony search algorithm. References to the Differential
 Evolution and Simulated Annealing has been mentioned (change
 accordingly)
 
-Quick install: Requires Python 3.10
------------------------------------
+Install: Requires Python 3.10
+-----------------------------
 
 Install ``metacountregressor`` using pip as follows:
 

metacountregressor-0.1.103/metacountregressor/app_main.py

@@ -0,0 +1,258 @@
+import warnings
+import argparse
+import csv
+import faulthandler
+import ast
+from typing import Any
+import cProfile
+import numpy as np
+import pandas as pd
+from pandas import DataFrame
+from pandas.io.parsers import TextFileReader
+import helperprocess
+from metaheuristics import (differential_evolution,
+                            harmony_search,
+                            simulated_annealing)
+from solution import ObjectiveFunction
+
+
+warnings.simplefilter("ignore")
+
+faulthandler.enable()
+
+
+def convert_df_columns_to_binary_and_wide(df):
+    columns = list(df.columns)
+
+    df = pd.get_dummies(df, columns=columns, drop_first=True)
+    return df
+
+
+def process_arguments():
+    '''
+    TRYING TO TURN THE CSV FILES INTO RELEVANT ARGS
+    '''
+    try:
+        data_characteristic = pd.read_csv('problem_data.csv')
+        analyst_d = pd.read_csv('decisions.csv')
+        hyper = pd.read_csv('setup_hyper.csv')
+    except Exception as e:
+        print(e)
+        print('Files Have Not Been Set Up Yet..')
+        print('Run the App')
+        exit()
+
+    new_data = {'data': data_characteristic,
+                'analyst':analyst_d,
+                'hyper': hyper}
+    return new_data
+
+def main(args, **kwargs):
+    '''METACOUNT REGRESSOR TESTING ENVIRONMENT'''
+
+
+
+
+    print('the args is:', args)
+    print('the kwargs is', kwargs)
+
+    # removing junk files if specicified
+    helperprocess.remove_files(args.get('removeFiles', True))
+
+    # do we want to run a test
+
+
+    data_info = process_arguments()
+    data_info['hyper']
+    data_info['analyst']
+    data_info['data']['Y']
+    #data_info['data']['Group'][0]
+    #data_info['data']['Panel'][0]
+    args['decisions'] = data_info['analyst']
+    grouped_c = data_info['data']['Grouped'][0]
+    if isinstance(data_info['data']['Grouped'][0],str):
+        args['group'] = data_info['data']['Grouped'][0]
+        args['ID'] = data_info['data']['Panel'][0]
+    if isinstance(data_info['data']['Panel'][0],str):
+        args['panels'] = data_info['data']['Panel'][0]
+
+    df = pd.read_csv(str(data_info['data']['Problem'][0]))
+    x_df = df.drop(columns=[data_info['data']['Y'][0]])
+    # drop the columns of x_df where column is string exclude the column stype args['group']
+    exclude_column = args['group']
+    columns_to_keep = x_df.dtypes != 'object'
+    columns_to_keep |= (x_df.columns == exclude_column)
+    x_df = x_df.loc[:, columns_to_keep]
+    y_df = df[[data_info['data']['Y'][0]]]
+    y_df.rename(columns={data_info['data']['Y'][0]: "Y"}, inplace=True)
+
+    manual_fit_spec = None #TODO add in manual fit
+    if args['Keep_Fit'] == str(2) or args['Keep_Fit'] == 2:
+        if manual_fit_spec is None:
+            args['Manual_Fit'] = None
+        else:
+            print('fitting manually')
+            args['Manual_Fit'] = manual_fit_spec
+    if args['problem_number'] == str(8) or args['problem_number'] == 8:
+        print('Maine County Dataset.')
+        args['group'] = 'county'
+        args['panels'] = 'element_ID'
+        args['ID'] = 'element_ID'
+        args['_max_characteristics'] = 55
+    elif args['problem_number'] == str(9) or args['problem_number'] == 9:
+        args['group'] = 'group'
+        args['panels'] = 'ind_id'
+        args['ID'] = 'ind_id'
+
+
+
+    args['complexity_level'] = args.get('complexity_level', 6)
+
+
+    # Initialize AnalystSpecs to None if not manually provided
+    args['AnalystSpecs'] = args.get('AnalystSpecs', None)
+
+    if args['algorithm'] == 'sa':
+        args_hyperparameters = {'alpha': float(args['temp_scale']),
+                                'STEPS_PER_TEMP': int(args['steps']),
+                                'INTL_ACPT': 0.5,
+                                '_crossover_perc': args['crossover'],
+                                'MAX_ITERATIONS': int(args['_max_imp']),
+                                '_num_intl_slns': 25,
+                                'Manual_Fit': args['Manual_Fit'],
+                                'MP': int(args['MP'])}
+        helperprocess.entries_to_remove(('crossover', '_max_imp', '_hms', '_hmcr', '_par'), args)
+        print(args)
+
+        obj_fun = ObjectiveFunction(x_df, y_df, **args)
+
+        results = simulated_annealing(obj_fun, None, **args_hyperparameters)
+
+        helperprocess.results_printer(results, args['algorithm'], int(args['is_multi']))
+
+        if args['dual_complexities']:
+            args['complexity_level'] = args['secondary_complexity']
+            obj_fun = ObjectiveFunction(x_df, y_df, **args)
+            results = simulated_annealing(obj_fun, None, **args_hyperparameters)
+            helperprocess.results_printer(results, args['algorithm'], int(args['is_multi']))
+
+    elif args['algorithm'] == 'hs':
+        args['_mpai'] = 1
+
+        obj_fun = ObjectiveFunction(x_df, y_df, **args)
+        args_hyperparameters = {
+            'Manual_Fit': args['Manual_Fit'],
+            'MP': int(args['MP'])
+        }
+
+        results = harmony_search(obj_fun, None, **args_hyperparameters)
+        helperprocess.results_printer(results, args['algorithm'], int(args['is_multi']))
+
+        if args.get('dual_complexities', 0):
+            args['complexity_level'] = args['secondary_complexity']
+            obj_fun = ObjectiveFunction(x_df, y_df, **args)
+            results = harmony_search(obj_fun, None, **args_hyperparameters)
+            helperprocess.results_printer(results, args['algorithm'], int(args['is_multi']))
+
+
+    elif args['algorithm'] == 'de':
+        # force variables
+        args['must_include'] = args.get('force', [])
+
+        args_hyperparameters = {'_AI': args.get('_AI', 2),
+                                '_crossover_perc': float(args['crossover']),
+                                '_max_iter': int(args['_max_imp'])
+            , '_pop_size': int(args['_hms']), 'instance_number': int(args['line'])
+            , 'Manual_Fit': args['Manual_Fit'],
+                                'MP': int(args['MP'])
+                                }
+
+        args_hyperparameters = dict(args_hyperparameters)
+
+        helperprocess.entries_to_remove(('crossover', '_max_imp', '_hms', '_hmcr', '_par'), args)
+        obj_fun = ObjectiveFunction(x_df, y_df, **args)
+
+        results = differential_evolution(obj_fun, None, **args_hyperparameters)
+
+        helperprocess.results_printer(results, args['algorithm'], int(args['is_multi']))
+
+        if args['dual_complexities']:
+            args['complexity_level'] = args['secondary_complexity']
+            obj_fun = ObjectiveFunction(x_df, y_df, **args)
+            results = differential_evolution(obj_fun, None, **args_hyperparameters)
+            helperprocess.results_printer(results, args['algorithm'], int(args['is_multi'])) #TODO FIX This
+
+
+if __name__ == '__main__':
+    """Loading in command line args.  """
+    alg_parser = argparse.ArgumentParser(prog='algorithm', epilog='algorithm specific arguments')
+    alg_parser.add_argument('-AI', default=2, help='adjustment index. For the allowable movement of the algorithm')
+    alg_parser.print_help()
+    parser = argparse.ArgumentParser(prog='main',
+                                     epilog=main.__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter, conflict_handler='resolve')
+
+    parser.add_argument('-line', type=int, default=1,
+                        help='line to read in csv to pass in argument')
+
+    if vars(parser.parse_args())['line'] is not None:
+        reader = csv.DictReader(open('set_data.csv', 'r'))
+        args = list()
+        line_number_obs = 0
+        for dictionary in reader:  # TODO find a way to handle multiple args
+            args = dictionary
+            if line_number_obs == int(vars(parser.parse_args())['line']):
+                break
+            line_number_obs += 1
+        args = dict(args)
+
+        for key, value in args.items():
+            try:
+                # Attempt to parse the string value to a Python literal if value is a string.
+                if isinstance(value, str):
+                    value = ast.literal_eval(value)
+            except (ValueError, SyntaxError):
+                # If there's a parsing error, value remains as the original string.
+                pass
+
+            # Add the argument to the parser with the potentially updated value.
+            parser.add_argument(f'-{key}', default=value)
+
+        for i, action in enumerate(parser._optionals._actions):
+            if "-algorithm" in action.option_strings:
+                parser._optionals._actions[i].help = "optimization algorithm"
+
+        override = True
+        if override:
+            print('todo turn off, in testing phase')
+            parser.add_argument('-problem_number', default='10')
+            print('did it make it')
+        if 'algorithm' not in args:
+            parser.add_argument('-algorithm', type=str, default='hs',
+                                help='optimization algorithm')
+        elif 'Manual_Fit' not in args:
+            parser.add_argument('-Manual_Fit', action='store_false', default=None,
+                                help='To fit a model manually if desired.')
+
+        parser.add_argument('-seperate_out_factors', action='store_false', default=False,
+                            help='Trie of wanting to split data that is potentially categorical as binary'
+                                 ' we want to split the data for processing')
+        parser.add_argument('-supply_csv', type = str, help = 'enter the name of the csv, please include it as a full directorys')
+
+    else:  # DIDN"T SPECIFY LINES TRY EACH ONE MANNUALY
+        parser.add_argument('-com', type=str, default='MetaCode',
+                            help='line to read csv')
+
+    # Check the args
+    parser.print_help()
+    args = vars(parser.parse_args())
+    print(type(args))
+    # TODO add in chi 2 and df in estimation and compare degrees of freedom this needs to be done in solution
+
+    # Print the args.
+    profiler = cProfile.Profile()
+    profiler.runcall(main,args)
+    profiler.print_stats(sort='time')
+    #TOO MAX_TIME
+
+

{metacountregressor-0.1.96 → metacountregressor-0.1.103}/metacountregressor/helperprocess.py

@@ -1,10 +1,28 @@
+from os.path import exists
 import numpy as np
 import pandas as pd
 import csv
 import matplotlib.pyplot as plt
+from scipy import stats as st
+from sklearn.preprocessing import StandardScaler
+
 
 plt.style.use('https://github.com/dhaitz/matplotlib-stylesheets/raw/master/pitayasmoothie-dark.mplstyle')
 
+
+
+
+
+from itertools import product
+
+# Function to create a list of dictionaries from a parameter grid
+def generate_param_combinations(param_grid):
+    keys = param_grid.keys()
+    values = param_grid.values()
+    combinations = [dict(zip(keys, v)) for v in product(*values)]
+    return combinations
+
+
 ##Select the best Features Based on RF
 def select_features(X_train, y_train, n_f=16):
     try:
@@ -77,6 +95,7 @@ def findCorrelation(corr, cutoff=0.9, exact=None):    """
     findCorrelation(R1, cutoff=0.6, exact=True)   # ['x1', 'x5', 'x4']
     """
 
+
 def _findCorrelation_fast(corr, avg, cutoff):
 
     combsAboveCutoff = corr.where(lambda x: (np.tril(x) == 0) & (x > cutoff)).stack().index
@@ -151,6 +170,230 @@ def remove_files(yes=1):
             os.remove('pop_log.csv')
 
 
+# Function to process the DataFrame
+'''
+Example usuage
+# Configuration dictionary
+config = {
+    'Age': {
+        'type': 'bin',
+        'bins': [0, 18, 35, 50, 100],
+        'labels': ['Child', 'YoungAdult', 'MiddleAged', 'Senior'],
+        'prefix': 'Age_Binned'
+    },
+    'Income': {
+        'type': 'bin',
+        'bins': [0, 2000, 5000, 10000],
+        'labels': ['Low', 'Medium', 'High'],
+        'prefix': 'Income_Binned'
+    },
+    'Gender': {
+        'type': 'one-hot',
+        'prefix': 'Gender'
+    },
+    'Score': {
+        'type': 'none'
+    }
+}
+'''
+def null_handler(vari):
+    if vari in locals():
+        return vari
+    else:
+        print(f'{vari} does not exist, setting None..')
+        return None
+
+
+def set_up_analyst_constraints(data_characteristic, model_terms,  variable_decisions_alt = None):
+
+
+    name_data_characteristics = data_characteristic.columns.tolist()
+    # Get non-None values as a list
+    non_none_terms = [value for value in model_terms.values() if value is not None]
+    # how to make name_data_characteristics - non_none_terms
+
+    result = [item for item in name_data_characteristics if item not in non_none_terms]
+    distu = ['normal', 'uniform', 'triangular']
+    tra = ['no', 'sqrt', 'arcsinh']
+    if model_terms.get('group') is None:
+        print('cant have grouped rpm, removing level 4 from every item')
+        MAKE_ALL_4_FALSE = True
+    else:
+        MAKE_ALL_4_FALSE = False
+
+    variable_decisions = {
+        name: {
+            'levels': list(range(6)),
+            'Distributions': distu,
+            'Transformations': tra
+        }
+        for name in result
+    }
+    # Override elements in the original dictionary with the alt dictionary
+    if variable_decisions_alt is not None:
+        for key, alt_value in variable_decisions_alt.items():
+            if key in variable_decisions:
+                # Update the existing entry
+                variable_decisions[key].update(alt_value)
+            else:
+                # Add new entry if it doesn't exist
+                variable_decisions[key] = alt_value
+    # Prepare the data for the DataFrame
+    rows = []
+    for column_name, details in variable_decisions.items():
+        # Create a row dictionary
+        row = {'Column': column_name}
+
+        # Add levels as True/False for Level 0 through Level 5
+        for level in range(6):  # Assuming Level 0 to Level 5
+
+            if level == 4 and MAKE_ALL_4_FALSE:
+                row[f'Level {level}'] = False
+            else:
+                row[f'Level {level}'] = level in details['levels']
+
+        # Add distributions and transformations directly
+
+        # Add distributions and transformations as comma-separated strings
+        row['Distributions'] = str(details['Distributions'])
+        row['Transformations'] = str(details['Transformations'])
+
+        rows.append(row)
+
+    # Create the DataFrame
+    df = pd.DataFrame(rows)
+
+    data_new = data_characteristic.rename(columns={v: k for k, v in model_terms.items() if v in data_characteristic.columns})
+    return  df, data_new
+
+# Function to guess Low, Medium, High ranges
+def guess_low_medium_high(column_name, series):
+    # Compute the tertiles (33rd and 66th percentiles)
+    #print('did it make it...')
+    #mode_value = st.mode(series)  # Get the most frequent value
+    #i dont think this works cayse its not a seriers any other way
+    is_binary = series.isin([0, 1]).all()
+    if is_binary:
+        return {
+            'type': 'binary',
+            'bins': [0,1],
+            'labels': ['Off', 'On'],
+            'prefix': f'{column_name}'
+
+        }
+
+   # series = pd.to_numeric(series, errors='coerce').fillna(mode_value)
+    low_threshold = np.quantile(series, 0.33)
+    high_threshold = np.quantile(series,0.66)
+
+    # Define the bins and labels
+    bins = [np.min(series) - 1, low_threshold, high_threshold, np.max(series)]
+    # Handle duplicate bins by adjusting labels
+    if len(set(bins)) < len(bins):  # Check for duplicate bin edges
+        if low_threshold == high_threshold:
+            # Collapse to two bins (Low and High)
+            bins = [np.min(series) - 1, low_threshold, np.max(series)]
+            labels = ['Low', 'High']
+        else:
+            # Collapse to three unique bins
+            bins = sorted(set(bins))  # Remove duplicate edges
+            labels = [f'Bin {i + 1}' for i in range(len(bins) - 1)]
+    else:
+        # Standard case: Low, Medium, High
+        labels = ['Low', 'Medium', 'High']
+
+    return {
+        'type': 'bin',
+        'bins': bins,
+        'labels': labels,
+        'prefix': f'{column_name}'
+    }
+
+def transform_dataframe(df, config):
+    output_df = pd.DataFrame()
+
+    for column, settings in config.items():
+        if settings['type'] == 'bin':
+            # Apply binning
+            # Get unique bins (remove duplicates)
+            unique_bins = sorted(set(settings['bins']))
+
+            # Adjust labels if necessary
+            if len(unique_bins) - 1 != len(settings['labels']):
+                print(f"Adjusting labels to match bins: {len(unique_bins) - 1} bins detected.")
+                labels = [f'Bin {i+1}' for i in range(len(unique_bins) - 1)]
+            else:
+                labels = settings['labels']
+
+            # Perform the binning
+            binned_d = pd.cut(
+                df[column],
+                bins=unique_bins,  # Deduplicated bins
+                labels=labels,     # Adjusted or original labels
+                right=False        # Adjust based on whether to include the right edge
+            )
+            # One-hot encode the binned column
+            binned_dummies = pd.get_dummies(binned_d, prefix=settings['prefix'])
+            output_df = pd.concat([output_df, binned_dummies], axis=1)
+
+        elif settings['type'] == 'one-hot':
+            # One-hot encode the column
+            one_hot_dummies = pd.get_dummies(df[column], prefix=settings.get('prefix', column))
+            output_df = pd.concat([output_df, one_hot_dummies], axis=1)
+
+        elif settings['type'] == 'continuous':
+            # Apply function to continuous data
+            data = df[column]
+            if 'bounds' in settings:
+                # Apply bounds filtering
+                lower, upper = settings['bounds']
+                data = data[(data >= lower) & (data <= upper)]
+            if 'apply_func' in settings:
+                # Apply custom function
+                data = data.apply(settings['apply_func'])
+            output_df[column] = data
+
+        elif settings['type'] == 'none':
+            # Leave the column unchanged
+            if column in df.columns:
+
+                output_df = pd.concat([output_df, df[[column]]], axis=1)
+            else: 
+                print(f'config variable {column} is not in the data. Ignoring ...')
+    return output_df
+
+# Helper function to guess column type and update `config`
+def guess_column_type(column_name, series):
+
+    if series.empty:
+        raise ValueError(f"The column {column_name} contains no numeric data.")
+
+    if series.dtype == 'object' or series.dtype.name == 'category':
+        # If the column is categorical (e.g., strings), assume one-hot encoding
+        return {'type': 'one-hot', 'prefix': column_name}
+    elif pd.api.types.is_numeric_dtype(series):
+        unique_values = series.nunique()
+
+        if unique_values < 5:
+            return {'type': 'one-hot', 'prefix': column_name}
+
+        elif np.max(series) - np.min(series) > 20:
+            print('made it through here')
+            # If there are few unique values, assume binning with default bins
+            return guess_low_medium_high(column_name,series)
+        else:
+           # # Otherwise, assume continuous data with normalization
+            # Otherwise, fallback to continuous standardization
+            return {
+                'type': 'continuous',
+                'apply_func': (lambda x: (x - series.mean()) / series.std())  # Z-Score Standardization
+            }
+    else:
+        # Default fallback (leave the column unchanged)
+        return {'type': 'none'}
+
+
+
 def as_wide_factor(x_df, yes=1, min_factor=2, max_factor=8, keep_original=0, exclude=[]):
     if not yes:
         return x_df
@@ -173,7 +416,7 @@ def PCA_code(X, n_components=5):
 
 
 def interactions(df, keep=None, drop_this_perc=0.6, interact = False):
-
+    full_columns = df.columns
     if interact:
         interactions_list = []
         for i, var_i in enumerate(df.columns):
@@ -199,14 +442,31 @@ def interactions(df, keep=None, drop_this_perc=0.6, interact = False):
         df = pd.concat([df, df_interactions], axis=1, sort=False)
 
     # second
-    corr_matrix = df.corr().abs()
+    # Remove `keep` columns from the correlation matrix
+    if keep is not None:
+        missing_columns = [col for col in keep if col not in df.columns]
+     
+        if missing_columns:
+            print(f"The following columns are not in the DataFrame and will be ignored: {missing_columns}")
+            keep = [col for col in keep if col not in missing_columns]
+        df_corr = df.drop(columns=keep, errors='ignore', inplace=False)  # Exclude `keep` columns
+    else:
+        df_corr = df
+
+    # Compute the absolute correlation matrix
+    corr_matrix = df_corr.corr().abs()
+
+    # Keep only the upper triangle of the correlation matrix
     upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
 
-    # Find features with correlation greater than 0.6
+    # Find features with correlation greater than the threshold
     to_drop = [column for column in upper.columns if any(upper[column] > drop_this_perc)]
+
+    # Ensure `keep` columns are not dropped
     if keep is not None:
-        to_drop = [column for column in to_drop if column not in keep]
-    # Drop features
+        to_drop = [column for column in to_drop if column not in full_columns]
+
+    # Drop the identified features
     df.drop(to_drop, axis=1, inplace=True)
 
     return df
@@ -330,3 +590,5 @@ def entries_to_remove(entries, the_dict):
     for key in entries:
         if key in the_dict:
             del the_dict[key]
+
+