hyvioq-v1.0.0

Hyvioq/hyvioq-v1.0.0

hyvioq-v1.0.0 is an XGBoost regression model that estimates flood probability from 20 environmental, infrastructure, climate, population, and disaster-preparedness factors. It is the first released model checkpoint from hyvioq, an ongoing flood-prediction project that also includes a companion mobile application.

The model outputs a continuous FloodProbability value in the approximate range 0–1, interpretable as an estimated probability of flooding under the given input conditions.

This model was independently developed and trained by Bindupautra Jyotibrat.

Model Details

Model Description

hyvioq-v1.0.0 is trained on a large tabular flood-risk dataset and learns the relationship between 20 numerical risk factors and the target variable FloodProbability.

It is intended as a research and demonstration model for flood-risk estimation, not as a substitute for official flood forecasting systems, hydrological models, emergency-management systems, or professional risk assessments.

• Developed by: Bindupautra Jyotibrat (BJyotibrat)
• Shared by: BJyotibrat
• Model type: XGBoost Regression
• Language(s): English (feature names and documentation)
• License: GPL-3.0

Model Sources

• Repository: Jyotibrat/hyvioq
• Training notebook: Flood_Prediction_XGBoost_v1.ipynb
• Evaluation results: Results/XGBoost
• Inference script: app.py in the repository (local script, no hosted demo at this time)

Uses

Direct Use

• Estimate flood probability from the 20 supported input features.
• Experiment with XGBoost-based flood-risk prediction.
• Demonstrate regression-based environmental risk modeling.
• Support research and educational work involving tabular flood prediction.

Input Features

The model accepts 20 numerical features, each on a scale of approximately 1–10:

Target: FloodProbability

Downstream Use

The model may be integrated into research prototypes, educational applications, data-analysis pipelines, environmental-risk dashboards, or experimental decision-support systems — including as one component of the broader hyvioq mobile app. Any downstream application should clearly communicate that predictions are model estimates, not authoritative flood warnings.

Out-of-Scope Use

This model should not be used as the sole basis for:

• Emergency evacuation or public safety decisions
• Disaster-response or infrastructure-safety decisions
• Insurance, financial, or government policy decisions
• Real-time flood forecasting

The model does not ingest real-time rainfall, river-level, weather-radar, satellite, hydrological, or sensor data, so its predictions should not be treated as real-time forecasts.

Bias, Risks, and Limitations

• The model is trained on one tabular dataset and may not generalize across all geographic regions or environmental conditions.
• Input features are abstract numerical scores rather than direct physical measurements.
• The model does not capture temporal dynamics in weather, rainfall, river discharge, or soil moisture.
• Predictions may be unreliable for inputs outside the training distribution.
• A high (or low) predicted probability does not guarantee that flooding will (or will not) occur.
• The model offers no causal explanation for its predictions.
• Reported metrics reflect performance on the held-out test split of the training dataset, not real-world deployment.

Recommendations

• Use the same feature definitions and numerical ranges as training.
• Validate inputs before inference and avoid extrapolating far outside the training distribution.
• Treat outputs as estimates, not definitive warnings.
• Validate against geographically and temporally independent data before any real-world use.
• Combine with real-time meteorological, hydrological, and sensor data for operational systems.
• Defer to official governmental flood-warning sources for real-world safety decisions.

How to Get Started with the Model

pip install -r requirements.txt

import xgboost as xgb

model = xgb.XGBRegressor()
model.load_model("flood_model.json")

import pandas as pd

input_data = pd.DataFrame([{
    "MonsoonIntensity": 5,
    "TopographyDrainage": 6,
    "RiverManagement": 5,
    "Deforestation": 4,
    "Urbanization": 6,
    "ClimateChange": 5,
    "DamsQuality": 6,
    "Siltation": 4,
    "AgriculturalPractices": 5,
    "Encroachments": 4,
    "IneffectiveDisasterPreparedness": 5,
    "DrainageSystems": 6,
    "CoastalVulnerability": 4,
    "Landslides": 3,
    "Watersheds": 5,
    "DeterioratingInfrastructure": 4,
    "PopulationScore": 5,
    "WetlandLoss": 4,
    "InadequatePlanning": 5,
    "PoliticalFactors": 4
}])

prediction = model.predict(input_data)[0]
print(f"Flood Probability: {prediction:.4f} ({prediction * 100:.2f}%)")

Alternatively, run the provided app.py for a local inference interface.

Example Run

Below is an example console session showing values entered for each feature and the resulting prediction and risk level:

(Replace path/to/inference-example.png with the image path once it's added to the repository, e.g. assets/inference-example.png.)

Training Details

Training Data

The model was trained on the Flood Prediction Dataset, hosted on Kaggle under the CC0 1.0 Universal (Public Domain) license, downloaded via the Kaggle API. train.csv (1,117,957 samples) was used for training and flood.csv for evaluation.

Note: The Kaggle listing notes the dataset has no verifiable external source and is re-uploaded for educational and research purposes only; provenance, collection methods, and exact geographic coverage are unknown.

Training Procedure

1. Load the dataset with pandas; drop the id column when present.
2. Separate FloodProbability as the regression target.
3. Use the remaining 20 columns as model features directly (no neural-network feature extraction or transfer learning).
4. Train with XGBoost's XGBRegressor.

Training Hyperparameters

XGBRegressor(
    n_estimators=200,
    learning_rate=0.05,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    random_state=42,
    objective="reg:squarederror",
    eval_metric="rmse"
)

The notebook also contains an earlier 500-estimator configuration evaluated on flood.csv.

Speeds, Sizes, Times

Training ran on a Google Colab NVIDIA T4 GPU in under one hour.

• Training regime: FP32 / standard XGBoost numerical computation

Evaluation

Testing Data

Evaluation used flood.csv from the same dataset, with the same 20 features and FloodProbability target.

Metrics

• RMSE — average magnitude of prediction error (lower is better)
• R² — proportion of variance explained (closer to 1 is better)

Results

Full evaluation logs and results are available at Results/XGBoost. These results are from the held-out evaluation split and should not be interpreted as guaranteed real-world performance.

Model Examination

The model is a gradient-boosted decision-tree ensemble (XGBoost). It can be examined further with feature importance, SHAP values, or partial-dependence analysis; no formal interpretability study is included in this release.

Environmental Impact

Carbon emissions can be estimated with the ML Impact calculator (Lacoste et al., 2019).

• Hardware Type: NVIDIA T4 GPU
• Hours used: < 1 hour
• Cloud Provider: Google Colab

Technical Specifications

Model Architecture and Objective

Extreme Gradient Boosting (XGBoost) regression, objective reg:squarederror, predicting continuous FloodProbability from 20 numerical features.

Compute Infrastructure

• Hardware: NVIDIA T4 GPU
• Software: Python, XGBoost, pandas, NumPy, scikit-learn, Matplotlib, Kaggle API

See requirements.txt in the repository for exact dependencies.

Citation

BibTeX:

@software{jyotibrat_hyvioq_v1,
  author  = {Bindupautra Jyotibrat},
  title   = {hyvioq-v1.0.0: XGBoost Flood Prediction Model},
  year    = {2026},
  publisher = {Hugging Face},
  url     = {https://huggingface.co/BJyotibrat/hyvioq-v1.0.0}
}

APA:

Jyotibrat, B. (2026). hyvioq-v1.0.0: XGBoost Flood Prediction Model. Hugging Face. https://huggingface.co/BJyotibrat/hyvioq-v1.0.0

Glossary

• FloodProbability — the continuous target predicted by the model, representing estimated flood probability.
• XGBoost — Extreme Gradient Boosting, a gradient-boosted decision-tree framework.
• RMSE — Root Mean Squared Error, a regression error metric.
• R² — coefficient of determination, describing variance explained by the model.
• Inference — using the trained model to generate a prediction for new input data.

Repository Contents

• flood_model.json — XGBoost model representation
• flood_model.pkl — serialized Python model
• config.json — model configuration
• app.py — local inference script
• requirements.txt — Python dependencies

Authors

• Bindupautra Jyotibrat (BJyotibrat)

Contact

Email: [email protected]