How freshoats/nfl_injury_analytics works
Project Type and Purpose
• This is a full-stack data analytics & machine-learning application, built in Python, that ingests NFL injury and punt datasets, cleans and stores them in PostgreSQL, performs exploratory analysis and model training (Random Forests, Neural Networks, PCA + K-Means), produces visualizations (Matplotlib, Tableau) and exposes an interactive web interface via Flask.
File-Structure Analysis
• Top-level scripts:
• app.py / app - Copy.py – Flask web server entry points
• scraping.py, Web_Scraper.ipynb, Injury_Scraper.ipynb – data retrieval
• requirements*.txt – Python dependencies
• Data folders:
• SQL/ – DDL scripts (ERDs, schema) for PostgreSQL
• Exploratory_Analysis/, Machine_Learning_Files/, Preliminary_Models/, Proof_of_Concept/, Post_Analysis/ – Jupyter notebooks and Python modules for EDA, model prototyping, post-processing
• Web UI assets:
• templates/ – HTML pages (index, algorithm, stats, report, etc.)
• static/ – CSS, images
• Artefacts: result CSVs, Tableau workbook (.twbx)
• Configuration: .gitignore, README.md
README Insights
• Data sources: two Kaggle competitions (Injury, Punt)
• Database: PostgreSQL with two ERDs (Injury_DB, PuntAnalytics_DB), ingested via SQLAlchemy (some CSV fallbacks for very large tables)
• Pipeline:
• ETL/Data Cleaning functions (InjuryCleaningFunctions.py, Punt_Cleaner.py, etc.)
• Exploratory Data Analysis (notebooks)
• Machine Learning (supervised & unsupervised)
• Post-analysis & visualizations (Tableau, Matplotlib)
• Web app stitches static dashboards, ML results, narrative pages
a. Main Components
• Data Sources:
• Kaggle CSVs, tracking data (local CSVs), external web scrapes
• ETL Layer:
• Python scripts & modules (scraping.py, Injury_Scraper.ipynb, cleaning modules)
• SQLAlchemy connectors
• Database: PostgreSQL server (two schemas: injury_analytics, punt_analytics)
• Processing & ML Layer:
• Jupyter notebooks & Python modules under Machine_Learning_Files, Preliminary_Models, Post_Analysis
• Scikit-Learn (RandomForest, PCA, K-Means), Keras/TensorFlow (Neural Networks)
• Result artefacts: CSVs, SQL tables (Random_Forest_Outputs, Neural_Network_Outputs, Concussion_Analysis)
• Visualization Layer:
• Tableau Public dashboards (embedded via iFrames/JS)
• Python/Matplotlib notebooks for static plots
• Web Application (Flask):
• app.py routes → templates/ rendering with data pulls from PostgreSQL (SQLAlchemy) and embedded Tableau content
• static/ for CSS and images
• External Services: Render.com (hosting), PostgreSQL cloud, Tableau Public
b. Relationships & Data Flow
• Database ↔ Processing/ML Layer (reads base tables, writes result tables)
• ML Layer → Visualization Layer (publishes static CSVs, notebooks, Tableau extracts)
• Web App (Flask) → Database (via SQLAlchemy) and → Visualization Layer (embeds dashboards) → Browser UI
c. Architectural Patterns & Principles
• Layered (n-tier) architecture: Data Layer, Business/Analytics Layer, Presentation Layer
• Modular design: separate notebooks/scripts for cleaning, EDA, modeling, post-analysis
• Reuse of cleaning functions across pipelines (InjuryCleaningFunctions.py reused in ML & viz)
• Separation of concerns: web UI logic (Flask) vs. analytics (Jupyter/ML scripts)
d. Key Technologies & Frameworks
• Python 3.x, Flask, Jinja2 (templates)
• Pandas, NumPy for data manipulation
• SQLAlchemy for DB ORM
• PostgreSQL for persistent storage
• Scikit-Learn, imbalanced-learn, Keras/TensorFlow for ML
• Jupyter Notebooks for prototyping
• Tableau for interactive dashboards
• HTML, CSS, JavaScript for front-end
• Render.com (or similar) for deployment