Neural Networks for River Flow Prediction

A comprehensive implementation and comparison of artificial neural networks for predicting river flow using Multi-Layer Perceptrons (MLPs) with various optimization techniques.

🎯 Project Overview

This project demonstrates the application of artificial neural networks to environmental data analysis, specifically focusing on river flow prediction. The implementation includes multiple neural network architectures, training algorithms, and comprehensive performance analysis.

Key Features

• Custom MLP Implementation: Built from scratch with sigmoid activation functions
• Multiple Training Algorithms: Backpropagation, momentum, bold driver, and learning rate annealing
• Comprehensive Data Processing: Interpolation, feature engineering, and multiple standardization methods
• Advanced Visualization: Interactive plots, correlation matrices, and performance comparisons
• Statistical Analysis: Bootstrap prediction intervals and model validation
• Professional Reporting: Automated figure generation and results export

📊 Results Summary

The project successfully demonstrates:

• High Prediction Accuracy: Best model achieved R² > 0.85 on test data
• Algorithm Comparison: Systematic evaluation of 6+ different training configurations
• Feature Analysis: Correlation analysis and feature importance evaluation
• Robust Validation: Cross-validation and prediction interval estimation

🚀 Quick Start

Option 1: Interactive Jupyter Notebook (Recommended)

# Clone the repository
git clone https://github.com/dominichubble/neural-networks-river-prediction.git
cd neural-networks-river-prediction

# Install dependencies
pip install -r requirements.txt

# Launch Jupyter and open the main analysis notebook
jupyter notebook AI_ANN_Coursework_Analysis.ipynb

Option 2: Command Line Execution

# Run the complete analysis
python main.py

📁 Project Structure

├── 📓 AI_ANN_Coursework_Analysis.ipynb    # Main interactive analysis notebook
├── 🐍 main.py                            # Command-line interface
├── 📊 data/                              # Processed datasets and results
├── 🧠 mlp/                               # Neural network implementation
│   ├── mlp.py                           # Core MLP functions
│   ├── network_training.py             # Training algorithms
│   └── network_initialization.py       # Weight initialization
├── 🔧 utils/                            # Utility modules
│   ├── data_processor.py               # Data preprocessing
│   ├── experiment_manager.py           # Experiment orchestration
│   └── report_visualizer.py            # Visualization functions
├── 🧪 evaluation/                       # Model evaluation tools
├── 📈 plots/                            # Generated visualizations
├── 📋 requirements.txt                  # Python dependencies
└── 📖 README.md                         # This file

🛠️ Technical Implementation

Neural Network Architecture

• Input Layer: Variable size based on feature engineering
• Hidden Layers: Configurable (single/multiple layers)
• Output Layer: Single node for regression
• Activation: Sigmoid function with custom derivative

Training Algorithms

1. Standard Backpropagation: Basic gradient descent
2. Momentum: Accelerated convergence with momentum term
3. Bold Driver: Adaptive learning rate adjustment
4. Learning Rate Annealing: Exponential, linear, and cosine decay

Data Processing Pipeline

1. Data Loading: Excel file parsing with pandas
2. Interpolation: Missing value handling
3. Feature Engineering: Time-based and statistical features
4. Standardization: Multiple methods (robust, z-score, min-max)
5. Train/Validation/Test Split: Temporal splitting for time series

📈 Performance Metrics

The models are evaluated using:

• Mean Squared Error (MSE)
• Root Mean Squared Error (RMSE)
• Mean Absolute Error (MAE)
• R-squared (R²)
• Training Time and Efficiency

📊 Visualizations

The project generates comprehensive visualizations including:

• Data distribution and correlation analysis
• Learning curves and training progress
• Model performance comparisons
• Prediction vs. actual scatter plots
• Feature importance analysis
• Bootstrap prediction intervals

🔬 Key Findings

1. Robust standardization performed best for this dataset
2. Momentum-based training showed superior convergence
3. Feature engineering significantly improved prediction accuracy
4. Model ensemble potential identified for future work

📚 Dependencies

• Core: numpy, pandas, matplotlib
• Analysis: scipy, seaborn
• UI: tqdm, jupyter
• Data: openpyxl

👔 Portfolio Project

This project was developed as part of an AI/Neural Networks coursework and serves as a professional portfolio demonstration of machine learning expertise, software engineering skills, and data science capabilities.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

📬 Contact

Dominic Hubble

• GitHub: @dominichubble
• LinkedIn: Connect with me
• Email: [email protected]

💼 For Employers

This project demonstrates:

• Machine Learning Expertise: Custom neural network implementation from scratch
• Software Engineering Skills: Clean, modular code with comprehensive documentation
• Data Science Workflow: Complete pipeline from raw data to actionable insights
• Technical Communication: Ability to explain complex concepts clearly
• Professional Standards: Industry best practices and attention to detail

🏆 Portfolio Showcase

This project demonstrates proficiency in:

• ✅ Custom neural network implementation from mathematical foundations
• ✅ Multiple optimization algorithm comparisons and analysis
• ✅ Professional data science workflow with comprehensive documentation
• ✅ Software engineering best practices with modular, maintainable code
• ✅ Technical communication through clear explanations and visualizations

🎯 Key Achievements

• High Accuracy: Achieved R² > 0.85 on environmental prediction task
• Algorithm Mastery: Implemented 6+ different training optimization techniques
• Professional Quality: Industry-standard code organization and documentation
• Complete Pipeline: End-to-end solution from raw data to deployment-ready model

---

This repository serves as a professional portfolio demonstration of machine learning and software engineering capabilities.