What is AI? & Machine Learning Fundamentals

// CONVENTIONAL: Rules explicitly written by a developer
// Every decision path is readable, traceable, reproducible

public class LoanApprovalConventional {

    public boolean approve(Applicant applicant) {

        // Rule 1: minimum credit score
        if (applicant.getCreditScore() < 650) {
            return false;  // ALWAYS false for score < 650
        }

        // Rule 2: debt-to-income ratio must be under 40%
        double dti = applicant.getMonthlyDebt() / applicant.getMonthlyIncome();
        if (dti > 0.40) {
            return false;
        }

        // Rule 3: employment history
        if (applicant.getYearsEmployed() < 2) {
            return false;
        }

        return true;
        // Testing this is straightforward:
        //   Input: creditScore=700, dti=0.30, years=3  → ALWAYS approves
        //   Input: creditScore=600                      → ALWAYS rejects
        // Same test, same result, every single time.
    }
}

// AI-BASED: The "rules" are not written — they are LEARNED
// from 10 million historical loan decisions

public class LoanApprovalML {

    private MLModel model;  // loaded trained model (thousands of weights)

    public Prediction approve(Applicant applicant) {

        // Features extracted from applicant data
        // The model was trained to understand which combinations
        // of these features historically led to repayment vs default
        double[] features = {
            applicant.getCreditScore(),
            applicant.getMonthlyIncome(),
            applicant.getMonthlyDebt(),
            applicant.getYearsEmployed(),
            applicant.getLoanAmount(),
            applicant.getAge()
            // ... potentially 50+ more features
        };

        // The model outputs a PROBABILITY (0.0 to 1.0)
        // NOT a hard yes/no — a confidence score
        double approvalProbability = model.predict(features);

        // Testing challenge:
        //   Same applicant data → model might give 0.73 one run, 0.71 next
        //   (due to non-determinism in some model types)
        //
        //   WHY did it approve? You can't read the reason from the code.
        //   The "reason" is distributed across thousands of weights.
        //   This is the BLACK BOX problem.
        //
        //   Is 0.73 correct? Who decides the threshold? What if the
        //   training data had historical bias against certain demographics?

        return new Prediction(approvalProbability > 0.7, approvalProbability);
    }
}

// A simple linear model (most basic form) for house price prediction
// y = w1*x1 + w2*x2 + b
//
// x1 = house size (sq ft)
// x2 = number of bedrooms
// w1, w2 = WEIGHTS — numbers the training process determines
// b       = BIAS — a constant offset term, also learned
// y       = predicted price

public class LinearModel {

    // These values were NOT written by a programmer.
    // They were found by the training algorithm after seeing
    // thousands of (size, bedrooms, actual_price) examples.
    private double w1 = 150.5;   // weight for house size
    private double w2 = 8200.0;  // weight for bedrooms
    private double b  = -12000.0; // bias

    public double predict(double sizeSqFt, double bedrooms) {
        return w1 * sizeSqFt + w2 * bedrooms + b;
        // For a 1500 sqft, 3-bedroom house:
        // = 150.5 * 1500 + 8200 * 3 + (-12000)
        // = 225750 + 24600 - 12000
        // = $238,350 predicted price
    }
}

// A real model might have MILLIONS of weights instead of 2.
// The math is the same — just vastly more dimensions.
// The key insight: the weights ARE the model.

// A training example for spam classification
public class EmailTrainingExample {

    // ── FEATURES (inputs) ────────────────────────────────────
    int    wordCount;         // total words in email
    double freqOfWord_FREE;  // how often "FREE" appears (per 100 words)
    double freqOfWord_CLICK; // how often "CLICK" appears
    int    numLinks;          // number of hyperlinks in email
    boolean hasAttachment;  // does it have an attachment?
    String senderDomain;    // domain of sender email address

    // ── LABEL (the correct answer for training) ──────────────
    boolean isSpam;
    // This was determined by a human labeller who read the email
    // and marked it spam=true or spam=false.
    // Quality of this label is critical — CT-AI Ch.5 covers label
    // correctness testing and inter-annotator agreement.
}

// Training dataset = List<EmailTrainingExample> with 500,000 rows
// Model learns: which feature combinations correlate with isSpam=true?

// CLASSIFICATION — output is a CLASS (category)
public enum SpamLabel { SPAM, NOT_SPAM }

public SpamLabel classifyEmail(double[] features) {
    double spamProbability = model.predict(features);  // e.g., 0.87
    return spamProbability > 0.5
        ? SpamLabel.SPAM
        : SpamLabel.NOT_SPAM;
    // The threshold (0.5) is a design decision.
    // Changing it affects Precision vs Recall tradeoff (CT-AI Ch.3).
}

// REGRESSION — output is a NUMBER (continuous)
public double predictHousePrice(double[] features) {
    return model.predict(features);  // e.g., 238350.72 (dollars)
    // There's no threshold decision here.
    // Correctness is measured by how far off the prediction is
    // from the actual sale price (MAE, RMSE etc.)
}

// The Training Loop — conceptual skeleton
// Real ML frameworks (TensorFlow, PyTorch) hide most of this,
// but understanding it is essential for CT-AI

public void train(
        List<TrainingExample> dataset,
        int numEpochs,
        double learningRate    // α — a HYPERPARAMETER you set before training
) {
    // Step 1: initialise weights randomly
    model.initializeWeightsRandomly();

    for (int epoch = 0; epoch < numEpochs; epoch++) {

        double totalLoss = 0.0;

        for (TrainingExample example : dataset) {

            // Step 2: forward pass — predict
            double prediction = model.predict(example.features);

            // Step 3: calculate loss (how wrong was the prediction?)
            double loss = lossFunction.compute(prediction, example.label);
            totalLoss += loss;

            // Step 4: backward pass — compute gradients (which direction
            //         to nudge each weight to reduce the loss?)
            double[] gradients = model.computeGradients(loss);

            // Step 5: update weights — gradient descent
            //   new_weight = old_weight - (learningRate * gradient)
            model.updateWeights(gradients, learningRate);
        }

        // Log progress — we want loss to decrease each epoch
        System.out.printf("Epoch %d | Loss: %.4f%n", epoch, totalLoss / dataset.size());
    }
    // After training: model.weights now contain the learned values.
    // The model is ready for inference (making predictions on new data).
}

// ══════════════════════════════════════════════════════════════
//  FULL ML PIPELINE — Spam Classification Example
//  This illustrates the complete lifecycle that CT-AI tests at
//  each stage (data testing, model testing, deployment testing)
// ══════════════════════════════════════════════════════════════

public class MLPipeline {

    public static void main(String[] args) {

        // ── STEP 1: Load raw data ─────────────────────────────────
        // CT-AI Ch.5 (Input Data Testing) tests this stage:
        //   - Is the data biased?
        //   - Are labels correct?
        //   - Is the data representative of production?
        List<Email> rawEmails = dataLoader.load("emails.csv");

        // ── STEP 2: Feature extraction ────────────────────────────
        // Convert raw emails into numerical feature vectors the model can process
        List<double[]> features = rawEmails.stream()
            .map(FeatureExtractor::extract)  // word freq, link count, sender domain etc.
            .collect(Collectors.toList());

        double[] labels = rawEmails.stream()
            .mapToDouble(e -> e.isSpam ? 1.0 : 0.0)
            .toArray();

        // ── STEP 3: Split dataset into 3 sets ────────────────────
        //   Training set:   80% — used to train the model
        //   Validation set: 10% — used for hyperparameter tuning
        //   Test set:       10% — used ONCE for final evaluation
        //
        //   CT-AI Ch.3 and Ch.5 cover why all 3 sets are needed.
        //   The test set must NEVER be seen during training or tuning —
        //   using it for tuning would give falsely optimistic results.
        DataSplit split = DataSplitter.split(features, labels,
            /*trainRatio=*/ 0.80,
            /*valRatio=*/   0.10,
            /*testRatio=*/  0.10,
            /*shuffle=*/    true   // always shuffle to avoid ordering bias
        );

        // ── STEP 4: Define model and hyperparameters ──────────────
        //   These are chosen BEFORE training — not learned from data
        HyperParameters hp = new HyperParameters();
        hp.learningRate = 0.001;   // step size for gradient descent
        hp.numEpochs    = 50;      // training passes through the data
        hp.batchSize    = 32;      // examples per weight update
        hp.hiddenLayers = 2;       // neural network depth

        NeuralNetworkModel model = new NeuralNetworkModel(hp);

        // ── STEP 5: TRAINING ──────────────────────────────────────
        //   Forward pass → compute loss → backprop → update weights
        //   Repeated for numEpochs passes over the TRAINING set
        model.train(split.trainFeatures, split.trainLabels);

        // ── STEP 6: Evaluate on VALIDATION set ───────────────────
        //   Used to detect overfitting and tune hyperparameters.
        //   If training accuracy is 99% but validation is 70%,
        //   the model is OVERFITTING (memorising, not generalising).
        Metrics valMetrics = model.evaluate(split.valFeatures, split.valLabels);
        System.out.printf("Validation Accuracy: %.2f%%%n", valMetrics.accuracy * 100);

        // ── STEP 7: Final evaluation on TEST set ─────────────────
        //   The test set is used EXACTLY ONCE for the honest final score.
        //   CT-AI Ch.3 covers the full confusion matrix metrics computed here.
        Metrics testMetrics = model.evaluate(split.testFeatures, split.testLabels);
        System.out.printf("Test Accuracy:  %.2f%%%n", testMetrics.accuracy  * 100);
        System.out.printf("Test Precision: %.2f%%%n", testMetrics.precision * 100);
        System.out.printf("Test Recall:    %.2f%%%n", testMetrics.recall    * 100);
        System.out.printf("Test F1-Score:  %.2f%%%n", testMetrics.f1        * 100);

        // ── STEP 8: Save and deploy model ────────────────────────
        //   CT-AI Ch.7 covers deployment testing:
        //   - Model format conversion (ONNX, TensorFlow SavedModel)
        //   - Model compression / quantisation (reduces size for edge devices)
        //   - Re-testing is required after format/compression changes
        //   - Monitoring after deployment: performance drift, data drift
        model.save("spam_model_v1.onnx");

        // ── STEP 9: INFERENCE — using the deployed model ──────────
        //   Completely separate from training. Just uses learned weights.
        Email newEmail = emailService.receive();
        double[] newFeatures = FeatureExtractor.extract(newEmail);
        double spamProb = model.predict(newFeatures);
        boolean isSpam = spamProb > 0.5;  // classification threshold

        System.out.printf("Email '%s' → spam probability: %.2f → %s%n",
            newEmail.subject, spamProb, isSpam ? "SPAM" : "NOT SPAM");
    }
}