Update README.md

README.md

@@ -12,68 +12,55 @@ short_description: End-to-End Automated MLOps Framework
 
 # End-to-End Automated MLOps Framework
 
-This project is a comprehensive, production-ready MLOps platform designed to automate the entire machine learning lifecycle. It provides an enterprise-grade solution for training, versioning, deploying, and monitoring models, complete with automated drift detection, retraining, and A/B testing capabilities.
+**Author**: Spencer Purdy
 
-The entire system is managed through a sophisticated, multi-tabbed dashboard, offering a transparent and interactive view into every stage of the model lifecycle. This framework is built to demonstrate best practices in MLOps and to serve as a robust foundation for real-world machine learning systems.
+This project is a comprehensive, enterprise-grade MLOps platform that demonstrates a complete, automated lifecycle for machine learning models. It handles everything from automated training and hyperparameter optimization to versioning, production deployment, drift detection, A/B testing, and ongoing performance monitoring.
 
-## Core Features
-
-This platform integrates a full suite of MLOps tools into a single, cohesive system:
-
-* **Automated Training & Hyperparameter Tuning**: Employs a custom PyTorch neural network and leverages `Optuna` for sophisticated, automated hyperparameter optimization to find the best-performing model architecture.
-
-* **Model Registry & Versioning**: A robust model registry, backed by a persistent SQLite database, tracks every model version, its associated metrics, metadata, and artifacts. It supports clear versioning and promotion of models to a production state.
-
-* **Data and Concept Drift Detection**: Integrates powerful libraries like `Evidently` and `Alibi-Detect` to continuously monitor for data drift. It provides detailed reports on drift scores and identifies which features are most affected.
+The entire system is orchestrated by a central engine and managed through a powerful, multi-tab Gradio interface, providing a single pane of glass for all MLOps activities.
 
-* **Automated Retraining on Drift**: The system can be configured to automatically trigger a model retraining pipeline when significant data drift is detected, ensuring that production models remain accurate and relevant.
-
-* **Live A/B Testing Framework**: A built-in A/B testing manager allows for controlled, live comparison between a champion (production) model and a challenger. It routes traffic, records performance, and uses statistical tests to determine a winner.
-
-* **Comprehensive Performance Monitoring**: Tracks key performance indicators in real-time using `Prometheus` metrics. It monitors prediction latency, throughput, and model accuracy, providing alerts for performance degradation.
-
-* **Detailed Cost Tracking**: An integrated cost tracker estimates the financial impact of the ML system, breaking down costs for training (compute), inference (API calls), and model storage.
-
-* **Automated Model Card Generation**: Generates detailed, shareable model cards that document a model's architecture, performance metrics, training data characteristics, and intended use cases, promoting transparency and responsible AI.
+## Core Features
 
-* **One-Click Hugging Face Deployment**: Seamlessly exports any registered model version, along with its model card, to the Hugging Face Hub, making it easy to share and collaborate.
+* **Automated Model Training**: The system features a `ModelTrainer` that automatically trains a custom PyTorch neural network on tabular data. It includes support for handling class imbalance with SMOTE and integrates `Optuna` for sophisticated hyperparameter optimization.
+* **Model Registry and Versioning**: A robust `ModelRegistry` tracks all trained model versions, their performance metrics, and metadata. Models are persisted to disk and logged in a SQLite database, with functionality to promote any version to the "production" stage.
+* **Data and Concept Drift Detection**: The platform integrates both `Evidently` and `Alibi-Detect` (with a statistical fallback) to continuously monitor for data drift between the reference training data and live inference data. Drift scores are tracked over time.
+* **Automated Retraining**: A background process can be enabled to periodically check for significant data drift. If the drift threshold is exceeded, it automatically triggers a new model training cycle and initiates an A/B test against the current production model.
+* **Live A/B Testing**: The `ABTestManager` allows for controlled experiments between the current production model and a challenger. It routes inference traffic, records performance metrics for both models, and determines a statistical winner.
+* **Comprehensive Monitoring & Cost Tracking**:
+    * **Performance**: The `PerformanceMonitor` uses Prometheus-compatible metrics to track prediction latency, accuracy, and throughput. It also logs detailed performance data to a database for historical analysis.
+    * **Cost**: The `CostTracker` provides reports on estimated operational costs, breaking them down by training, inference, and model storage based on configurable rates.
+* **Model Cards and Explainability**: The system can generate detailed model cards that consolidate metadata, performance metrics, and operational history. It also has `SHAP` integrated as a dependency for future explainability features.
+* **Hugging Face Hub Integration**: Models can be exported directly from the registry to the Hugging Face Hub, with an automatically generated model card (`README.md`).
 
 ## How It Works
 
-The MLOps Engine orchestrates a continuous, automated loop for managing the model lifecycle:
+The platform operates as a cohesive system of specialized components orchestrated by the main `MLOpsEngine`:
 
-1.  **Initial Training**: The system begins by training an initial model on a baseline dataset. This process includes hyperparameter optimization with Optuna to find the most effective architecture.
-2.  **Model Registration**: The trained model, its performance metrics, training duration, and metadata are logged in the Model Registry. The best-performing initial model is automatically promoted to "Production."
-3.  **Inference & Monitoring**: The production model serves predictions via the interactive UI. The `PerformanceMonitor` and `CostTracker` log every prediction, tracking latency, confidence, and associated costs.
-4.  **Drift Detection**: On a configurable schedule or by manual trigger, the `DriftDetector` compares incoming data to the reference dataset used for training.
-5.  **Automated Retraining & A/B Testing**:
-    * If significant drift is detected, the system automatically triggers a retraining job on the new data.
-    * The newly trained model becomes a "challenger" and is placed into an A/B test against the current "champion" production model.
-    * The `ABTestManager` splits live traffic between the two models, and the winner is automatically promoted to production after reaching statistical significance.
-6.  **Analysis & Reporting**: At any point, users can generate detailed performance reports, cost breakdowns, and model cards directly from the dashboard.
+1.  **Training**: A user initiates a training job from the UI. The `ModelTrainer` uses `Optuna` to find the best hyperparameters and then trains a `CustomNeuralNetwork` model.
+2.  **Registration**: The newly trained model, along with its performance metrics and metadata, is registered in the `ModelRegistry`. The model artifact is saved, and its details are recorded in the SQLite database.
+3.  **Promotion**: A user can review all registered models and promote a specific version to be the active "production" model via the UI.
+4.  **Prediction**: When a prediction request is made, the engine retrieves the current production model (or routes to an A/B test model if active) to perform inference. Latency and other performance metrics are logged by the `PerformanceMonitor`.
+5.  **Monitoring & Drift Detection**: In the background, the `DriftDetector` continuously compares incoming data against a reference dataset. If drift is detected and auto-retraining is enabled, it triggers the training of a new "challenger" model.
+6.  **A/B Testing**: The new challenger model is automatically placed into an A/B test against the current production model. Live traffic is split between them until a statistically significant winner is found, which can then be automatically promoted.
 
 ## Technical Stack
 
-* **Machine Learning & Deep Learning**: PyTorch, Scikit-learn
-* **MLOps & Experiment Tracking**: MLflow, Optuna, Evidently, Alibi-Detect, SHAP
-* **Data Processing & Storage**: Pandas, NumPy, SQLite, Joblib
-* **Monitoring**: Prometheus Client
-* **Deployment & UI**: Gradio, Hugging Face Hub
-* **Core Language**: Python
+* [cite_start]**Machine Learning & Training**: scikit-learn, PyTorch, imbalanced-learn [cite: 1]
+* [cite_start]**MLOps & Experiment Tracking**: MLflow, Optuna, Hugging Face Hub, W&B [cite: 1]
+* [cite_start]**Drift & Anomaly Detection**: Evidently, Alibi-Detect, SHAP [cite: 1]
+* [cite_start]**Web Interface & Visualization**: Gradio, Matplotlib, Seaborn, Plotly, Yellowbrick [cite: 1]
+* **Infrastructure & Utilities**: Prometheus Client, Joblib, SQLite
 
 ## How to Use the Demo
 
-The Gradio interface is organized into logical tabs that cover the entire MLOps lifecycle.
+The Gradio interface is organized into tabs that follow a logical MLOps workflow.
 
-1.  **Model Training**: Generate synthetic data and train a new model. Choose whether to run hyperparameter optimization. The training results and performance metrics will be displayed.
-2.  **Model Registry**: View all registered model versions. Select a model and promote it to the production environment.
-3.  **Make Predictions**: Input feature values to get a real-time prediction from the current production model.
-4.  **Drift Detection**: Manually trigger a drift check to compare the current data distribution against the model's training data.
-5.  **A/B Testing**: Start a new A/B test between the production model and a new challenger, check the status of an active test, or complete a test to promote the winner.
-6.  **Performance Monitoring & Cost Tracking**: View dashboards summarizing model performance and operational costs over various time windows.
-7.  **Model Card**: Select any model version and generate a complete documentation card with its metrics and metadata.
-8.  **Settings**: Configure system-level parameters, such as enabling or disabling the automated retraining loop.
+1.  **Train a Model**: Navigate to the **Model Training** tab, select the number of training samples, and click **Train New Model**. This will create the first version in the registry.
+2.  **Manage Models**: Go to the **Model Registry** tab. Click **Refresh Model List** to see all trained models. Select a version from the dropdown and click **Promote to Production** to make it active.
+3.  **Make Predictions**: In the **Make Predictions** tab, enter values for the features and click **Predict**. The result from the current production model will be displayed.
+4.  **Detect Drift**: Go to the **Drift Detection** tab and click **Check for Data Drift** to simulate checking a new batch of data against the original training data.
+5.  **Run an A/B Test**: In the **A/B Testing** tab, click **Start New A/B Test**. This will train a new challenger model and run it against the current production model. To generate results, make several predictions in the "Make Predictions" tab with the "Use A/B Test" checkbox ticked.
+6.  **Monitor Performance**: Check the **Performance Monitoring** and **Cost Tracking** tabs to see live operational dashboards for the system.
 
 ## Disclaimer
 
-This project is a comprehensive demonstration of an MLOps framework and operates on synthetically generated data. The models and workflows are designed for educational and illustrative purposes and should be adapted and validated for use in real-world production environments.
+This project is an advanced demonstration of MLOps principles and is intended for educational and portfolio purposes. It uses synthetically generated data for its training and drift detection processes. While built to be robust, it is not intended for direct use in a live production environment without extensive testing and validation.