dragon-ml-toolbox 10.1.1__py3-none-any.whl → 14.2.0__py3-none-any.whl

ml_tools/utilities.py

@@ -1,27 +1,25 @@
-import math
 import numpy as np
 import pandas as pd
 import polars as pl
 from pathlib import Path
-from typing import Literal, Union, Sequence, Optional, Any, Iterator, Tuple, overload
-import joblib
-from joblib.externals.loky.process_executor import TerminatedWorkerError
+from typing import Literal, Union, Optional, Any, Iterator, Tuple, overload
+
 from .path_manager import sanitize_filename, make_fullpath, list_csv_paths
 from ._script_info import _script_info
 from ._logger import _LOGGER
+from ._schema import FeatureSchema
 
 
 # Keep track of available tools
 __all__ = [
     "load_dataframe",
+    "load_dataframe_greedy",
+    "load_dataframe_with_schema",
     "yield_dataframes_from_dir",
     "merge_dataframes",
+    "save_dataframe_filename",
     "save_dataframe",
-    "normalize_mixed_list",
-    "threshold_binary_values",
-    "threshold_binary_values_batch",
-    "serialize_object",
-    "deserialize_object",
+    "save_dataframe_with_schema",
     "distribute_dataset_by_target",
     "train_dataset_orchestrator",
     "train_dataset_yielder"
@@ -32,6 +30,7 @@ __all__ = [
 @overload
 def load_dataframe(
     df_path: Union[str, Path], 
+    use_columns: Optional[list[str]] = None, 
     kind: Literal["pandas"] = "pandas",
     all_strings: bool = False,
     verbose: bool = True
@@ -42,7 +41,8 @@ def load_dataframe(
 @overload
 def load_dataframe(
     df_path: Union[str, Path], 
-    kind: Literal["polars"],
+    use_columns: Optional[list[str]] = None,
+    kind: Literal["polars"] = "polars",
     all_strings: bool = False,
     verbose: bool = True
 ) -> Tuple[pl.DataFrame, str]:
@@ -50,6 +50,7 @@ def load_dataframe(
 
 def load_dataframe(
     df_path: Union[str, Path], 
+    use_columns: Optional[list[str]] = None,
     kind: Literal["pandas", "polars"] = "pandas",
     all_strings: bool = False,
     verbose: bool = True
@@ -58,11 +59,13 @@ def load_dataframe(
     Load a CSV file into a DataFrame and extract its base name.
 
     Can load data as either a pandas or a polars DataFrame. Allows for loading all
-    columns as string types to prevent type inference errors.
+    columns or a subset of columns as string types to prevent type inference errors.
 
     Args:
         df_path (str, Path): 
             The path to the CSV file.
+        use_columns (list[str] | None):
+            If provided, only these columns will be loaded from the CSV.
         kind ("pandas", "polars"): 
             The type of DataFrame to load. Defaults to "pandas".
         all_strings (bool): 
@@ -76,28 +79,44 @@ def load_dataframe(
             
     Raises:
         FileNotFoundError: If the file does not exist at the given path.
-        ValueError: If the DataFrame is empty or an invalid 'kind' is provided.
+        ValueError: If the DataFrame is empty, an invalid 'kind' is provided, or a column in 'use_columns' is not found in the file.
     """
     path = make_fullpath(df_path)
     
     df_name = path.stem
 
-    if kind == "pandas":
-        if all_strings:
-            df = pd.read_csv(path, encoding='utf-8', dtype=str)
-        else:
-            df = pd.read_csv(path, encoding='utf-8')
-            
-    elif kind == "polars":
-        if all_strings:
-            df = pl.read_csv(path, infer_schema=False)
+    try:
+        if kind == "pandas":
+            pd_kwargs: dict[str,Any]
+            pd_kwargs = {'encoding': 'utf-8'}
+            if use_columns:
+                pd_kwargs['usecols'] = use_columns
+            if all_strings:
+                pd_kwargs['dtype'] = str
+                
+            df = pd.read_csv(path, **pd_kwargs)
+
+        elif kind == "polars":
+            pl_kwargs: dict[str,Any]
+            pl_kwargs = {}
+            pl_kwargs['null_values'] = ["", " "]
+            if use_columns:
+                pl_kwargs['columns'] = use_columns
+                
+            if all_strings:
+                pl_kwargs['infer_schema'] = False
+            else:
+                pl_kwargs['infer_schema_length'] = 1000
+                
+            df = pl.read_csv(path, **pl_kwargs)
+
         else:
-            # Default behavior: infer the schema.
-            df = pl.read_csv(path, infer_schema_length=1000)
+            _LOGGER.error(f"Invalid kind '{kind}'. Must be one of 'pandas' or 'polars'.")
+            raise ValueError()
             
-    else:
-        _LOGGER.error(f"Invalid kind '{kind}'. Must be one of 'pandas' or 'polars'.")
-        raise ValueError()
+    except (ValueError, pl.exceptions.ColumnNotFoundError) as e:
+        _LOGGER.error(f"Failed to load '{df_name}'. A specified column may not exist in the file.")
+        raise e
 
     # This check works for both pandas and polars DataFrames
     if df.shape[0] == 0:
@@ -110,6 +129,116 @@ def load_dataframe(
     return df, df_name # type: ignore
 
 
+def load_dataframe_greedy(directory: Union[str, Path],
+                          use_columns: Optional[list[str]] = None,
+                          all_strings: bool = False,
+                          verbose: bool = True) -> pd.DataFrame:
+    """
+    Greedily loads the first found CSV file from a directory into a Pandas DataFrame.
+
+    This function scans the specified directory for any CSV files. It will
+    attempt to load the *first* CSV file it finds using the `load_dataframe`
+    function as a Pandas DataFrame.
+
+    Args:
+        directory (str, Path): 
+            The path to the directory to search for a CSV file.
+        use_columns (list[str] | None):
+            A list of column names to load. If None, all columns are loaded.
+        all_strings (bool): 
+            If True, loads all columns as string data types.
+
+    Returns:
+        pd.DataFrame: 
+            A pandas DataFrame loaded from the first CSV file found.
+
+    Raises:
+        FileNotFoundError: 
+            If the specified directory does not exist or the CSV file path
+            found is invalid.
+        ValueError: 
+            If the loaded DataFrame is empty or `use_columns` contains
+            invalid column names.
+    """
+    # validate directory
+    dir_path = make_fullpath(directory, enforce="directory")
+    
+    # list all csv files and grab one (should be the only one)
+    csv_dict = list_csv_paths(directory=dir_path, verbose=False)
+    
+    for df_path in csv_dict.values():
+        df , _df_name = load_dataframe(df_path=df_path,
+                                    use_columns=use_columns,
+                                    kind="pandas",
+                                    all_strings=all_strings,
+                                    verbose=verbose)
+        break
+    
+    return df
+
+
+def load_dataframe_with_schema(
+    df_path: Union[str, Path], 
+    schema: "FeatureSchema",
+    all_strings: bool = False,
+) -> Tuple[pd.DataFrame, str]:
+    """
+    Loads a CSV file into a Pandas DataFrame, strictly validating its
+    feature columns against a FeatureSchema.
+
+    This function wraps `load_dataframe`. After loading, it validates
+    that the first N columns of the DataFrame (where N =
+    len(schema.feature_names)) contain *exactly* the set of features
+    specified in the schema.
+
+    - If the columns are present but out of order, they are reordered.
+    - If any required feature is missing from the first N columns, it fails.
+    - If any extra column is found within the first N columns, it fails.
+
+    Columns *after* the first N are considered target columns and are
+    logged for verification.
+
+    Args:
+        df_path (str, Path): 
+            The path to the CSV file.
+        schema (FeatureSchema): 
+            The schema object to validate against.
+        all_strings (bool): 
+            If True, loads all columns as string data types.
+
+    Returns:
+        (Tuple[pd.DataFrame, str]):
+            A tuple containing the loaded, validated (and possibly
+            reordered) pandas DataFrame and the base name of the file.
+            
+    Raises:
+        ValueError: 
+            - If the DataFrame is missing columns required by the schema
+              within its first N columns.
+            - If the DataFrame's first N columns contain unexpected
+              columns that are not in the schema.
+        FileNotFoundError: 
+            If the file does not exist at the given path.
+    """
+    # Step 1: Load the dataframe using the original function
+    try:
+        df, df_name = load_dataframe(
+            df_path=df_path, 
+            use_columns=None,  # Load all columns for validation
+            kind="pandas", 
+            all_strings=all_strings,
+            verbose=True
+        )
+    except Exception as e:
+        _LOGGER.error(f"Failed during initial load for schema validation: {e}")
+        raise e
+    
+    # Step 2: Call the helper to validate and reorder
+    df_validated = _validate_and_reorder_schema(df=df, schema=schema)
+
+    return df_validated, df_name
+
+
 def yield_dataframes_from_dir(datasets_dir: Union[str,Path], verbose: bool=True):
     """
     Iterates over all CSV files in a given directory, loading each into a Pandas DataFrame.
@@ -196,7 +325,7 @@ def merge_dataframes(
     return merged_df
 
 
-def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Union[str,Path], filename: str) -> None:
+def save_dataframe_filename(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Union[str,Path], filename: str) -> None:
     """
     Saves a pandas or polars DataFrame to a CSV file.
 
@@ -214,7 +343,7 @@ def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Union[str,Pa
         return
     
     # Create the directory if it doesn't exist
-    save_path = make_fullpath(save_dir, make=True)
+    save_path = make_fullpath(save_dir, make=True, enforce="directory")
     
     # Clean the filename
     filename = sanitize_filename(filename)
@@ -225,227 +354,91 @@ def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Union[str,Pa
         
     # --- Type-specific saving logic ---
     if isinstance(df, pd.DataFrame):
-        df.to_csv(output_path, index=False, encoding='utf-8')
+        # Transform "" to np.nan before saving
+        df_to_save = df.replace(r'^\s*$', np.nan, regex=True)
+        # Save
+        df_to_save.to_csv(output_path, index=False, encoding='utf-8')
     elif isinstance(df, pl.DataFrame):
-        df.write_csv(output_path) # Polars defaults to utf8 and no index
+        # Transform empty strings to Null
+        df_to_save = df.with_columns(
+            pl.when(pl.col(pl.Utf8).str.strip() == "")
+            .then(None)
+            .otherwise(pl.col(pl.Utf8))
+        )
+        # Save
+        df_to_save.write_csv(output_path)
     else:
         # This error handles cases where an unsupported type is passed
         _LOGGER.error(f"Unsupported DataFrame type: {type(df)}. Must be pandas or polars.")
         raise TypeError()
     
-    _LOGGER.info(f"Saved dataset: '{filename}' with shape: {df.shape}")
+    _LOGGER.info(f"Saved dataset: '{filename}' with shape: {df_to_save.shape}")
 
 
-def normalize_mixed_list(data: list, threshold: int = 2) -> list[float]:
+def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], full_path: Path):
     """
-    Normalize a mixed list of numeric values and strings casted to floats so that the sum of the values equals 1.0,
-    applying heuristic adjustments to correct for potential data entry scale mismatches.
+    Saves a DataFrame to a specified full path.
 
-    Parameters:
-        data (list): 
-            A list of values that may include strings, floats, integers, or None.
-            None values are treated as 0.0.
-        
-        threshold (int, optional): 
-            The number of log10 orders of magnitude below the median scale 
-            at which a value is considered suspect and is scaled upward accordingly. 
-            Default is 2.
-
-    Returns:
-        List[float]: A list of normalized float values summing to 1.0. 
-    
-    Notes:
-        - Zeros and None values remain zero.
-        - Input strings are automatically cast to floats if possible.
+    This function is a wrapper for `save_dataframe_filename()`. It takes a
+    single `pathlib.Path` object pointing to a `.csv` file.
 
-    Example:
-        >>> normalize_mixed_list([1, "0.01", 4, None])
-        [0.2, 0.2, 0.6, 0.0]
+    Args:
+        df (Union[pd.DataFrame, pl.DataFrame]): The pandas or polars DataFrame to save.
+        full_path (Path): The complete file path, including the filename and `.csv` extension, where the DataFrame will be saved.
     """
-    # Step 1: Convert all values to float, treat None as 0.0
-    float_list = [float(x) if x is not None else 0.0 for x in data]
-    
-    # Raise for negative values
-    if any(x < 0 for x in float_list):
-        _LOGGER.error("Negative values are not allowed in the input list.")
+    if not isinstance(full_path, Path) or not full_path.suffix.endswith(".csv"):
+        _LOGGER.error('A path object pointing to a .csv file must be provided.')
         raise ValueError()
-    
-    # Step 2: Compute log10 of non-zero values
-    nonzero = [x for x in float_list if x > 0]
-    if not nonzero:
-        return [0.0 for _ in float_list]
-    
-    log_scales = [math.log10(x) for x in nonzero]
-    log_median = np.median(log_scales)
-    
-    # Step 3: Adjust values that are much smaller than median
-    adjusted = []
-    for x in float_list:
-        if x == 0.0:
-            adjusted.append(0.0)
-        else:
-            log_x = math.log10(x)
-            if log_median - log_x > threshold:
-                scale_diff = round(log_median - log_x)
-                adjusted.append(x * (10 ** scale_diff))
-            else:
-                adjusted.append(x)
-    
-    # Step 4: Normalize to sum to 1.0
-    total = sum(adjusted)
-    if total == 0:
-        return [0.0 for _ in adjusted]
-    
-    return [x / total for x in adjusted]
-
-
-def threshold_binary_values(
-    input_array: Union[Sequence[float], np.ndarray, pd.Series, pl.Series],
-    binary_values: Optional[int] = None
-) -> Union[np.ndarray, pd.Series, pl.Series, list[float], tuple[float]]:
-    """
-    Thresholds binary features in a 1D input. The number of binary features are counted starting from the end.
-    
-    Binary elements are converted to 0 or 1 using a 0.5 threshold.
-
-    Parameters:
-        input_array: 1D sequence, NumPy array, pandas Series, or polars Series.
-        binary_values (Optional[int]) :
-            - If `None`, all values are treated as binary.
-            - If `int`, only this many last `binary_values` are thresholded.
-
-    Returns:
-        Any:
-        Same type as input
-    """
-    original_type = type(input_array)
-
-    if isinstance(input_array, pl.Series):
-        array = input_array.to_numpy()
-    elif isinstance(input_array, (pd.Series, np.ndarray)):
-        array = np.asarray(input_array)
-    elif isinstance(input_array, (list, tuple)):
-        array = np.array(input_array)
-    else:
-        _LOGGER.error("Unsupported input type")
-        raise TypeError()
-
-    array = array.flatten()
-    total = array.shape[0]
+        
+    save_dataframe_filename(df=df, 
+                            save_dir=full_path.parent,
+                            filename=full_path.name)
 
-    bin_count = total if binary_values is None else binary_values
-    if not (0 <= bin_count <= total):
-        _LOGGER.error("'binary_values' must be between 0 and the total number of elements")
-        raise ValueError()
 
-    if bin_count == 0:
-        result = array
-    else:
-        cont_part = array[:-bin_count] if bin_count < total else np.array([])
-        bin_part = (array[-bin_count:] > 0.5).astype(int)
-        result = np.concatenate([cont_part, bin_part])
-
-    if original_type is pd.Series:
-        return pd.Series(result, index=input_array.index if hasattr(input_array, 'index') else None) # type: ignore
-    elif original_type is pl.Series:
-        return pl.Series(input_array.name if hasattr(input_array, 'name') else "binary", result) # type: ignore
-    elif original_type is list:
-        return result.tolist()
-    elif original_type is tuple:
-        return tuple(result)
-    else:
-        return result
-    
-    
-def threshold_binary_values_batch(
-    input_array: np.ndarray,
-    binary_values: int
-) -> np.ndarray:
+def save_dataframe_with_schema(
+    df: pd.DataFrame, 
+    full_path: Path,
+    schema: "FeatureSchema"
+) -> None:
     """
-    Threshold the last `binary_values` columns of a 2D NumPy array to binary {0,1} using 0.5 cutoff.
+    Saves a pandas DataFrame to a CSV, strictly enforcing that the
+    first N columns match the FeatureSchema.
 
-    Parameters
-    ----------
-    input_array : np.ndarray
-        2D array with shape (batch_size, n_features).
-    binary_values : int
-        Number of binary features located at the END of each row.
-
-    Returns
-    -------
-    np.ndarray
-        Thresholded array, same shape as input.
-    """
-    if input_array.ndim != 2:
-        _LOGGER.error(f"Expected 2D array, got {input_array.ndim}D array.")
-        raise AssertionError()
-    
-    batch_size, total_features = input_array.shape
+    This function validates that the first N columns of the DataFrame
+    (where N = len(schema.feature_names)) contain *exactly* the set
+    of features specified in the schema.
     
-    if not (0 <= binary_values <= total_features):
-        _LOGGER.error("'binary_values' out of valid range.")
-        raise AssertionError()
+    - If the columns are present but out of order, they are reordered.
+    - If any required feature is missing from the first N columns, it fails.
+    - If any extra column is found within the first N columns, it fails.
 
-    if binary_values == 0:
-        return input_array.copy()
+    Columns *after* the first N are considered target columns and are
+    logged for verification.
 
-    cont_part = input_array[:, :-binary_values] if binary_values < total_features else np.empty((batch_size, 0))
-    bin_part = input_array[:, -binary_values:] > 0.5
-    bin_part = bin_part.astype(np.int32)
-
-    return np.hstack([cont_part, bin_part])
-
-
-def serialize_object(obj: Any, save_dir: Union[str,Path], filename: str, verbose: bool=True, raise_on_error: bool=False) -> None:
-    """
-    Serializes a Python object using joblib; suitable for Python built-ins, numpy, and pandas.
-
-    Parameters:
-        obj (Any) : The Python object to serialize.
-        save_dir (str | Path) : Directory path where the serialized object will be saved.
-        filename (str) : Name for the output file, extension will be appended if needed.
-    """
-    try:
-        save_path = make_fullpath(save_dir, make=True)
-        sanitized_name = sanitize_filename(filename)
-        if not sanitized_name.endswith('.joblib'):
-            sanitized_name = sanitized_name + ".joblib"
-        full_path = save_path / sanitized_name
-        joblib.dump(obj, full_path)
-    except (IOError, OSError, TypeError, TerminatedWorkerError) as e:
-        _LOGGER.error(f"Failed to serialize object of type '{type(obj)}'.")
-        if raise_on_error:
-            raise e
-        return None
-    else:
-        if verbose:
-            _LOGGER.info(f"Object of type '{type(obj)}' saved to '{full_path}'")
-        return None
-
-
-def deserialize_object(filepath: Union[str,Path], verbose: bool=True, raise_on_error: bool=True) -> Optional[Any]:
-    """
-    Loads a serialized object from a .joblib file.
-
-    Parameters:
-        filepath (str | Path): Full path to the serialized .joblib file.
+    Args:
+        df (pd.DataFrame): 
+            The DataFrame to save.
+        full_path (Path): 
+            The complete file path where the DataFrame will be saved.
+        schema (FeatureSchema): 
+            The schema object to validate against.
 
-    Returns:
-        (Any | None): The deserialized Python object, or None if loading fails.
+    Raises:
+        ValueError: 
+            - If the DataFrame is missing columns required by the schema
+              within its first N columns.
+            - If the DataFrame's first N columns contain unexpected
+              columns that are not in the schema.
     """
-    true_filepath = make_fullpath(filepath)
+    if not isinstance(full_path, Path) or not full_path.suffix.endswith(".csv"):
+        _LOGGER.error('A path object pointing to a .csv file must be provided.')
+        raise ValueError()
     
-    try:
-        obj = joblib.load(true_filepath)
-    except (IOError, OSError, EOFError, TypeError, ValueError) as e:
-        _LOGGER.error(f"Failed to deserialize object from '{true_filepath}'.")
-        if raise_on_error:
-            raise e
-        return None
-    else:
-        if verbose:
-            _LOGGER.info(f"Loaded object of type '{type(obj)}'.")
-        return obj
+    # Call the helper to validate and reorder
+    df_to_save = _validate_and_reorder_schema(df=df, schema=schema)
+    
+    # Call the original save function
+    save_dataframe(df=df_to_save, full_path=full_path)
 
 
 def distribute_dataset_by_target(
@@ -529,7 +522,7 @@ def train_dataset_orchestrator(list_of_dirs: list[Union[str,Path]],
                         filename = df_dir.name + '_' + target_name + '_' + df_name
                     else:
                         filename = target_name + '_' + df_name
-                    save_dataframe(df=df, save_dir=save_dir, filename=filename)
+                    save_dataframe_filename(df=df, save_dir=save_dir, filename=filename)
                     total_saved += 1
             except Exception as e:
                 _LOGGER.error(f"Failed to process file '{df_path}'. Reason: {e}")
@@ -560,5 +553,72 @@ def train_dataset_yielder(
         yield (df_features, df_target, feature_names, target_col)
 
 
+def _validate_and_reorder_schema(
+    df: pd.DataFrame, 
+    schema: "FeatureSchema"
+) -> pd.DataFrame:
+    """
+    Internal helper to validate and reorder a DataFrame against a schema.
+
+    Checks for missing, extra, and out-of-order feature columns
+    (the first N columns). Returns a reordered DataFrame if necessary.
+    Logs all actions.
+
+    Raises:
+        ValueError: If validation fails.
+    """
+    # Get schema and DataFrame column info
+    expected_features = list(schema.feature_names)
+    expected_set = set(expected_features)
+    n_features = len(expected_features)
+    
+    all_df_columns = df.columns.to_list()
+
+    # --- Strict Validation ---
+
+    # 0. Check if DataFrame is long enough
+    if len(all_df_columns) < n_features:
+        _LOGGER.error(f"DataFrame has only {len(all_df_columns)} columns, but schema requires {n_features} features.")
+        raise ValueError()
+    
+    df_feature_cols = all_df_columns[:n_features]
+    df_feature_set = set(df_feature_cols)
+    df_target_cols = all_df_columns[n_features:]
+
+    # 1. Check for missing features
+    missing_from_df = expected_set - df_feature_set
+    if missing_from_df:
+        _LOGGER.error(f"DataFrame's first {n_features} columns are missing required schema features: {missing_from_df}")
+        raise ValueError()
+
+    # 2. Check for extra (unexpected) features
+    extra_in_df = df_feature_set - expected_set
+    if extra_in_df:
+        _LOGGER.error(f"DataFrame's first {n_features} columns contain unexpected columns: {extra_in_df}")
+        raise ValueError()
+
+    # --- Reordering ---
+    
+    df_to_process = df
+
+    # If we pass validation, the sets are equal. Now check order.
+    if df_feature_cols == expected_features:
+        _LOGGER.info("DataFrame feature columns already match schema order.")
+    else:
+        _LOGGER.warning("DataFrame feature columns do not match schema order. Reordering...")
+        
+        # Rebuild the DataFrame with the correct feature order + target columns
+        new_order = expected_features + df_target_cols
+        df_to_process = df[new_order]
+
+    # Log the presumed target columns for user verification
+    if not df_target_cols:
+        _LOGGER.warning(f"No target columns were found after index {n_features-1}.")
+    else:
+        _LOGGER.info(f"Presumed Target Columns: {df_target_cols}")
+    
+    return df_to_process # type: ignore
+
+
 def info():
     _script_info(__all__)

dragon_ml_toolbox-10.1.1.dist-info/RECORD

@@ -1,36 +0,0 @@
-dragon_ml_toolbox-10.1.1.dist-info/licenses/LICENSE,sha256=2uUFNy7D0TLgHim1K5s3DIJ4q_KvxEXVilnU20cWliY,1066
-dragon_ml_toolbox-10.1.1.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=lY4_rJPnLnMu7YBQaY-_iz1JRDcLdQzNCyeLAF1glJY,1837
-ml_tools/ETL_cleaning.py,sha256=i-hrafaAivg8wprcCmwHA5MkXFsUmHNR9RRGbIyw4ZE,15981
-ml_tools/ETL_engineering.py,sha256=sgpIhlFIeId4eSJ-a33MnVuPNXs50msxFWa8-kw2hOI,36369
-ml_tools/GUI_tools.py,sha256=kEQWg-bog3pB5tI22gMGKWaCGHnz9TB2Lvvfhf5F2CI,45412
-ml_tools/MICE_imputation.py,sha256=kVSythWfxJFR4-2mtcYCWQaQ1Oz5yyx_SJu5gjnS7H8,11670
-ml_tools/ML_callbacks.py,sha256=JPvEw_cW5tYNJ2rMSgnNrKLuni_UrmuhDFaOw-u2SvA,13926
-ml_tools/ML_datasetmaster.py,sha256=CBZFpvm0qiY-8gP89iKTkd7jvU-rGQcJwk-_mBJmRSg,29273
-ml_tools/ML_evaluation.py,sha256=28JJ2M71p4pxniwav2Hv3b1a5dsvaoIYNLm-UJQuXvY,16002
-ml_tools/ML_evaluation_multi.py,sha256=2jTSNFCu8cz5C05EusnrDyffs59M2Fq3UXSHxo2TR1A,12515
-ml_tools/ML_inference.py,sha256=SGDPiPxs_OYDKKRZziFMyaWcC8A37c70W9t-dMP5niI,23066
-ml_tools/ML_models.py,sha256=Dl2mTMgVCtnNCSRlyqvMnInsKJVldS7vnBPimD-TnHo,27999
-ml_tools/ML_optimization.py,sha256=a2Uxe1g-y4I-gFa8ENIM8QDS-Pz3hoPRRaVXAWMbyQA,13491
-ml_tools/ML_scaler.py,sha256=O8JzHr2551zPpKRRReEIMvq0lNAAPau6hV59KUMAySg,7420
-ml_tools/ML_trainer.py,sha256=xM-o-gbPhWXm2lOVXbeaTFotgJSDRSHyE7H0-9OOij4,23712
-ml_tools/PSO_optimization.py,sha256=q0VYpssQGbPum7xdnkDXlJQKhZMYZo8acHpKhajPK3c,22954
-ml_tools/RNN_forecast.py,sha256=8rNZr-eWOBXMiDQV22e_tQTPM5LM2IFggEAa1FaoXaI,1965
-ml_tools/SQL.py,sha256=WDgdZUYuLBUpv-4Am9XjVY_Aq_jxBWdLrbcgAIEwefI,10704
-ml_tools/VIF_factor.py,sha256=MkMh_RIdsN2XUPzKNGRiEcmB17R_MmvGV4ezpL5zD2E,10403
-ml_tools/__init__.py,sha256=q0y9faQ6e17XCQ7eUiCZ1FJ4Bg5EQqLjZ9f_l5REUUY,41
-ml_tools/_logger.py,sha256=wcImAiXEZKPNcwM30qBh3t7HvoPURonJY0nrgMGF0sM,4719
-ml_tools/_script_info.py,sha256=21r83LV3RubsNZ_RTEUON6RbDf7Mh4_udweNcvdF_Fk,212
-ml_tools/custom_logger.py,sha256=ry43hk54K6xKo8jRAgq1sFxUpOA9T0LIJ7sw0so2BW0,5880
-ml_tools/data_exploration.py,sha256=hKA_3U-piJ8TtDWhzX_T2Awkg-25e0DC5E8qloqPo6w,27206
-ml_tools/ensemble_evaluation.py,sha256=xMEMfXJ5MjTkTfr1LkFOeD7iUtnVDCW3S9lm3zT-6tY,24778
-ml_tools/ensemble_inference.py,sha256=EFHnbjbu31fcVp88NBx8lWAVdu2Gpg9MY9huVZJHFfM,9350
-ml_tools/ensemble_learning.py,sha256=3s0kH4i_naj0IVl_T4knst-Hwg4TScWjEdsXX5KAi7I,21929
-ml_tools/handle_excel.py,sha256=He4UT15sCGhaG-JKfs7uYVAubxWjrqgJ6U7OhMR2fuE,14005
-ml_tools/keys.py,sha256=HtPG8-MWh89C32A7eIlfuuA-DLwkxGkoDfwR2TGN9CQ,1074
-ml_tools/optimization_tools.py,sha256=P3I6lIpvZ8Xf2kX5FvvBKBmrK2pB6idBpkTzfUJxTeE,5073
-ml_tools/path_manager.py,sha256=TJgoqMAryc5F0dal8W_zvJgE1TpOzlskIyYJk614WW4,13809
-ml_tools/utilities.py,sha256=SVMaSDigh6SUoAeig2_sXLLIj5w5mUs5KuVWpHvFDec,19816
-dragon_ml_toolbox-10.1.1.dist-info/METADATA,sha256=wJ2byoP5azuIBrLRpUUQ96DkDAQuxVtgf2lFPafBUUQ,6968
-dragon_ml_toolbox-10.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dragon_ml_toolbox-10.1.1.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
-dragon_ml_toolbox-10.1.1.dist-info/RECORD,,