Hi, I’m Nadine Shill, a data-driven researcher trained in applied & computational mathematics, building bioinformatics tools that turn complex biological data into actionable insight.

Build a reproducible ML workflow for tabular fraud prediction

Handle a feature schema consistently between training and inference

Deploy an interactive scoring app that:

Data preprocessing + feature engineering

Model training (XGBoost)

Save inference artifacts:

scaler.joblib (preprocessing)

feature_columns.json (expected schema/order)

xgboost.json (trained Booster)

Load a sample input file (sample_input.csv)

Upload a CSV (up to 200MB)

Adjust a fraud threshold slider (controls the classification cutoff)

Preview scored rows + download results

fraud_probability (0–1)

fraud_prediction (0/1 based on threshold)

Artifact-driven inference: ensures the same preprocessing + feature order used in training is enforced at prediction time

Threshold tuning UI: shows how business constraints can influence classification decisions

Batch scoring workflow: supports scoring many rows and exporting results for review

.

├── app.py

├── requirements.txt

├── sample_input.csv

├── artifacts/

│ ├── scaler.joblib

│ ├── feature_columns.json

│ └── xgboost.json

├── Fraud Detection 2.ipynb

└── README.md

Build an interactive clustering workflow that works out-of-the-box using a sample dataset and supports “bring your own CSV.”

Provide a practical output format: exportable clustered data for downstream use.

Make model choices explainable through:

visual cluster inspection (2D projection)

cluster size summaries

feature-level cluster profiles

selecting numeric features for clustering

cleaning invalid values (e.g., missing/infinite)

standardizing features (so distance-based clustering behaves as expected)

Data selection (sample dataset or uploaded CSV)

Feature selection (user-defined)

Scaling / preprocessing

Fit clustering model (K-Means)

Evaluate clustering quality (when applicable)

Visualize clusters using PCA (2D)

Export results with cluster assignments

Use a sample dataset (so the demo works immediately without external files)

(Optional) Upload a CSV and select clustering features

Tune K (number of clusters) via slider

View results instantly:

PCA cluster plot (2D visualization)

cluster counts (size distribution)

cluster profiles (mean feature values per cluster)

Download outputs:

original rows + cluster_id column for analysis and reuse

cluster_id (integer cluster assignment per row)

clustered dataset export (CSV)

Exploration-first UX: designed to help users choose reasonable clustering settings, not just run a model once.

Interpretability via profiling: cluster summaries reveal which features drive separation between segments.

Visualization as validation: PCA projection provides a quick sanity check for separation, overlap, and outliers.

Reproducible demo workflow: an end-to-end pipeline that runs cleanly in a deployed environment (not just locally).

.

├── app.py

├── Clustering.ipynb

├── requirements.txt

└── README.md

Build an interactive explorer to demonstrate and diagnose overdispersion in RNA-seq count data

Compare Poisson vs NB2 model fit in a reproducible, scalable workflow

Support multiple data workflows for real-world usability:

Sample dataset (works instantly)

Simulated dataset (controlled overdispersion + condition effects)

User upload (tidy RNA-seq counts CSV)

Poisson GLM (baseline for count data)

NB2 GLM (adds dispersion: Var(Y)=μ+αμ

Estimate gene-wise dispersion 𝛼 via a method-of-moments approach using each gene’s mean/variance

Load counts (sample / simulated / upload)

Validate schema and types for reliable modeling

Visualize gene-wise Mean vs Variance

Fit Poisson + NB2 per gene (capped for performance)

Compare fit metrics (AIC / log-likelihood)

Export a per-gene results table for downstream analysis

Choose a data source

Sample dataset (preloaded)

Simulated RNA-seq dataset (interactive sliders)

Upload your own tidy CSV: gene, sample, count (optional condition)

Simulated controls

Genes / samples

Dispersion 𝛼 (controls overdispersion)

Condition effect strength

Random seed

Modeling controls

Max genes to score (keeps the app fast)

Interactive outputs

Data preview + quick dataset stats

Mean–variance scatter (overdispersion check)

Poisson vs NB2 fit comparison:

AIC comparison plot

Table of per-gene fit metrics

Download results as CSV

Per-gene summary table including:

mean, var

alpha_est

poissonaic, nbaic

poissonllf, nbllf

better_model (Poisson vs NB2 based on AIC)

Educational + practical modeling: shows why Poisson often fails for RNA-seq counts and when NB2 is preferred

Three data workflows: sample + simulated + upload makes the demo immediately usable for anyone

Performance-aware scoring: gene scoring cap prevents slow deployments while still demonstrating real workflows

Clear reproducibility: modular src/ functions keep IO, simulation, and modeling logic clean and reusable

.

├── app.py

├── requirements.txt

├── data/

│ └── samplecountstidy.csv

├── src/

│ ├── init.py

│ ├── io_utils.py

│ ├── simulate.py

│ └── modeling.py

├── assets/ (figures/screenshots)

├── archive/ (original exports/plots/scripts)

└── README.md

Build a real-time pipeline that:

fetches live NWS alerts by state

normalizes and displays alerts in a readable table

Train a fast text-based classifier to identify Red Flag Warnings

Provide a stable demo experience even when live alerts are sparse by supporting:

Sample training dataset (recommended)

Live-alert training (experimental)

Add optional weather context (hourly temperature/humidity/wind) for a chosen location

Enable exportable outputs (scored alerts as CSV)

Sample dataset (recommended): uses a labeled CSV shipped with the repo so the app is always functional

Live alerts (experimental): derives labels from the alert event name when enough active alerts exist

Fetch live alerts → normalize into a consistent DataFrame

Build a training frame:

text = headline + description

target = 1 if event contains “Red Flag Warning” (live mode) or from labeled sample file (sample mode)

Train vectorizer + model (cached for performance)

Score alerts and display:

predicted probability (rfw_proba)

predicted label (rfw_pred)

Export scored results

Choose a state (CA, CO, OR, etc.) to view active alerts

Select training mode:

Sample dataset (recommended) for consistent behavior

Live alerts (experimental) for real-time training when enough alerts exist

Review training diagnostics:

training rows

positive labels

class diversity

View scored alerts ranked by predicted Red Flag Warning probability

Download the scored output as CSV

(Optional) View a 3-day hourly forecast for a chosen latitude/longitude to add context (temperature, humidity, wind)

rfw_proba (0–1)

rfw_pred (0/1)

Real-time ingestion: pulls active alerts from NWS and renders them in a clean interface

Two-mode training design: sample mode ensures the demo works reliably; live mode shows realism when alert volume supports it

Fast, explainable baseline: TF-IDF + XGBoost provides strong performance for text classification without heavy runtime cost

Guardrails for reliability: minimum-row checks and “single-class” detection prevent misleading training runs

Exportable workflow: users can download scored alert data for downstream review/analysis

.

├── app.py

├── requirements.txt

├── README.md

├── data/

│ └── sample_alerts.csv

├── src/

│ ├── init.py

│ ├── nws.py

│ ├── weather.py

│ └── ml.py

└── archive/

└── redflagwarning_classifier.py