comprehensive_demo.php

<?php

/**
 * Comprehensive Machine Learning Library Demonstration
 * 
 * This script demonstrates all concepts from the 12-article series:
 * Articles 1-12: Complete implementation from introduction to practical examples
 * 
 * Run this script to see the full ML pipeline in action!
 */

require_once __DIR__ . '/src/LinearAlgebra/Vector.php';
require_once __DIR__ . '/src/LinearAlgebra/Matrix.php';
require_once __DIR__ . '/src/Algorithms/Sorting.php';
require_once __DIR__ . '/src/Algorithms/Searching.php';
require_once __DIR__ . '/src/DataProcessing/DataCleaner.php';
require_once __DIR__ . '/src/NeuralNetwork/Perceptron.php';
require_once __DIR__ . '/src/NeuralNetwork/NeuralNetwork.php';
require_once __DIR__ . '/src/NeuralNetwork/LossFunctions.php';
require_once __DIR__ . '/src/Training/GradientDescent.php';
require_once __DIR__ . '/src/Training/HyperparameterTuner.php';
require_once __DIR__ . '/src/Evaluation/Metrics.php';
require_once __DIR__ . '/src/Evaluation/DataSplitter.php';
require_once __DIR__ . '/src/Examples/CompleteExample.php';

use MLPyHP\LinearAlgebra\Vector;
use MLPyHP\LinearAlgebra\Matrix;
use MLPyHP\Algorithms\Sorting;
use MLPyHP\Algorithms\Searching;
use MLPyHP\DataProcessing\DataCleaner;
use MLPyHP\NeuralNetwork\Perceptron;
use MLPyHP\NeuralNetwork\NeuralNetwork;
use MLPyHP\NeuralNetwork\LossFunctions;
use MLPyHP\Training\GradientDescent;
use MLPyHP\Training\HyperparameterTuner;
use MLPyHP\Evaluation\Metrics;
use MLPyHP\Evaluation\DataSplitter;

function printHeader($title, $article = null) {
    echo "\n" . str_repeat("=", 70) . "\n";
    if ($article) {
        echo "ARTICLE {$article}: {$title}\n";
    } else {
        echo $title . "\n";
    }
    echo str_repeat("=", 70) . "\n";
}

function printSection($title) {
    echo "\n" . str_repeat("-", 50) . "\n";
    echo $title . "\n";
    echo str_repeat("-", 50) . "\n";
}

// Start the comprehensive demonstration
printHeader("COMPLETE MACHINE LEARNING LIBRARY DEMONSTRATION");
echo "This demonstrates all concepts from the 12-article ML series\n";
echo "Each section shows working code that you can use in production!\n";

// ============================================================================
// ARTICLE 2: LINEAR ALGEBRA
// ============================================================================
printHeader("LINEAR ALGEBRA: THE MATHEMATICAL FOUNDATION", "2");

printSection("Vector Operations");
$userPrefs = new Vector([4, 2, 5, 1, 3]);
$movie1 = new Vector([3, 1, 4, 0, 2]);
$movie2 = new Vector([1, 4, 2, 3, 1]);

echo "User preferences: {$userPrefs}\n";
echo "Movie 1 features: {$movie1}\n";
echo "Movie 2 features: {$movie2}\n\n";

$similarity1 = $userPrefs->dotProduct($movie1);
$similarity2 = $userPrefs->dotProduct($movie2);
echo "Movie 1 similarity score: {$similarity1}\n";
echo "Movie 2 similarity score: {$similarity2}\n";
echo "Recommendation: " . ($similarity1 > $similarity2 ? "Movie 1" : "Movie 2") . "\n";

printSection("Matrix Operations");
$customerData = new Matrix([
    [25, 50000, 2, 1],   // Age, Income, Kids, Previous_purchases
    [35, 75000, 1, 3],
    [45, 100000, 3, 5],
    [28, 60000, 0, 2]
]);

echo "Customer data matrix:\n{$customerData}\n";

$featureWeights = new Matrix([[0.1], [0.00001], [0.2], [0.3]]);
$customerScores = $customerData->multiply($featureWeights);
echo "Customer value scores:\n{$customerScores}\n";

// Demonstrate matrix operations
echo "Matrix transpose:\n{$customerData->transpose()}\n";

// ============================================================================
// ARTICLE 3: SORTING AND SEARCHING ALGORITHMS
// ============================================================================
printHeader("ALGORITHMS: SORTING AND SEARCHING", "3");

printSection("Sorting Algorithms Performance");
$data = [];
for ($i = 0; $i < 20; $i++) {
    $data[] = mt_rand(1, 100);
}
echo "Random data: [" . implode(', ', $data) . "]\n\n";

$results = Sorting::compareAlgorithms($data);
foreach ($results as $algorithm => $result) {
    echo "{$algorithm}: " . number_format($result['time'] * 1000, 3) . "ms\n";
}

printSection("Searching Performance");
$sortedData = Sorting::quickSort($data);
echo "Sorted data: [" . implode(', ', array_slice($sortedData, 0, 10)) . "...]\n\n";

$searchResults = Searching::compareSearchMethods($sortedData, 50);
foreach ($searchResults as $method => $result) {
    echo "{$method}: Found at index {$result['index']} in " . 
         number_format($result['time'] * 1000000, 2) . " microseconds\n";
}

// ============================================================================
// ARTICLE 4: DATA PROCESSING
// ============================================================================
printHeader("DATA PROCESSING: CLEANING THE MESS", "4");

printSection("Data Cleaning Demonstration");
$messyData = [
    [25, 50000, 85, 1],
    [null, 75000, 92, 1], 
    [35, null, 78, 0],
    [45, 100000, 95, 1],
    [22, 30000, 45, 0],   // Outlier score
    [null, null, 88, 1],
    [39, 85000, 91, 1]
];

echo "Original messy data:\n";
foreach ($messyData as $i => $row) {
    echo "Row {$i}: [" . implode(', ', array_map(function($x) { 
        return $x === null ? 'NULL' : $x; 
    }, $row)) . "]\n";
}

$cleaner = new DataCleaner();
$cleanedData = $cleaner->handleMissingValues($messyData, 'mean');

echo "\nAfter cleaning:\n";
foreach ($cleanedData as $i => $row) {
    echo "Row {$i}: [" . implode(', ', array_map(function($x) { 
        return number_format($x, 1); 
    }, $row)) . "]\n";
}

// Outlier detection
$scores = array_column($cleanedData, 2);
$outlierIndices = $cleaner->detectOutliers($scores, 2.0);
echo "\nOutlier analysis:\n";
$mean = array_sum($scores) / count($scores);
$variance = array_sum(array_map(function($x) use ($mean) {
    return pow($x - $mean, 2);
}, $scores)) / count($scores);
$stdDev = sqrt($variance);
echo "Mean: " . number_format($mean, 2) . "\n";
echo "Std Dev: " . number_format($stdDev, 2) . "\n";
echo "Outliers found at indices: [" . implode(', ', $outlierIndices) . "]\n";

// ============================================================================
// ARTICLE 5: PERCEPTRONS
// ============================================================================
printHeader("PERCEPTRONS: THE BOUNCER AT THE CLUB", "5");

printSection("Learning Logic Gates");
echo "Training perceptron on AND gate:\n";
$andPerceptron = new Perceptron(2, 0.1, 'step');
$andData = Perceptron::createAndGateData();
$andHistory = $andPerceptron->train($andData, 20, false);

echo "Testing AND gate:\n";
foreach ($andData as $example) {
    $inputs = $example[0];
    $expected = $example[1];
    $prediction = $andPerceptron->predict($inputs);
    echo "[" . implode(', ', $inputs) . "] -> Expected: {$expected}, Got: {$prediction} " . 
         ($prediction == $expected ? "✓" : "✗") . "\n";
}

echo "\nTraining perceptron on OR gate:\n";
$orPerceptron = new Perceptron(2, 0.1, 'step');
$orData = Perceptron::createOrGateData();
$orHistory = $orPerceptron->train($orData, 20, false);

echo "Testing OR gate:\n";
foreach ($orData as $example) {
    $inputs = $example[0];
    $expected = $example[1];
    $prediction = $orPerceptron->predict($inputs);
    echo "[" . implode(', ', $inputs) . "] -> Expected: {$expected}, Got: {$prediction} " . 
         ($prediction == $expected ? "✓" : "✗") . "\n";
}

// ============================================================================
// ARTICLE 6: FORWARD PROPAGATION
// ============================================================================
printHeader("FORWARD PROPAGATION: THE ASSEMBLY LINE", "6");

printSection("Neural Network Architecture");
$network = new NeuralNetwork([2, 4, 3, 1], 'sigmoid');
$architecture = $network->getArchitecture();

echo "Network architecture: [" . implode(' -> ', $architecture['layers']) . "]\n";
echo "Total parameters: " . $architecture['total_parameters'] . "\n";
echo "Activation function: " . $architecture['activation_function'] . "\n\n";

printSection("Forward Propagation Demo");
$input = [0.7, 0.3];
echo "Processing input: [" . implode(', ', $input) . "]\n\n";
$output = $network->demonstrateAssemblyLine($input);

printSection("XOR Problem Solution");
NeuralNetwork::demonstrateXorSolution();

// ============================================================================
// ARTICLE 7: LOSS FUNCTIONS
// ============================================================================
printHeader("LOSS FUNCTIONS: THE TEACHER'S RED PEN", "7");

printSection("Loss Function Comparison");
LossFunctions::demonstrateLossBehavior();

printSection("Why Loss Function Choice Matters");
LossFunctions::demonstrateWhyChoiceMatters();

// ============================================================================
// ARTICLE 8: GRADIENT DESCENT
// ============================================================================
printHeader("GRADIENT DESCENT: HIKING DOWN THE MOUNTAIN", "8");

printSection("Training Data Generation");
$trainingData = [];
for ($i = 0; $i < 200; $i++) {
    $x1 = (mt_rand() / mt_getrandmax()) * 2 - 1;
    $x2 = (mt_rand() / mt_getrandmax()) * 2 - 1;
    $target = $x1 * $x2 > 0 ? 1.0 : 0.0; // Simple quadrant-based classification
    $trainingData[] = [[$x1, $x2], [$target]];
}
echo "Generated " . count($trainingData) . " training samples\n\n";

printSection("Gradient Descent Variants");
$network = new NeuralNetwork([2, 4, 1], 'sigmoid');
$optimizer = new GradientDescent(0.1, 'mini-batch', 0.0);

echo "Training with mini-batch gradient descent:\n";
$history = $optimizer->train($network, array_slice($trainingData, 0, 50), 30, 16, true);

// Test a few predictions
echo "\nTesting trained network:\n";
$testData = array_slice($trainingData, 50, 5);
foreach ($testData as $example) {
    $prediction = $network->forwardPropagate($example[0]);
    echo "Input: [" . implode(', ', array_map(function($x) { return number_format($x, 2); }, $example[0])) . 
         "] -> Prediction: " . number_format($prediction[0], 3) . 
         ", Target: " . $example[1][0] . "\n";
}

// ============================================================================
// ARTICLE 9: EVALUATING PERFORMANCE
// ============================================================================
printHeader("EVALUATING PERFORMANCE: THE REPORT CARD", "9");

printSection("Data Splitting Demonstration");
$demoInputs = array_map(function($x) { return $x[0]; }, $trainingData);
$demoTargets = array_map(function($x) { return $x[1][0]; }, $trainingData);

$split = DataSplitter::trainTestSplit($demoInputs, $demoTargets, 0.3, true, 42);
echo "Original dataset: " . count($demoInputs) . " samples\n";
echo "Training set: " . count($split['train']['inputs']) . " samples\n";
echo "Test set: " . count($split['test']['inputs']) . " samples\n\n";

printSection("Model Evaluation");
// Generate predictions for evaluation
$predictions = [];
$targets = [];
foreach ($split['test']['inputs'] as $i => $input) {
    $pred = $network->forwardPropagate($input);
    $predictions[] = $pred[0];
    $targets[] = $split['test']['targets'][$i];
}

$report = Metrics::evaluationReport($predictions, $targets);
Metrics::printReport($report);

printSection("Cross-Validation Demo");
$folds = DataSplitter::kFoldSplit($demoInputs, $demoTargets, 5, true, 42);
echo "Created " . count($folds) . " folds for cross-validation\n";
foreach ($folds as $fold) {
    echo "Fold {$fold['fold_number']}: Train=" . count($fold['train']['inputs']) . 
         ", Test=" . count($fold['test']['inputs']) . "\n";
}

// ============================================================================
// ARTICLE 10: HYPERPARAMETER TUNING
// ============================================================================
printHeader("HYPERPARAMETER TUNING: FINDING THE PERFECT SETTINGS", "10");

printSection("Search Space Definition");
$searchSpace = HyperparameterTuner::createDefaultSearchSpace('classification');
echo "Default search space for classification:\n";
foreach ($searchSpace as $param => $values) {
    if (is_array($values) && isset($values[0])) {
        echo "- {$param}: [" . implode(', ', array_slice($values, 0, 3)) . 
             (count($values) > 3 ? ", ..." : "") . "]\n";
    }
}

printSection("Hyperparameter Tuning Demo");
$smallSearchSpace = [
    'learning_rate' => [0.01, 0.1],
    'batch_size' => [16, 32],
    'epochs' => [10, 20],
    'architecture' => [[2, 4, 1], [2, 8, 1]]
];

$tuner = new HyperparameterTuner($smallSearchSpace, 'f1_score', true);
$tuningResults = $tuner->randomSearch(
    array_slice($trainingData, 0, 80), 
    array_slice($trainingData, 80, 20), 
    6, 
    true
);

echo "Best parameters found:\n";
foreach ($tuningResults['best_parameters'] as $param => $value) {
    if (is_array($value)) {
        echo "- {$param}: [" . implode(', ', $value) . "]\n";
    } else {
        echo "- {$param}: {$value}\n";
    }
}

// ============================================================================
// ARTICLE 11: BACKPROPAGATION
// ============================================================================
printHeader("BACKPROPAGATION: LEARNING FROM MISTAKES", "11");

printSection("Backpropagation Demonstration");
$demoNetwork = new NeuralNetwork([2, 3, 1], 'sigmoid');
$sampleInput = [0.5, 0.8];
$sampleTarget = [1.0];

echo "Demonstrating backpropagation step by step:\n";
$backpropDemo = $demoNetwork->demonstrateBackpropagation($sampleInput, $sampleTarget);

echo "This shows how errors propagate backwards through the network\n";
echo "to update weights and improve future predictions.\n";

// ============================================================================
// ARTICLE 12: PRACTICAL EXAMPLES
// ============================================================================
printHeader("PRACTICAL EXAMPLES: PUTTING IT ALL TOGETHER", "12");

printSection("Complete ML Pipeline");
echo "Running the complete machine learning pipeline...\n";
echo "This demonstrates every concept from all 12 articles!\n\n";

$pipelineResults = CompleteExample::completeMachineLearningPipeline();

// ============================================================================
// FINAL SUMMARY
// ============================================================================
printHeader("DEMONSTRATION COMPLETE!");

echo "🎉 Congratulations! You've seen the complete ML library in action!\n\n";

echo "What you've learned:\n";
echo "✓ Article 1: Introduction to machine learning concepts\n";
echo "✓ Article 2: Linear algebra operations with vectors and matrices\n";
echo "✓ Article 3: Sorting and searching algorithms for efficient computation\n";
echo "✓ Article 4: Data preprocessing and cleaning techniques\n";
echo "✓ Article 5: Perceptron learning for basic classification\n";
echo "✓ Article 6: Forward propagation through neural networks\n";
echo "✓ Article 7: Loss functions for measuring prediction quality\n";
echo "✓ Article 8: Gradient descent for network training\n";
echo "✓ Article 9: Performance evaluation and data splitting\n";
echo "✓ Article 10: Hyperparameter tuning for optimal performance\n";
echo "✓ Article 11: Backpropagation for learning from mistakes\n";
echo "✓ Article 12: Complete practical examples and production workflows\n\n";

echo "Next steps:\n";
echo "• Experiment with different network architectures\n";
echo "• Try different datasets and problem types\n";
echo "• Implement additional optimization algorithms\n";
echo "• Add regularization techniques\n";
echo "• Build real-world applications\n\n";

echo "This library provides a solid foundation for understanding\n";
echo "and implementing machine learning algorithms from scratch!\n\n";

echo "Happy machine learning! 🤖\n";
echo str_repeat("=", 70) . "\n";