ilovetools 0.1.2__tar.gz → 0.1.4__tar.gz

{ilovetools-0.1.2/ilovetools.egg-info → ilovetools-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.1.2
+Version: 0.1.4
 Summary: A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs
 Home-page: https://github.com/AliMehdi512/ilovetools
 Author: Ali Mehdi

{ilovetools-0.1.2 → ilovetools-0.1.4}/ilovetools/__init__.py

@@ -2,13 +2,14 @@
 ilovetools - A comprehensive Python utility library
 """
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 __author__ = "Ali Mehdi"
 __email__ = "ali.mehdi.dev579@gmail.com"
 
 # Import all modules for easy access
 from . import ai
 from . import data
+from . import ml
 from . import files
 from . import text
 from . import image
@@ -25,6 +26,7 @@ from . import utils
 __all__ = [
     "ai",
     "data",
+    "ml",
     "files",
     "text",
     "image",

ilovetools-0.1.4/ilovetools/data/__init__.py

@@ -0,0 +1,27 @@
+"""
+Data processing and manipulation utilities
+"""
+
+from .preprocessing import train_test_split, normalize_data, standardize_data
+from .feature_engineering import (
+    create_polynomial_features,
+    bin_numerical_feature,
+    one_hot_encode,
+    label_encode,
+    extract_datetime_features,
+    handle_missing_values,
+    create_interaction_features
+)
+
+__all__ = [
+    'train_test_split',
+    'normalize_data',
+    'standardize_data',
+    'create_polynomial_features',
+    'bin_numerical_feature',
+    'one_hot_encode',
+    'label_encode',
+    'extract_datetime_features',
+    'handle_missing_values',
+    'create_interaction_features',
+]

ilovetools-0.1.4/ilovetools/data/feature_engineering.py

@@ -0,0 +1,497 @@
+"""
+Feature engineering utilities for ML workflows
+"""
+
+from typing import List, Union, Dict, Tuple, Optional
+import numpy as np
+from datetime import datetime
+
+__all__ = [
+    'create_polynomial_features',
+    'bin_numerical_feature',
+    'one_hot_encode',
+    'label_encode',
+    'extract_datetime_features',
+    'handle_missing_values',
+    'create_interaction_features'
+]
+
+
+def create_polynomial_features(
+    data: Union[List[float], np.ndarray],
+    degree: int = 2,
+    include_bias: bool = False
+) -> List[List[float]]:
+    """
+    Create polynomial features from numerical data.
+    
+    Transforms [x] into [x, x^2, x^3, ...] to capture non-linear relationships.
+    Essential for models that need to learn curved patterns.
+    
+    Args:
+        data: List or array of numerical values
+        degree: Maximum polynomial degree. Default: 2
+        include_bias: Include bias term (column of 1s). Default: False
+    
+    Returns:
+        list: Polynomial features as list of lists
+    
+    Examples:
+        >>> from ilovetools.data import create_polynomial_features
+        
+        # Basic usage
+        >>> ages = [20, 25, 30, 35, 40]
+        >>> poly_features = create_polynomial_features(ages, degree=2)
+        >>> print(poly_features)
+        [[20, 400], [25, 625], [30, 900], [35, 1225], [40, 1600]]
+        
+        # With bias term
+        >>> poly_features = create_polynomial_features(ages, degree=2, include_bias=True)
+        >>> print(poly_features[0])
+        [1, 20, 400]
+        
+        # Degree 3
+        >>> poly_features = create_polynomial_features([2, 3, 4], degree=3)
+        >>> print(poly_features)
+        [[2, 4, 8], [3, 9, 27], [4, 16, 64]]
+        
+        # Real-world: Age features for insurance pricing
+        >>> customer_ages = [25, 35, 45, 55, 65]
+        >>> age_features = create_polynomial_features(customer_ages, degree=2)
+        # Now model can learn: premium = a*age + b*age^2
+    
+    Notes:
+        - Useful for capturing non-linear relationships
+        - Common in regression problems
+        - Be careful with high degrees (overfitting risk)
+        - Normalize features after polynomial expansion
+    """
+    if isinstance(data, np.ndarray):
+        data = data.tolist()
+    
+    result = []
+    for value in data:
+        features = []
+        if include_bias:
+            features.append(1)
+        for d in range(1, degree + 1):
+            features.append(value ** d)
+        result.append(features)
+    
+    return result
+
+
+def bin_numerical_feature(
+    data: Union[List[float], np.ndarray],
+    bins: Union[int, List[float]] = 5,
+    labels: Optional[List[str]] = None
+) -> List[Union[int, str]]:
+    """
+    Bin continuous numerical data into discrete categories.
+    
+    Converts continuous values into groups/bins. Useful for creating
+    categorical features from numerical data.
+    
+    Args:
+        data: List or array of numerical values
+        bins: Number of equal-width bins OR list of bin edges
+        labels: Optional labels for bins. If None, returns bin indices
+    
+    Returns:
+        list: Binned values (indices or labels)
+    
+    Examples:
+        >>> from ilovetools.data import bin_numerical_feature
+        
+        # Age groups
+        >>> ages = [5, 15, 25, 35, 45, 55, 65, 75]
+        >>> age_groups = bin_numerical_feature(
+        ...     ages,
+        ...     bins=[0, 18, 35, 60, 100],
+        ...     labels=["Child", "Young Adult", "Adult", "Senior"]
+        ... )
+        >>> print(age_groups)
+        ['Child', 'Child', 'Young Adult', 'Adult', 'Adult', 'Senior', 'Senior', 'Senior']
+        
+        # Income brackets
+        >>> incomes = [25000, 45000, 65000, 85000, 120000]
+        >>> income_brackets = bin_numerical_feature(
+        ...     incomes,
+        ...     bins=[0, 40000, 80000, 150000],
+        ...     labels=["Low", "Medium", "High"]
+        ... )
+        
+        # Equal-width bins
+        >>> scores = [45, 67, 89, 92, 78, 56, 34, 88]
+        >>> score_bins = bin_numerical_feature(scores, bins=3)
+        >>> print(score_bins)
+        [0, 1, 2, 2, 2, 1, 0, 2]
+    
+    Notes:
+        - Useful for creating categorical features
+        - Helps models learn threshold effects
+        - Can reduce noise in continuous data
+        - Choose bins based on domain knowledge
+    """
+    if isinstance(data, np.ndarray):
+        data = data.tolist()
+    
+    if isinstance(bins, int):
+        # Create equal-width bins
+        min_val = min(data)
+        max_val = max(data)
+        bin_width = (max_val - min_val) / bins
+        bin_edges = [min_val + i * bin_width for i in range(bins + 1)]
+        bin_edges[-1] += 0.001  # Ensure max value is included
+    else:
+        bin_edges = bins
+    
+    result = []
+    for value in data:
+        bin_idx = 0
+        for i in range(len(bin_edges) - 1):
+            if bin_edges[i] <= value < bin_edges[i + 1]:
+                bin_idx = i
+                break
+        
+        if labels:
+            result.append(labels[bin_idx])
+        else:
+            result.append(bin_idx)
+    
+    return result
+
+
+def one_hot_encode(
+    data: List[str],
+    categories: Optional[List[str]] = None
+) -> Dict[str, List[int]]:
+    """
+    One-hot encode categorical data.
+    
+    Converts categories into binary columns. Each category becomes
+    a separate binary feature.
+    
+    Args:
+        data: List of categorical values
+        categories: Optional list of all possible categories
+    
+    Returns:
+        dict: Dictionary with category names as keys, binary lists as values
+    
+    Examples:
+        >>> from ilovetools.data import one_hot_encode
+        
+        # Basic encoding
+        >>> colors = ["Red", "Blue", "Green", "Red", "Blue"]
+        >>> encoded = one_hot_encode(colors)
+        >>> print(encoded)
+        {'Red': [1, 0, 0, 1, 0], 'Blue': [0, 1, 0, 0, 1], 'Green': [0, 0, 1, 0, 0]}
+        
+        # With predefined categories
+        >>> sizes = ["S", "M", "L", "M"]
+        >>> encoded = one_hot_encode(sizes, categories=["XS", "S", "M", "L", "XL"])
+        
+        # Real-world: Product categories
+        >>> products = ["Electronics", "Clothing", "Electronics", "Food"]
+        >>> encoded = one_hot_encode(products)
+        # Use in ML: Each category becomes a feature
+    
+    Notes:
+        - Standard encoding for categorical features
+        - Creates sparse features (mostly zeros)
+        - Number of features = number of categories
+        - Use for nominal categories (no order)
+    """
+    if categories is None:
+        categories = sorted(list(set(data)))
+    
+    result = {cat: [] for cat in categories}
+    
+    for value in data:
+        for cat in categories:
+            result[cat].append(1 if value == cat else 0)
+    
+    return result
+
+
+def label_encode(data: List[str]) -> Tuple[List[int], Dict[str, int]]:
+    """
+    Label encode categorical data to integers.
+    
+    Converts categories to integer labels. Useful for ordinal categories
+    or when one-hot encoding creates too many features.
+    
+    Args:
+        data: List of categorical values
+    
+    Returns:
+        tuple: (encoded_data, label_mapping)
+    
+    Examples:
+        >>> from ilovetools.data import label_encode
+        
+        # Basic encoding
+        >>> sizes = ["Small", "Large", "Medium", "Small", "Large"]
+        >>> encoded, mapping = label_encode(sizes)
+        >>> print(encoded)
+        [2, 0, 1, 2, 0]
+        >>> print(mapping)
+        {'Large': 0, 'Medium': 1, 'Small': 2}
+        
+        # Education levels (ordinal)
+        >>> education = ["High School", "Bachelor", "Master", "Bachelor"]
+        >>> encoded, mapping = label_encode(education)
+        
+        # Decode back
+        >>> reverse_mapping = {v: k for k, v in mapping.items()}
+        >>> original = [reverse_mapping[code] for code in encoded]
+    
+    Notes:
+        - More memory efficient than one-hot encoding
+        - Use for ordinal categories (has order)
+        - Model may assume order exists
+        - Returns mapping for decoding
+    """
+    unique_values = sorted(list(set(data)))
+    mapping = {val: idx for idx, val in enumerate(unique_values)}
+    encoded = [mapping[val] for val in data]
+    
+    return encoded, mapping
+
+
+def extract_datetime_features(
+    timestamps: List[str],
+    format: str = "%Y-%m-%d %H:%M:%S"
+) -> Dict[str, List[int]]:
+    """
+    Extract useful features from datetime strings.
+    
+    Converts timestamps into multiple temporal features like hour,
+    day of week, month, etc. Essential for time-series ML.
+    
+    Args:
+        timestamps: List of datetime strings
+        format: Datetime format string. Default: "%Y-%m-%d %H:%M:%S"
+    
+    Returns:
+        dict: Dictionary with feature names and values
+    
+    Examples:
+        >>> from ilovetools.data import extract_datetime_features
+        
+        # Basic usage
+        >>> dates = [
+        ...     "2024-03-15 14:30:00",
+        ...     "2024-03-16 09:15:00",
+        ...     "2024-03-17 18:45:00"
+        ... ]
+        >>> features = extract_datetime_features(dates)
+        >>> print(features.keys())
+        dict_keys(['year', 'month', 'day', 'hour', 'minute', 'day_of_week', 'is_weekend'])
+        
+        # E-commerce: Purchase patterns
+        >>> purchase_times = ["2024-12-25 10:30:00", "2024-12-26 15:45:00"]
+        >>> features = extract_datetime_features(purchase_times)
+        >>> print(features['is_weekend'])
+        [0, 0]
+        >>> print(features['hour'])
+        [10, 15]
+        
+        # Different format
+        >>> dates = ["15/03/2024", "16/03/2024"]
+        >>> features = extract_datetime_features(dates, format="%d/%m/%Y")
+    
+    Notes:
+        - Captures temporal patterns
+        - Essential for time-series forecasting
+        - Helps model learn seasonality
+        - Common features: hour, day, month, is_weekend
+    """
+    result = {
+        'year': [],
+        'month': [],
+        'day': [],
+        'hour': [],
+        'minute': [],
+        'day_of_week': [],  # 0=Monday, 6=Sunday
+        'is_weekend': []
+    }
+    
+    for ts in timestamps:
+        dt = datetime.strptime(ts, format)
+        result['year'].append(dt.year)
+        result['month'].append(dt.month)
+        result['day'].append(dt.day)
+        result['hour'].append(dt.hour)
+        result['minute'].append(dt.minute)
+        result['day_of_week'].append(dt.weekday())
+        result['is_weekend'].append(1 if dt.weekday() >= 5 else 0)
+    
+    return result
+
+
+def handle_missing_values(
+    data: List[Optional[float]],
+    strategy: str = "mean"
+) -> List[float]:
+    """
+    Handle missing values in numerical data.
+    
+    Fills None/NaN values using various strategies. Essential
+    preprocessing step for ML models.
+    
+    Args:
+        data: List with potential None values
+        strategy: Fill strategy - "mean", "median", "mode", "forward", "backward", "zero"
+    
+    Returns:
+        list: Data with missing values filled
+    
+    Examples:
+        >>> from ilovetools.data import handle_missing_values
+        
+        # Mean imputation
+        >>> data = [1.0, 2.0, None, 4.0, 5.0]
+        >>> filled = handle_missing_values(data, strategy="mean")
+        >>> print(filled)
+        [1.0, 2.0, 3.0, 4.0, 5.0]
+        
+        # Median imputation
+        >>> data = [1.0, 2.0, None, 100.0]
+        >>> filled = handle_missing_values(data, strategy="median")
+        
+        # Forward fill
+        >>> data = [1.0, None, None, 4.0]
+        >>> filled = handle_missing_values(data, strategy="forward")
+        >>> print(filled)
+        [1.0, 1.0, 1.0, 4.0]
+        
+        # Zero fill
+        >>> data = [1.0, None, 3.0]
+        >>> filled = handle_missing_values(data, strategy="zero")
+        >>> print(filled)
+        [1.0, 0.0, 3.0]
+    
+    Notes:
+        - Most ML models can't handle missing values
+        - Choose strategy based on data distribution
+        - Mean: Sensitive to outliers
+        - Median: Robust to outliers
+        - Forward/Backward: For time-series data
+    """
+    valid_values = [x for x in data if x is not None]
+    
+    if not valid_values:
+        return [0.0] * len(data)
+    
+    if strategy == "mean":
+        fill_value = sum(valid_values) / len(valid_values)
+    elif strategy == "median":
+        sorted_vals = sorted(valid_values)
+        n = len(sorted_vals)
+        fill_value = sorted_vals[n // 2] if n % 2 else (sorted_vals[n // 2 - 1] + sorted_vals[n // 2]) / 2
+    elif strategy == "mode":
+        fill_value = max(set(valid_values), key=valid_values.count)
+    elif strategy == "zero":
+        fill_value = 0.0
+    else:
+        fill_value = sum(valid_values) / len(valid_values)
+    
+    result = []
+    last_valid = fill_value
+    
+    for value in data:
+        if value is None:
+            if strategy == "forward":
+                result.append(last_valid)
+            else:
+                result.append(fill_value)
+        else:
+            result.append(value)
+            last_valid = value
+    
+    # Backward fill if needed
+    if strategy == "backward":
+        result_reversed = []
+        last_valid = fill_value
+        for value in reversed(result):
+            if value is None:
+                result_reversed.append(last_valid)
+            else:
+                result_reversed.append(value)
+                last_valid = value
+        result = list(reversed(result_reversed))
+    
+    return result
+
+
+def create_interaction_features(
+    feature1: Union[List[float], np.ndarray],
+    feature2: Union[List[float], np.ndarray],
+    operation: str = "multiply"
+) -> List[float]:
+    """
+    Create interaction features between two features.
+    
+    Combines two features to capture their joint effect. Useful when
+    features interact in meaningful ways.
+    
+    Args:
+        feature1: First feature
+        feature2: Second feature
+        operation: "multiply", "add", "subtract", "divide"
+    
+    Returns:
+        list: Interaction feature values
+    
+    Examples:
+        >>> from ilovetools.data import create_interaction_features
+        
+        # Multiply interaction
+        >>> height = [170, 180, 160, 175]
+        >>> weight = [70, 85, 60, 80]
+        >>> bmi_proxy = create_interaction_features(height, weight, "multiply")
+        
+        # Real-world: Price per square foot
+        >>> prices = [300000, 450000, 250000]
+        >>> sqft = [1500, 2000, 1200]
+        >>> price_per_sqft = create_interaction_features(prices, sqft, "divide")
+        >>> print(price_per_sqft)
+        [200.0, 225.0, 208.33]
+        
+        # Add interaction
+        >>> feature1 = [1, 2, 3]
+        >>> feature2 = [4, 5, 6]
+        >>> combined = create_interaction_features(feature1, feature2, "add")
+        >>> print(combined)
+        [5, 7, 9]
+    
+    Notes:
+        - Captures feature interactions
+        - Common in real estate (price * sqft)
+        - Useful in e-commerce (quantity * price)
+        - Can significantly improve model performance
+    """
+    if isinstance(feature1, np.ndarray):
+        feature1 = feature1.tolist()
+    if isinstance(feature2, np.ndarray):
+        feature2 = feature2.tolist()
+    
+    if len(feature1) != len(feature2):
+        raise ValueError("Features must have same length")
+    
+    result = []
+    for v1, v2 in zip(feature1, feature2):
+        if operation == "multiply":
+            result.append(v1 * v2)
+        elif operation == "add":
+            result.append(v1 + v2)
+        elif operation == "subtract":
+            result.append(v1 - v2)
+        elif operation == "divide":
+            result.append(v1 / v2 if v2 != 0 else 0.0)
+        else:
+            result.append(v1 * v2)
+    
+    return result

ilovetools-0.1.4/ilovetools/ml/__init__.py

@@ -0,0 +1,31 @@
+"""
+Machine Learning utilities module
+"""
+
+from .metrics import (
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score,
+    confusion_matrix,
+    classification_report,
+    mean_squared_error,
+    mean_absolute_error,
+    root_mean_squared_error,
+    r2_score,
+    roc_auc_score
+)
+
+__all__ = [
+    'accuracy_score',
+    'precision_score',
+    'recall_score',
+    'f1_score',
+    'confusion_matrix',
+    'classification_report',
+    'mean_squared_error',
+    'mean_absolute_error',
+    'root_mean_squared_error',
+    'r2_score',
+    'roc_auc_score',
+]

ilovetools-0.1.4/ilovetools/ml/metrics.py

@@ -0,0 +1,589 @@
+"""
+Model evaluation metrics for ML workflows
+"""
+
+from typing import List, Tuple, Dict, Union, Optional
+import numpy as np
+
+__all__ = [
+    'accuracy_score',
+    'precision_score',
+    'recall_score',
+    'f1_score',
+    'confusion_matrix',
+    'classification_report',
+    'mean_squared_error',
+    'mean_absolute_error',
+    'root_mean_squared_error',
+    'r2_score',
+    'roc_auc_score'
+]
+
+
+def accuracy_score(y_true: List, y_pred: List) -> float:
+    """
+    Calculate accuracy score for classification.
+    
+    Accuracy = (Correct Predictions) / (Total Predictions)
+    
+    Args:
+        y_true: True labels
+        y_pred: Predicted labels
+    
+    Returns:
+        float: Accuracy score (0.0 to 1.0)
+    
+    Examples:
+        >>> from ilovetools.ml import accuracy_score
+        
+        # Perfect predictions
+        >>> y_true = [1, 0, 1, 1, 0]
+        >>> y_pred = [1, 0, 1, 1, 0]
+        >>> accuracy_score(y_true, y_pred)
+        1.0
+        
+        # 80% accuracy
+        >>> y_true = [1, 0, 1, 1, 0]
+        >>> y_pred = [1, 0, 1, 0, 0]
+        >>> accuracy_score(y_true, y_pred)
+        0.8
+        
+        # Real-world: Email spam detection
+        >>> actual = [1, 1, 0, 0, 1, 0, 1, 0]
+        >>> predicted = [1, 0, 0, 0, 1, 0, 1, 1]
+        >>> acc = accuracy_score(actual, predicted)
+        >>> print(f"Model accuracy: {acc:.2%}")
+        Model accuracy: 75.00%
+    
+    Notes:
+        - Use for balanced datasets
+        - Don't use for imbalanced datasets
+        - Range: 0.0 (worst) to 1.0 (best)
+        - Simple and intuitive metric
+    """
+    if len(y_true) != len(y_pred):
+        raise ValueError("y_true and y_pred must have same length")
+    
+    correct = sum(1 for true, pred in zip(y_true, y_pred) if true == pred)
+    return correct / len(y_true)
+
+
+def precision_score(y_true: List, y_pred: List, positive_label: int = 1) -> float:
+    """
+    Calculate precision score for binary classification.
+    
+    Precision = TP / (TP + FP)
+    "Of all positive predictions, how many were correct?"
+    
+    Args:
+        y_true: True labels
+        y_pred: Predicted labels
+        positive_label: Label considered as positive class. Default: 1
+    
+    Returns:
+        float: Precision score (0.0 to 1.0)
+    
+    Examples:
+        >>> from ilovetools.ml import precision_score
+        
+        # High precision (few false positives)
+        >>> y_true = [1, 0, 1, 1, 0, 0, 1, 0]
+        >>> y_pred = [1, 0, 1, 1, 0, 0, 0, 0]
+        >>> precision_score(y_true, y_pred)
+        1.0
+        
+        # Lower precision (some false positives)
+        >>> y_true = [1, 0, 1, 1, 0]
+        >>> y_pred = [1, 1, 1, 1, 0]
+        >>> precision_score(y_true, y_pred)
+        0.75
+        
+        # Spam detection (don't mark important emails as spam)
+        >>> actual_spam = [1, 1, 0, 0, 1, 0, 1, 0]
+        >>> predicted_spam = [1, 1, 1, 0, 1, 0, 1, 0]
+        >>> prec = precision_score(actual_spam, predicted_spam)
+        >>> print(f"Precision: {prec:.2%}")
+        Precision: 80.00%
+    
+    Notes:
+        - Use when false positives are costly
+        - High precision = Few false alarms
+        - Example: Spam detection, fraud detection
+        - Returns 0.0 if no positive predictions
+    """
+    if len(y_true) != len(y_pred):
+        raise ValueError("y_true and y_pred must have same length")
+    
+    tp = sum(1 for true, pred in zip(y_true, y_pred) 
+             if true == positive_label and pred == positive_label)
+    fp = sum(1 for true, pred in zip(y_true, y_pred) 
+             if true != positive_label and pred == positive_label)
+    
+    if tp + fp == 0:
+        return 0.0
+    
+    return tp / (tp + fp)
+
+
+def recall_score(y_true: List, y_pred: List, positive_label: int = 1) -> float:
+    """
+    Calculate recall score (sensitivity) for binary classification.
+    
+    Recall = TP / (TP + FN)
+    "Of all actual positives, how many did we catch?"
+    
+    Args:
+        y_true: True labels
+        y_pred: Predicted labels
+        positive_label: Label considered as positive class. Default: 1
+    
+    Returns:
+        float: Recall score (0.0 to 1.0)
+    
+    Examples:
+        >>> from ilovetools.ml import recall_score
+        
+        # High recall (caught most positives)
+        >>> y_true = [1, 0, 1, 1, 0, 0, 1, 0]
+        >>> y_pred = [1, 1, 1, 1, 0, 0, 1, 0]
+        >>> recall_score(y_true, y_pred)
+        1.0
+        
+        # Lower recall (missed some positives)
+        >>> y_true = [1, 0, 1, 1, 0]
+        >>> y_pred = [1, 0, 0, 1, 0]
+        >>> recall_score(y_true, y_pred)
+        0.6666666666666666
+        
+        # Cancer detection (don't miss any cases)
+        >>> actual_cancer = [1, 1, 0, 0, 1, 0, 1, 0]
+        >>> predicted_cancer = [1, 1, 0, 1, 1, 0, 0, 0]
+        >>> rec = recall_score(actual_cancer, predicted_cancer)
+        >>> print(f"Recall: {rec:.2%}")
+        Recall: 75.00%
+    
+    Notes:
+        - Use when false negatives are costly
+        - High recall = Few missed cases
+        - Example: Disease detection, fraud detection
+        - Returns 0.0 if no actual positives
+    """
+    if len(y_true) != len(y_pred):
+        raise ValueError("y_true and y_pred must have same length")
+    
+    tp = sum(1 for true, pred in zip(y_true, y_pred) 
+             if true == positive_label and pred == positive_label)
+    fn = sum(1 for true, pred in zip(y_true, y_pred) 
+             if true == positive_label and pred != positive_label)
+    
+    if tp + fn == 0:
+        return 0.0
+    
+    return tp / (tp + fn)
+
+
+def f1_score(y_true: List, y_pred: List, positive_label: int = 1) -> float:
+    """
+    Calculate F1 score (harmonic mean of precision and recall).
+    
+    F1 = 2 * (Precision * Recall) / (Precision + Recall)
+    
+    Args:
+        y_true: True labels
+        y_pred: Predicted labels
+        positive_label: Label considered as positive class. Default: 1
+    
+    Returns:
+        float: F1 score (0.0 to 1.0)
+    
+    Examples:
+        >>> from ilovetools.ml import f1_score
+        
+        # Balanced precision and recall
+        >>> y_true = [1, 0, 1, 1, 0, 0, 1, 0]
+        >>> y_pred = [1, 0, 1, 1, 0, 0, 1, 1]
+        >>> f1_score(y_true, y_pred)
+        0.8888888888888888
+        
+        # Imbalanced dataset
+        >>> y_true = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        >>> y_pred = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        >>> f1 = f1_score(y_true, y_pred)
+        >>> print(f"F1 Score: {f1:.2%}")
+        F1 Score: 100.00%
+    
+    Notes:
+        - Best metric for imbalanced datasets
+        - Balances precision and recall
+        - Range: 0.0 (worst) to 1.0 (best)
+        - Use when both false positives and negatives matter
+    """
+    precision = precision_score(y_true, y_pred, positive_label)
+    recall = recall_score(y_true, y_pred, positive_label)
+    
+    if precision + recall == 0:
+        return 0.0
+    
+    return 2 * (precision * recall) / (precision + recall)
+
+
+def confusion_matrix(y_true: List, y_pred: List) -> List[List[int]]:
+    """
+    Calculate confusion matrix for binary classification.
+    
+    Returns 2x2 matrix:
+    [[TN, FP],
+     [FN, TP]]
+    
+    Args:
+        y_true: True labels
+        y_pred: Predicted labels
+    
+    Returns:
+        list: 2x2 confusion matrix
+    
+    Examples:
+        >>> from ilovetools.ml import confusion_matrix
+        
+        # Perfect predictions
+        >>> y_true = [1, 0, 1, 1, 0]
+        >>> y_pred = [1, 0, 1, 1, 0]
+        >>> cm = confusion_matrix(y_true, y_pred)
+        >>> print(cm)
+        [[2, 0], [0, 3]]
+        
+        # With errors
+        >>> y_true = [1, 0, 1, 1, 0, 0, 1, 0]
+        >>> y_pred = [1, 0, 1, 0, 0, 1, 1, 0]
+        >>> cm = confusion_matrix(y_true, y_pred)
+        >>> print(cm)
+        [[3, 1], [1, 3]]
+        
+        # Interpret results
+        >>> tn, fp, fn, tp = cm[0][0], cm[0][1], cm[1][0], cm[1][1]
+        >>> print(f"True Negatives: {tn}")
+        >>> print(f"False Positives: {fp}")
+        >>> print(f"False Negatives: {fn}")
+        >>> print(f"True Positives: {tp}")
+    
+    Notes:
+        - Foundation of classification metrics
+        - Shows all types of errors
+        - Format: [[TN, FP], [FN, TP]]
+        - Use to understand model behavior
+    """
+    if len(y_true) != len(y_pred):
+        raise ValueError("y_true and y_pred must have same length")
+    
+    tn = sum(1 for true, pred in zip(y_true, y_pred) if true == 0 and pred == 0)
+    fp = sum(1 for true, pred in zip(y_true, y_pred) if true == 0 and pred == 1)
+    fn = sum(1 for true, pred in zip(y_true, y_pred) if true == 1 and pred == 0)
+    tp = sum(1 for true, pred in zip(y_true, y_pred) if true == 1 and pred == 1)
+    
+    return [[tn, fp], [fn, tp]]
+
+
+def classification_report(y_true: List, y_pred: List) -> Dict[str, float]:
+    """
+    Generate comprehensive classification report.
+    
+    Returns accuracy, precision, recall, and F1 score.
+    
+    Args:
+        y_true: True labels
+        y_pred: Predicted labels
+    
+    Returns:
+        dict: Dictionary with all metrics
+    
+    Examples:
+        >>> from ilovetools.ml import classification_report
+        
+        >>> y_true = [1, 0, 1, 1, 0, 0, 1, 0]
+        >>> y_pred = [1, 0, 1, 0, 0, 1, 1, 0]
+        >>> report = classification_report(y_true, y_pred)
+        >>> print(report)
+        {'accuracy': 0.75, 'precision': 0.75, 'recall': 0.75, 'f1_score': 0.75}
+        
+        # Pretty print
+        >>> for metric, value in report.items():
+        ...     print(f"{metric}: {value:.2%}")
+        accuracy: 75.00%
+        precision: 75.00%
+        recall: 75.00%
+        f1_score: 75.00%
+    
+    Notes:
+        - Comprehensive overview of model performance
+        - All metrics in one call
+        - Easy to compare models
+        - Returns dictionary for flexibility
+    """
+    return {
+        'accuracy': accuracy_score(y_true, y_pred),
+        'precision': precision_score(y_true, y_pred),
+        'recall': recall_score(y_true, y_pred),
+        'f1_score': f1_score(y_true, y_pred)
+    }
+
+
+def mean_squared_error(y_true: List[float], y_pred: List[float]) -> float:
+    """
+    Calculate Mean Squared Error for regression.
+    
+    MSE = Average of (actual - predicted)^2
+    
+    Args:
+        y_true: True values
+        y_pred: Predicted values
+    
+    Returns:
+        float: MSE value
+    
+    Examples:
+        >>> from ilovetools.ml import mean_squared_error
+        
+        # Perfect predictions
+        >>> y_true = [1.0, 2.0, 3.0, 4.0]
+        >>> y_pred = [1.0, 2.0, 3.0, 4.0]
+        >>> mean_squared_error(y_true, y_pred)
+        0.0
+        
+        # With errors
+        >>> y_true = [100, 200, 300, 400]
+        >>> y_pred = [110, 190, 310, 390]
+        >>> mse = mean_squared_error(y_true, y_pred)
+        >>> print(f"MSE: {mse:.2f}")
+        MSE: 100.00
+        
+        # House price prediction
+        >>> actual_prices = [250000, 300000, 350000]
+        >>> predicted_prices = [245000, 310000, 340000]
+        >>> mse = mean_squared_error(actual_prices, predicted_prices)
+    
+    Notes:
+        - Penalizes large errors heavily
+        - Not in original units (squared)
+        - Sensitive to outliers
+        - Lower is better
+    """
+    if len(y_true) != len(y_pred):
+        raise ValueError("y_true and y_pred must have same length")
+    
+    squared_errors = [(true - pred) ** 2 for true, pred in zip(y_true, y_pred)]
+    return sum(squared_errors) / len(squared_errors)
+
+
+def mean_absolute_error(y_true: List[float], y_pred: List[float]) -> float:
+    """
+    Calculate Mean Absolute Error for regression.
+    
+    MAE = Average of |actual - predicted|
+    
+    Args:
+        y_true: True values
+        y_pred: Predicted values
+    
+    Returns:
+        float: MAE value
+    
+    Examples:
+        >>> from ilovetools.ml import mean_absolute_error
+        
+        # Perfect predictions
+        >>> y_true = [1.0, 2.0, 3.0, 4.0]
+        >>> y_pred = [1.0, 2.0, 3.0, 4.0]
+        >>> mean_absolute_error(y_true, y_pred)
+        0.0
+        
+        # With errors
+        >>> y_true = [100, 200, 300, 400]
+        >>> y_pred = [110, 190, 310, 390]
+        >>> mae = mean_absolute_error(y_true, y_pred)
+        >>> print(f"MAE: ${mae:.2f}")
+        MAE: $10.00
+        
+        # House price prediction
+        >>> actual_prices = [250000, 300000, 350000]
+        >>> predicted_prices = [245000, 310000, 340000]
+        >>> mae = mean_absolute_error(actual_prices, predicted_prices)
+        >>> print(f"Average error: ${mae:,.0f}")
+        Average error: $8,333
+    
+    Notes:
+        - Easy to interpret
+        - Same units as target variable
+        - Less sensitive to outliers than MSE
+        - Lower is better
+    """
+    if len(y_true) != len(y_pred):
+        raise ValueError("y_true and y_pred must have same length")
+    
+    absolute_errors = [abs(true - pred) for true, pred in zip(y_true, y_pred)]
+    return sum(absolute_errors) / len(absolute_errors)
+
+
+def root_mean_squared_error(y_true: List[float], y_pred: List[float]) -> float:
+    """
+    Calculate Root Mean Squared Error for regression.
+    
+    RMSE = sqrt(MSE)
+    
+    Args:
+        y_true: True values
+        y_pred: Predicted values
+    
+    Returns:
+        float: RMSE value
+    
+    Examples:
+        >>> from ilovetools.ml import root_mean_squared_error
+        
+        # Perfect predictions
+        >>> y_true = [1.0, 2.0, 3.0, 4.0]
+        >>> y_pred = [1.0, 2.0, 3.0, 4.0]
+        >>> root_mean_squared_error(y_true, y_pred)
+        0.0
+        
+        # With errors
+        >>> y_true = [100, 200, 300, 400]
+        >>> y_pred = [110, 190, 310, 390]
+        >>> rmse = root_mean_squared_error(y_true, y_pred)
+        >>> print(f"RMSE: {rmse:.2f}")
+        RMSE: 10.00
+        
+        # House price prediction
+        >>> actual_prices = [250000, 300000, 350000]
+        >>> predicted_prices = [245000, 310000, 340000]
+        >>> rmse = root_mean_squared_error(actual_prices, predicted_prices)
+        >>> print(f"RMSE: ${rmse:,.0f}")
+        RMSE: $8,165
+    
+    Notes:
+        - Most common regression metric
+        - Same units as target variable
+        - Penalizes large errors
+        - Lower is better
+    """
+    mse = mean_squared_error(y_true, y_pred)
+    return mse ** 0.5
+
+
+def r2_score(y_true: List[float], y_pred: List[float]) -> float:
+    """
+    Calculate R-squared (coefficient of determination) for regression.
+    
+    R² = 1 - (SS_res / SS_tot)
+    Proportion of variance explained by the model.
+    
+    Args:
+        y_true: True values
+        y_pred: Predicted values
+    
+    Returns:
+        float: R² value (-inf to 1.0, higher is better)
+    
+    Examples:
+        >>> from ilovetools.ml import r2_score
+        
+        # Perfect predictions
+        >>> y_true = [1.0, 2.0, 3.0, 4.0]
+        >>> y_pred = [1.0, 2.0, 3.0, 4.0]
+        >>> r2_score(y_true, y_pred)
+        1.0
+        
+        # Good predictions
+        >>> y_true = [100, 200, 300, 400, 500]
+        >>> y_pred = [110, 190, 310, 390, 510]
+        >>> r2 = r2_score(y_true, y_pred)
+        >>> print(f"R²: {r2:.2%}")
+        R²: 99.00%
+        
+        # Interpretation
+        >>> r2 = 0.85
+        >>> print(f"Model explains {r2:.0%} of variance")
+        Model explains 85% of variance
+    
+    Notes:
+        - Range: -inf to 1.0 (1.0 is perfect)
+        - 0.0 = Model as good as mean baseline
+        - Negative = Model worse than mean
+        - Easy to interpret as percentage
+    """
+    if len(y_true) != len(y_pred):
+        raise ValueError("y_true and y_pred must have same length")
+    
+    mean_true = sum(y_true) / len(y_true)
+    
+    ss_tot = sum((true - mean_true) ** 2 for true in y_true)
+    ss_res = sum((true - pred) ** 2 for true, pred in zip(y_true, y_pred))
+    
+    if ss_tot == 0:
+        return 0.0
+    
+    return 1 - (ss_res / ss_tot)
+
+
+def roc_auc_score(y_true: List[int], y_scores: List[float]) -> float:
+    """
+    Calculate ROC AUC score for binary classification.
+    
+    AUC = Area Under the ROC Curve
+    Measures model's ability to distinguish between classes.
+    
+    Args:
+        y_true: True binary labels (0 or 1)
+        y_scores: Predicted probabilities or scores
+    
+    Returns:
+        float: AUC score (0.0 to 1.0)
+    
+    Examples:
+        >>> from ilovetools.ml import roc_auc_score
+        
+        # Perfect separation
+        >>> y_true = [0, 0, 1, 1]
+        >>> y_scores = [0.1, 0.2, 0.8, 0.9]
+        >>> roc_auc_score(y_true, y_scores)
+        1.0
+        
+        # Good separation
+        >>> y_true = [0, 0, 1, 1, 0, 1]
+        >>> y_scores = [0.2, 0.3, 0.7, 0.8, 0.4, 0.9]
+        >>> auc = roc_auc_score(y_true, y_scores)
+        >>> print(f"AUC: {auc:.2%}")
+        AUC: 91.67%
+    
+    Notes:
+        - 1.0 = Perfect classifier
+        - 0.5 = Random guessing
+        - < 0.5 = Worse than random
+        - Threshold-independent metric
+    """
+    if len(y_true) != len(y_scores):
+        raise ValueError("y_true and y_scores must have same length")
+    
+    # Sort by scores
+    pairs = sorted(zip(y_scores, y_true), reverse=True)
+    
+    # Count positive and negative samples
+    n_pos = sum(y_true)
+    n_neg = len(y_true) - n_pos
+    
+    if n_pos == 0 or n_neg == 0:
+        return 0.5
+    
+    # Calculate AUC using trapezoidal rule
+    tp = 0
+    fp = 0
+    auc = 0.0
+    prev_score = None
+    
+    for score, label in pairs:
+        if label == 1:
+            tp += 1
+        else:
+            fp += 1
+            auc += tp
+    
+    return auc / (n_pos * n_neg)

{ilovetools-0.1.2 → ilovetools-0.1.4/ilovetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.1.2
+Version: 0.1.4
 Summary: A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs
 Home-page: https://github.com/AliMehdi512/ilovetools
 Author: Ali Mehdi

{ilovetools-0.1.2 → ilovetools-0.1.4}/ilovetools.egg-info/SOURCES.txt

@@ -17,11 +17,14 @@ ilovetools/audio/__init__.py
 ilovetools/automation/__init__.py
 ilovetools/conversion/__init__.py
 ilovetools/data/__init__.py
+ilovetools/data/feature_engineering.py
 ilovetools/data/preprocessing.py
 ilovetools/database/__init__.py
 ilovetools/datetime/__init__.py
 ilovetools/files/__init__.py
 ilovetools/image/__init__.py
+ilovetools/ml/__init__.py
+ilovetools/ml/metrics.py
 ilovetools/security/__init__.py
 ilovetools/text/__init__.py
 ilovetools/utils/__init__.py

{ilovetools-0.1.2 → ilovetools-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ilovetools"
-version = "0.1.2"
+version = "0.1.4"
 description = "A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs"
 readme = "README.md"
 requires-python = ">=3.8"

{ilovetools-0.1.2 → ilovetools-0.1.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="ilovetools",
-    version="0.1.2",
+    version="0.1.3",
     author="Ali Mehdi",
     author_email="ali.mehdi.dev579@gmail.com",
     description="A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs",

ilovetools-0.1.2/ilovetools/data/__init__.py

@@ -1,11 +0,0 @@
-"""
-Data processing and manipulation utilities
-"""
-
-from .preprocessing import train_test_split, normalize_data, standardize_data
-
-__all__ = [
-    'train_test_split',
-    'normalize_data',
-    'standardize_data',
-]