import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import re
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer

# Load dataset from csv file
df = pd.read_csv('combined-data.csv')

# Reduce the sample size for faster training
df = df.sample(n=1000, random_state=42).reset_index(drop=True)

# Preview the dataset
df.head()

def clean_text(text):
    """
    Cleans a raw email text string for use in machine learning models.
    
    This function applies basic text preprocessing steps:
    - Converts all characters to lowercase
    - Removes all non-alphanumeric characters (excluding spaces)
    - Replaces multiple spaces with a single space
    - Strips leading and trailing whitespace
    
    Parameters:
    -----------
    text : str
        The raw email text to be cleaned.
    
    Returns:
    --------
    str
        The cleaned and normalized text.
    """
    
    # Convert all characters to lowercase
    text = text.lower()
    
    # Remove all characters that are NOT a-z, 0-9, or whitespace
    text = re.sub(r'[^a-z0-9\s]', '', text)
    
    # Replace multiple spaces with a single space and strip leading/trailing space
    text = re.sub(r'\s+', ' ', text).strip()
    
    return text


# Apply the cleaning function to the 'text' column
df['clean_text'] = df['text'].apply(clean_text)

Original: "Hello! This is your LAST chance!!! $$$"
Cleaned: "hello this is your last chance"

Email 1: "I love Python"
Email 2: "Python loves me"
Email 3: "I love machine learning"

["i", "love", "python", "loves", "me", "machine", "learning"]

# Initialize a CountVectorizer to extract the top 3,000 most frequent words.
vectorizer = CountVectorizer(max_features=3000)

# Fit the vectorizer on the cleaned email text and transform the text into a numeric feature matrix.
# Each row represents an email, and each column represents the count of a specific word.
X = vectorizer.fit_transform(df['clean_text']).toarray()

# Extract the target labels (0 = ham, 1 = spam) from the DataFrame.
y = df['label'].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

def sigmoid(z):
    """
    Applies the sigmoid activation function to map input values 
    into a range between 0 and 1.

    This function is commonly used in binary classification problems
    (like logistic regression) to convert raw model outputs (logits)
    into interpretable probabilities.

    Mathematically:
        sigmoid(z) = 1 / (1 + e^(-z))

    Parameters:
    -----------
    z : float or np.ndarray
        A scalar or NumPy array of real values (the linear output of a model).

    Returns:
    --------
    float or np.ndarray
        The sigmoid-transformed value(s), ranging from 0 to 1.
    """

    # Prevent extreme values of z from causing numerical overflow in exp()
    # Clipping helps maintain numerical stability for very large or small z
    z = np.clip(z, -500, 500)

    # Compute the sigmoid: 1 / (1 + e^(-z))
    return 1 / (1 + np.exp(-z))

def compute_cost(X, y, w, b, lambda_):
    """
    Computes the regularized binary cross-entropy loss (cost) 
    for logistic regression.

    This function measures how well the model's predicted probabilities
    match the actual labels, and includes an L2 regularization term 
    to help reduce <a href="https://erickhangati.com/underfitting-and-overfitting-with-polynomial-regression/">overfitting</a>.

    Parameters:
    -----------
    X : np.ndarray, shape (m, n)
        Feature matrix where m is the number of examples and 
        n is the number of features.

    y : np.ndarray, shape (m,)
        Actual binary labels (0 for ham, 1 for spam).

    w : np.ndarray, shape (n,)
        Weight vector (model parameters for each feature).

    b : float
        Bias term (intercept).

    lambda_ : float
        Regularization strength. Higher values penalize large weights.

    Returns:
    --------
    float
        The total cost: binary cross-entropy + L2 regularization.
    """

    # Number of training examples
    m = X.shape[0]

    # Compute the model output (z = X.w + b)
    z = np.dot(X, w) + b

    # Apply the sigmoid function to get predicted probabilities
    y_hat = sigmoid(z)

    # Clip predicted values to avoid log(0) errors during cost calculation
    y_hat = np.clip(y_hat, 1e-15, 1 - 1e-15)

    # Compute binary cross-entropy loss
    cost = -(1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))

    # Compute L2 regularization term (excluding the bias b)
    reg = (lambda_ / (2 * m)) * np.sum(w ** 2)

    # Total cost = loss + regularization
    return cost + reg

def train_logistic_regression(X, y, learning_rate=0.01, iterations=10000, lambda_=10.0):
    """
    Trains a logistic regression model using batch gradient descent 
    and L2 regularization (also known as Ridge regularization).
    
    Parameters:
    -----------
    X : np.ndarray, shape (m, n)
        Feature matrix where m is the number of examples and 
        n is the number of features (e.g., BoW word counts).

    y : np.ndarray, shape (m,)
        Binary labels (0 = ham, 1 = spam).

    learning_rate : float, optional (default=0.01)
        Step size for updating weights during training.

    iterations : int, optional (default=10000)
        Maximum number of training iterations.

    lambda_ : float, optional (default=10.0)
        Regularization strength to reduce overfitting by 
        penalizing large weight values (L2 regularization).
    
    Returns:
    --------
    w : np.ndarray, shape (n,)
        Final optimized weights after training.

    b : float
        Final optimized bias (intercept).

    costs : list of float
        Cost at each iteration — useful for plotting convergence.
    """

    m, n = X.shape  # m = number of samples, n = number of features

    # Initialize weights and bias to zero
    w = np.zeros(n)
    b = 0

    # Keep track of cost at each iteration for visualization
    costs = []

    # Begin gradient descent loop
    for i in range(iterations):
        # Compute model output (z = X.w + b)
        z = np.dot(X, w) + b

        # Apply sigmoid to get predicted probabilities (0 to 1)
        y_hat = sigmoid(z)

        # Compute gradients with respect to weights and bias
        # Includes L2 regularization: (lambda_ / m) * w
        dw = (1 / m) * np.dot(X.T, (y_hat - y)) + (lambda_ / m) * w
        db = (1 / m) * np.sum(y_hat - y)

        # Update parameters using gradient descent
        w -= learning_rate * dw
        b -= learning_rate * db

        # Compute current cost (loss + regularization)
        cost = compute_cost(X, y, w, b, lambda_)
        costs.append(cost)

        # Print progress every 100 steps
        if i % 100 == 0:
            print(f"Iteration {i}: Cost = {cost:.4f}")

    # Return the learned weights, bias, and the list of costs
    return w, b, costs

w, b, costs = train_logistic_regression(X_train, y_train)

plt.plot(costs)
plt.title("Cost Over Iterations")
plt.xlabel("Iteration")
plt.ylabel("Cost")
plt.grid(True)
plt.show()

def predict(X, w, b):
    """
    Predicts binary labels (0 or 1) for input feature vectors 
    using a trained logistic regression model.

    This function performs the following steps:
    1. Computes the linear combination of inputs and weights (z = X·w + b)
    2. Applies the sigmoid function to convert z into probabilities
    3. Converts probabilities into final class labels:
       - If probability ≥ 0.5, predict 1 (spam)
       - If probability < 0.5, predict 0 (ham)

    Parameters:
    -----------
    X : np.ndarray, shape (m, n)
        Feature matrix of input samples (e.g., Bag-of-Words vectors).

    w : np.ndarray, shape (n,)
        Trained weight vector from the logistic regression model.

    b : float
        Trained bias (intercept) from the model.

    Returns:
    --------
    np.ndarray, shape (m,)
        Predicted class labels (0 or 1) for each input example.
    """

    # Step 1: Compute the raw score (z = X·w + b)
    z = np.dot(X, w) + b

    # Step 2: Apply sigmoid to get probabilities between 0 and 1
    y_hat = sigmoid(z)

    # Step 3: Classify as 1 if probability ≥ 0.5, else 0
    return np.where(y_hat > 0.5, 1, 0)

def accuracy(y_pred, y_true):
    """
    Calculates the classification accuracy of the model.
    
    Accuracy is the proportion of correct predictions out of 
    all predictions made. It's a basic but useful metric for 
    evaluating classification performance.

    Parameters:
    -----------
    y_pred : np.ndarray, shape (m,)
        Predicted labels (0 or 1) from the model.
    
    y_true : np.ndarray, shape (m,)
        Actual true labels (0 or 1) from the dataset.

    Returns:
    --------
    float
        Accuracy score between 0 and 1.
        Multiply by 100 for percentage.
    """
    return np.mean(y_pred == y_true)

# Evaluate the model on the test set
# y_pred_test: model's predictions
# y_test: actual labels

acc = accuracy(y_pred_test, y_test)

# Print accuracy as a percentage with 2 decimal places
print(f"Test Accuracy: {acc * 100:.2f}%")