metacountregressor 0.1.88__py3-none-any.whl → 0.1.89__py3-none-any.whl

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/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,220 @@ 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
+    #print('good')
+   # 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 +406,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 +432,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 +580,5 @@ def entries_to_remove(entries, the_dict):
     for key in entries:
         if key in the_dict:
             del the_dict[key]
+
+