Overfitting - When Fraud Detection Blocks All Transactions

import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import learning_curve

# io.thecodeforge approach: Systematic Diagnostic
def generate_learning_curve(model, X, y):
    train_sizes, train_scores, test_scores = learning_curve(
        model, X, y, cv=5, scoring='neg_mean_squared_error'
    )
    
    # Calculate mean and standard deviation
    train_mean = -np.mean(train_scores, axis=1)
    test_mean = -np.mean(test_scores, axis=1)
    
    return train_sizes, train_mean, test_mean

# Underfitting: Linear model on non-linear data
underfit_model = LinearRegression()

# Overfitting: High-degree polynomial
overfit_model = Pipeline([
    ("poly_features", PolynomialFeatures(degree=15, include_bias=False)),
    ("std_scaler", StandardScaler()),
    ("lin_reg", LinearRegression()),
])

from sklearn.model_selection import validation_curve
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
import numpy as np

def generate_validation_curve(X, y, param_range):
    model = Pipeline([
        ("poly", PolynomialFeatures(include_bias=False)),
        ("reg", LinearRegression()),
    ])
    train_scores, test_scores = validation_curve(
        model, X, y,
        param_name="poly__degree",
        param_range=param_range,
        cv=5,
        scoring="neg_mean_squared_error"
    )
    train_mean = -np.mean(train_scores, axis=1)
    test_mean = -np.mean(test_scores, axis=1)
    return param_range, train_mean, test_mean

import numpy as np
from sklearn.neural_network import MLPRegressor
from tensorflow import keras
from keras import layers, regularizers, callbacks

def build_regularised_model(input_dim):
    model = keras.Sequential([
        layers.Dense(64, activation='relu', 
                     kernel_regularizer=regularizers.l2(0.01)),
        layers.Dropout(0.5),
        layers.Dense(32, activation='relu',
                     kernel_regularizer=regularizers.l2(0.01)),
        layers.Dropout(0.3),
        layers.Dense(1)
    ])
    model.compile(optimizer='adam', loss='mse')
    return model

# Early stopping callback
early_stop = callbacks.EarlyStopping(
    monitor='val_loss', patience=10, restore_best_weights=True
)

model = build_regularised_model(X_train.shape[1])
history = model.fit(X_train, y_train,
                    validation_data=(X_val, y_val),
                    epochs=200, callbacks=[early_stop], verbose=0)

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score

def diagnose_and_fix_underfitting(X, y):
    # Baseline linear model
    linear_model = LinearRegression()
    linear_score = -cross_val_score(linear_model, X, y, cv=5, 
                                    scoring='neg_mean_squared_error').mean()
    
    # Try polynomial features (degree 3)
    poly_model = Pipeline([
        ('poly', PolynomialFeatures(degree=3, include_bias=False)),
        ('scaler', StandardScaler()),
        ('reg', LinearRegression())
    ])
    poly_score = -cross_val_score(poly_model, X, y, cv=5, 
                                  scoring='neg_mean_squared_error').mean()
    
    if poly_score < linear_score * 0.8:
        print("Underfitting fixed with polynomial features. Using poly model.")
        return poly_model
    else:
        print("Still underfitting. Try feature engineering or more complex algorithm.")
        return None

package io.thecodeforge.ml;

import java.util.logging.Logger;
import java.time.Instant;

public class ModelHealthMonitor {
    private static final Logger logger = Logger.getLogger(ModelHealthMonitor.class.getName());
    private double baselineErrorRate;
    private double driftThreshold = 0.2; // 20% increase
    
    public ModelHealthMonitor(double baselineErrorRate) {
        this.baselineErrorRate = baselineErrorRate;
    }
    
    public void checkCurrentErrorRate(double currentErrorRate) {
        double relativeChange = (currentErrorRate - baselineErrorRate) / baselineErrorRate;
        if (relativeChange > driftThreshold) {
            logger.warning("CRITICAL: Model error rate increased by " + 
                           Math.round(relativeChange * 100) + "%. Overfitting? Underfitting? Check learning curves.");
        } else {
            logger.info("Model error rate within bounds.");
        }
    }
    
    public static void main(String[] args) {
        ModelHealthMonitor monitor = new ModelHealthMonitor(0.10);
        monitor.checkCurrentErrorRate(0.18);
    }
}