From 6c0f7ab798ee9a0d657cd4a875f289cda584215a Mon Sep 17 00:00:00 2001 From: fasfous92 Date: Fri, 13 Feb 2026 10:43:01 +0100 Subject: [PATCH 1/6] finalized first version of the challenge --- .gitignore | 1 + competition.yaml | 42 +- ingestion_program/ingestion.py | 132 +-- requirements.txt | 2 + scoring_program/scoring.py | 107 ++- solution/submission.py | 38 +- starting_kit/zip_submission.py | 26 + template_starting_kit.ipynb | 1561 +++++++++++++++++++++++++++++++- tools/setup_data.py | 114 ++- 9 files changed, 1784 insertions(+), 239 deletions(-) create mode 100644 starting_kit/zip_submission.py diff --git a/.gitignore b/.gitignore index 9728749..8800a6e 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ ingestion_res/* scoring_res/* dev_phase/* +test_notebook/* diff --git a/competition.yaml b/competition.yaml index 3a1e4de..54467c2 100755 --- a/competition.yaml +++ b/competition.yaml @@ -1,22 +1,24 @@ version: 2 -title: Templat competition - Dummy classification -description: Dummy classification task +title: GEMS-GER Groundwater Level Prediction Challenge +description: Predict groundwater level (GWL) across Germany using 50+ environmental features. image: logo.png -registration_auto_approve: False # if True, do not require approval from admin to join the comp +registration_auto_approve: True # Set to True to let people jump right in terms: pages/terms.md pages: + - title: Overview + file: pages/overview.md + - title: Data Description + file: pages/data.md - title: Participation file: pages/participate.md - - title: Seed - file: pages/seed.md - title: Timeline file: pages/timeline.md tasks: - index: 0 - name: Developement Task - description: 'Tune models with training data, test against examples contained in public test data' + name: GWL Regression Task + description: 'Predict depth to groundwater using historical time-series and static site data.' input_data: dev_phase/input_data/ reference_data: dev_phase/reference_data/ ingestion_program: ingestion_program/ @@ -28,12 +30,11 @@ solutions: - 0 path: solution/ - phases: - name: Development Phase - description: 'Development phase: tune your models.' - start: 10-07-2025 - end: 03-31-2026 + description: 'Train on historical data and submit predictions for the Public Leaderboard.' + start: 02-13-2026 # Starting today! + end: 05-31-2026 tasks: - 0 @@ -41,20 +42,7 @@ leaderboards: - title: Results key: main columns: - - title: Test Accuracy - key: test + - title: RMSE + key: rmse # Must match scores['rmse'] in scoring.py index: 0 - sorting: asc - - title: Private Test Accuracy - key: private_test - index: 1 - sorting: asc - hidden: True - - title: Train time - key: train_time - index: 2 - sorting: desc - - title: Test time - key: test_time - index: 3 - sorting: desc + sorting: asc # Lower is better! diff --git a/ingestion_program/ingestion.py b/ingestion_program/ingestion.py index f150b05..5d1b00b 100755 --- a/ingestion_program/ingestion.py +++ b/ingestion_program/ingestion.py @@ -2,91 +2,99 @@ import sys import time from pathlib import Path - import pandas as pd - -EVAL_SETS = ["test", "private_test"] - +# We only have one test set now +EVAL_SETS = ["test"] def evaluate_model(model, X_test): - + """ + Generate predictions. + Note: We pass the RAW X_test to the model. + The participant's pipeline must handle dropping strings! + """ y_pred = model.predict(X_test) - return pd.DataFrame(y_pred) - + return pd.DataFrame({'GWL': y_pred}) -def get_train_data(data_dir): +def get_train_data(data_dir, chunksize=100000): + """ + Loads 'train.csv' in chunks for memory safety. + Contains both features and labels. + """ data_dir = Path(data_dir) - training_dir = data_dir / "train" - X_train = pd.read_csv(training_dir / "train_features.csv") - y_train = pd.read_csv(training_dir / "train_labels.csv") + train_path = data_dir / "train" / "train.csv" + + # Fallback for local testing vs Codabench environment + if not train_path.exists(): + train_path = data_dir / "train.csv" + + print(f"Reading {train_path} in chunks...") + + chunks = [] + for chunk in pd.read_csv(train_path, chunksize=chunksize): + chunks.append(chunk) + + full_df = pd.concat(chunks, axis=0) + + y_train = full_df['GWL'] + X_train = full_df.drop(columns=['GWL']) + return X_train, y_train - def main(data_dir, output_dir): - # Here, you can import info from the submission module, to evaluate the - # submission + # Import the participant's model from submission import get_model + print("--- 1. Loading Training Data ---") X_train, y_train = get_train_data(data_dir) - print("Training the model") - + print("--- 2. Training the Model ---") model = get_model() - start = time.time() + start_train = time.time() model.fit(X_train, y_train) - train_time = time.time() - start - print("-" * 10) - print("Evaluate the model") - start = time.time() - res = {} - for eval_set in EVAL_SETS: - X_test = pd.read_csv(data_dir / eval_set / f"{eval_set}_features.csv") - res[eval_set] = evaluate_model(model, X_test) - test_time = time.time() - start - print("-" * 10) - duration = train_time + test_time - print(f"Completed Prediction. Total duration: {duration}") - - # Write output files + train_time = time.time() - start_train + print(f"Training completed in {train_time:.2f}s") + + print("--- 3. Evaluating on Test Set ---") + start_test = time.time() + + # Load test features (Matches setup_data.py output) + X_test_path = data_dir / "test" / "test_features.csv" + X_test = pd.read_csv(X_test_path) + + y_test_pred = evaluate_model(model, X_test) + + test_time = time.time() - start_test + print(f"Testing completed in {test_time:.2f}s") + + # --- 4. Write Output Files --- output_dir.mkdir(parents=True, exist_ok=True) - with open(output_dir / "metadata.json", "w+") as f: - json.dump(dict(train_time=train_time, test_time=test_time), f) - for eval_set in EVAL_SETS: - filepath = output_dir / f"{eval_set}_predictions.csv" - res[eval_set].to_csv(filepath, index=False) - print() - print("Ingestion Program finished. Moving on to scoring") - + + # Save metadata for the leaderboard (Runtime) + with open(output_dir / "metadata.json", "w") as f: + json.dump({ + "train_time": train_time, + "test_time": test_time, + "duration": train_time + test_time + }, f) + + # Save predictions (Matches what scoring.py expects) + y_test_pred.to_csv(output_dir / "test_predictions.csv", index=False) + + print(f"Ingestion finished. Total duration: {train_time + test_time:.2f}s") if __name__ == "__main__": import argparse - - parser = argparse.ArgumentParser( - description="Ingestion program for codabench" - ) - parser.add_argument( - "--data-dir", - type=str, - default="/app/input_data", - help="", - ) - parser.add_argument( - "--output-dir", - type=str, - default="/app/output", - help="", - ) - parser.add_argument( - "--submission-dir", - type=str, - default="/app/ingested_program", - help="", - ) + parser = argparse.ArgumentParser(description="Ingestion program") + parser.add_argument("--data-dir", type=str, default="/app/input_data") + parser.add_argument("--output-dir", type=str, default="/app/output") + parser.add_argument("--submission-dir", type=str, default="/app/ingested_program") args = parser.parse_args() + + # Add submission and current folder to path so we can find 'submission.py' sys.path.append(args.submission_dir) - sys.path.append(Path(__file__).parent.resolve()) + sys.path.append(str(Path(__file__).parent.resolve())) main(Path(args.data_dir), Path(args.output_dir)) diff --git a/requirements.txt b/requirements.txt index fda4dd6..210fb4e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,4 @@ pandas scikit-learn +tqdm +matplotlib diff --git a/scoring_program/scoring.py b/scoring_program/scoring.py index 701f78f..79f2654 100755 --- a/scoring_program/scoring.py +++ b/scoring_program/scoring.py @@ -1,72 +1,69 @@ import json from pathlib import Path - import pandas as pd +import numpy as np +from sklearn.metrics import mean_squared_error -EVAL_SETS = ["test", "private_test"] - - -def compute_accuracy(predictions, targets): - # Make sure there is no NaN, as pandas ignores them in mean computation - predictions = predictions.fillna(-10).values - # Return mean of correct predictions - return (predictions == targets.values).mean() +def compute_rmse(predictions, targets): + """ + Calculates the Root Mean Squared Error (RMSE) for Groundwater Level Prediction. + """ + # Ensure inputs are handled correctly whether they are DataFrames or Series + y_pred = predictions.iloc[:, 0] if isinstance(predictions, pd.DataFrame) else predictions + y_true = targets.iloc[:, 0] if isinstance(targets, pd.DataFrame) else targets + # Align predictions with ground truth and remove any missing values in labels + combined = pd.concat([ + pd.Series(y_pred, name='pred').reset_index(drop=True), + pd.Series(y_true, name='true').reset_index(drop=True) + ], axis=1).dropna() + + if combined.empty: + print("Warning: No overlapping data found for scoring.") + return 999.0 + + # Calculate RMSE + rmse = np.sqrt(mean_squared_error(combined['true'], combined['pred'])) + return float(rmse) def main(reference_dir, prediction_dir, output_dir): scores = {} - for eval_set in EVAL_SETS: - print(f'Scoring {eval_set}') - - predictions = pd.read_csv( - prediction_dir / f'{eval_set}_predictions.csv' - ) - targets = pd.read_csv( - reference_dir / f'{eval_set}_labels.csv' - ) + eval_set = "test" + + try: + # Load predictions and reference labels + predictions = pd.read_csv(prediction_dir / f'{eval_set}_predictions.csv') + targets = pd.read_csv(reference_dir / eval_set / f'{eval_set}_labels.csv') - scores[eval_set] = float(compute_accuracy(predictions, targets)) + # Calculate the score + scores['rmse'] = compute_rmse(predictions, targets) + + except Exception as e: + print(f"❌ Scoring Error: {e}") + scores['rmse'] = 999.0 - # Add train and test times in the score - json_durations = (prediction_dir / 'metadata.json').read_text() - durations = json.loads(json_durations) - scores.update(**durations) - print(scores) + # Include runtime metadata for the leaderboard + try: + metadata_path = prediction_dir / 'metadata.json' + if metadata_path.exists(): + durations = json.loads(metadata_path.read_text()) + scores.update(durations) + except Exception: + pass - # Write output scores + # Save to scores.json for Codabench output_dir.mkdir(parents=True, exist_ok=True) - (output_dir / 'scores.json').write_text(json.dumps(scores)) - + with open(output_dir / 'scores.json', 'w') as f: + json.dump(scores, f) + + print(f"Scoring finished. Leaderboard RMSE: {scores['rmse']:.4f}") if __name__ == "__main__": import argparse - - parser = argparse.ArgumentParser( - description="Scoring program for codabench" - ) - parser.add_argument( - "--reference-dir", - type=str, - default="/app/input/ref", - help="", - ) - parser.add_argument( - "--prediction-dir", - type=str, - default="/app/input/res", - help="", - ) - parser.add_argument( - "--output-dir", - type=str, - default="/app/output", - help="", - ) - + parser = argparse.ArgumentParser() + parser.add_argument("--reference-dir", type=str, default="/app/input/ref") + parser.add_argument("--prediction-dir", type=str, default="/app/input/res") + parser.add_argument("--output-dir", type=str, default="/app/output") args = parser.parse_args() - main( - Path(args.reference_dir), - Path(args.prediction_dir), - Path(args.output_dir) - ) + main(Path(args.reference_dir), Path(args.prediction_dir), Path(args.output_dir)) diff --git a/solution/submission.py b/solution/submission.py index a8076b0..ed399dd 100644 --- a/solution/submission.py +++ b/solution/submission.py @@ -1,7 +1,37 @@ -from sklearn.ensemble import RandomForestClassifier +from sklearn.ensemble import RandomForestRegressor +from sklearn.compose import ColumnTransformer +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import StandardScaler +from sklearn.ensemble import RandomForestRegressor +from sklearn.compose import ColumnTransformer +from sklearn.compose import make_column_selector as selector +from sklearn.pipeline import Pipeline +from sklearn.impute import SimpleImputer -# The submission here should simply be a function that returns a model -# compatible with scikit-learn API def get_model(): - return RandomForestClassifier() + """ + Returns a model that automatically filters out string columns + to avoid ValueErrors and fits on numeric data only. + """ + + # 1. Define a transformer that ONLY picks numeric columns (float64, int64) + # This automatically ignores 'well_id_str' and 'date_dt' because they are strings/objects + numeric_transformer = Pipeline(steps=[ + ('imputer', SimpleImputer(strategy='median')) + ]) + + preprocessor = ColumnTransformer( + transformers=[ + ('num', numeric_transformer, selector(dtype_include=['float64', 'int64'])) + ], + remainder='drop' # This explicitly drops anything that isn't a number + ) + + # 2. Create the full pipeline + model = Pipeline(steps=[ + ('preprocessor', preprocessor), + ('regressor', RandomForestRegressor(n_estimators=50, max_depth=8, random_state=42)) + ]) + + return model diff --git a/starting_kit/zip_submission.py b/starting_kit/zip_submission.py new file mode 100644 index 0000000..c3fe5a8 --- /dev/null +++ b/starting_kit/zip_submission.py @@ -0,0 +1,26 @@ +import zipfile +from pathlib import Path + +# This script zips the submission.py from the solution folder +# so it's ready to be uploaded to Codabench. + +def create_submission_zip(output_filename="submission.zip"): + # Path to the participant's actual code + # Assuming they are working in the starting_kit/solution/ directory + submission_script = Path("solution/submission.py") + + if not submission_script.exists(): + print(f"❌ Error: {submission_script} not found!") + print("Make sure you are running this script from the starting_kit root.") + return + + with zipfile.ZipFile(output_filename, 'w') as zipf: + # Crucial: We write 'submission.py' as the arcname + # so it's at the root of the ZIP, not in a folder. + zipf.write(submission_script, arcname="submission.py") + + print(f"✅ Success! Created '{output_filename}'.") + print("You can now upload this file to the Codabench platform.") + +if __name__ == "__main__": + create_submission_zip() diff --git a/template_starting_kit.ipynb b/template_starting_kit.ipynb index 7167a3a..f654f03 100644 --- a/template_starting_kit.ipynb +++ b/template_starting_kit.ipynb @@ -11,23 +11,62 @@ " \n", "\n", "\n", - "# Template Kit for Cadabench challenge in the Datacamp\n", + "# GEMS-GER Groundwater Level Prediction Challenge\n", "\n", - " Thomas Moreau (Inria)
\n", - " Pedro Rodrigues (Inria) " + "## Introduction\n", + "Groundwater is a critical resource for drinking water and agriculture. This challenge uses the **GEMS-GER** dataset, which provides historical groundwater levels (GWL) and over 50 environmental features (meteorological and static site data) across Germany.\n", + "\n", + "**The Task:** Predict the depth to groundwater (GWL) for various monitoring wells.\n", + "**The Metric:** Root Mean Squared Error (RMSE). Lower is better.\n", + "\n", + " Youssef SIDHOM
\n", + " Ralph " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Introduction\n", + "## 📊 Data Source & Attribution\n", + "\n", + "This challenge utilizes the **GEMS-GER (Groundwater Levels, Environment, Meteorology, and Site Properties for Germany)** dataset, a multi-source benchmark for groundwater level prediction.\n", + "\n", + "### **Dataset Overview**\n", "\n", - "Describe the challenge, in particular:\n", + "* **Source:** [Copernicus ESSD / Zenodo](https://doi.org/10.5281/zenodo.15530171)\n", + "* **Temporal Coverage:** Filtered for the most recent 5 years (2021–2026).\n", + "* **Spatial Coverage:** 3,200+ monitoring wells across Germany.\n", + "* **Features:** Includes 50+ static environmental variables (geology, soil, topography) and dynamic meteorological drivers (HYRAS, ERA5, and DWD products).\n", "\n", - "- Where the data comes from?\n", - "- What is the task this challenge aims to solve?\n", - "- Why does it matter?" + "### **Data Citation**\n", + "\n", + "If you use this data or the results of this challenge in your own research, please cite the original authors:\n", + "\n", + "> *Benz, S. A., et al. (2026). GEMS-GER: A machine learning benchmark dataset for groundwater level modeling in Germany. Earth System Science Data (ESSD).*\n", + "\n", + "### **License**\n", + "\n", + "This dataset is provided under the **Creative Commons Attribution 4.0 International (CC BY 4.0)** license. You are free to share and adapt the material as long as appropriate credit is given.\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Getting Started\n", + "Before loading data, we run the setup script to download and split the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the setup script to download and prepare the folders\n", + "!python tools/setup_data.py" ] }, { @@ -46,7 +85,15 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading dev_phase/input_data/train/train.csv in chunks...\n" + ] + } + ], "source": [ "%matplotlib inline\n", "import numpy as np\n", @@ -63,43 +110,150 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Challenge evaluation\n", + "# Challenge Evaluation\n", "\n", - "A particularly important point in a challenge is to describe how it is evaluated. This is the section where you should describe the metric that will be used to evaluate the participants' submissions, as well as your evaluation strategy, in particular if there is some complexity in the way the data should be split to ensure valid results." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Submission format\n", + "To ensure the results are robust and reflect real-world forecasting capabilities, we evaluate submissions using a **Temporal Split** strategy.\n", + "\n", + "#### 1. Evaluation Metric: RMSE\n", + "\n", + "The primary metric for this challenge is the **Root Mean Squared Error (RMSE)**.\n", + "\n", + "\n", + "This metric is particularly suitable for groundwater prediction because it penalizes large errors more heavily than small ones, which is critical for water resource management and flood/drought prevention.\n", + "\n", + "* **Lower is Better:** A perfect prediction would result in an RMSE of 0.\n", + "* **Units:** The RMSE is in the same units as the target variable (meters of depth to groundwater).\n", + "\n", + "#### 2. Evaluation Strategy: Temporal Holdout\n", + "\n", + "Unlike standard cross-validation where data is shuffled, groundwater levels are highly dependent on time and seasonal cycles. To simulate a real-world scenario where we predict the *future* based on the *past*:\n", + "\n", + "* **Training Data:** Consists of the earliest **80%** of the historical timeline.\n", + "* **Test Data:** Consists of the most recent **20%** of the records.\n", + "* **Data Leakage Prevention:** By splitting strictly by date, we ensure the model cannot \"see\" future weather patterns or water levels during the training phase.\n", + "\n", + "#### 3. Handling Metadata\n", "\n", - "Here, you should describe the submission format. This is the format the participants should follow to submit their predictions on the codabench platform." + "Participants are provided with raw `well_id` and `date` columns. While these cannot be passed directly into a standard regressor (like Random Forest or XGBoost), they are essential for:\n", + "\n", + "* **Seasonal Features:** Extracting month/year patterns.\n", + "* **Spatial Consistency:** Understanding that certain wells behave similarly due to shared geological characteristics.\n", + "\n", + "Submissions must include a preprocessing step (ideally via a `scikit-learn` Pipeline) to manage these non-numeric columns.\n", + "\n", + "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## The submission file\n", + "## The Submission File\n", + "\n", + "In this challenge, your submission is not a file of predictions, but the **code** itself. The ingestion program expects a file named `submission.py` containing a `get_model()` function.\n", + "\n", + "### From DataFrames to Numeric Arrays\n", + "\n", + "The input data provided by the competition is stored in a **Pandas DataFrame**. However, most machine learning models (like those in Scikit-Learn) require a **NumPy array** of floats to perform calculations. \n", + "\n", + "Because our dataset contains \"metadata\" columns like `well_id_str` (strings) and `date_dt` (dates), we cannot simply pass the whole DataFrame to the model. We must transform it first.\n", + "\n", + "### Using Scikit-Learn `ColumnTransformer`\n", + "\n", + "To bridge the gap between a messy DataFrame and a clean NumPy array, we use a `ColumnTransformer`. This tool allows us to apply different transformations to different columns. \n", + "\n", + "**The simplest strategy is to select only the numeric columns and drop the rest.**\n", + "\n", + "\n", + "\n", + "### Example: Simple Column Selection\n", + "\n", + "Here is how you can define a model that automatically filters out the string columns and only works with the numeric features:\n", + "\n", + "```python\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.compose import make_column_selector as selector\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "def get_model():\n", + " # 1. Define the ColumnTransformer\n", + " # We use a selector to automatically pick columns with float or int types.\n", + " # The 'remainder=drop' setting ensures that strings like well IDs are removed.\n", + " preprocessor = ColumnTransformer(\n", + " transformers=[\n", + " ('num', 'passthrough', selector(dtype_include=['float64', 'int64']))\n", + " ],\n", + " remainder='drop'\n", + " )\n", + "\n", + " # 2. Bundle the preprocessor and the regressor into a Pipeline\n", + " model = Pipeline(steps=[\n", + " ('preprocessor', preprocessor),\n", + " ('regressor', RandomForestRegressor(n_estimators=10, max_depth=5))\n", + " ])\n", + " \n", + " return model\n", + "\n", + "```\n", + "\n", + "### Why use a Pipeline?\n", + "\n", + "By using a `Pipeline`, you ensure that the same transformations applied to your **Training Data** are automatically applied to the **Test Data** during evaluation. This prevents \"Dimension Mismatch\" errors and ensures your model always receives the correct numeric input format.\n", + "\n", + "\n", + "\n", "\n", - "The input data are stored in a dataframe. To go from a dataframe to a numpy array we will use a scikit-learn column transformer. The first example we will write will just consist in selecting a subset of columns we want to work with." + "### What this explains to your participants:\n", + "\n", + "1. **Data Format**: They now know the input is a DataFrame.\n", + "2. **The \"Why\"**: They understand why they can't just throw the whole table at a model (because of the string columns).\n", + "3. **The \"How\"**: They see a concrete example of using `selector` to pick only numbers, which is the most robust way to avoid the `ValueError` they would otherwise get.\n", + "\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# %load solution/submission.py\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.compose import make_column_selector as selector\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.impute import SimpleImputer\n", "\n", - "# The submission here should simply be a function that returns a model\n", - "# compatible with scikit-learn API\n", "def get_model():\n", - " return RandomForestClassifier()\n" + " \"\"\"\n", + " Returns a model that automatically filters out string columns \n", + " to avoid ValueErrors and fits on numeric data only.\n", + " \"\"\"\n", + " \n", + " # 1. Define a transformer that ONLY picks numeric columns (float64, int64)\n", + " # This automatically ignores 'well_id_str' and 'date_dt' because they are strings/objects\n", + " numeric_transformer = Pipeline(steps=[\n", + " ('imputer', SimpleImputer(strategy='median'))\n", + " ])\n", + "\n", + " preprocessor = ColumnTransformer(\n", + " transformers=[\n", + " ('num', numeric_transformer, selector(dtype_include=['float64', 'int64']))\n", + " ],\n", + " remainder='drop' # This explicitly drops anything that isn't a number\n", + " )\n", + "\n", + " # 2. Create the full pipeline\n", + " model = Pipeline(steps=[\n", + " ('preprocessor', preprocessor),\n", + " ('regressor', RandomForestRegressor(n_estimators=50, max_depth=8, random_state=42))\n", + " ])\n", + " \n", + " return model\n" ] }, { @@ -120,29 +274,1337 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy on test set: 0.95\n" + "Reading dev_phase/input_data/train/train.csv in chunks...\n" ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/tom/.local/miniconda/lib/python3.12/site-packages/sklearn/base.py:1363: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n", - " return fit_method(estimator, *args, **kwargs)\n" - ] + "data": { + "text/html": [ + "
Pipeline(steps=[('preprocessor',\n",
+       "                 ColumnTransformer(transformers=[('num',\n",
+       "                                                  Pipeline(steps=[('imputer',\n",
+       "                                                                   SimpleImputer(strategy='median'))]),\n",
+       "                                                  <sklearn.compose._column_transformer.make_column_selector object at 0x71f94a7443e0>)])),\n",
+       "                ('regressor',\n",
+       "                 RandomForestRegressor(max_depth=8, n_estimators=50,\n",
+       "                                       random_state=42))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('preprocessor',\n", + " ColumnTransformer(transformers=[('num',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(strategy='median'))]),\n", + " )])),\n", + " ('regressor',\n", + " RandomForestRegressor(max_depth=8, n_estimators=50,\n", + " random_state=42))])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ + "from solution.submission import get_model\n", "model = get_model()\n", "X_train, y_train = get_train_data(\"dev_phase/input_data\")\n", - "model.fit(X_train, y_train)\n", + "model.fit(X_train, y_train)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "\n", "X_test = pd.read_csv(\"dev_phase/input_data/test/test_features.csv\")\n", "from ingestion_program.ingestion import evaluate_model\n", "y_test = evaluate_model(model, X_test)\n", - "\n", - "from scoring_program.scoring import compute_accuracy\n", - "print(\"Accuracy on test set:\", compute_accuracy(y_test, pd.read_csv(\"dev_phase/input_data/test/test_labels.csv\")))" + "from scoring_program.scoring import compute_rmse\n", + "print(\"Accuracy on test set:\", compute_rmse(y_test, pd.read_csv(\"path_to_test_labels\"))) #the test data wouldn't be accesible keep in minde " ] }, { @@ -151,18 +1613,23 @@ "source": [ "## Submission\n", "\n", - "To submit your code, you can refer to the actual challenge." + "Once you have refined your model in `solution/submission.py`, you need to upload it to the Codabench platform. \n", + "\n", + "### The Rules of the ZIP\n", + "Codabench is very strict about the structure of your upload:\n", + "1. Your ZIP file must contain `submission.py` at the **root level**.\n", + "2. If `submission.py` is hidden inside a folder within the ZIP, the platform will not find your `get_model()` function and your submission will fail.\n", + "\n", + "\n", + "\n", + "### Using the Helper Script\n", + "To make this easy, we have provided a helper script called `zip_submission.py`. This script automatically finds your code and packages it into a `submission.zip` file with the correct internal structure." ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -176,7 +1643,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.10" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/tools/setup_data.py b/tools/setup_data.py index 5bdc3a9..8c6f3f1 100644 --- a/tools/setup_data.py +++ b/tools/setup_data.py @@ -1,53 +1,79 @@ -# Script to download the data from a given source and create the splits -# This is a mock version that generate fake problems +import pandas as pd +import os +import requests +import zipfile +import shutil from pathlib import Path -import numpy as np -import pandas as pd -from sklearn.datasets import make_classification -from sklearn.model_selection import train_test_split +# --- CONFIGURATION --- +ZENODO_URL = "https://zenodo.org/records/16736908/files/GEMS-GER_data.zip?download=1" +RAW_DIR = Path("raw_data") +EXTRACT_DIR = RAW_DIR / "extracted" +MAX_TRAIN_ROWS = 100000 # <--- LIMIT TRAINING SIZE HERE (e.g., 100k rows) -PHASE = 'dev_phase' +def run_setup(): + # 1. Directory Setup + input_base = Path("dev_phase/input_data") + for f in ["train", "test"]: (input_base / f).mkdir(parents=True, exist_ok=True) + Path("dev_phase/reference_data/test").mkdir(parents=True, exist_ok=True) + EXTRACT_DIR.mkdir(parents=True, exist_ok=True) -DATA_DIR = Path(PHASE) / 'input_data' -REF_DIR = Path(PHASE) / 'reference_data' + # 2. Download & Extract (Same logic as before) + zip_path = RAW_DIR / "GEMS-GER_data.zip" + if not zip_path.exists(): + print("Downloading...") + r = requests.get(ZENODO_URL, stream=True) + with open(zip_path, 'wb') as f: + for chunk in r.iter_content(chunk_size=8192): f.write(chunk) + + with zipfile.ZipFile(zip_path, 'r') as zip_ref: + zip_ref.extractall(EXTRACT_DIR) + # 3. Locate & Merge + static_file = next(EXTRACT_DIR.rglob("*static*.csv")) + dynamic_folder = next(EXTRACT_DIR.rglob("dynamic")) + df_static = pd.read_csv(static_file) + df_static.columns = df_static.columns.str.strip() -def make_csv(data, filepath): - filepath.parent.mkdir(parents=True, exist_ok=True) - pd.DataFrame(data).to_csv(filepath, index=False) + li = [] + for filename in dynamic_folder.glob("*.csv"): + df = pd.read_csv(filename) + df['well_id_str'] = filename.stem + if 'Unnamed: 0' in df.columns: + df['date_dt'] = pd.to_datetime(df['Unnamed: 0']) + df['month'] = df['date_dt'].dt.month + df['year'] = df['date_dt'].dt.year + df.drop(columns=[c for c in ['Unnamed: 0', 'GWL_flag'] if c in df.columns], inplace=True) + li.append(df) + master_df = pd.concat(li, ignore_index=True) + master_df = pd.merge(master_df, df_static, left_on='well_id_str', right_on='MW_ID', how='left').drop(columns=['MW_ID']) -if __name__ == "__main__": + # 4. Temporal Split (80/20) + master_df = master_df.sort_values('date_dt') + unique_dates = sorted(master_df['date_dt'].unique()) + split_date = unique_dates[int(len(unique_dates) * 0.8)] + + train_df = master_df[master_df['date_dt'] < split_date] + test_df = master_df[master_df['date_dt'] >= split_date] + + # --- 5. REDUCE DATA SIZE --- + if len(train_df) > MAX_TRAIN_ROWS: + print(f"Reducing training data from {len(train_df)} to {MAX_TRAIN_ROWS} rows...") + # Option A: Take the MOST RECENT rows (Best for time-series) + train_df = train_df.tail(MAX_TRAIN_ROWS) + + # Option B: Random Sampling (Uncomment if you prefer variety over recency) + # train_df = train_df.sample(n=MAX_TRAIN_ROWS, random_state=42).sort_values('date_dt') - import argparse - parser = argparse.ArgumentParser( - description='Load or generate data for the benchmark' - ) - parser.add_argument('--seed', type=int, default=42, - help='Random seed for data generation') - args = parser.parse_args() - - # Generate and split the data - rng = np.random.RandomState(args.seed) - X, y = make_classification(n_samples=500, n_features=5, random_state=rng) - X_train, X_test, y_train, y_test = train_test_split( - X, y, test_size=0.4, random_state=rng - ) - X_test, X_private_test, y_test, y_private_test = train_test_split( - X_test, y_test, test_size=0.5, random_state=rng - ) - - # Store the data in the correct folders: - # - input_data contains train data (both features and labels) and only - # test features so the test labels are kept secret - # - reference_data contains the test labels for scoring - for split, X_split, y_split in [ - ('train', X_train, y_train), - ('test', X_test, y_test), - ('private_test', X_private_test, y_private_test), - ]: - split_dir = DATA_DIR / split - make_csv(X_split, split_dir / f'{split}_features.csv') - label_dir = split_dir if split == "train" else REF_DIR - make_csv(y_split, label_dir / f'{split}_labels.csv') \ No newline at end of file + # 6. Save Files + train_df.to_csv(input_base / "train/train.csv", index=False) + + meta_cols = ['well_id_str', 'date_dt'] + test_df.drop(columns=['GWL'] + meta_cols).to_csv(input_base / "test/test_features.csv", index=False) + test_df[['GWL']].to_csv("dev_phase/reference_data/test/test_labels.csv", index=False) + + print(f"🚀 Setup Complete! Final Train Size: {len(train_df)}") + +if __name__ == "__main__": + run_setup() From c0a919bd25ec882c7a3aaaa5479195800df72d1b Mon Sep 17 00:00:00 2001 From: fasfous92 Date: Fri, 13 Feb 2026 15:08:57 +0100 Subject: [PATCH 2/6] stuggle to load challenge en codabench --- .gitignore | 1 + bundle/competition.yaml | 48 + .../ingestion_program/bench_utils/__init__.py | 7 + bundle/ingestion_program/ingestion.py | 100 + bundle/ingestion_program/metadata.yaml | 1 + bundle/logo.png | Bin 0 -> 3797 bytes bundle/pages/participate.md | 10 + bundle/pages/seed.md | 21 + bundle/pages/terms.md | 18 + bundle/pages/timeline.md | 11 + bundle/scoring_program/metadata.yaml | 1 + bundle/scoring_program/scoring.py | 69 + bundle/solution/submission.py | 37 + competition.yaml | 47 +- ingestion_program/ingestion.py | 23 +- ingestion_program/metadata.yaml | 2 +- pages/data.md | 34 + pages/overview.md | 58 + pages/participate.md | 46 +- pages/seed.md | 39 +- pages/terms.md | 31 +- pages/timeline.md | 21 +- scoring_program/metadata.yaml | 2 +- scoring_program/scoring.py | 41 +- starting_kit/README.md | 11 + starting_kit/ingestion_program/ingestion.py | 93 + starting_kit/requirements.txt | 4 + starting_kit/scoring_program/scoring.py | 80 + starting_kit/solution/submission.py | 37 + starting_kit/template_starting_kit.ipynb | 1651 +++++++++++++++++ starting_kit/{ => tools}/zip_submission.py | 0 tools/create_bundle.py | 59 +- tools/create_starting_kit.py | 76 + tools/setup_data.py | 78 +- tools/zip_submission.py | 26 + 35 files changed, 2637 insertions(+), 146 deletions(-) create mode 100755 bundle/competition.yaml create mode 100644 bundle/ingestion_program/bench_utils/__init__.py create mode 100755 bundle/ingestion_program/ingestion.py create mode 100755 bundle/ingestion_program/metadata.yaml create mode 100644 bundle/logo.png create mode 100755 bundle/pages/participate.md create mode 100644 bundle/pages/seed.md create mode 100755 bundle/pages/terms.md create mode 100644 bundle/pages/timeline.md create mode 100755 bundle/scoring_program/metadata.yaml create mode 100755 bundle/scoring_program/scoring.py create mode 100644 bundle/solution/submission.py create mode 100644 pages/data.md create mode 100644 pages/overview.md create mode 100644 starting_kit/README.md create mode 100755 starting_kit/ingestion_program/ingestion.py create mode 100644 starting_kit/requirements.txt create mode 100755 starting_kit/scoring_program/scoring.py create mode 100644 starting_kit/solution/submission.py create mode 100644 starting_kit/template_starting_kit.ipynb rename starting_kit/{ => tools}/zip_submission.py (100%) create mode 100644 tools/create_starting_kit.py create mode 100644 tools/zip_submission.py diff --git a/.gitignore b/.gitignore index 8800a6e..c2c654c 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ ingestion_res/* scoring_res/* dev_phase/* test_notebook/* +raw_data/* diff --git a/bundle/competition.yaml b/bundle/competition.yaml new file mode 100755 index 0000000..54467c2 --- /dev/null +++ b/bundle/competition.yaml @@ -0,0 +1,48 @@ +version: 2 +title: GEMS-GER Groundwater Level Prediction Challenge +description: Predict groundwater level (GWL) across Germany using 50+ environmental features. +image: logo.png +registration_auto_approve: True # Set to True to let people jump right in + +terms: pages/terms.md +pages: + - title: Overview + file: pages/overview.md + - title: Data Description + file: pages/data.md + - title: Participation + file: pages/participate.md + - title: Timeline + file: pages/timeline.md + +tasks: + - index: 0 + name: GWL Regression Task + description: 'Predict depth to groundwater using historical time-series and static site data.' + input_data: dev_phase/input_data/ + reference_data: dev_phase/reference_data/ + ingestion_program: ingestion_program/ + scoring_program: scoring_program/ + +solutions: + - index: 0 + tasks: + - 0 + path: solution/ + +phases: + - name: Development Phase + description: 'Train on historical data and submit predictions for the Public Leaderboard.' + start: 02-13-2026 # Starting today! + end: 05-31-2026 + tasks: + - 0 + +leaderboards: + - title: Results + key: main + columns: + - title: RMSE + key: rmse # Must match scores['rmse'] in scoring.py + index: 0 + sorting: asc # Lower is better! diff --git a/bundle/ingestion_program/bench_utils/__init__.py b/bundle/ingestion_program/bench_utils/__init__.py new file mode 100644 index 0000000..8e19e63 --- /dev/null +++ b/bundle/ingestion_program/bench_utils/__init__.py @@ -0,0 +1,7 @@ +# A module for the benchmark, to provide utilities usable in both the +# ingestion and the submission programs. +# +# Note that the import cannot be done at the top level of +# the ingestion program + +N_SAMPLES = 1000 diff --git a/bundle/ingestion_program/ingestion.py b/bundle/ingestion_program/ingestion.py new file mode 100755 index 0000000..5d1b00b --- /dev/null +++ b/bundle/ingestion_program/ingestion.py @@ -0,0 +1,100 @@ +import json +import sys +import time +from pathlib import Path +import pandas as pd + +# We only have one test set now +EVAL_SETS = ["test"] + +def evaluate_model(model, X_test): + """ + Generate predictions. + Note: We pass the RAW X_test to the model. + The participant's pipeline must handle dropping strings! + """ + y_pred = model.predict(X_test) + return pd.DataFrame({'GWL': y_pred}) + +def get_train_data(data_dir, chunksize=100000): + """ + Loads 'train.csv' in chunks for memory safety. + Contains both features and labels. + """ + data_dir = Path(data_dir) + train_path = data_dir / "train" / "train.csv" + + # Fallback for local testing vs Codabench environment + if not train_path.exists(): + train_path = data_dir / "train.csv" + + print(f"Reading {train_path} in chunks...") + + chunks = [] + for chunk in pd.read_csv(train_path, chunksize=chunksize): + chunks.append(chunk) + + full_df = pd.concat(chunks, axis=0) + + y_train = full_df['GWL'] + X_train = full_df.drop(columns=['GWL']) + + return X_train, y_train + +def main(data_dir, output_dir): + # Import the participant's model + from submission import get_model + + print("--- 1. Loading Training Data ---") + X_train, y_train = get_train_data(data_dir) + + print("--- 2. Training the Model ---") + model = get_model() + + start_train = time.time() + model.fit(X_train, y_train) + train_time = time.time() - start_train + print(f"Training completed in {train_time:.2f}s") + + print("--- 3. Evaluating on Test Set ---") + start_test = time.time() + + # Load test features (Matches setup_data.py output) + X_test_path = data_dir / "test" / "test_features.csv" + X_test = pd.read_csv(X_test_path) + + y_test_pred = evaluate_model(model, X_test) + + test_time = time.time() - start_test + print(f"Testing completed in {test_time:.2f}s") + + # --- 4. Write Output Files --- + output_dir.mkdir(parents=True, exist_ok=True) + + # Save metadata for the leaderboard (Runtime) + with open(output_dir / "metadata.json", "w") as f: + json.dump({ + "train_time": train_time, + "test_time": test_time, + "duration": train_time + test_time + }, f) + + # Save predictions (Matches what scoring.py expects) + y_test_pred.to_csv(output_dir / "test_predictions.csv", index=False) + + print(f"Ingestion finished. Total duration: {train_time + test_time:.2f}s") + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser(description="Ingestion program") + parser.add_argument("--data-dir", type=str, default="/app/input_data") + parser.add_argument("--output-dir", type=str, default="/app/output") + parser.add_argument("--submission-dir", type=str, default="/app/ingested_program") + + args = parser.parse_args() + + # Add submission and current folder to path so we can find 'submission.py' + sys.path.append(args.submission_dir) + sys.path.append(str(Path(__file__).parent.resolve())) + + main(Path(args.data_dir), Path(args.output_dir)) diff --git a/bundle/ingestion_program/metadata.yaml b/bundle/ingestion_program/metadata.yaml new file mode 100755 index 0000000..bcf0d24 --- /dev/null +++ b/bundle/ingestion_program/metadata.yaml @@ -0,0 +1 @@ +command: python3 ingestion.py \ No newline at end of file diff --git a/bundle/logo.png b/bundle/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..9616456c1d354140c0055fb6ee32e23d76519df3 GIT binary patch literal 3797 zcmZu!2UJs8w+>_wM1=uq(nJuXgd#OyfKi%AiGV<;3ZWVyR0+}s8R-!L0R@CXn$mkH zF(8m2U3xJ?NeoCQAicfd%yZsb|9{WAXSeTs`|PvUxp(cDyT*DKn0c820Kf(P+uEiy znR@y%ouSPTI&Tt9(D|C`-2#;L@h{MfyUs9u7b7EpBu!@m(9^L4fTs}J07SV1e)*vT z0Ae%=0094_`#1V0{m*FXpTK|hQy@dCiw2Fv%KaY94`yVj21k0xI5;64on=rSUZ(&6 z1f@n(J)HdcT$|YBc@SEh{Ya1LB8J7ls+#71BcbI14GsD9XqQYcLB5 z2|;|ET+~dpb^lpTv($y%{QSJsWMu;a0%QUdWRO0tve#8rRb}PmW##3iX$WcGKu$loOY%cJe=3-@vN@^eRe3Z3#gI3oT1)P;pl6a9St-lw0t%fFdCeg7$oR-o)@ zME1Ijoa|3-+EU1=R}Jdp?o7*k%CB)9@&oz*eE;Nu$et$uKb!fx(jQ)0sT#}>*`LRz z!ED%i%?bcG->0vA^B#(B#cH;0uI{Yill|jzV&wAc$g1Ceqqo{lIk}zsz=g*l4A&HP z=v}_l;yAl*b0p{u!~DepIMw zguoXV<~;$Or;|Bo+o3f2{(=tU<09pW2iFwGOwe1yAE^-)it9Z5d7K6Z@>6jP_7w3w zsY(&pN$f8x(Gwn!5$(Al&i89)L)h#r&M)M5Pp;XszMhmO=>y-^23|llhC+jCjvo=5 ztIwuT1sH{mmS^652f%CtYF%2%yEDuDmxJKu8G2&wbLP}#0wKq80dq(P-P*kkH&4f3 zNQ}}X%~Eq=eHY*O26s`xP9QLrzuieU?pg#}%wNY;dyjj0pZGQtfK7+f`-DZA*en8D z$F~>(%89S`aS!>DxAx-tL`PE=&U+i|Xah(0e9vqBgY*0h@Z1iM-neyES}tC%;ny+s zC%l#omye3&gmKloOwHVFwVh(QK{!_aOHo^|6UmmOKDR_wn<M_v>#Ri*DZiGj)oouKe6Fx871AY5lq2XmW!Ou80A} zCKFq`i^6dN%eoRb%VttfICKr)u_v@<&-@ZF#`9jHtM{m^eQVc7b4s1m6i@&(M_cX_ zVxvh=R;yylCmt!!`2n|daI*#D^jaojGHY0?HuXcL3-f@FVzL@5!+72^8R8~Y!pOF* zuYsbat2NOP^o)nyQ^1h{_sj^(g-g>4tgksVDN6-nd)%lcB%69R4^d>v2)*zvWKR>n z_z_`I(hgy}=1T2kYP@Q^eawA_ zzwoI-F&ot?;l-G$-~nNy=gG#eH&`PoK1^232LeM9dDTQmK4R~Wunnr*+;dQ;}V?TT6a}6Qn9%A^4j<$S=R|AU&)2B-7#F5 zNj^NpMU(@R6`?9zvf~-9&o&E$Z5z{g{A9^a@r4piV=<-fv%&9@%iUF@$w9gNf;Q^e z4@+b|rmNnQD>X0zl?Fd>LYL%2^;Wu1 z@~gG-zE&8%^!9@m4Cb#;Yww$o!C6B}mq%14*9KEQdLTja;brmSg54P;?xY0HnAu%B z-?F9%kwte5OL5&cp(=W9|As)c^20?Vb_Po7Y-f5W1+2)JYCECMrabF}NWvPy>VTI`eUfH7tIH($3pd%oPfhSxd#s-a7AJwhN$jH%T+{a-_JSf=hN z2nt1Ec^v*ig6jP{Oc^!CVBZx7%ohjsKI$Uhq*Q$gW43Jn%XT{4j`g!4F!DsQM4X;p z8noMWsuQ_~3n^EOzi8Qapr&C0Wu7hZ%6AmYtT#qgQbnhv1fl%> zBcxhzR@*#8Gr8mX|aQE{(TvguML77`avBh z94@R^96cFb{z!Ao`uhA~Npujl^3%8FiwpP!7SEdd4n>iPl&y!u>rfk70HjqDfohtt zDD^oy=kIyMI4H{_mN7H6#PY}kWY=nU^cJ`h#_2P(P8bZGLuD%KmDLrN_IkO2p(W0U zkXz*F&2eN&;`+61N_cZaVAD~P=Chko&SnflgAPro!Pca+*+KA?CvnT9m`qpQxJR~M zySA9hxrdI?3?Ic?I5#cjww)nf6-cyvf9#FGkU9$~=#!`5hAiqYJQjUyNRZLh(Yp{d ztU7j2e`(#hU@nCyK3#~be9Xh8RHtBEyjc^q8m*EVz~sae-~J7+x4nDio`Wt*B618) zSsry-fLUqcDlKA%d;-nf59|<7>f;fGRu5!}EF?ta;@a^VOYkD!($2=}ohV=;26@02 z$IZ2eo1rRVrcl=27NCy!_VwMxz4Of_{%3LE*d?73N$R732}7+rt(n4-m32`cl4ASD*<{#hloIlOyMd?2FuoztAFT-TRl%Pa9D zo%O(b--f*3MJ%D<0=8lEkP(>EYV7MoTmA=E>xN#bJO~nWcctJh#}3l7Tkn{C^0PJ3 z5^csNko*WaV!Sboa8B1VYbVEt2~6JxpnE0%pjRpB0~+wd90MwswWG+4q%*|ZSB&v_6va;3W$M-{db?aK)u3-hCe z>{dzA`98BbCq>+qQAEqbBQx}f=v{=6#|5z$ETIlZ2$6?1i&c=;eevm5ycz{AC_uYd zSD1C4|Di+vy_@Q0G)K0Nn{UY76Tb`*$z0Z$#}mmL+f_s<>JVB-$0hc62`R@!n-~T| zWH9jl90+S&yj>8=?AjT?0X6z9Z5T`{2x)Z6iWG%gtSa@f*<-}|G`nkSE9+-&oYVn_ zG@m)0^Y`73=_agIG~Y`8PXB81V!{W3TDA^Qc7b|P;OS?%u)UWT`&P62l4=iVF7|kW zNFgLai#U>$Zt`aIrX5!An0A2r`XFV2BP!38%-W6!>E0`I=LL3G$_pJL*(&z`0E|8{ zy&9^>QeT~m7op~9G-Nkm!0Ig09dSF~-C*|EI?SON(_MB28zwn<^7%B^@$>fDD*{O=X77#KHWb~dc8Gkml8C7?S%R=`Z9F`jQ@-IKeo|av%CE9kyg8Kd zcyuRKB{le*zPEtOb8vnnhDg3yy57?UfTqYgpAi2%yTLp_szzj8;=-iB@mk3#Q6bXP zT?3BcTDhqzU9)==4TLoO3#v2{q%ZF)8#fYre>kt)pBtDO=i{>bLZMAB zQ^0ahg^N4p>E7fru}!V>^Ta+D+qVz7uWpq4VU!@eAv2rXx_Uew-dF981WA@x1ID8Y z({&pwj_a=Hz6s7p6c8q`;$tu0iPy(>zlyZ=Y%$dE+WmCBa@7Gr{git>V+rp|9LQYi za@-)Y_4gdpD8sFQF0mUvx{=oVH4rJTLu-~5H0>tvs)n9Po=1aSb}%YjXM11C*}O_o zk*~dz(P4&n82MHj)QH6{Po*M35=F)JGPduV53&|p%sX{nrJw{ym4%J8x00pMe6yRo zCM5-7H3X`}DEUQY%eK$27cWU4-d;8A$wlitEshrf^vGq|ul8rf+%z5DGcL1LR4cZK+6vJ``I0>&^ZD-gEry eNT%jm!ssLiJ=~t@6|tN)iTXOm+GV#MJpCV&VN8+$ literal 0 HcmV?d00001 diff --git a/bundle/pages/participate.md b/bundle/pages/participate.md new file mode 100755 index 0000000..4d5427b --- /dev/null +++ b/bundle/pages/participate.md @@ -0,0 +1,10 @@ +# How to participate + +You should submit an untrained model in a python file `model.py` which contains +your `class Model`, which will be imported, trained, and tested on Codalab. + +See the "Seed" page for the outline of a `Model` class, with the expected +function names. + +See the "Timeline" page for additional information about the phases of this +competition diff --git a/bundle/pages/seed.md b/bundle/pages/seed.md new file mode 100644 index 0000000..9b15f6a --- /dev/null +++ b/bundle/pages/seed.md @@ -0,0 +1,21 @@ +# Seed: + +``` +class Model: + def fit(self, X_train, y_train): + """ + This should handle the logic of training your model + :param X_train: np.array of training data + :param y_train: np.array of the same length as X_train. Contains classifications of X_train + """ + pass + + def predict(self, X_test): + """ + This should handle making predictions with a trained model + :param X_test: np.array of testing data + :return: np.array of the same length as X_test containing predictions to each point in X_test + """ + pass + +``` \ No newline at end of file diff --git a/bundle/pages/terms.md b/bundle/pages/terms.md new file mode 100755 index 0000000..0d69023 --- /dev/null +++ b/bundle/pages/terms.md @@ -0,0 +1,18 @@ +# Terms and Conditions + +## Lorem Ipsum + +Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. +Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure +dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non +proident, sunt in culpa qui officia deserunt mollit anim id est laborum. + +## Sed ut perspiciatis + +Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae +ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit +aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam +est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore +et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, +nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae +consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur? diff --git a/bundle/pages/timeline.md b/bundle/pages/timeline.md new file mode 100644 index 0000000..4e613bf --- /dev/null +++ b/bundle/pages/timeline.md @@ -0,0 +1,11 @@ +# Timeline + +## Development phase +This phase should be used to tune your models, testing against a small +set of testing data + +## Final phase +Resubmit your preferred submission from the development phase to test +against a new set of testing data. Your model will be trained against +the same set of training data as in the development phase. You may only +make one submission to this phase, so choose wisely. diff --git a/bundle/scoring_program/metadata.yaml b/bundle/scoring_program/metadata.yaml new file mode 100755 index 0000000..1dfabf8 --- /dev/null +++ b/bundle/scoring_program/metadata.yaml @@ -0,0 +1 @@ +command: python3 scoring.py \ No newline at end of file diff --git a/bundle/scoring_program/scoring.py b/bundle/scoring_program/scoring.py new file mode 100755 index 0000000..79f2654 --- /dev/null +++ b/bundle/scoring_program/scoring.py @@ -0,0 +1,69 @@ +import json +from pathlib import Path +import pandas as pd +import numpy as np +from sklearn.metrics import mean_squared_error + +def compute_rmse(predictions, targets): + """ + Calculates the Root Mean Squared Error (RMSE) for Groundwater Level Prediction. + """ + # Ensure inputs are handled correctly whether they are DataFrames or Series + y_pred = predictions.iloc[:, 0] if isinstance(predictions, pd.DataFrame) else predictions + y_true = targets.iloc[:, 0] if isinstance(targets, pd.DataFrame) else targets + + # Align predictions with ground truth and remove any missing values in labels + combined = pd.concat([ + pd.Series(y_pred, name='pred').reset_index(drop=True), + pd.Series(y_true, name='true').reset_index(drop=True) + ], axis=1).dropna() + + if combined.empty: + print("Warning: No overlapping data found for scoring.") + return 999.0 + + # Calculate RMSE + rmse = np.sqrt(mean_squared_error(combined['true'], combined['pred'])) + return float(rmse) + +def main(reference_dir, prediction_dir, output_dir): + scores = {} + eval_set = "test" + + try: + # Load predictions and reference labels + predictions = pd.read_csv(prediction_dir / f'{eval_set}_predictions.csv') + targets = pd.read_csv(reference_dir / eval_set / f'{eval_set}_labels.csv') + + # Calculate the score + scores['rmse'] = compute_rmse(predictions, targets) + + except Exception as e: + print(f"❌ Scoring Error: {e}") + scores['rmse'] = 999.0 + + # Include runtime metadata for the leaderboard + try: + metadata_path = prediction_dir / 'metadata.json' + if metadata_path.exists(): + durations = json.loads(metadata_path.read_text()) + scores.update(durations) + except Exception: + pass + + # Save to scores.json for Codabench + output_dir.mkdir(parents=True, exist_ok=True) + with open(output_dir / 'scores.json', 'w') as f: + json.dump(scores, f) + + print(f"Scoring finished. Leaderboard RMSE: {scores['rmse']:.4f}") + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--reference-dir", type=str, default="/app/input/ref") + parser.add_argument("--prediction-dir", type=str, default="/app/input/res") + parser.add_argument("--output-dir", type=str, default="/app/output") + args = parser.parse_args() + + main(Path(args.reference_dir), Path(args.prediction_dir), Path(args.output_dir)) diff --git a/bundle/solution/submission.py b/bundle/solution/submission.py new file mode 100644 index 0000000..ed399dd --- /dev/null +++ b/bundle/solution/submission.py @@ -0,0 +1,37 @@ +from sklearn.ensemble import RandomForestRegressor +from sklearn.compose import ColumnTransformer +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import StandardScaler + +from sklearn.ensemble import RandomForestRegressor +from sklearn.compose import ColumnTransformer +from sklearn.compose import make_column_selector as selector +from sklearn.pipeline import Pipeline +from sklearn.impute import SimpleImputer + +def get_model(): + """ + Returns a model that automatically filters out string columns + to avoid ValueErrors and fits on numeric data only. + """ + + # 1. Define a transformer that ONLY picks numeric columns (float64, int64) + # This automatically ignores 'well_id_str' and 'date_dt' because they are strings/objects + numeric_transformer = Pipeline(steps=[ + ('imputer', SimpleImputer(strategy='median')) + ]) + + preprocessor = ColumnTransformer( + transformers=[ + ('num', numeric_transformer, selector(dtype_include=['float64', 'int64'])) + ], + remainder='drop' # This explicitly drops anything that isn't a number + ) + + # 2. Create the full pipeline + model = Pipeline(steps=[ + ('preprocessor', preprocessor), + ('regressor', RandomForestRegressor(n_estimators=50, max_depth=8, random_state=42)) + ]) + + return model diff --git a/competition.yaml b/competition.yaml index 54467c2..d1f4ba3 100755 --- a/competition.yaml +++ b/competition.yaml @@ -1,10 +1,10 @@ version: 2 -title: GEMS-GER Groundwater Level Prediction Challenge -description: Predict groundwater level (GWL) across Germany using 50+ environmental features. +title: "GEMS-GER Groundwater Level Prediction Challenge" +description: "Predict groundwater levels (GWL) across Germany." image: logo.png -registration_auto_approve: True # Set to True to let people jump right in - +registration_auto_approve: True terms: pages/terms.md + pages: - title: Overview file: pages/overview.md @@ -17,32 +17,41 @@ pages: tasks: - index: 0 - name: GWL Regression Task - description: 'Predict depth to groundwater using historical time-series and static site data.' + name: "Development Task" input_data: dev_phase/input_data/ reference_data: dev_phase/reference_data/ + scoring_program: scoring_program/ ingestion_program: ingestion_program/ + - index: 1 + name: "Final Task" + input_data: final_phase/input_data/ + reference_data: final_phase/reference_data/ scoring_program: scoring_program/ + ingestion_program: ingestion_program/ -solutions: +phases: - index: 0 - tasks: - - 0 - path: solution/ + name: "Development Phase" + start: 2026-02-13 12:00:00 + end: 2026-04-14 00:00:00 # Phase 1 ends here + max_submissions: 100 + max_submissions_per_day: 5 + starting_kit: starting_kit.zip + public_data: starting_kit.zip + tasks: [0] -phases: - - name: Development Phase - description: 'Train on historical data and submit predictions for the Public Leaderboard.' - start: 02-13-2026 # Starting today! - end: 05-31-2026 - tasks: - - 0 + - index: 1 + name: "Final Phase" + start: 2026-04-15 # Must start AFTER Phase 1 ends + max_submissions: 1 + auto_migrate_to_this_phase: True + tasks: [1] leaderboards: - title: Results key: main columns: - title: RMSE - key: rmse # Must match scores['rmse'] in scoring.py + key: rmse index: 0 - sorting: asc # Lower is better! + sorting: asc diff --git a/ingestion_program/ingestion.py b/ingestion_program/ingestion.py index 5d1b00b..7fba742 100755 --- a/ingestion_program/ingestion.py +++ b/ingestion_program/ingestion.py @@ -16,26 +16,19 @@ def evaluate_model(model, X_test): y_pred = model.predict(X_test) return pd.DataFrame({'GWL': y_pred}) -def get_train_data(data_dir, chunksize=100000): - """ - Loads 'train.csv' in chunks for memory safety. - Contains both features and labels. - """ - data_dir = Path(data_dir) - train_path = data_dir / "train" / "train.csv" - - # Fallback for local testing vs Codabench environment - if not train_path.exists(): - train_path = data_dir / "train.csv" - - print(f"Reading {train_path} in chunks...") - +def get_train_data(data_dir, chunksize=200000): + train_path = Path(data_dir) / "train" / "train.csv" chunks = [] + + print(f"Reading training data in chunks of {chunksize}...") + # Use chunksize to keep RAM usage low during load for chunk in pd.read_csv(train_path, chunksize=chunksize): + # Optional: Optimize float precision to save more RAM + for col in chunk.select_dtypes(include=['float64']).columns: + chunk[col] = chunk[col].astype('float32') chunks.append(chunk) full_df = pd.concat(chunks, axis=0) - y_train = full_df['GWL'] X_train = full_df.drop(columns=['GWL']) diff --git a/ingestion_program/metadata.yaml b/ingestion_program/metadata.yaml index bcf0d24..afb1eac 100755 --- a/ingestion_program/metadata.yaml +++ b/ingestion_program/metadata.yaml @@ -1 +1 @@ -command: python3 ingestion.py \ No newline at end of file +command: python3 ingestion.py /app/input_data/ /app/output/ /app/program /app/ingested_program diff --git a/pages/data.md b/pages/data.md new file mode 100644 index 0000000..9eff24e --- /dev/null +++ b/pages/data.md @@ -0,0 +1,34 @@ +# Data Description + +This page provides details about the GEMS-GER dataset and the submission format. + +## Dataset Overview +- **Total Samples:** 1,000,000 historical records. +- **Goal:** Predict groundwater depth (**GWL**) based on environmental factors. + +## File Structure +The competition data is organized as follows: + +- **Training Data:** `dev_phase/input_data/train/train.csv` + - Contains features and the target variable `GWL`. +- **Test Features:** `dev_phase/input_data/test/test_features.csv` + - Contains features for which you must provide predictions. +- **Sample Submission:** `dev_phase/input_data/test/sample_submission.csv` + - A template file showing the exact format required for your results. + +## Features and Target Variable +### Input Features (X) +Includes daily precipitation, temperature, soil moisture, and static well characteristics. + +### Target Variable (y) +- **GWL:** Depth to groundwater in meters. + +## 📋 Submission Format +Your model must output a CSV file that matches the structure of the sample found in the `test` folder. +- **Columns:** `Id` (matching the test feature index) and `GWL` (your prediction). +- **Header:** The file must include the header row `Id,GWL`. +- **Example:** + ```csv + Id,GWL + 0,5.23 + 1,5.45 diff --git a/pages/overview.md b/pages/overview.md new file mode 100644 index 0000000..3019e0d --- /dev/null +++ b/pages/overview.md @@ -0,0 +1,58 @@ +Here is a polished, professional **Overview** in Markdown. You can paste this directly into your Codabench "Overview" page or include it as a `README.md` for the competition. + +--- + +# 🌍 GEMS-GER: Groundwater Level Prediction Challenge + +Welcome to the **GEMS-GER Challenge**! This competition invites you to tackle one of the most pressing environmental issues: managing groundwater resources in the face of climate change. Your mission is to build a machine learning model that accurately predicts groundwater levels across Germany using high-dimensional environmental data. + +## 🎯 The Task + +The goal is to predict the **depth to groundwater (GWL)** measured in meters. This is a **regression task** where you will leverage over 50 features, including: + +* **Dynamic Features:** Daily precipitation, temperature, soil moisture, and evapotranspiration. +* **Static Features:** Well depth, land cover type, and geological characteristics of the site. + +## 📊 The Dataset + +This challenge uses a massive, curated dataset derived from the **GEMS-GER** project, containing: + +* **Training Set:** 1,000,000 historical records optimized for large-scale learning. +* **Temporal Continuity:** Observations from multiple monitoring wells across Germany. +* **Phased Evaluation:** A strict time-series split ensuring your model is tested on the "future" relative to its training data. + +## 🏗️ Challenge Structure + +The competition is divided into two phases to test the robustness and generalization of your models: + +1. **Development Phase:** * Train on the provided 1M records. +* Get instant feedback on the **Public Leaderboard** using a validation set from the period immediately following the training data. + + +2. **Final Phase:** +* Your best-performing model is automatically evaluated against the **Private Test Set**. +* This set contains the most recent data points, representing the ultimate test of your model's predictive power. + + + +## 📏 Evaluation Metric + +Submissions are ranked based on the **Root Mean Squared Error (RMSE)**: + +* **Lower is better.** +* Large errors are penalized more heavily, emphasizing the importance of consistency in environmental forecasting. + +--- + +## 🚀 How to Participate + +1. **Download the Starting Kit:** Navigate to the **Files** tab and download the `gems_ger_starting_kit.zip`. +2. **Explore the Notebook:** Open `template_starting_kit.ipynb` to load the data and build your baseline model. +3. **Develop Your Model:** Modify `solution/submission.py` to implement your custom regressor. +4. **Zip and Submit:** Run the provided `zip_submission.py` and upload your results to the **My Submissions** tab. + +--- + +**Ready to start?** Head over to the **Files** tab to grab your Starting Kit and see how your baseline model performs! + +**Would you like me to generate the content for the "Evaluation" or "Data" pages next?** diff --git a/pages/participate.md b/pages/participate.md index 4d5427b..b3ad8b0 100755 --- a/pages/participate.md +++ b/pages/participate.md @@ -1,10 +1,42 @@ -# How to participate +## How to Participate -You should submit an untrained model in a python file `model.py` which contains -your `class Model`, which will be imported, trained, and tested on Codalab. +To participate in this challenge, you will submit your **code**, not your predictions. This ensures that your model is reproducible and can be evaluated on hidden data. -See the "Seed" page for the outline of a `Model` class, with the expected -function names. +### 1. The Submission File +Your model logic must be contained in a single Python file named `submission.py`. This file **must** contain a function named `get_model()` that returns an object with Scikit-Learn compatible `.fit()` and `.predict()` methods. -See the "Timeline" page for additional information about the phases of this -competition +We recommend using a `Pipeline` to bundle your preprocessing (handling metadata) and your regressor together. + + + +### 2. The Model Interface +The evaluation platform will import your code and execute it as follows: + +```python +from submission import get_model + +# The platform initializes your model +model = get_model() + +# The platform trains your model on the 1M row dataset +model.fit(X_train, y_train) + +# The platform generates predictions on the test set +y_pred = model.predict(X_test) + +``` + +### 3. Packaging for Upload + +Once you have modified `solution/submission.py`, use the provided helper script to create your submission archive. + +1. Open a terminal in the starting kit folder. +2. Run `python zip_submission.py`. +3. Upload the resulting `submission.zip` to the **"My Submissions"** tab on the Codabench platform. + +### 4. Phases + +* **Development Phase:** Your model is trained on the historical training set and evaluated on the **Public Test Set**. You receive immediate feedback on the leaderboard. +* **Final Phase:** At the end of the competition, your best submission will be evaluated on the **Private Test Set** (the most recent data). This determines the final ranking. + +> **Note:** Refer to the **Timeline** section for specific dates and submission limits for each phase. diff --git a/pages/seed.md b/pages/seed.md index 9b15f6a..5bd705e 100644 --- a/pages/seed.md +++ b/pages/seed.md @@ -1,21 +1,38 @@ -# Seed: +# Seed: The Model Class -``` + +> **Important:** The input `X_train` and `X_test` are **Pandas DataFrames**. Your model must handle or drop the non-numeric columns (`well_id_str`, `date_dt`) to avoid errors during training. +Basically apply all the necessary feature engineer you see fit. + +```python class Model: - def fit(self, X_train, y_train): + def __init__(self): """ - This should handle the logic of training your model - :param X_train: np.array of training data - :param y_train: np.array of the same length as X_train. Contains classifications of X_train + Initialize your model here. + You can define hyperparameters or internal pipelines. """ pass - def predict(self, X_test): + def fit(self, X_train, y_train): """ - This should handle making predictions with a trained model - :param X_test: np.array of testing data - :return: np.array of the same length as X_test containing predictions to each point in X_test + This handles the training logic. + :param X_train: Pandas DataFrame of training features (1M rows). + :param y_train: Pandas Series/Array of groundwater levels. """ + # Example: Drop strings before fitting + X_numeric = X_train.drop(columns=['well_id_str', 'date_dt'], errors='ignore') + + # Your training logic here pass -``` \ No newline at end of file + def predict(self, X_test): + """ + This handles making predictions. + :param X_test: Pandas DataFrame of testing features. + :return: np.array of predictions. + """ + # Example: Drop strings before predicting + X_numeric = X_test.drop(columns=['well_id_str', 'date_dt'], errors='ignore') + + # Your prediction logic here + return predictions diff --git a/pages/terms.md b/pages/terms.md index 0d69023..2ac0e85 100755 --- a/pages/terms.md +++ b/pages/terms.md @@ -1,18 +1,23 @@ # Terms and Conditions -## Lorem Ipsum +By participating in the GEMS-GER Groundwater Level Prediction Challenge, you agree to the following terms: -Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. -Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure -dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non -proident, sunt in culpa qui officia deserunt mollit anim id est laborum. +## 1. Data Usage & Intellectual Property +* **Academic Use:** The dataset provided (GEMS-GER) is for educational and competition purposes only. Commercial redistribution of the raw data is prohibited. +* **Winning Submissions:** Winners of the challenge agree to make their winning code (submission.zip) available under an open-source license (e.g., MIT or Apache 2.0) to allow for scientific verification. -## Sed ut perspiciatis +## 2. Competition Integrity +* **No Manual Labeling:** Participants are strictly forbidden from manually labeling the test data or searching for the original Zenodo dataset to extract the hidden ground truth labels. +* **No External Data:** You may only use the provided dataset and static site features. The use of external meteorological data (e.g., from DWD or other sources) is not permitted unless specifically authorized by the organizers. +* **One Account per Person:** Multiple accounts per participant are not allowed. Collaborating in teams is encouraged, but a team must submit under a single account. -Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae -ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit -aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam -est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore -et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, -nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae -consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur? +## 3. Submission Limits & Phases +* **Daily Limit:** You are limited to **5 submissions per day** during the Development Phase to prevent "leaderboard probing." +* **Final Selection:** At the end of the Development Phase, you must select **one** submission for the Final Phase. This submission will be re-evaluated against the private test set. + +## 4. Resource Usage +* **Memory Constraints:** Submissions must run within the memory limits of the Codabench server (typically 4GB-8GB RAM). Models that require excessive resources or crash the ingestion program will be disqualified. +* **Training Time:** Your model's `fit` and `predict` logic must complete within the allotted time limit (e.g., 30 minutes for the 1M row dataset). + +## 5. Disqualification +The organizers reserve the right to disqualify any participant found to be in violation of these rules or behaving in a way that undermines the fairness of the competition. diff --git a/pages/timeline.md b/pages/timeline.md index 4e613bf..5cb8c69 100644 --- a/pages/timeline.md +++ b/pages/timeline.md @@ -1,11 +1,14 @@ -# Timeline +## Timeline -## Development phase -This phase should be used to tune your models, testing against a small -set of testing data +The competition is divided into two distinct phases to ensure the models generalize well to unseen future data. -## Final phase -Resubmit your preferred submission from the development phase to test -against a new set of testing data. Your model will be trained against -the same set of training data as in the development phase. You may only -make one submission to this phase, so choose wisely. +### 1. Development Phase (Public) +* **Purpose:** Tune your models, perform feature engineering, and validate your approach. +* **Data:** You are provided with a large training set and a smaller validation set. +* **Feedback:** When you submit, your score on the leaderboard is calculated using the **Public Test Set** (Development data). You can submit multiple times per day to improve your ranking. + +### 2. Final Phase (Private) +* **Purpose:** Determine the final winners based on the model's ability to predict the most recent groundwater levels. +* **Data:** Your model will be trained on the same training data, but evaluated on a completely new **Private Test Set** (Final data) from a later time period. +* **Selection:** You must choose your best submission from the Development Phase to be re-run against the Final Phase data. +* **Restriction:** You may only make **Two** submission to this phase, so choose the model that you believe is most robust, not just the one that overfitted the public leaderboard! diff --git a/scoring_program/metadata.yaml b/scoring_program/metadata.yaml index 1dfabf8..d3a59bc 100755 --- a/scoring_program/metadata.yaml +++ b/scoring_program/metadata.yaml @@ -1 +1 @@ -command: python3 scoring.py \ No newline at end of file +command: python3 scoring.py /app/input/ /app/output/ diff --git a/scoring_program/scoring.py b/scoring_program/scoring.py index 79f2654..95b9b9f 100755 --- a/scoring_program/scoring.py +++ b/scoring_program/scoring.py @@ -6,61 +6,72 @@ def compute_rmse(predictions, targets): """ - Calculates the Root Mean Squared Error (RMSE) for Groundwater Level Prediction. + Calculates the Root Mean Squared Error (RMSE). """ - # Ensure inputs are handled correctly whether they are DataFrames or Series + # Ensure we are comparing the same number of rows + # Targets usually has 1 column ('GWL'), Predictions usually has 1 column ('GWL') y_pred = predictions.iloc[:, 0] if isinstance(predictions, pd.DataFrame) else predictions y_true = targets.iloc[:, 0] if isinstance(targets, pd.DataFrame) else targets - # Align predictions with ground truth and remove any missing values in labels + # Align by index and drop any rows with NaNs in ground truth (if any) combined = pd.concat([ pd.Series(y_pred, name='pred').reset_index(drop=True), pd.Series(y_true, name='true').reset_index(drop=True) ], axis=1).dropna() if combined.empty: - print("Warning: No overlapping data found for scoring.") + print("Warning: No data to score.") return 999.0 - # Calculate RMSE rmse = np.sqrt(mean_squared_error(combined['true'], combined['pred'])) return float(rmse) def main(reference_dir, prediction_dir, output_dir): scores = {} - eval_set = "test" try: - # Load predictions and reference labels - predictions = pd.read_csv(prediction_dir / f'{eval_set}_predictions.csv') - targets = pd.read_csv(reference_dir / eval_set / f'{eval_set}_labels.csv') + # 1. Path Setup + # Reference labels: [ref_dir]/test/test_labels.csv (from setup_data.py) + # Predictions: [pred_dir]/test_predictions.csv (from ingestion.py) + label_path = reference_dir / 'test' / 'test_labels.csv' + pred_path = prediction_dir / 'test_predictions.csv' - # Calculate the score + # Fallback if structure differs slightly on different platforms + if not label_path.exists(): + label_path = reference_dir / 'test_labels.csv' + + # 2. Load Data + targets = pd.read_csv(label_path) + predictions = pd.read_csv(pred_path) + + # 3. Compute Score scores['rmse'] = compute_rmse(predictions, targets) except Exception as e: print(f"❌ Scoring Error: {e}") scores['rmse'] = 999.0 - # Include runtime metadata for the leaderboard + # 4. Include Runtime Metadata (Captured by ingestion.py) try: metadata_path = prediction_dir / 'metadata.json' if metadata_path.exists(): - durations = json.loads(metadata_path.read_text()) - scores.update(durations) + with open(metadata_path, 'r') as f: + metadata = json.load(f) + scores.update(metadata) except Exception: pass - # Save to scores.json for Codabench + # 5. Save results for the Leaderboard output_dir.mkdir(parents=True, exist_ok=True) with open(output_dir / 'scores.json', 'w') as f: json.dump(scores, f) - print(f"Scoring finished. Leaderboard RMSE: {scores['rmse']:.4f}") + print(f"Scoring finished. RMSE: {scores['rmse']:.4f}") if __name__ == "__main__": import argparse parser = argparse.ArgumentParser() + # Paths provided by Codabench environment parser.add_argument("--reference-dir", type=str, default="/app/input/ref") parser.add_argument("--prediction-dir", type=str, default="/app/input/res") parser.add_argument("--output-dir", type=str, default="/app/output") diff --git a/starting_kit/README.md b/starting_kit/README.md new file mode 100644 index 0000000..ec28fee --- /dev/null +++ b/starting_kit/README.md @@ -0,0 +1,11 @@ +# GEMS-GER Starting Kit + +This kit contains everything you need to participate in the challenge. + +### Quick Start: +1. Install dependencies: `pip install -r requirements.txt` +2. Open `template_starting_kit.ipynb` in Jupyter or VS Code. +3. The data is already located in the `dev_phase/` folder. + +### Submitting: +When ready, run `python zip_submission.py` to create your upload package. \ No newline at end of file diff --git a/starting_kit/ingestion_program/ingestion.py b/starting_kit/ingestion_program/ingestion.py new file mode 100755 index 0000000..7fba742 --- /dev/null +++ b/starting_kit/ingestion_program/ingestion.py @@ -0,0 +1,93 @@ +import json +import sys +import time +from pathlib import Path +import pandas as pd + +# We only have one test set now +EVAL_SETS = ["test"] + +def evaluate_model(model, X_test): + """ + Generate predictions. + Note: We pass the RAW X_test to the model. + The participant's pipeline must handle dropping strings! + """ + y_pred = model.predict(X_test) + return pd.DataFrame({'GWL': y_pred}) + +def get_train_data(data_dir, chunksize=200000): + train_path = Path(data_dir) / "train" / "train.csv" + chunks = [] + + print(f"Reading training data in chunks of {chunksize}...") + # Use chunksize to keep RAM usage low during load + for chunk in pd.read_csv(train_path, chunksize=chunksize): + # Optional: Optimize float precision to save more RAM + for col in chunk.select_dtypes(include=['float64']).columns: + chunk[col] = chunk[col].astype('float32') + chunks.append(chunk) + + full_df = pd.concat(chunks, axis=0) + y_train = full_df['GWL'] + X_train = full_df.drop(columns=['GWL']) + + return X_train, y_train + +def main(data_dir, output_dir): + # Import the participant's model + from submission import get_model + + print("--- 1. Loading Training Data ---") + X_train, y_train = get_train_data(data_dir) + + print("--- 2. Training the Model ---") + model = get_model() + + start_train = time.time() + model.fit(X_train, y_train) + train_time = time.time() - start_train + print(f"Training completed in {train_time:.2f}s") + + print("--- 3. Evaluating on Test Set ---") + start_test = time.time() + + # Load test features (Matches setup_data.py output) + X_test_path = data_dir / "test" / "test_features.csv" + X_test = pd.read_csv(X_test_path) + + y_test_pred = evaluate_model(model, X_test) + + test_time = time.time() - start_test + print(f"Testing completed in {test_time:.2f}s") + + # --- 4. Write Output Files --- + output_dir.mkdir(parents=True, exist_ok=True) + + # Save metadata for the leaderboard (Runtime) + with open(output_dir / "metadata.json", "w") as f: + json.dump({ + "train_time": train_time, + "test_time": test_time, + "duration": train_time + test_time + }, f) + + # Save predictions (Matches what scoring.py expects) + y_test_pred.to_csv(output_dir / "test_predictions.csv", index=False) + + print(f"Ingestion finished. Total duration: {train_time + test_time:.2f}s") + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser(description="Ingestion program") + parser.add_argument("--data-dir", type=str, default="/app/input_data") + parser.add_argument("--output-dir", type=str, default="/app/output") + parser.add_argument("--submission-dir", type=str, default="/app/ingested_program") + + args = parser.parse_args() + + # Add submission and current folder to path so we can find 'submission.py' + sys.path.append(args.submission_dir) + sys.path.append(str(Path(__file__).parent.resolve())) + + main(Path(args.data_dir), Path(args.output_dir)) diff --git a/starting_kit/requirements.txt b/starting_kit/requirements.txt new file mode 100644 index 0000000..210fb4e --- /dev/null +++ b/starting_kit/requirements.txt @@ -0,0 +1,4 @@ +pandas +scikit-learn +tqdm +matplotlib diff --git a/starting_kit/scoring_program/scoring.py b/starting_kit/scoring_program/scoring.py new file mode 100755 index 0000000..95b9b9f --- /dev/null +++ b/starting_kit/scoring_program/scoring.py @@ -0,0 +1,80 @@ +import json +from pathlib import Path +import pandas as pd +import numpy as np +from sklearn.metrics import mean_squared_error + +def compute_rmse(predictions, targets): + """ + Calculates the Root Mean Squared Error (RMSE). + """ + # Ensure we are comparing the same number of rows + # Targets usually has 1 column ('GWL'), Predictions usually has 1 column ('GWL') + y_pred = predictions.iloc[:, 0] if isinstance(predictions, pd.DataFrame) else predictions + y_true = targets.iloc[:, 0] if isinstance(targets, pd.DataFrame) else targets + + # Align by index and drop any rows with NaNs in ground truth (if any) + combined = pd.concat([ + pd.Series(y_pred, name='pred').reset_index(drop=True), + pd.Series(y_true, name='true').reset_index(drop=True) + ], axis=1).dropna() + + if combined.empty: + print("Warning: No data to score.") + return 999.0 + + rmse = np.sqrt(mean_squared_error(combined['true'], combined['pred'])) + return float(rmse) + +def main(reference_dir, prediction_dir, output_dir): + scores = {} + + try: + # 1. Path Setup + # Reference labels: [ref_dir]/test/test_labels.csv (from setup_data.py) + # Predictions: [pred_dir]/test_predictions.csv (from ingestion.py) + label_path = reference_dir / 'test' / 'test_labels.csv' + pred_path = prediction_dir / 'test_predictions.csv' + + # Fallback if structure differs slightly on different platforms + if not label_path.exists(): + label_path = reference_dir / 'test_labels.csv' + + # 2. Load Data + targets = pd.read_csv(label_path) + predictions = pd.read_csv(pred_path) + + # 3. Compute Score + scores['rmse'] = compute_rmse(predictions, targets) + + except Exception as e: + print(f"❌ Scoring Error: {e}") + scores['rmse'] = 999.0 + + # 4. Include Runtime Metadata (Captured by ingestion.py) + try: + metadata_path = prediction_dir / 'metadata.json' + if metadata_path.exists(): + with open(metadata_path, 'r') as f: + metadata = json.load(f) + scores.update(metadata) + except Exception: + pass + + # 5. Save results for the Leaderboard + output_dir.mkdir(parents=True, exist_ok=True) + with open(output_dir / 'scores.json', 'w') as f: + json.dump(scores, f) + + print(f"Scoring finished. RMSE: {scores['rmse']:.4f}") + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + # Paths provided by Codabench environment + parser.add_argument("--reference-dir", type=str, default="/app/input/ref") + parser.add_argument("--prediction-dir", type=str, default="/app/input/res") + parser.add_argument("--output-dir", type=str, default="/app/output") + args = parser.parse_args() + + main(Path(args.reference_dir), Path(args.prediction_dir), Path(args.output_dir)) diff --git a/starting_kit/solution/submission.py b/starting_kit/solution/submission.py new file mode 100644 index 0000000..ed399dd --- /dev/null +++ b/starting_kit/solution/submission.py @@ -0,0 +1,37 @@ +from sklearn.ensemble import RandomForestRegressor +from sklearn.compose import ColumnTransformer +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import StandardScaler + +from sklearn.ensemble import RandomForestRegressor +from sklearn.compose import ColumnTransformer +from sklearn.compose import make_column_selector as selector +from sklearn.pipeline import Pipeline +from sklearn.impute import SimpleImputer + +def get_model(): + """ + Returns a model that automatically filters out string columns + to avoid ValueErrors and fits on numeric data only. + """ + + # 1. Define a transformer that ONLY picks numeric columns (float64, int64) + # This automatically ignores 'well_id_str' and 'date_dt' because they are strings/objects + numeric_transformer = Pipeline(steps=[ + ('imputer', SimpleImputer(strategy='median')) + ]) + + preprocessor = ColumnTransformer( + transformers=[ + ('num', numeric_transformer, selector(dtype_include=['float64', 'int64'])) + ], + remainder='drop' # This explicitly drops anything that isn't a number + ) + + # 2. Create the full pipeline + model = Pipeline(steps=[ + ('preprocessor', preprocessor), + ('regressor', RandomForestRegressor(n_estimators=50, max_depth=8, random_state=42)) + ]) + + return model diff --git a/starting_kit/template_starting_kit.ipynb b/starting_kit/template_starting_kit.ipynb new file mode 100644 index 0000000..f654f03 --- /dev/null +++ b/starting_kit/template_starting_kit.ipynb @@ -0,0 +1,1651 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "# GEMS-GER Groundwater Level Prediction Challenge\n", + "\n", + "## Introduction\n", + "Groundwater is a critical resource for drinking water and agriculture. This challenge uses the **GEMS-GER** dataset, which provides historical groundwater levels (GWL) and over 50 environmental features (meteorological and static site data) across Germany.\n", + "\n", + "**The Task:** Predict the depth to groundwater (GWL) for various monitoring wells.\n", + "**The Metric:** Root Mean Squared Error (RMSE). Lower is better.\n", + "\n", + " Youssef SIDHOM
\n", + " Ralph " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 📊 Data Source & Attribution\n", + "\n", + "This challenge utilizes the **GEMS-GER (Groundwater Levels, Environment, Meteorology, and Site Properties for Germany)** dataset, a multi-source benchmark for groundwater level prediction.\n", + "\n", + "### **Dataset Overview**\n", + "\n", + "* **Source:** [Copernicus ESSD / Zenodo](https://doi.org/10.5281/zenodo.15530171)\n", + "* **Temporal Coverage:** Filtered for the most recent 5 years (2021–2026).\n", + "* **Spatial Coverage:** 3,200+ monitoring wells across Germany.\n", + "* **Features:** Includes 50+ static environmental variables (geology, soil, topography) and dynamic meteorological drivers (HYRAS, ERA5, and DWD products).\n", + "\n", + "### **Data Citation**\n", + "\n", + "If you use this data or the results of this challenge in your own research, please cite the original authors:\n", + "\n", + "> *Benz, S. A., et al. (2026). GEMS-GER: A machine learning benchmark dataset for groundwater level modeling in Germany. Earth System Science Data (ESSD).*\n", + "\n", + "### **License**\n", + "\n", + "This dataset is provided under the **Creative Commons Attribution 4.0 International (CC BY 4.0)** license. You are free to share and adapt the material as long as appropriate credit is given.\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Getting Started\n", + "Before loading data, we run the setup script to download and split the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the setup script to download and prepare the folders\n", + "!python tools/setup_data.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory data analysis\n", + "\n", + "The goal of this section is to show what's in the data, and how to play with it.\n", + "This is the first set in any data science project, and here, you should give a sense of the data the participants will be working with.\n", + "\n", + "You can first load and describe the data, and then show some interesting properties of it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading dev_phase/input_data/train/train.csv in chunks...\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "pd.set_option('display.max_columns', None)\n", + "\n", + "# Load the data\n", + "from ingestion_program.ingestion import get_train_data\n", + "X_df, y = get_train_data(\"dev_phase/input_data\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Challenge Evaluation\n", + "\n", + "To ensure the results are robust and reflect real-world forecasting capabilities, we evaluate submissions using a **Temporal Split** strategy.\n", + "\n", + "#### 1. Evaluation Metric: RMSE\n", + "\n", + "The primary metric for this challenge is the **Root Mean Squared Error (RMSE)**.\n", + "\n", + "\n", + "This metric is particularly suitable for groundwater prediction because it penalizes large errors more heavily than small ones, which is critical for water resource management and flood/drought prevention.\n", + "\n", + "* **Lower is Better:** A perfect prediction would result in an RMSE of 0.\n", + "* **Units:** The RMSE is in the same units as the target variable (meters of depth to groundwater).\n", + "\n", + "#### 2. Evaluation Strategy: Temporal Holdout\n", + "\n", + "Unlike standard cross-validation where data is shuffled, groundwater levels are highly dependent on time and seasonal cycles. To simulate a real-world scenario where we predict the *future* based on the *past*:\n", + "\n", + "* **Training Data:** Consists of the earliest **80%** of the historical timeline.\n", + "* **Test Data:** Consists of the most recent **20%** of the records.\n", + "* **Data Leakage Prevention:** By splitting strictly by date, we ensure the model cannot \"see\" future weather patterns or water levels during the training phase.\n", + "\n", + "#### 3. Handling Metadata\n", + "\n", + "Participants are provided with raw `well_id` and `date` columns. While these cannot be passed directly into a standard regressor (like Random Forest or XGBoost), they are essential for:\n", + "\n", + "* **Seasonal Features:** Extracting month/year patterns.\n", + "* **Spatial Consistency:** Understanding that certain wells behave similarly due to shared geological characteristics.\n", + "\n", + "Submissions must include a preprocessing step (ideally via a `scikit-learn` Pipeline) to manage these non-numeric columns.\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Submission File\n", + "\n", + "In this challenge, your submission is not a file of predictions, but the **code** itself. The ingestion program expects a file named `submission.py` containing a `get_model()` function.\n", + "\n", + "### From DataFrames to Numeric Arrays\n", + "\n", + "The input data provided by the competition is stored in a **Pandas DataFrame**. However, most machine learning models (like those in Scikit-Learn) require a **NumPy array** of floats to perform calculations. \n", + "\n", + "Because our dataset contains \"metadata\" columns like `well_id_str` (strings) and `date_dt` (dates), we cannot simply pass the whole DataFrame to the model. We must transform it first.\n", + "\n", + "### Using Scikit-Learn `ColumnTransformer`\n", + "\n", + "To bridge the gap between a messy DataFrame and a clean NumPy array, we use a `ColumnTransformer`. This tool allows us to apply different transformations to different columns. \n", + "\n", + "**The simplest strategy is to select only the numeric columns and drop the rest.**\n", + "\n", + "\n", + "\n", + "### Example: Simple Column Selection\n", + "\n", + "Here is how you can define a model that automatically filters out the string columns and only works with the numeric features:\n", + "\n", + "```python\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.compose import make_column_selector as selector\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "def get_model():\n", + " # 1. Define the ColumnTransformer\n", + " # We use a selector to automatically pick columns with float or int types.\n", + " # The 'remainder=drop' setting ensures that strings like well IDs are removed.\n", + " preprocessor = ColumnTransformer(\n", + " transformers=[\n", + " ('num', 'passthrough', selector(dtype_include=['float64', 'int64']))\n", + " ],\n", + " remainder='drop'\n", + " )\n", + "\n", + " # 2. Bundle the preprocessor and the regressor into a Pipeline\n", + " model = Pipeline(steps=[\n", + " ('preprocessor', preprocessor),\n", + " ('regressor', RandomForestRegressor(n_estimators=10, max_depth=5))\n", + " ])\n", + " \n", + " return model\n", + "\n", + "```\n", + "\n", + "### Why use a Pipeline?\n", + "\n", + "By using a `Pipeline`, you ensure that the same transformations applied to your **Training Data** are automatically applied to the **Test Data** during evaluation. This prevents \"Dimension Mismatch\" errors and ensures your model always receives the correct numeric input format.\n", + "\n", + "\n", + "\n", + "\n", + "### What this explains to your participants:\n", + "\n", + "1. **Data Format**: They now know the input is a DataFrame.\n", + "2. **The \"Why\"**: They understand why they can't just throw the whole table at a model (because of the string columns).\n", + "3. **The \"How\"**: They see a concrete example of using `selector` to pick only numbers, which is the most robust way to avoid the `ValueError` they would otherwise get.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.compose import make_column_selector as selector\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.impute import SimpleImputer\n", + "\n", + "def get_model():\n", + " \"\"\"\n", + " Returns a model that automatically filters out string columns \n", + " to avoid ValueErrors and fits on numeric data only.\n", + " \"\"\"\n", + " \n", + " # 1. Define a transformer that ONLY picks numeric columns (float64, int64)\n", + " # This automatically ignores 'well_id_str' and 'date_dt' because they are strings/objects\n", + " numeric_transformer = Pipeline(steps=[\n", + " ('imputer', SimpleImputer(strategy='median'))\n", + " ])\n", + "\n", + " preprocessor = ColumnTransformer(\n", + " transformers=[\n", + " ('num', numeric_transformer, selector(dtype_include=['float64', 'int64']))\n", + " ],\n", + " remainder='drop' # This explicitly drops anything that isn't a number\n", + " )\n", + "\n", + " # 2. Create the full pipeline\n", + " model = Pipeline(steps=[\n", + " ('preprocessor', preprocessor),\n", + " ('regressor', RandomForestRegressor(n_estimators=50, max_depth=8, random_state=42))\n", + " ])\n", + " \n", + " return model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Local testing pipeline\n", + "\n", + "Here you can show how the model will be used to generate predictions on the test set, and how the evaluation will be performed." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading dev_phase/input_data/train/train.csv in chunks...\n" + ] + }, + { + "data": { + "text/html": [ + "
Pipeline(steps=[('preprocessor',\n",
+       "                 ColumnTransformer(transformers=[('num',\n",
+       "                                                  Pipeline(steps=[('imputer',\n",
+       "                                                                   SimpleImputer(strategy='median'))]),\n",
+       "                                                  <sklearn.compose._column_transformer.make_column_selector object at 0x71f94a7443e0>)])),\n",
+       "                ('regressor',\n",
+       "                 RandomForestRegressor(max_depth=8, n_estimators=50,\n",
+       "                                       random_state=42))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('preprocessor',\n", + " ColumnTransformer(transformers=[('num',\n", + " Pipeline(steps=[('imputer',\n", + " SimpleImputer(strategy='median'))]),\n", + " )])),\n", + " ('regressor',\n", + " RandomForestRegressor(max_depth=8, n_estimators=50,\n", + " random_state=42))])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from solution.submission import get_model\n", + "model = get_model()\n", + "X_train, y_train = get_train_data(\"dev_phase/input_data\")\n", + "model.fit(X_train, y_train)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "X_test = pd.read_csv(\"dev_phase/input_data/test/test_features.csv\")\n", + "from ingestion_program.ingestion import evaluate_model\n", + "y_test = evaluate_model(model, X_test)\n", + "from scoring_program.scoring import compute_rmse\n", + "print(\"Accuracy on test set:\", compute_rmse(y_test, pd.read_csv(\"path_to_test_labels\"))) #the test data wouldn't be accesible keep in minde " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Submission\n", + "\n", + "Once you have refined your model in `solution/submission.py`, you need to upload it to the Codabench platform. \n", + "\n", + "### The Rules of the ZIP\n", + "Codabench is very strict about the structure of your upload:\n", + "1. Your ZIP file must contain `submission.py` at the **root level**.\n", + "2. If `submission.py` is hidden inside a folder within the ZIP, the platform will not find your `get_model()` function and your submission will fail.\n", + "\n", + "\n", + "\n", + "### Using the Helper Script\n", + "To make this easy, we have provided a helper script called `zip_submission.py`. This script automatically finds your code and packages it into a `submission.zip` file with the correct internal structure." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/starting_kit/zip_submission.py b/starting_kit/tools/zip_submission.py similarity index 100% rename from starting_kit/zip_submission.py rename to starting_kit/tools/zip_submission.py diff --git a/tools/create_bundle.py b/tools/create_bundle.py index 9f612ec..3153973 100644 --- a/tools/create_bundle.py +++ b/tools/create_bundle.py @@ -1,38 +1,49 @@ import zipfile from pathlib import Path +# Adjust this to point to your project root ROOT_DIR = Path(__file__).parent.parent - -PAGES_DIR = ROOT_DIR / "pages" -INGESTION_DIR = ROOT_DIR / "ingestion_program" -SCORING_DIR = ROOT_DIR / "scoring_program" -PHASE_DATA = ROOT_DIR / "dev_phase" - +# Files that MUST be at the root of the ZIP BUNDLE_FILES = [ ROOT_DIR / "competition.yaml", ROOT_DIR / "logo.png", - ROOT_DIR / "solution/submission.py", + ROOT_DIR / "starting_kit.zip", # Ensure this was built first! ] +# Folders to include as directories +BUNDLE_DIRS = { + "pages": ROOT_DIR / "pages", + "ingestion_program": ROOT_DIR / "ingestion_program", + "scoring_program": ROOT_DIR / "scoring_program", + "dev_phase": ROOT_DIR / "dev_phase", + "final_phase": ROOT_DIR / "final_phase", +} if __name__ == "__main__": - with zipfile.ZipFile("bundle.zip", mode="w") as bundle: + output_filename = "bundle.zip" + print(f"📦 Creating {output_filename}...") + + with zipfile.ZipFile(output_filename, mode="w") as bundle: + # 1. Add root files for f in BUNDLE_FILES: - f = f.relative_to(ROOT_DIR) - print(f) - bundle.write(f) - for dirpath in [INGESTION_DIR, SCORING_DIR, PAGES_DIR, PHASE_DATA]: - assert dirpath.exists(), ( - f"{dirpath} does not exist while it should. Make sure you " - "followed all the instructions in the README before " - "creating the bundle." - ) + if f.exists(): + print(f" [File] Adding {f.name}") + bundle.write(f, arcname=f.name) + else: + print(f" ⚠️ Warning: {f.name} not found!") + + # 2. Add directories recursively + for arc_dirname, dirpath in BUNDLE_DIRS.items(): + if not dirpath.exists(): + print(f" ❌ Error: {arc_dirname} directory missing!") + continue + + print(f" [Dir] Adding {arc_dirname}/") for f in dirpath.rglob("*"): - if not f.is_file(): - continue - if f.name.startswith(".") or f.name.endswith(".pyc"): - continue - f = f.relative_to(ROOT_DIR) - print(f) - bundle.write(f) + if f.is_file() and not f.name.startswith(".") and not f.name.endswith(".pyc"): + # Maintain internal folder structure + relative_path = f.relative_to(ROOT_DIR) + bundle.write(f, arcname=relative_path) + + print(f"\n✅ Success! Upload {output_filename} to Codabench.") diff --git a/tools/create_starting_kit.py b/tools/create_starting_kit.py new file mode 100644 index 0000000..312b1cf --- /dev/null +++ b/tools/create_starting_kit.py @@ -0,0 +1,76 @@ +import shutil +import zipfile +import os +from pathlib import Path + +# Configuration +KIT_NAME = "starting_kit" +ROOT_DIR = Path(".") +# Temporary staging directory +STAGING_DIR = ROOT_DIR / "temp_kit_staging" + +# Items to include in the kit +# Format: (Source Path, Destination Path inside the ZIP) +ITEMS_TO_COPY = [ + ("template_starting_kit.ipynb", "template_starting_kit.ipynb"), + ("tools/zip_submission.py", "zip_submission.py"), # Move to root for easier use + ("requirements.txt", "requirements.txt"), + ("solution/submission.py", "submission.py"), # Move to root as the template + ("ingestion_program/ingestion.py", "ingestion_program/ingestion.py"), + ("scoring_program/scoring.py", "scoring_program/scoring.py"), + ("dev_phase/input_data", "dev_phase/input_data"), # Include only input data +] + +def build(): + # 1. Clean up old builds + if STAGING_DIR.exists(): + shutil.rmtree(STAGING_DIR) + STAGING_DIR.mkdir(exist_ok=True) + + print(f"📦 Preparing files for {KIT_NAME}.zip...") + + # 2. Copy files and folders to staging + for src_path, dst_rel_path in ITEMS_TO_COPY: + src = ROOT_DIR / src_path + dst = STAGING_DIR / dst_rel_path + + if not src.exists(): + print(f"⚠️ Warning: {src} not found, skipping.") + continue + + dst.parent.mkdir(parents=True, exist_ok=True) + + if src.is_dir(): + shutil.copytree(src, dst, dirs_exist_ok=True) + print(f" + Added directory: {src_path}/") + else: + shutil.copy2(src, dst) + print(f" + Added file: {src_path}") + + # 3. Create a README for the user + with open(STAGING_DIR / "README.md", "w") as f: + f.write("# GEMS-GER Starting Kit\n\n" + "This kit contains everything you need to participate in the challenge.\n\n" + "### Quick Start:\n" + "1. Install dependencies: `pip install -r requirements.txt`\n" + "2. Open `template_starting_kit.ipynb` and run the cells.\n" + "### Submitting:\n" + "Run `python zip_submission.py` to create your submission package.") + + # 4. Create the ZIP and CLEAN UP + zip_filename = f"{KIT_NAME}.zip" + + # We use shutil.make_archive to zip the content of STAGING_DIR + # base_name is the path/name of the zip to create + # root_dir is the directory we want to zip the contents of + shutil.make_archive(KIT_NAME, 'zip', STAGING_DIR) + + # Clean up the staging folder so only the ZIP remains + shutil.rmtree(STAGING_DIR) + + print(f"\n✅ SUCCESS!") + print(f"Generated: {zip_filename}") + print(f"Temporary staging folder has been removed.") + +if __name__ == "__main__": + build() diff --git a/tools/setup_data.py b/tools/setup_data.py index 8c6f3f1..72e39eb 100644 --- a/tools/setup_data.py +++ b/tools/setup_data.py @@ -1,79 +1,95 @@ import pandas as pd -import os +import numpy as np import requests import zipfile -import shutil from pathlib import Path # --- CONFIGURATION --- ZENODO_URL = "https://zenodo.org/records/16736908/files/GEMS-GER_data.zip?download=1" RAW_DIR = Path("raw_data") EXTRACT_DIR = RAW_DIR / "extracted" -MAX_TRAIN_ROWS = 100000 # <--- LIMIT TRAINING SIZE HERE (e.g., 100k rows) +MAX_TRAIN_ROWS = 1000000 +MAX_TEST_ROWS = 50000 # <--- Capping test size for efficiency def run_setup(): # 1. Directory Setup - input_base = Path("dev_phase/input_data") - for f in ["train", "test"]: (input_base / f).mkdir(parents=True, exist_ok=True) - Path("dev_phase/reference_data/test").mkdir(parents=True, exist_ok=True) + for phase in ["dev_phase", "final_phase"]: + (Path(phase) / "input_data/test").mkdir(parents=True, exist_ok=True) + (Path(phase) / "reference_data/test").mkdir(parents=True, exist_ok=True) + (Path("dev_phase/input_data/train")).mkdir(parents=True, exist_ok=True) + EXTRACT_DIR.mkdir(parents=True, exist_ok=True) - # 2. Download & Extract (Same logic as before) + # 2. Download & Extract (Skipped if exists) zip_path = RAW_DIR / "GEMS-GER_data.zip" if not zip_path.exists(): - print("Downloading...") + print("📥 Downloading dataset...") r = requests.get(ZENODO_URL, stream=True) with open(zip_path, 'wb') as f: for chunk in r.iter_content(chunk_size=8192): f.write(chunk) - with zipfile.ZipFile(zip_path, 'r') as zip_ref: - zip_ref.extractall(EXTRACT_DIR) + if not any(EXTRACT_DIR.iterdir()): + with zipfile.ZipFile(zip_path, 'r') as zip_ref: + zip_ref.extractall(EXTRACT_DIR) - # 3. Locate & Merge + # 3. Process Data + print("📊 Merging and optimizing memory...") static_file = next(EXTRACT_DIR.rglob("*static*.csv")) - dynamic_folder = next(EXTRACT_DIR.rglob("dynamic")) df_static = pd.read_csv(static_file) df_static.columns = df_static.columns.str.strip() li = [] + dynamic_folder = next(EXTRACT_DIR.rglob("dynamic")) for filename in dynamic_folder.glob("*.csv"): df = pd.read_csv(filename) df['well_id_str'] = filename.stem if 'Unnamed: 0' in df.columns: df['date_dt'] = pd.to_datetime(df['Unnamed: 0']) - df['month'] = df['date_dt'].dt.month - df['year'] = df['date_dt'].dt.year - df.drop(columns=[c for c in ['Unnamed: 0', 'GWL_flag'] if c in df.columns], inplace=True) + df.drop(columns=['Unnamed: 0'], inplace=True) + # Drop and optimize + df.drop(columns=[c for c in ['GWL_flag'] if c in df.columns], inplace=True) + for col in df.select_dtypes(include=['float64']).columns: + df[col] = df[col].astype('float32') li.append(df) master_df = pd.concat(li, ignore_index=True) master_df = pd.merge(master_df, df_static, left_on='well_id_str', right_on='MW_ID', how='left').drop(columns=['MW_ID']) - # 4. Temporal Split (80/20) + # 4. Strict Temporal Split master_df = master_df.sort_values('date_dt') unique_dates = sorted(master_df['date_dt'].unique()) - split_date = unique_dates[int(len(unique_dates) * 0.8)] - train_df = master_df[master_df['date_dt'] < split_date] - test_df = master_df[master_df['date_dt'] >= split_date] + # We define the boundaries based on the total timeline + idx_80 = int(len(unique_dates) * 0.8) + idx_90 = int(len(unique_dates) * 0.9) + + train_df = master_df[master_df['date_dt'] < unique_dates[idx_80]] + dev_df = master_df[(master_df['date_dt'] >= unique_dates[idx_80]) & (master_df['date_dt'] < unique_dates[idx_90])] + final_df = master_df[master_df['date_dt'] >= unique_dates[idx_90]] - # --- 5. REDUCE DATA SIZE --- + # 5. Applying the Caps if len(train_df) > MAX_TRAIN_ROWS: - print(f"Reducing training data from {len(train_df)} to {MAX_TRAIN_ROWS} rows...") - # Option A: Take the MOST RECENT rows (Best for time-series) train_df = train_df.tail(MAX_TRAIN_ROWS) - - # Option B: Random Sampling (Uncomment if you prefer variety over recency) - # train_df = train_df.sample(n=MAX_TRAIN_ROWS, random_state=42).sort_values('date_dt') - - # 6. Save Files - train_df.to_csv(input_base / "train/train.csv", index=False) + # We take the FIRST rows of the test segments to stay close to training timeline + if len(dev_df) > MAX_TEST_ROWS: + dev_df = dev_df.head(MAX_TEST_ROWS) + if len(final_df) > MAX_TEST_ROWS: + final_df = final_df.head(MAX_TEST_ROWS) + + # 6. Saving meta_cols = ['well_id_str', 'date_dt'] - test_df.drop(columns=['GWL'] + meta_cols).to_csv(input_base / "test/test_features.csv", index=False) - test_df[['GWL']].to_csv("dev_phase/reference_data/test/test_labels.csv", index=False) + train_df.to_csv("dev_phase/input_data/train/train.csv", index=False) + + # Public Dev + dev_df.drop(columns=['GWL'] + meta_cols).to_csv("dev_phase/input_data/test/test_features.csv", index=False) + dev_df[['GWL']].to_csv("dev_phase/reference_data/test/test_labels.csv", index=False) + + # Private Final + final_df.drop(columns=['GWL'] + meta_cols).to_csv("final_phase/input_data/test/test_features.csv", index=False) + final_df[['GWL']].to_csv("final_phase/reference_data/test/test_labels.csv", index=False) - print(f"🚀 Setup Complete! Final Train Size: {len(train_df)}") + print(f"🚀 Setup Complete!\nTrain: {len(train_df):,}\nDev Test: {len(dev_df):,}\nFinal Test: {len(final_df):,}") if __name__ == "__main__": run_setup() diff --git a/tools/zip_submission.py b/tools/zip_submission.py new file mode 100644 index 0000000..c3fe5a8 --- /dev/null +++ b/tools/zip_submission.py @@ -0,0 +1,26 @@ +import zipfile +from pathlib import Path + +# This script zips the submission.py from the solution folder +# so it's ready to be uploaded to Codabench. + +def create_submission_zip(output_filename="submission.zip"): + # Path to the participant's actual code + # Assuming they are working in the starting_kit/solution/ directory + submission_script = Path("solution/submission.py") + + if not submission_script.exists(): + print(f"❌ Error: {submission_script} not found!") + print("Make sure you are running this script from the starting_kit root.") + return + + with zipfile.ZipFile(output_filename, 'w') as zipf: + # Crucial: We write 'submission.py' as the arcname + # so it's at the root of the ZIP, not in a folder. + zipf.write(submission_script, arcname="submission.py") + + print(f"✅ Success! Created '{output_filename}'.") + print("You can now upload this file to the Codabench platform.") + +if __name__ == "__main__": + create_submission_zip() From bd0298e5bca2ca8ed042175520648425f6d9b8af Mon Sep 17 00:00:00 2001 From: CharlesKarrer Date: Wed, 4 Mar 2026 13:53:13 +0100 Subject: [PATCH 3/6] Spyridon / Karrer --- template_starting_kit.ipynb | 1907 ++++++++++++++++++++++++++++++++++- 1 file changed, 1900 insertions(+), 7 deletions(-) diff --git a/template_starting_kit.ipynb b/template_starting_kit.ipynb index f654f03..2373024 100644 --- a/template_starting_kit.ipynb +++ b/template_starting_kit.ipynb @@ -20,7 +20,11 @@ "**The Metric:** Root Mean Squared Error (RMSE). Lower is better.\n", "\n", " Youssef SIDHOM
\n", - " Ralph " + " Ralph MOUAWAD
\n", + " Spyridon PAIPETIS
\n", + " Charles KARRER
\n", + " Clément DESTOUESSE
\n", + " Felix BLANCHARD
" ] }, { @@ -61,9 +65,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📥 Downloading dataset...\n", + "📊 Merging and optimizing memory...\n", + "🚀 Setup Complete!\n", + "Train: 1,000,000\n", + "Dev Test: 50,000\n", + "Final Test: 50,000\n" + ] + } + ], "source": [ "# Run the setup script to download and prepare the folders\n", "!python tools/setup_data.py" @@ -83,14 +100,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Reading dev_phase/input_data/train/train.csv in chunks...\n" + "Reading training data in chunks of 200000...\n" ] } ], @@ -99,13 +116,1889 @@ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from scipy import stats\n", "pd.set_option('display.max_columns', None)\n", + "sns.set_style('whitegrid')\n", "\n", "# Load the data\n", "from ingestion_program.ingestion import get_train_data\n", "X_df, y = get_train_data(\"dev_phase/input_data\")" ] }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DATASET OVERVIEW\n", + "================================================================================\n", + "\n", + "Shape: (1000000, 69)\n", + "Target variable (y) shape: (1000000,)\n", + "\n", + "Column types:\n", + "float32 34\n", + "int64 23\n", + "object 12\n", + "Name: count, dtype: int64\n", + "\n", + "Missing values per column:\n", + " missing_count percentage\n", + "UpFilter 551899 55.19\n", + "LoFilter 551587 55.16\n", + "ScrLength 425309 42.53\n", + "Depth 293728 29.37\n", + "\n", + "First few rows:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
HYRAS_prHYRAS_tasHYRAS_tasmaxHYRAS_tasminHYRAS_hursDWD_evapo_pDWD_evapo_rDWD_evapo_faoDWD_soil_moistDWD_soil_temp5cmERA5_sroERA5_ssroERA5_sdweERA5_smERA5_sfwell_id_strdate_dtUnnamed: 0Proj_IDOperatorElevationDepthUpFilterLoFilterScrLengthAquiferMedPreStateEasting (EPSG:3035)Northing (EPSG:3035)HYRAUM_HDHYRAUM_MHDEU_MOHP_DSD_1EU_MOHP_DSD_2EU_MOHP_DSD_3EU_MOHP_SD_1EU_MOHP_SD_2EU_MOHP_SD_3EU_MOHP_LP_1EU_MOHP_LP_2EU_MOHP_LP_3BUEK1000_RSAGWN1000_GRHUEK250_HUHUEK250_KHUEK250_RTHUEK250_CTHUEK250_DCHUEK250_GCHYSOG_SGSWR_PRCLC_90CLC_00CLC_06CLC_12CLC_18MUNDIALIS_LUHUMUS1000_OCGMK1000_GUDTM20_FDDTM20_SLDTM20_FADTM20_ASDTM20_GCDTM20_PLCDTM20_PRCDTM20_TPIDTM20_TRIDTM20_CIDTM20_MRI
047.09999818.71428522.85714314.52857177.6142812.5571432.1571432.8571437.72857121.2857150.0018380.001611-7.345365e-251.490116e-080.0MW_21852010-08-162185RP_2375137500Landesamt für Umwelt Rheinland-Pfalz (LfU)139.1799936.95NaNNaNNaNPorousUnknown4182069.752885505.253136043317142871243003140472049905298321118703K (2-3)B12SPLs13286.5018312020201818182 - <3%32115.01.5612294793.7915045.588550-1.346539-0.001508-4.515871e-07-3.3151764.648530-0.1134490.895954
155.79999916.04285820.51428612.38571584.6142811.8285711.7142862.05714310.27142818.7142850.0018790.003050-7.345365e-257.450581e-090.0MW_27012010-08-162701SN_55393700Sächsisches Landesamt für Umwelt, Landwirtscha...442.89999415.104.3014.3010.0PorousAndFracturedUnknown4483330.503043150.509692247405790788585528537820958225714309P 2F5MaKFs13291.4094241212122226 - <8%1160.01.57001817958.5253912.732285-46.5253070.016564-2.102138e-08-0.0574450.801671-34.6297800.142776
271.59999819.41428825.24285914.37142983.0000002.6000002.5142862.84285710.21428622.4571440.0084770.001183-7.345365e-253.725290e-090.0MW_5182010-08-16518BB_42530371Landesamt für Umwelt Brandenburg (LfU)69.419998NaNNaNNaNNaNPorousunconfined4641452.003195904.7513140119141914371371371925219391939128801K L1.2A9SPLs2155.4444732222221 - <2%1122.01.570340951.6646734.711417-215.7817690.000080-1.027928e-08-0.1621960.7308764.9405030.094399
318.29999917.62857223.04285812.21428676.1428602.4571431.9285712.8285715.90000020.3142850.0001040.001494-7.345365e-257.450581e-090.0MW_19742010-08-161974NI_40510490Niedersächsischer Landesbetrieb für Wasserwirt...28.0499995.493.495.492.0PorousUnknown4137212.253261389.75131138465746574117222402240846734083408118301K L1.2A9SPLs2349.5931402424242424243 - <4%1154.01.5472551729.8052980.3333825.8410160.096889-1.557907e-05-0.2308491.067289-41.2573620.061859
421.20000118.08571423.20000113.41428680.8857192.3428572.0142862.6285717.20000020.7857150.0005960.001919-7.345365e-251.490116e-080.0MW_16282010-08-161628HE_12354Hessisches Landesamt für Naturschutz, Umwelt u...129.88000520.40NaNNaN2.0PorousUnknown4248638.502987661.25323263232043204245224522452931676557655167303K 2C3SPLm2179.7999272424242424244 - <6%32113.01.475317449.7566834.856913-2.2298890.011956-1.074220e-030.2001160.53787848.5231930.000000
\n", + "
" + ], + "text/plain": [ + " HYRAS_pr HYRAS_tas HYRAS_tasmax HYRAS_tasmin HYRAS_hurs DWD_evapo_p \\\n", + "0 47.099998 18.714285 22.857143 14.528571 77.614281 2.557143 \n", + "1 55.799999 16.042858 20.514286 12.385715 84.614281 1.828571 \n", + "2 71.599998 19.414288 25.242859 14.371429 83.000000 2.600000 \n", + "3 18.299999 17.628572 23.042858 12.214286 76.142860 2.457143 \n", + "4 21.200001 18.085714 23.200001 13.414286 80.885719 2.342857 \n", + "\n", + " DWD_evapo_r DWD_evapo_fao DWD_soil_moist DWD_soil_temp5cm ERA5_sro \\\n", + "0 2.157143 2.857143 7.728571 21.285715 0.001838 \n", + "1 1.714286 2.057143 10.271428 18.714285 0.001879 \n", + "2 2.514286 2.842857 10.214286 22.457144 0.008477 \n", + "3 1.928571 2.828571 5.900000 20.314285 0.000104 \n", + "4 2.014286 2.628571 7.200000 20.785715 0.000596 \n", + "\n", + " ERA5_ssro ERA5_sdwe ERA5_sm ERA5_sf well_id_str date_dt \\\n", + "0 0.001611 -7.345365e-25 1.490116e-08 0.0 MW_2185 2010-08-16 \n", + "1 0.003050 -7.345365e-25 7.450581e-09 0.0 MW_2701 2010-08-16 \n", + "2 0.001183 -7.345365e-25 3.725290e-09 0.0 MW_518 2010-08-16 \n", + "3 0.001494 -7.345365e-25 7.450581e-09 0.0 MW_1974 2010-08-16 \n", + "4 0.001919 -7.345365e-25 1.490116e-08 0.0 MW_1628 2010-08-16 \n", + "\n", + " Unnamed: 0 Proj_ID \\\n", + "0 2185 RP_2375137500 \n", + "1 2701 SN_55393700 \n", + "2 518 BB_42530371 \n", + "3 1974 NI_40510490 \n", + "4 1628 HE_12354 \n", + "\n", + " Operator Elevation Depth \\\n", + "0 Landesamt für Umwelt Rheinland-Pfalz (LfU) 139.179993 6.95 \n", + "1 Sächsisches Landesamt für Umwelt, Landwirtscha... 442.899994 15.10 \n", + "2 Landesamt für Umwelt Brandenburg (LfU) 69.419998 NaN \n", + "3 Niedersächsischer Landesbetrieb für Wasserwirt... 28.049999 5.49 \n", + "4 Hessisches Landesamt für Naturschutz, Umwelt u... 129.880005 20.40 \n", + "\n", + " UpFilter LoFilter ScrLength AquiferMed PreState \\\n", + "0 NaN NaN NaN Porous Unknown \n", + "1 4.30 14.30 10.0 PorousAndFractured Unknown \n", + "2 NaN NaN NaN Porous unconfined \n", + "3 3.49 5.49 2.0 Porous Unknown \n", + "4 NaN NaN 2.0 Porous Unknown \n", + "\n", + " Easting (EPSG:3035) Northing (EPSG:3035) HYRAUM_HD HYRAUM_MHD \\\n", + "0 4182069.75 2885505.25 31 3 \n", + "1 4483330.50 3043150.50 96 9 \n", + "2 4641452.00 3195904.75 13 1 \n", + "3 4137212.25 3261389.75 13 1 \n", + "4 4248638.50 2987661.25 32 3 \n", + "\n", + " EU_MOHP_DSD_1 EU_MOHP_DSD_2 EU_MOHP_DSD_3 EU_MOHP_SD_1 EU_MOHP_SD_2 \\\n", + "0 604 3317 14287 124 3003 \n", + "1 2247 4057 9078 85 85 \n", + "2 401 1914 1914 371 371 \n", + "3 1384 6574 6574 1172 2240 \n", + "4 2632 3204 3204 2452 2452 \n", + "\n", + " EU_MOHP_SD_3 EU_MOHP_LP_1 EU_MOHP_LP_2 EU_MOHP_LP_3 BUEK1000_RSA \\\n", + "0 14047 2049 9052 9832 11 \n", + "1 5285 378 209 5822 57 \n", + "2 371 9252 1939 1939 12 \n", + "3 2240 8467 3408 3408 1 \n", + "4 2452 9316 7655 7655 16 \n", + "\n", + " GWN1000_GR HUEK250_HU HUEK250_K HUEK250_RT HUEK250_CT HUEK250_DC \\\n", + "0 187 03K (2-3)B 12 S P L \n", + "1 143 09P 2F 5 Ma K F \n", + "2 88 01K L1.2A 9 S P L \n", + "3 183 01K L1.2A 9 S P L \n", + "4 73 03K 2C 3 S P L \n", + "\n", + " HUEK250_GC HYSOG_SG SWR_PR CLC_90 CLC_00 CLC_06 CLC_12 CLC_18 \\\n", + "0 s 13 286.501831 20 20 20 18 18 \n", + "1 s 13 291.409424 12 12 12 2 2 \n", + "2 s 2 155.444473 2 2 2 2 2 \n", + "3 s 2 349.593140 24 24 24 24 24 \n", + "4 m 2 179.799927 24 24 24 24 24 \n", + "\n", + " MUNDIALIS_LU HUMUS1000_OC GMK1000_GU DTM20_FD DTM20_SL DTM20_FA \\\n", + "0 18 2 - <3% 3211 5.0 1.561229 4793.791504 \n", + "1 2 6 - <8% 116 0.0 1.570018 17958.525391 \n", + "2 2 1 - <2% 112 2.0 1.570340 951.664673 \n", + "3 24 3 - <4% 115 4.0 1.547255 1729.805298 \n", + "4 24 4 - <6% 3211 3.0 1.475317 449.756683 \n", + "\n", + " DTM20_AS DTM20_GC DTM20_PLC DTM20_PRC DTM20_TPI DTM20_TRI \\\n", + "0 5.588550 -1.346539 -0.001508 -4.515871e-07 -3.315176 4.648530 \n", + "1 2.732285 -46.525307 0.016564 -2.102138e-08 -0.057445 0.801671 \n", + "2 4.711417 -215.781769 0.000080 -1.027928e-08 -0.162196 0.730876 \n", + "3 0.333382 5.841016 0.096889 -1.557907e-05 -0.230849 1.067289 \n", + "4 4.856913 -2.229889 0.011956 -1.074220e-03 0.200116 0.537878 \n", + "\n", + " DTM20_CI DTM20_MRI \n", + "0 -0.113449 0.895954 \n", + "1 -34.629780 0.142776 \n", + "2 4.940503 0.094399 \n", + "3 -41.257362 0.061859 \n", + "4 48.523193 0.000000 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"DATASET OVERVIEW\")\n", + "print(\"=\"*80)\n", + "print(f\"\\nShape: {X_df.shape}\")\n", + "print(f\"Target variable (y) shape: {y.shape}\")\n", + "print(f\"\\nColumn types:\")\n", + "print(X_df.dtypes.value_counts())\n", + "print(f\"\\nMissing values per column:\")\n", + "missing = X_df.isnull().sum()\n", + "missing_pct = (missing / len(X_df) * 100).round(2)\n", + "missing_info = pd.DataFrame({'missing_count': missing, 'percentage': missing_pct})\n", + "print(missing_info[missing_info['missing_count'] > 0].sort_values('percentage', ascending=False))\n", + "print(f\"\\nFirst few rows:\")\n", + "display(X_df.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Target Variable Analysis (Groundwater Level)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================================================\n", + "TARGET VARIABLE STATISTICS\n", + "================================================================================\n", + "\n", + "Groundwater Level (GWL) - Descriptive Statistics:\n", + " Count: 1000000\n", + " Mean: 145.775 m\n", + " Std Dev: 157.648 m\n", + " Min: -1.870 m\n", + " Median: 92.030 m\n", + " Max: 915.401 m\n", + " Q1 (25%): 37.425 m\n", + " Q3 (75%): 172.753 m\n", + " Missing values: 0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Target distribution: Skewed\n" + ] + } + ], + "source": [ + "# Analyze the target variable\n", + "print(\"=\"*80)\n", + "print(\"TARGET VARIABLE STATISTICS\")\n", + "print(\"=\"*80)\n", + "print(f\"\\nGroundwater Level (GWL) - Descriptive Statistics:\")\n", + "print(f\" Count: {y.size}\")\n", + "print(f\" Mean: {np.mean(y):.3f} m\")\n", + "print(f\" Std Dev: {np.std(y):.3f} m\")\n", + "print(f\" Min: {np.min(y):.3f} m\")\n", + "print(f\" Median: {np.median(y):.3f} m\")\n", + "print(f\" Max: {np.max(y):.3f} m\")\n", + "print(f\" Q1 (25%): {np.percentile(y, 25):.3f} m\")\n", + "print(f\" Q3 (75%): {np.percentile(y, 75):.3f} m\")\n", + "print(f\" Missing values: {pd.isna(y).sum()}\")\n", + "\n", + "# Visualize the target distribution\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "\n", + "# Histogram\n", + "axes[0].hist(y, bins=50, edgecolor='black', alpha=0.7, color='steelblue')\n", + "axes[0].set_xlabel('Groundwater Level (m)')\n", + "axes[0].set_ylabel('Frequency')\n", + "axes[0].set_title('Distribution of Groundwater Level')\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "# Box plot\n", + "axes[1].boxplot(y, vert=True)\n", + "axes[1].set_ylabel('Groundwater Level (m)')\n", + "axes[1].set_title('Boxplot of GWL')\n", + "axes[1].grid(True, alpha=0.3)\n", + "\n", + "# Plot of the sorted target\n", + "ysorted = sorted(y)\n", + "axes[2].set_title('Evoluation of underground water level')\n", + "axes[2].grid(True, alpha=0.3)\n", + "axes[2].scatter([x for x in range(len(y))], ysorted)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Feature Overview & Data Quality" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================================================\n", + "FEATURE ANALYSIS\n", + "================================================================================\n", + "\n", + "Numeric features: 57\n", + "Non-numeric features: 12\n", + "\n", + "Non-numeric columns: ['well_id_str', 'date_dt', 'Proj_ID', 'Operator', 'AquiferMed', 'PreState', 'HUEK250_HU', 'HUEK250_RT', 'HUEK250_CT', 'HUEK250_DC', 'HUEK250_GC', 'HUMUS1000_OC']\n", + "\n", + "Numeric Features Statistics:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
HYRAS_prHYRAS_tasHYRAS_tasmaxHYRAS_tasminHYRAS_hursDWD_evapo_pDWD_evapo_rDWD_evapo_faoDWD_soil_moistDWD_soil_temp5cmERA5_sroERA5_ssroERA5_sdweERA5_smERA5_sfUnnamed: 0ElevationDepthUpFilterLoFilterScrLengthEasting (EPSG:3035)Northing (EPSG:3035)HYRAUM_HDHYRAUM_MHDEU_MOHP_DSD_1EU_MOHP_DSD_2EU_MOHP_DSD_3EU_MOHP_SD_1EU_MOHP_SD_2EU_MOHP_SD_3EU_MOHP_LP_1EU_MOHP_LP_2EU_MOHP_LP_3BUEK1000_RSAGWN1000_GRHUEK250_KHYSOG_SGSWR_PRCLC_90CLC_00CLC_06CLC_12CLC_18MUNDIALIS_LUGMK1000_GUDTM20_FDDTM20_SLDTM20_FADTM20_ASDTM20_GCDTM20_PLCDTM20_PRCDTM20_TPIDTM20_TRIDTM20_CIDTM20_MRI
count1000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001.000000e+061.000000e+061.000000e+061000000.0000001000000.000000706272.000000448101.000000448413.000000574691.0000001.000000e+061.000000e+061000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001000000.0000001.000000e+061000000.0000001.000000e+061000000.0000001.000000e+061000000.0000001000000.0000001000000.0000001000000.000000
mean13.42348410.03317314.5196685.47258178.5134661.8083361.2687171.9096648.16727811.5254970.0004330.0040361.917849e-031.201935e-031.247569e-031604.012868151.44538933.99161134.89761738.8883934.2563874.355092e+063.095006e+0633.0426123.0335701993.2716964227.0065638496.1728371002.9772501987.5522183856.6191394960.7345614727.7611134590.35877325.082600125.7518874.8141505.486990206.24166913.20482713.18338113.18866413.18357413.17423313.174233843.9553582.8880991.5413991.178062e+073.1119613.116713e+0424.252069-1.816974e-01-0.2036281.4047072.0202540.194532
std14.3998396.9452718.2367745.9762959.4197041.4231310.8903161.4103742.0459527.8445490.0011000.0045209.861646e-034.513066e-033.818486e-03925.780850159.58761657.69885353.01322954.8375597.6151781.549647e+051.988693e+0522.1533992.2568711443.1583022730.4504525247.7542891056.8547971925.4011843887.7550433045.4117413008.3304333114.80556218.58607377.1189703.0875064.715842158.6100317.8288767.9305647.9621078.0957388.1043278.1043271140.3603872.5044960.0791904.836090e+081.7787202.180028e+06709.2373059.969011e+001.2312102.33276724.2048990.522487
min0.000000-15.028572-10.300001-19.90000041.3428570.0000000.000000-0.4714292.642857-8.0000000.0000000.000000-7.345365e-25-3.725290e-09-7.450581e-091.000000-0.9300000.010000-22.797001-23.7970010.0000004.051826e+062.702745e+0611.0000001.0000000.00000060.000000115.0000000.0000000.0000000.0000000.0000000.0000000.0000001.0000000.0000002.0000001.000000-125.0875851.0000001.0000001.0000001.0000001.0000001.000000111.0000000.0000000.3496344.000000e+020.000005-1.448026e+07-1341.310791-5.463545e+02-21.3464930.006886-91.7971500.000000
25%2.8000004.7142867.8000001.14285772.1714320.5428570.5285710.6285716.2714294.2714290.0000470.001250-7.345365e-253.725290e-090.000000e+00802.00000044.0999988.5000007.50000010.3000001.5000004.209254e+062.923267e+0614.0000001.0000001017.0000002303.0000004505.000000255.000000514.000000924.0000002139.0000001997.0000001647.00000011.00000068.0000003.0000002.000000113.83343512.00000010.0000007.0000003.0000003.0000003.000000113.0000000.0000001.5431018.458751e+021.570796-2.565216e+01-0.010350-3.266010e-06-0.2039770.033221-7.5227720.000000
50%9.30000010.11428615.0142875.37142879.3285751.4714291.0857141.5857148.62857211.3714280.0001400.002453-7.345365e-251.117587e-080.000000e+001604.00000095.84999815.00000016.00000019.0000002.0000004.340624e+063.117001e+0631.0000003.0000001657.0000003727.0000007416.000000680.0000001396.0000002592.0000005031.0000004614.0000004333.00000016.000000116.0000003.0000003.000000187.85145612.00000012.00000012.00000012.00000012.00000012.000000115.0000002.0000001.5643124.072391e+033.136244-2.031849e+000.000028-9.301164e-090.0000000.6326430.0000000.032316
75%19.29999915.74285721.15714510.34285785.8571402.9428571.9285713.02857210.08571418.5142860.0003210.0051967.631665e-051.246464e-048.570775e-052406.000000177.31599436.20000140.00000045.0000004.0000004.490542e+063.268702e+0641.0000004.0000002566.0000005468.00000011759.0000001371.0000002848.0000005580.0000007657.0000007356.0000007370.00000035.000000173.0000009.00000012.000000289.32492120.00000020.00000020.00000018.00000018.00000018.0000001012.0000006.0000001.5700815.846213e+044.6581651.798892e+000.0176402.973460e-090.1304731.60106310.5967900.136971
max303.29998827.62857235.22857319.94285899.7857136.8857146.2571437.82857112.05714329.5714280.0636390.1549445.310345e-011.485884e-011.080338e-013207.000000921.0700071460.000000570.349976590.34997693.0000004.671558e+063.523046e+06101.00000010.0000008502.00000018635.00000035427.0000008008.00000012944.00000021486.00000010000.00000010000.00000010000.00000072.000000659.00000012.00000013.0000001949.72216841.00000041.00000041.00000041.00000041.00000041.0000004211.0000007.0000001.5707962.722045e+106.2831561.217034e+0827340.3398448.660786e+015.37257329.03683998.6968157.206553
\n", + "
" + ], + "text/plain": [ + " HYRAS_pr HYRAS_tas HYRAS_tasmax HYRAS_tasmin \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 13.423484 10.033173 14.519668 5.472581 \n", + "std 14.399839 6.945271 8.236774 5.976295 \n", + "min 0.000000 -15.028572 -10.300001 -19.900000 \n", + "25% 2.800000 4.714286 7.800000 1.142857 \n", + "50% 9.300000 10.114286 15.014287 5.371428 \n", + "75% 19.299999 15.742857 21.157145 10.342857 \n", + "max 303.299988 27.628572 35.228573 19.942858 \n", + "\n", + " HYRAS_hurs DWD_evapo_p DWD_evapo_r DWD_evapo_fao \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 78.513466 1.808336 1.268717 1.909664 \n", + "std 9.419704 1.423131 0.890316 1.410374 \n", + "min 41.342857 0.000000 0.000000 -0.471429 \n", + "25% 72.171432 0.542857 0.528571 0.628571 \n", + "50% 79.328575 1.471429 1.085714 1.585714 \n", + "75% 85.857140 2.942857 1.928571 3.028572 \n", + "max 99.785713 6.885714 6.257143 7.828571 \n", + "\n", + " DWD_soil_moist DWD_soil_temp5cm ERA5_sro ERA5_ssro \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 8.167278 11.525497 0.000433 0.004036 \n", + "std 2.045952 7.844549 0.001100 0.004520 \n", + "min 2.642857 -8.000000 0.000000 0.000000 \n", + "25% 6.271429 4.271429 0.000047 0.001250 \n", + "50% 8.628572 11.371428 0.000140 0.002453 \n", + "75% 10.085714 18.514286 0.000321 0.005196 \n", + "max 12.057143 29.571428 0.063639 0.154944 \n", + "\n", + " ERA5_sdwe ERA5_sm ERA5_sf Unnamed: 0 \\\n", + "count 1.000000e+06 1.000000e+06 1.000000e+06 1000000.000000 \n", + "mean 1.917849e-03 1.201935e-03 1.247569e-03 1604.012868 \n", + "std 9.861646e-03 4.513066e-03 3.818486e-03 925.780850 \n", + "min -7.345365e-25 -3.725290e-09 -7.450581e-09 1.000000 \n", + "25% -7.345365e-25 3.725290e-09 0.000000e+00 802.000000 \n", + "50% -7.345365e-25 1.117587e-08 0.000000e+00 1604.000000 \n", + "75% 7.631665e-05 1.246464e-04 8.570775e-05 2406.000000 \n", + "max 5.310345e-01 1.485884e-01 1.080338e-01 3207.000000 \n", + "\n", + " Elevation Depth UpFilter LoFilter \\\n", + "count 1000000.000000 706272.000000 448101.000000 448413.000000 \n", + "mean 151.445389 33.991611 34.897617 38.888393 \n", + "std 159.587616 57.698853 53.013229 54.837559 \n", + "min -0.930000 0.010000 -22.797001 -23.797001 \n", + "25% 44.099998 8.500000 7.500000 10.300000 \n", + "50% 95.849998 15.000000 16.000000 19.000000 \n", + "75% 177.315994 36.200001 40.000000 45.000000 \n", + "max 921.070007 1460.000000 570.349976 590.349976 \n", + "\n", + " ScrLength Easting (EPSG:3035) Northing (EPSG:3035) \\\n", + "count 574691.000000 1.000000e+06 1.000000e+06 \n", + "mean 4.256387 4.355092e+06 3.095006e+06 \n", + "std 7.615178 1.549647e+05 1.988693e+05 \n", + "min 0.000000 4.051826e+06 2.702745e+06 \n", + "25% 1.500000 4.209254e+06 2.923267e+06 \n", + "50% 2.000000 4.340624e+06 3.117001e+06 \n", + "75% 4.000000 4.490542e+06 3.268702e+06 \n", + "max 93.000000 4.671558e+06 3.523046e+06 \n", + "\n", + " HYRAUM_HD HYRAUM_MHD EU_MOHP_DSD_1 EU_MOHP_DSD_2 \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 33.042612 3.033570 1993.271696 4227.006563 \n", + "std 22.153399 2.256871 1443.158302 2730.450452 \n", + "min 11.000000 1.000000 0.000000 60.000000 \n", + "25% 14.000000 1.000000 1017.000000 2303.000000 \n", + "50% 31.000000 3.000000 1657.000000 3727.000000 \n", + "75% 41.000000 4.000000 2566.000000 5468.000000 \n", + "max 101.000000 10.000000 8502.000000 18635.000000 \n", + "\n", + " EU_MOHP_DSD_3 EU_MOHP_SD_1 EU_MOHP_SD_2 EU_MOHP_SD_3 \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 8496.172837 1002.977250 1987.552218 3856.619139 \n", + "std 5247.754289 1056.854797 1925.401184 3887.755043 \n", + "min 115.000000 0.000000 0.000000 0.000000 \n", + "25% 4505.000000 255.000000 514.000000 924.000000 \n", + "50% 7416.000000 680.000000 1396.000000 2592.000000 \n", + "75% 11759.000000 1371.000000 2848.000000 5580.000000 \n", + "max 35427.000000 8008.000000 12944.000000 21486.000000 \n", + "\n", + " EU_MOHP_LP_1 EU_MOHP_LP_2 EU_MOHP_LP_3 BUEK1000_RSA \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 4960.734561 4727.761113 4590.358773 25.082600 \n", + "std 3045.411741 3008.330433 3114.805562 18.586073 \n", + "min 0.000000 0.000000 0.000000 1.000000 \n", + "25% 2139.000000 1997.000000 1647.000000 11.000000 \n", + "50% 5031.000000 4614.000000 4333.000000 16.000000 \n", + "75% 7657.000000 7356.000000 7370.000000 35.000000 \n", + "max 10000.000000 10000.000000 10000.000000 72.000000 \n", + "\n", + " GWN1000_GR HUEK250_K HYSOG_SG SWR_PR \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 125.751887 4.814150 5.486990 206.241669 \n", + "std 77.118970 3.087506 4.715842 158.610031 \n", + "min 0.000000 2.000000 1.000000 -125.087585 \n", + "25% 68.000000 3.000000 2.000000 113.833435 \n", + "50% 116.000000 3.000000 3.000000 187.851456 \n", + "75% 173.000000 9.000000 12.000000 289.324921 \n", + "max 659.000000 12.000000 13.000000 1949.722168 \n", + "\n", + " CLC_90 CLC_00 CLC_06 CLC_12 \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 13.204827 13.183381 13.188664 13.183574 \n", + "std 7.828876 7.930564 7.962107 8.095738 \n", + "min 1.000000 1.000000 1.000000 1.000000 \n", + "25% 12.000000 10.000000 7.000000 3.000000 \n", + "50% 12.000000 12.000000 12.000000 12.000000 \n", + "75% 20.000000 20.000000 20.000000 18.000000 \n", + "max 41.000000 41.000000 41.000000 41.000000 \n", + "\n", + " CLC_18 MUNDIALIS_LU GMK1000_GU DTM20_FD \\\n", + "count 1000000.000000 1000000.000000 1000000.000000 1000000.000000 \n", + "mean 13.174233 13.174233 843.955358 2.888099 \n", + "std 8.104327 8.104327 1140.360387 2.504496 \n", + "min 1.000000 1.000000 111.000000 0.000000 \n", + "25% 3.000000 3.000000 113.000000 0.000000 \n", + "50% 12.000000 12.000000 115.000000 2.000000 \n", + "75% 18.000000 18.000000 1012.000000 6.000000 \n", + "max 41.000000 41.000000 4211.000000 7.000000 \n", + "\n", + " DTM20_SL DTM20_FA DTM20_AS DTM20_GC \\\n", + "count 1000000.000000 1.000000e+06 1000000.000000 1.000000e+06 \n", + "mean 1.541399 1.178062e+07 3.111961 3.116713e+04 \n", + "std 0.079190 4.836090e+08 1.778720 2.180028e+06 \n", + "min 0.349634 4.000000e+02 0.000005 -1.448026e+07 \n", + "25% 1.543101 8.458751e+02 1.570796 -2.565216e+01 \n", + "50% 1.564312 4.072391e+03 3.136244 -2.031849e+00 \n", + "75% 1.570081 5.846213e+04 4.658165 1.798892e+00 \n", + "max 1.570796 2.722045e+10 6.283156 1.217034e+08 \n", + "\n", + " DTM20_PLC DTM20_PRC DTM20_TPI DTM20_TRI \\\n", + "count 1000000.000000 1.000000e+06 1000000.000000 1000000.000000 \n", + "mean 24.252069 -1.816974e-01 -0.203628 1.404707 \n", + "std 709.237305 9.969011e+00 1.231210 2.332767 \n", + "min -1341.310791 -5.463545e+02 -21.346493 0.006886 \n", + "25% -0.010350 -3.266010e-06 -0.203977 0.033221 \n", + "50% 0.000028 -9.301164e-09 0.000000 0.632643 \n", + "75% 0.017640 2.973460e-09 0.130473 1.601063 \n", + "max 27340.339844 8.660786e+01 5.372573 29.036839 \n", + "\n", + " DTM20_CI DTM20_MRI \n", + "count 1000000.000000 1000000.000000 \n", + "mean 2.020254 0.194532 \n", + "std 24.204899 0.522487 \n", + "min -91.797150 0.000000 \n", + "25% -7.522772 0.000000 \n", + "50% 0.000000 0.032316 \n", + "75% 10.596790 0.136971 \n", + "max 98.696815 7.206553 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Data Quality Summary:\n", + " Total missing values: 1822523\n", + " Percentage of missing data: 2.64%\n" + ] + } + ], + "source": [ + "# Detailed feature analysis\n", + "print(\"=\"*80)\n", + "print(\"FEATURE ANALYSIS\")\n", + "print(\"=\"*80)\n", + "\n", + "# Separate numeric and non-numeric columns\n", + "numeric_cols = X_df.select_dtypes(include=[np.number]).columns.tolist()\n", + "non_numeric_cols = X_df.select_dtypes(exclude=[np.number]).columns.tolist()\n", + "\n", + "print(f\"\\nNumeric features: {len(numeric_cols)}\")\n", + "print(f\"Non-numeric features: {len(non_numeric_cols)}\")\n", + "print(f\"\\nNon-numeric columns: {non_numeric_cols}\")\n", + "\n", + "# Descriptive statistics for numeric features\n", + "print(f\"\\nNumeric Features Statistics:\")\n", + "display(X_df[numeric_cols].describe())\n", + "\n", + "# Missing data visualization\n", + "fig, ax = plt.subplots(figsize=(12, 5))\n", + "missing_data = (X_df[numeric_cols].isnull().sum() / len(X_df) * 100).sort_values(ascending=False)\n", + "missing_data_nonzero = missing_data[missing_data > 0]\n", + "\n", + "if len(missing_data_nonzero) > 0:\n", + " missing_data_nonzero.plot(kind='barh', ax=ax, color='coral')\n", + " ax.set_xlabel('Missing Data (%)')\n", + " ax.set_title('Missing Data Distribution (Numeric Features)')\n", + " ax.grid(True, alpha=0.3, axis='x')\n", + "else:\n", + " ax.text(0.5, 0.5, 'No missing data in numeric features', ha='center', va='center')\n", + " ax.set_title('Missing Data Distribution')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"\\nData Quality Summary:\")\n", + "print(f\" Total missing values: {X_df.isnull().sum().sum()}\")\n", + "print(f\" Percentage of missing data: {(X_df.isnull().sum().sum() / (X_df.shape[0] * X_df.shape[1]) * 100):.2f}%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Temporal and Spatial Patterns" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================================================\n", + "TEMPORAL AND SPATIAL ANALYSIS\n", + "================================================================================\n", + "\n", + "Date range: 2010-08-16 to 2016-08-01\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\charl\\AppData\\Local\\Temp\\ipykernel_20808\\3987621940.py:25: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " plt.tight_layout()\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\IPython\\core\\pylabtools.py:170: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Number of unique wells: 3207\n", + "Samples per well - Mean: 311.8\n", + "\n", + "Top 10 wells by number of samples:\n", + "well_id_str\n", + "MW_113 312\n", + "MW_843 312\n", + "MW_2804 312\n", + "MW_721 312\n", + "MW_1211 312\n", + "MW_233 312\n", + "MW_1865 312\n", + "MW_2610 312\n", + "MW_1564 312\n", + "MW_371 312\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "# Analyze temporal and spatial patterns\n", + "print(\"=\"*80)\n", + "print(\"TEMPORAL AND SPATIAL ANALYSIS\")\n", + "print(\"=\"*80)\n", + "\n", + "# Check for date and well_id columns\n", + "if 'date_dt' in X_df.columns:\n", + " print(f\"\\nDate range: {X_df['date_dt'].min()} to {X_df['date_dt'].max()}\")\n", + " \n", + " # Convert to datetime if not already\n", + " X_df['date_dt'] = pd.to_datetime(X_df['date_dt'], errors='coerce')\n", + " \n", + " # Create temporal index\n", + " df_temporal = pd.DataFrame({'date': X_df['date_dt'], 'gwl': y})\n", + " df_temporal = df_temporal.sort_values('date')\n", + " \n", + " fig, ax = plt.subplots(figsize=(14, 5))\n", + " ax.plot(df_temporal['date'], df_temporal['gwl'], alpha=0.5, linewidth=0.5, label='GWL over time')\n", + " ax.scatter(df_temporal['date'], df_temporal['gwl'], alpha=0.3, s=10, color='steelblue')\n", + " ax.set_xlabel('Date')\n", + " ax.set_ylabel('Groundwater Level (m)')\n", + " ax.set_title('Temporal Pattern: Groundwater Level Over Time')\n", + " ax.grid(True, alpha=0.3)\n", + " ax.legend()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "if 'well_id_str' in X_df.columns:\n", + " print(f\"\\nNumber of unique wells: {X_df['well_id_str'].nunique()}\")\n", + " print(f\"Samples per well - Mean: {len(X_df) / X_df['well_id_str'].nunique():.1f}\")\n", + " \n", + " # Top wells by number of samples\n", + " well_counts = X_df['well_id_str'].value_counts()\n", + " print(f\"\\nTop 10 wells by number of samples:\")\n", + " print(well_counts.head(10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Feature Correlations" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================================================\n", + "FEATURE CORRELATIONS WITH TARGET\n", + "================================================================================\n", + "\n", + "Top 15 features most correlated with target:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FeatureCorrelation
16Elevation0.998862
22Northing (EPSG:3035)-0.668498
38SWR_PR0.595287
24HYRAUM_MHD0.579648
23HYRAUM_HD0.570596
35GWN1000_GR0.490695
11ERA5_ssro0.351183
54DTM20_TRI0.309845
45GMK1000_GU0.281671
20ScrLength0.262487
27EU_MOHP_DSD_3-0.223510
56DTM20_MRI0.212636
37HYSOG_SG0.192064
26EU_MOHP_DSD_2-0.190340
12ERA5_sdwe0.190238
\n", + "
" + ], + "text/plain": [ + " Feature Correlation\n", + "16 Elevation 0.998862\n", + "22 Northing (EPSG:3035) -0.668498\n", + "38 SWR_PR 0.595287\n", + "24 HYRAUM_MHD 0.579648\n", + "23 HYRAUM_HD 0.570596\n", + "35 GWN1000_GR 0.490695\n", + "11 ERA5_ssro 0.351183\n", + "54 DTM20_TRI 0.309845\n", + "45 GMK1000_GU 0.281671\n", + "20 ScrLength 0.262487\n", + "27 EU_MOHP_DSD_3 -0.223510\n", + "56 DTM20_MRI 0.212636\n", + "37 HYSOG_SG 0.192064\n", + "26 EU_MOHP_DSD_2 -0.190340\n", + "12 ERA5_sdwe 0.190238" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Correlation analysis with target variable\n", + "print(\"=\"*80)\n", + "print(\"FEATURE CORRELATIONS WITH TARGET\")\n", + "print(\"=\"*80)\n", + "\n", + "# Calculate correlations with target\n", + "correlations = {}\n", + "for col in numeric_cols:\n", + " valid_mask = ~(X_df[col].isnull() | pd.isna(y))\n", + " if valid_mask.sum() > 0:\n", + " corr = np.corrcoef(X_df.loc[valid_mask, col], y[valid_mask])[0, 1]\n", + " if not np.isnan(corr):\n", + " correlations[col] = corr\n", + "\n", + "# Sort by absolute correlation\n", + "corr_df = pd.DataFrame(list(correlations.items()), columns=['Feature', 'Correlation'])\n", + "corr_df['Abs_Correlation'] = np.abs(corr_df['Correlation'])\n", + "corr_df = corr_df.sort_values('Abs_Correlation', ascending=False)\n", + "\n", + "print(f\"\\nTop 15 features most correlated with target:\")\n", + "display(corr_df.head(15)[['Feature', 'Correlation']])\n", + "\n", + "# Visualize top correlations\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "top_corr = corr_df.head(15)\n", + "colors = ['green' if x > 0 else 'red' for x in top_corr['Correlation']]\n", + "ax.barh(range(len(top_corr)), top_corr['Correlation'], color=colors, alpha=0.7)\n", + "ax.set_yticks(range(len(top_corr)))\n", + "ax.set_yticklabels(top_corr['Feature'])\n", + "ax.set_xlabel('Correlation with Target')\n", + "ax.set_title('Top 15 Features by Correlation with Groundwater Level')\n", + "ax.grid(True, alpha=0.3, axis='x')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Key Insights" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================================================\n", + "KEY INSIGHTS\n", + "================================================================================\n", + "\n", + "1. DATA CHARACTERISTICS:\n", + " - Total samples: 1,000,000\n", + " - Number of features: 69\n", + " - Numeric features: 57\n", + " - Missing data: 2.64%\n", + "\n", + "2. TARGET DISTRIBUTION:\n", + " - Range: -1.87m to 915.40m\n", + " - Mean: 145.78m ± 157.65m\n", + " - Distribution: Skewed\n", + "\n", + "3. FEATURE RELATIONSHIPS:\n", + " - Strongest predictor: Elevation (r=0.999)\n", + " - Features with |correlation| > 0.3: 8\n", + "\n" + ] + } + ], + "source": [ + "print(\"=\"*80)\n", + "print(\"KEY INSIGHTS\")\n", + "print(\"=\"*80)\n", + "print(f\"\"\"\n", + "1. DATA CHARACTERISTICS:\n", + " - Total samples: {len(X_df):,}\n", + " - Number of features: {X_df.shape[1]}\n", + " - Numeric features: {len(numeric_cols)}\n", + " - Missing data: {(X_df.isnull().sum().sum() / (X_df.shape[0] * X_df.shape[1]) * 100):.2f}%\n", + "\n", + "2. TARGET DISTRIBUTION:\n", + " - Range: {y.min():.2f}m to {y.max():.2f}m\n", + " - Mean: {y.mean():.2f}m ± {y.std():.2f}m\n", + " - Distribution: {'Skewed' if abs(stats.skew(y)) > 0.5 else 'Approximately Normal'}\n", + "\n", + "3. FEATURE RELATIONSHIPS:\n", + " - Strongest predictor: {corr_df.iloc[0]['Feature']} (r={corr_df.iloc[0]['Correlation']:.3f})\n", + " - Features with |correlation| > 0.3: {sum(corr_df['Abs_Correlation'] > 0.3)}\n", + "\"\"\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1629,7 +3522,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "base", "language": "python", "name": "python3" }, @@ -1643,7 +3536,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.13.5" } }, "nbformat": 4, From a3dd2e16bae5ecb044c28e2c4034c797c39aed13 Mon Sep 17 00:00:00 2001 From: fasfous92 Date: Wed, 4 Mar 2026 14:14:19 +0100 Subject: [PATCH 4/6] final fixes --- README.md | 48 +++--------------------------------------------- 1 file changed, 3 insertions(+), 45 deletions(-) diff --git a/README.md b/README.md index 56384d2..8ffcd7a 100644 --- a/README.md +++ b/README.md @@ -67,7 +67,9 @@ public and private test set. Make sure that the `setup_data.py` script has been run to generate the data for the competition. -Then, run the `create_bundle.py` script to create the codabench bundle archive: +First, run the `tools/create_starting_kit.py` script + +Then, run the `tools/create_bundle.py` script to create the codabench bundle archive: ```bash python create_bundle.py @@ -89,47 +91,3 @@ To test the scoring program, run: python scoring_program/scoring.py --reference-dir dev_phase/reference_data/ --output-dir scoring_res --prediction-dir ingestion_res/ ``` - -### Setting up and testing the docker image - -For convenience, a python script `tools/run_docker.py` is provided to build -the docker image, and run the ingestion and scoring programs inside the docker -container. -This script requires installing the `docker` python package, which can be done via pip: - -```bash -pip install docker -python tools/run_docker.py -``` - -You can also perform these steps manually. -You first need to build the docker image locally from the `Dockerfile` with: - -```bash -docker build -t docker-image tools -``` - -To test the docker image locally, run: - -```bash -docker run --rm -u root \ - -v "./ingestion_program":"/app/ingestion_program" \ - -v "./dev_phase/input_data":/app/input_data \ - -v "./ingestion_res":/app/output \ - -v "./solution":/app/ingested_program \ - --name ingestion docker-image \ - python /app/ingestion_program/ingestion.py - -docker run --rm -u root \ - -v "./scoring_program":"/app/scoring_program" \ - -v "./dev_phase/reference_data":/app/input/ref \ - -v "./ingestion_res":/app/input/res \ - -v "./scoring_res":/app/output \ - --name scoring docker-image \ - python /app/scoring_program/scoring.py -``` - -### CI for the bundle - -This repo defines a CI for the bundle, which build a docker image from the `tools/Dockerfile`, -and try to run `tools/setup_data.py` and then the ingestion/scoring programs. From 085e3e3766f24a4d8bf8f4544cc460f5dff2298e Mon Sep 17 00:00:00 2001 From: fasfous92 Date: Wed, 4 Mar 2026 14:17:51 +0100 Subject: [PATCH 5/6] final fixes + merge --- template_starting_kit.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/template_starting_kit.ipynb b/template_starting_kit.ipynb index 2373024..a4b8c83 100644 --- a/template_starting_kit.ipynb +++ b/template_starting_kit.ipynb @@ -3522,7 +3522,7 @@ ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -3536,7 +3536,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.12.3" } }, "nbformat": 4, From 28120abb7a28baaa1500dfa7cdbd399c24372831 Mon Sep 17 00:00:00 2001 From: fasfous92 Date: Thu, 5 Mar 2026 16:20:12 +0100 Subject: [PATCH 6/6] finalized project and tested the link --- bundle/competition.yaml | 48 --------- .../ingestion_program/bench_utils/__init__.py | 7 -- bundle/ingestion_program/ingestion.py | 100 ------------------ bundle/ingestion_program/metadata.yaml | 1 - bundle/logo.png | Bin 3797 -> 0 bytes bundle/pages/participate.md | 10 -- bundle/pages/seed.md | 21 ---- bundle/pages/terms.md | 18 ---- bundle/pages/timeline.md | 11 -- bundle/scoring_program/metadata.yaml | 1 - bundle/scoring_program/scoring.py | 69 ------------ bundle/solution/submission.py | 37 ------- competition.yaml | 23 ++-- ingestion_program/ingestion.py | 12 ++- scoring_program/metadata.yaml | 2 +- scoring_program/scoring.py | 89 ++++++++-------- solution/submission.py | 46 ++++---- tools/create_bundle.py | 4 +- tools/create_starting_kit.py | 3 +- 19 files changed, 97 insertions(+), 405 deletions(-) delete mode 100755 bundle/competition.yaml delete mode 100644 bundle/ingestion_program/bench_utils/__init__.py delete mode 100755 bundle/ingestion_program/ingestion.py delete mode 100755 bundle/ingestion_program/metadata.yaml delete mode 100644 bundle/logo.png delete mode 100755 bundle/pages/participate.md delete mode 100644 bundle/pages/seed.md delete mode 100755 bundle/pages/terms.md delete mode 100644 bundle/pages/timeline.md delete mode 100755 bundle/scoring_program/metadata.yaml delete mode 100755 bundle/scoring_program/scoring.py delete mode 100644 bundle/solution/submission.py diff --git a/bundle/competition.yaml b/bundle/competition.yaml deleted file mode 100755 index 54467c2..0000000 --- a/bundle/competition.yaml +++ /dev/null @@ -1,48 +0,0 @@ -version: 2 -title: GEMS-GER Groundwater Level Prediction Challenge -description: Predict groundwater level (GWL) across Germany using 50+ environmental features. -image: logo.png -registration_auto_approve: True # Set to True to let people jump right in - -terms: pages/terms.md -pages: - - title: Overview - file: pages/overview.md - - title: Data Description - file: pages/data.md - - title: Participation - file: pages/participate.md - - title: Timeline - file: pages/timeline.md - -tasks: - - index: 0 - name: GWL Regression Task - description: 'Predict depth to groundwater using historical time-series and static site data.' - input_data: dev_phase/input_data/ - reference_data: dev_phase/reference_data/ - ingestion_program: ingestion_program/ - scoring_program: scoring_program/ - -solutions: - - index: 0 - tasks: - - 0 - path: solution/ - -phases: - - name: Development Phase - description: 'Train on historical data and submit predictions for the Public Leaderboard.' - start: 02-13-2026 # Starting today! - end: 05-31-2026 - tasks: - - 0 - -leaderboards: - - title: Results - key: main - columns: - - title: RMSE - key: rmse # Must match scores['rmse'] in scoring.py - index: 0 - sorting: asc # Lower is better! diff --git a/bundle/ingestion_program/bench_utils/__init__.py b/bundle/ingestion_program/bench_utils/__init__.py deleted file mode 100644 index 8e19e63..0000000 --- a/bundle/ingestion_program/bench_utils/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -# A module for the benchmark, to provide utilities usable in both the -# ingestion and the submission programs. -# -# Note that the import cannot be done at the top level of -# the ingestion program - -N_SAMPLES = 1000 diff --git a/bundle/ingestion_program/ingestion.py b/bundle/ingestion_program/ingestion.py deleted file mode 100755 index 5d1b00b..0000000 --- a/bundle/ingestion_program/ingestion.py +++ /dev/null @@ -1,100 +0,0 @@ -import json -import sys -import time -from pathlib import Path -import pandas as pd - -# We only have one test set now -EVAL_SETS = ["test"] - -def evaluate_model(model, X_test): - """ - Generate predictions. - Note: We pass the RAW X_test to the model. - The participant's pipeline must handle dropping strings! - """ - y_pred = model.predict(X_test) - return pd.DataFrame({'GWL': y_pred}) - -def get_train_data(data_dir, chunksize=100000): - """ - Loads 'train.csv' in chunks for memory safety. - Contains both features and labels. - """ - data_dir = Path(data_dir) - train_path = data_dir / "train" / "train.csv" - - # Fallback for local testing vs Codabench environment - if not train_path.exists(): - train_path = data_dir / "train.csv" - - print(f"Reading {train_path} in chunks...") - - chunks = [] - for chunk in pd.read_csv(train_path, chunksize=chunksize): - chunks.append(chunk) - - full_df = pd.concat(chunks, axis=0) - - y_train = full_df['GWL'] - X_train = full_df.drop(columns=['GWL']) - - return X_train, y_train - -def main(data_dir, output_dir): - # Import the participant's model - from submission import get_model - - print("--- 1. Loading Training Data ---") - X_train, y_train = get_train_data(data_dir) - - print("--- 2. Training the Model ---") - model = get_model() - - start_train = time.time() - model.fit(X_train, y_train) - train_time = time.time() - start_train - print(f"Training completed in {train_time:.2f}s") - - print("--- 3. Evaluating on Test Set ---") - start_test = time.time() - - # Load test features (Matches setup_data.py output) - X_test_path = data_dir / "test" / "test_features.csv" - X_test = pd.read_csv(X_test_path) - - y_test_pred = evaluate_model(model, X_test) - - test_time = time.time() - start_test - print(f"Testing completed in {test_time:.2f}s") - - # --- 4. Write Output Files --- - output_dir.mkdir(parents=True, exist_ok=True) - - # Save metadata for the leaderboard (Runtime) - with open(output_dir / "metadata.json", "w") as f: - json.dump({ - "train_time": train_time, - "test_time": test_time, - "duration": train_time + test_time - }, f) - - # Save predictions (Matches what scoring.py expects) - y_test_pred.to_csv(output_dir / "test_predictions.csv", index=False) - - print(f"Ingestion finished. Total duration: {train_time + test_time:.2f}s") - -if __name__ == "__main__": - import argparse - parser = argparse.ArgumentParser(description="Ingestion program") - parser.add_argument("--data-dir", type=str, default="/app/input_data") - parser.add_argument("--output-dir", type=str, default="/app/output") - parser.add_argument("--submission-dir", type=str, default="/app/ingested_program") - - args = parser.parse_args() - - # Add submission and current folder to path so we can find 'submission.py' - sys.path.append(args.submission_dir) - sys.path.append(str(Path(__file__).parent.resolve())) - - main(Path(args.data_dir), Path(args.output_dir)) diff --git a/bundle/ingestion_program/metadata.yaml b/bundle/ingestion_program/metadata.yaml deleted file mode 100755 index bcf0d24..0000000 --- a/bundle/ingestion_program/metadata.yaml +++ /dev/null @@ -1 +0,0 @@ -command: python3 ingestion.py \ No newline at end of file diff --git a/bundle/logo.png b/bundle/logo.png deleted file mode 100644 index 9616456c1d354140c0055fb6ee32e23d76519df3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3797 zcmZu!2UJs8w+>_wM1=uq(nJuXgd#OyfKi%AiGV<;3ZWVyR0+}s8R-!L0R@CXn$mkH zF(8m2U3xJ?NeoCQAicfd%yZsb|9{WAXSeTs`|PvUxp(cDyT*DKn0c820Kf(P+uEiy znR@y%ouSPTI&Tt9(D|C`-2#;L@h{MfyUs9u7b7EpBu!@m(9^L4fTs}J07SV1e)*vT z0Ae%=0094_`#1V0{m*FXpTK|hQy@dCiw2Fv%KaY94`yVj21k0xI5;64on=rSUZ(&6 z1f@n(J)HdcT$|YBc@SEh{Ya1LB8J7ls+#71BcbI14GsD9XqQYcLB5 z2|;|ET+~dpb^lpTv($y%{QSJsWMu;a0%QUdWRO0tve#8rRb}PmW##3iX$WcGKu$loOY%cJe=3-@vN@^eRe3Z3#gI3oT1)P;pl6a9St-lw0t%fFdCeg7$oR-o)@ zME1Ijoa|3-+EU1=R}Jdp?o7*k%CB)9@&oz*eE;Nu$et$uKb!fx(jQ)0sT#}>*`LRz z!ED%i%?bcG->0vA^B#(B#cH;0uI{Yill|jzV&wAc$g1Ceqqo{lIk}zsz=g*l4A&HP z=v}_l;yAl*b0p{u!~DepIMw zguoXV<~;$Or;|Bo+o3f2{(=tU<09pW2iFwGOwe1yAE^-)it9Z5d7K6Z@>6jP_7w3w zsY(&pN$f8x(Gwn!5$(Al&i89)L)h#r&M)M5Pp;XszMhmO=>y-^23|llhC+jCjvo=5 ztIwuT1sH{mmS^652f%CtYF%2%yEDuDmxJKu8G2&wbLP}#0wKq80dq(P-P*kkH&4f3 zNQ}}X%~Eq=eHY*O26s`xP9QLrzuieU?pg#}%wNY;dyjj0pZGQtfK7+f`-DZA*en8D z$F~>(%89S`aS!>DxAx-tL`PE=&U+i|Xah(0e9vqBgY*0h@Z1iM-neyES}tC%;ny+s zC%l#omye3&gmKloOwHVFwVh(QK{!_aOHo^|6UmmOKDR_wn<M_v>#Ri*DZiGj)oouKe6Fx871AY5lq2XmW!Ou80A} zCKFq`i^6dN%eoRb%VttfICKr)u_v@<&-@ZF#`9jHtM{m^eQVc7b4s1m6i@&(M_cX_ zVxvh=R;yylCmt!!`2n|daI*#D^jaojGHY0?HuXcL3-f@FVzL@5!+72^8R8~Y!pOF* zuYsbat2NOP^o)nyQ^1h{_sj^(g-g>4tgksVDN6-nd)%lcB%69R4^d>v2)*zvWKR>n z_z_`I(hgy}=1T2kYP@Q^eawA_ zzwoI-F&ot?;l-G$-~nNy=gG#eH&`PoK1^232LeM9dDTQmK4R~Wunnr*+;dQ;}V?TT6a}6Qn9%A^4j<$S=R|AU&)2B-7#F5 zNj^NpMU(@R6`?9zvf~-9&o&E$Z5z{g{A9^a@r4piV=<-fv%&9@%iUF@$w9gNf;Q^e z4@+b|rmNnQD>X0zl?Fd>LYL%2^;Wu1 z@~gG-zE&8%^!9@m4Cb#;Yww$o!C6B}mq%14*9KEQdLTja;brmSg54P;?xY0HnAu%B z-?F9%kwte5OL5&cp(=W9|As)c^20?Vb_Po7Y-f5W1+2)JYCECMrabF}NWvPy>VTI`eUfH7tIH($3pd%oPfhSxd#s-a7AJwhN$jH%T+{a-_JSf=hN z2nt1Ec^v*ig6jP{Oc^!CVBZx7%ohjsKI$Uhq*Q$gW43Jn%XT{4j`g!4F!DsQM4X;p z8noMWsuQ_~3n^EOzi8Qapr&C0Wu7hZ%6AmYtT#qgQbnhv1fl%> zBcxhzR@*#8Gr8mX|aQE{(TvguML77`avBh z94@R^96cFb{z!Ao`uhA~Npujl^3%8FiwpP!7SEdd4n>iPl&y!u>rfk70HjqDfohtt zDD^oy=kIyMI4H{_mN7H6#PY}kWY=nU^cJ`h#_2P(P8bZGLuD%KmDLrN_IkO2p(W0U zkXz*F&2eN&;`+61N_cZaVAD~P=Chko&SnflgAPro!Pca+*+KA?CvnT9m`qpQxJR~M zySA9hxrdI?3?Ic?I5#cjww)nf6-cyvf9#FGkU9$~=#!`5hAiqYJQjUyNRZLh(Yp{d ztU7j2e`(#hU@nCyK3#~be9Xh8RHtBEyjc^q8m*EVz~sae-~J7+x4nDio`Wt*B618) zSsry-fLUqcDlKA%d;-nf59|<7>f;fGRu5!}EF?ta;@a^VOYkD!($2=}ohV=;26@02 z$IZ2eo1rRVrcl=27NCy!_VwMxz4Of_{%3LE*d?73N$R732}7+rt(n4-m32`cl4ASD*<{#hloIlOyMd?2FuoztAFT-TRl%Pa9D zo%O(b--f*3MJ%D<0=8lEkP(>EYV7MoTmA=E>xN#bJO~nWcctJh#}3l7Tkn{C^0PJ3 z5^csNko*WaV!Sboa8B1VYbVEt2~6JxpnE0%pjRpB0~+wd90MwswWG+4q%*|ZSB&v_6va;3W$M-{db?aK)u3-hCe z>{dzA`98BbCq>+qQAEqbBQx}f=v{=6#|5z$ETIlZ2$6?1i&c=;eevm5ycz{AC_uYd zSD1C4|Di+vy_@Q0G)K0Nn{UY76Tb`*$z0Z$#}mmL+f_s<>JVB-$0hc62`R@!n-~T| zWH9jl90+S&yj>8=?AjT?0X6z9Z5T`{2x)Z6iWG%gtSa@f*<-}|G`nkSE9+-&oYVn_ zG@m)0^Y`73=_agIG~Y`8PXB81V!{W3TDA^Qc7b|P;OS?%u)UWT`&P62l4=iVF7|kW zNFgLai#U>$Zt`aIrX5!An0A2r`XFV2BP!38%-W6!>E0`I=LL3G$_pJL*(&z`0E|8{ zy&9^>QeT~m7op~9G-Nkm!0Ig09dSF~-C*|EI?SON(_MB28zwn<^7%B^@$>fDD*{O=X77#KHWb~dc8Gkml8C7?S%R=`Z9F`jQ@-IKeo|av%CE9kyg8Kd zcyuRKB{le*zPEtOb8vnnhDg3yy57?UfTqYgpAi2%yTLp_szzj8;=-iB@mk3#Q6bXP zT?3BcTDhqzU9)==4TLoO3#v2{q%ZF)8#fYre>kt)pBtDO=i{>bLZMAB zQ^0ahg^N4p>E7fru}!V>^Ta+D+qVz7uWpq4VU!@eAv2rXx_Uew-dF981WA@x1ID8Y z({&pwj_a=Hz6s7p6c8q`;$tu0iPy(>zlyZ=Y%$dE+WmCBa@7Gr{git>V+rp|9LQYi za@-)Y_4gdpD8sFQF0mUvx{=oVH4rJTLu-~5H0>tvs)n9Po=1aSb}%YjXM11C*}O_o zk*~dz(P4&n82MHj)QH6{Po*M35=F)JGPduV53&|p%sX{nrJw{ym4%J8x00pMe6yRo zCM5-7H3X`}DEUQY%eK$27cWU4-d;8A$wlitEshrf^vGq|ul8rf+%z5DGcL1LR4cZK+6vJ``I0>&^ZD-gEry eNT%jm!ssLiJ=~t@6|tN)iTXOm+GV#MJpCV&VN8+$ diff --git a/bundle/pages/participate.md b/bundle/pages/participate.md deleted file mode 100755 index 4d5427b..0000000 --- a/bundle/pages/participate.md +++ /dev/null @@ -1,10 +0,0 @@ -# How to participate - -You should submit an untrained model in a python file `model.py` which contains -your `class Model`, which will be imported, trained, and tested on Codalab. - -See the "Seed" page for the outline of a `Model` class, with the expected -function names. - -See the "Timeline" page for additional information about the phases of this -competition diff --git a/bundle/pages/seed.md b/bundle/pages/seed.md deleted file mode 100644 index 9b15f6a..0000000 --- a/bundle/pages/seed.md +++ /dev/null @@ -1,21 +0,0 @@ -# Seed: - -``` -class Model: - def fit(self, X_train, y_train): - """ - This should handle the logic of training your model - :param X_train: np.array of training data - :param y_train: np.array of the same length as X_train. Contains classifications of X_train - """ - pass - - def predict(self, X_test): - """ - This should handle making predictions with a trained model - :param X_test: np.array of testing data - :return: np.array of the same length as X_test containing predictions to each point in X_test - """ - pass - -``` \ No newline at end of file diff --git a/bundle/pages/terms.md b/bundle/pages/terms.md deleted file mode 100755 index 0d69023..0000000 --- a/bundle/pages/terms.md +++ /dev/null @@ -1,18 +0,0 @@ -# Terms and Conditions - -## Lorem Ipsum - -Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. -Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure -dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non -proident, sunt in culpa qui officia deserunt mollit anim id est laborum. - -## Sed ut perspiciatis - -Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae -ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit -aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam -est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore -et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, -nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae -consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur? diff --git a/bundle/pages/timeline.md b/bundle/pages/timeline.md deleted file mode 100644 index 4e613bf..0000000 --- a/bundle/pages/timeline.md +++ /dev/null @@ -1,11 +0,0 @@ -# Timeline - -## Development phase -This phase should be used to tune your models, testing against a small -set of testing data - -## Final phase -Resubmit your preferred submission from the development phase to test -against a new set of testing data. Your model will be trained against -the same set of training data as in the development phase. You may only -make one submission to this phase, so choose wisely. diff --git a/bundle/scoring_program/metadata.yaml b/bundle/scoring_program/metadata.yaml deleted file mode 100755 index 1dfabf8..0000000 --- a/bundle/scoring_program/metadata.yaml +++ /dev/null @@ -1 +0,0 @@ -command: python3 scoring.py \ No newline at end of file diff --git a/bundle/scoring_program/scoring.py b/bundle/scoring_program/scoring.py deleted file mode 100755 index 79f2654..0000000 --- a/bundle/scoring_program/scoring.py +++ /dev/null @@ -1,69 +0,0 @@ -import json -from pathlib import Path -import pandas as pd -import numpy as np -from sklearn.metrics import mean_squared_error - -def compute_rmse(predictions, targets): - """ - Calculates the Root Mean Squared Error (RMSE) for Groundwater Level Prediction. - """ - # Ensure inputs are handled correctly whether they are DataFrames or Series - y_pred = predictions.iloc[:, 0] if isinstance(predictions, pd.DataFrame) else predictions - y_true = targets.iloc[:, 0] if isinstance(targets, pd.DataFrame) else targets - - # Align predictions with ground truth and remove any missing values in labels - combined = pd.concat([ - pd.Series(y_pred, name='pred').reset_index(drop=True), - pd.Series(y_true, name='true').reset_index(drop=True) - ], axis=1).dropna() - - if combined.empty: - print("Warning: No overlapping data found for scoring.") - return 999.0 - - # Calculate RMSE - rmse = np.sqrt(mean_squared_error(combined['true'], combined['pred'])) - return float(rmse) - -def main(reference_dir, prediction_dir, output_dir): - scores = {} - eval_set = "test" - - try: - # Load predictions and reference labels - predictions = pd.read_csv(prediction_dir / f'{eval_set}_predictions.csv') - targets = pd.read_csv(reference_dir / eval_set / f'{eval_set}_labels.csv') - - # Calculate the score - scores['rmse'] = compute_rmse(predictions, targets) - - except Exception as e: - print(f"❌ Scoring Error: {e}") - scores['rmse'] = 999.0 - - # Include runtime metadata for the leaderboard - try: - metadata_path = prediction_dir / 'metadata.json' - if metadata_path.exists(): - durations = json.loads(metadata_path.read_text()) - scores.update(durations) - except Exception: - pass - - # Save to scores.json for Codabench - output_dir.mkdir(parents=True, exist_ok=True) - with open(output_dir / 'scores.json', 'w') as f: - json.dump(scores, f) - - print(f"Scoring finished. Leaderboard RMSE: {scores['rmse']:.4f}") - -if __name__ == "__main__": - import argparse - parser = argparse.ArgumentParser() - parser.add_argument("--reference-dir", type=str, default="/app/input/ref") - parser.add_argument("--prediction-dir", type=str, default="/app/input/res") - parser.add_argument("--output-dir", type=str, default="/app/output") - args = parser.parse_args() - - main(Path(args.reference_dir), Path(args.prediction_dir), Path(args.output_dir)) diff --git a/bundle/solution/submission.py b/bundle/solution/submission.py deleted file mode 100644 index ed399dd..0000000 --- a/bundle/solution/submission.py +++ /dev/null @@ -1,37 +0,0 @@ -from sklearn.ensemble import RandomForestRegressor -from sklearn.compose import ColumnTransformer -from sklearn.pipeline import Pipeline -from sklearn.preprocessing import StandardScaler - -from sklearn.ensemble import RandomForestRegressor -from sklearn.compose import ColumnTransformer -from sklearn.compose import make_column_selector as selector -from sklearn.pipeline import Pipeline -from sklearn.impute import SimpleImputer - -def get_model(): - """ - Returns a model that automatically filters out string columns - to avoid ValueErrors and fits on numeric data only. - """ - - # 1. Define a transformer that ONLY picks numeric columns (float64, int64) - # This automatically ignores 'well_id_str' and 'date_dt' because they are strings/objects - numeric_transformer = Pipeline(steps=[ - ('imputer', SimpleImputer(strategy='median')) - ]) - - preprocessor = ColumnTransformer( - transformers=[ - ('num', numeric_transformer, selector(dtype_include=['float64', 'int64'])) - ], - remainder='drop' # This explicitly drops anything that isn't a number - ) - - # 2. Create the full pipeline - model = Pipeline(steps=[ - ('preprocessor', preprocessor), - ('regressor', RandomForestRegressor(n_estimators=50, max_depth=8, random_state=42)) - ]) - - return model diff --git a/competition.yaml b/competition.yaml index d1f4ba3..16423d8 100755 --- a/competition.yaml +++ b/competition.yaml @@ -18,14 +18,11 @@ pages: tasks: - index: 0 name: "Development Task" - input_data: dev_phase/input_data/ - reference_data: dev_phase/reference_data/ + # Notice we left the data out! We will add it in the UI later. scoring_program: scoring_program/ ingestion_program: ingestion_program/ - index: 1 name: "Final Task" - input_data: final_phase/input_data/ - reference_data: final_phase/reference_data/ scoring_program: scoring_program/ ingestion_program: ingestion_program/ @@ -33,16 +30,16 @@ phases: - index: 0 name: "Development Phase" start: 2026-02-13 12:00:00 - end: 2026-04-14 00:00:00 # Phase 1 ends here + end: 2026-04-14 00:00:00 max_submissions: 100 max_submissions_per_day: 5 starting_kit: starting_kit.zip - public_data: starting_kit.zip + # public_data removed to prevent server crashes tasks: [0] - index: 1 name: "Final Phase" - start: 2026-04-15 # Must start AFTER Phase 1 ends + start: 2026-04-15 00:00:00 # Added the required timestamp! max_submissions: 1 auto_migrate_to_this_phase: True tasks: [1] @@ -55,3 +52,15 @@ leaderboards: key: rmse index: 0 sorting: asc + - title: Train Time (s) + key: train_time + index: 1 + sorting: desc + - title: Test Time (s) + key: test_time + index: 2 + sorting: desc + - title: Total Duration + key: duration + index: 3 + sorting: desc diff --git a/ingestion_program/ingestion.py b/ingestion_program/ingestion.py index 7fba742..06da5c5 100755 --- a/ingestion_program/ingestion.py +++ b/ingestion_program/ingestion.py @@ -80,14 +80,18 @@ def main(data_dir, output_dir): if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description="Ingestion program") - parser.add_argument("--data-dir", type=str, default="/app/input_data") - parser.add_argument("--output-dir", type=str, default="/app/output") - parser.add_argument("--submission-dir", type=str, default="/app/ingested_program") + + # Changed from optional flags (--flag) to positional arguments + # to match the Codabench backend command formatin + parser.add_argument("data_dir", type=str, help="Path to input data") + parser.add_argument("output_dir", type=str, help="Path to output results") + parser.add_argument("program_dir", type=str, help="Path to the ingestion program") + parser.add_argument("submission_dir", type=str, help="Path to the participant's submission") args = parser.parse_args() # Add submission and current folder to path so we can find 'submission.py' sys.path.append(args.submission_dir) - sys.path.append(str(Path(__file__).parent.resolve())) + sys.path.append(args.program_dir) main(Path(args.data_dir), Path(args.output_dir)) diff --git a/scoring_program/metadata.yaml b/scoring_program/metadata.yaml index d3a59bc..dd3ba2d 100755 --- a/scoring_program/metadata.yaml +++ b/scoring_program/metadata.yaml @@ -1 +1 @@ -command: python3 scoring.py /app/input/ /app/output/ +command: python3 scoring.py /app/input /app/output /app/program diff --git a/scoring_program/scoring.py b/scoring_program/scoring.py index 95b9b9f..958dad9 100755 --- a/scoring_program/scoring.py +++ b/scoring_program/scoring.py @@ -1,4 +1,5 @@ import json +import argparse from pathlib import Path import pandas as pd import numpy as np @@ -6,75 +7,71 @@ def compute_rmse(predictions, targets): """ - Calculates the Root Mean Squared Error (RMSE). + Calculates the Root Mean Squared Error (RMSE) for the GWL column. """ - # Ensure we are comparing the same number of rows - # Targets usually has 1 column ('GWL'), Predictions usually has 1 column ('GWL') - y_pred = predictions.iloc[:, 0] if isinstance(predictions, pd.DataFrame) else predictions - y_true = targets.iloc[:, 0] if isinstance(targets, pd.DataFrame) else targets - - # Align by index and drop any rows with NaNs in ground truth (if any) - combined = pd.concat([ - pd.Series(y_pred, name='pred').reset_index(drop=True), - pd.Series(y_true, name='true').reset_index(drop=True) - ], axis=1).dropna() - - if combined.empty: - print("Warning: No data to score.") - return 999.0 + # Assuming both DataFrames have a 'GWL' column based on ingestion.py + y_pred = predictions['GWL'].values + y_true = targets['GWL'].values - rmse = np.sqrt(mean_squared_error(combined['true'], combined['pred'])) + rmse = np.sqrt(mean_squared_error(y_true, y_pred)) return float(rmse) -def main(reference_dir, prediction_dir, output_dir): +def main(input_dir, output_dir): + # Codabench passes a single input_dir containing 'ref' (answers) and 'res' (predictions) + ref_dir = Path(input_dir) / 'ref' + res_dir = Path(input_dir) / 'res' + scores = {} - + try: - # 1. Path Setup - # Reference labels: [ref_dir]/test/test_labels.csv (from setup_data.py) - # Predictions: [pred_dir]/test_predictions.csv (from ingestion.py) - label_path = reference_dir / 'test' / 'test_labels.csv' - pred_path = prediction_dir / 'test_predictions.csv' + # --- 1. Collect Predictions (from Ingestion) --- + pred_path = res_dir / "test_predictions.csv" + predictions = pd.read_csv(pred_path) - # Fallback if structure differs slightly on different platforms + # --- 2. Collect Reference Labels (Ground Truth) --- + # Adjust this path if your labels are not inside a 'test' subfolder! + label_path = ref_dir / "test" / "test_labels.csv" if not label_path.exists(): - label_path = reference_dir / 'test_labels.csv' - - # 2. Load Data + label_path = ref_dir / "test_labels.csv" # Fallback + targets = pd.read_csv(label_path) - predictions = pd.read_csv(pred_path) - # 3. Compute Score + # --- 3. Compute Score --- scores['rmse'] = compute_rmse(predictions, targets) except Exception as e: print(f"❌ Scoring Error: {e}") + # Assign a terrible score if something breaks so the leaderboard doesn't crash scores['rmse'] = 999.0 - # 4. Include Runtime Metadata (Captured by ingestion.py) + # --- 4. Collect Metadata (from Ingestion) --- + # This pulls your train_time, test_time, and duration into the leaderboard! try: - metadata_path = prediction_dir / 'metadata.json' + metadata_path = res_dir / "metadata.json" if metadata_path.exists(): - with open(metadata_path, 'r') as f: + with open(metadata_path, "r") as f: metadata = json.load(f) - scores.update(metadata) - except Exception: - pass + scores.update(metadata) + except Exception as e: + print(f"Warning: Could not read metadata.json. {e}") - # 5. Save results for the Leaderboard + # --- 5. Save Results for Leaderboard --- + output_dir = Path(output_dir) output_dir.mkdir(parents=True, exist_ok=True) - with open(output_dir / 'scores.json', 'w') as f: - json.dump(scores, f) - print(f"Scoring finished. RMSE: {scores['rmse']:.4f}") + with open(output_dir / "scores.json", "w") as f: + json.dump(scores, f) + + print(f"Scoring complete. RMSE: {scores.get('rmse', 'ERROR'):.4f}") if __name__ == "__main__": - import argparse - parser = argparse.ArgumentParser() - # Paths provided by Codabench environment - parser.add_argument("--reference-dir", type=str, default="/app/input/ref") - parser.add_argument("--prediction-dir", type=str, default="/app/input/res") - parser.add_argument("--output-dir", type=str, default="/app/output") + parser = argparse.ArgumentParser(description="Scoring program") + + # Codabench passes these as positional arguments + parser.add_argument("input_dir", type=str, help="Directory containing ref and res folders") + parser.add_argument("output_dir", type=str, help="Directory to save scores.json") + parser.add_argument("program_dir", type=str, nargs='?', default="", help="Optional program dir") + args = parser.parse_args() - main(Path(args.reference_dir), Path(args.prediction_dir), Path(args.output_dir)) + main(args.input_dir, args.output_dir) diff --git a/solution/submission.py b/solution/submission.py index ed399dd..959ff7a 100644 --- a/solution/submission.py +++ b/solution/submission.py @@ -1,37 +1,41 @@ +import pandas as pd +from sklearn.base import BaseEstimator, TransformerMixin from sklearn.ensemble import RandomForestRegressor -from sklearn.compose import ColumnTransformer -from sklearn.pipeline import Pipeline -from sklearn.preprocessing import StandardScaler - -from sklearn.ensemble import RandomForestRegressor -from sklearn.compose import ColumnTransformer -from sklearn.compose import make_column_selector as selector from sklearn.pipeline import Pipeline from sklearn.impute import SimpleImputer +class NumericSelector(BaseEstimator, TransformerMixin): + """ + Custom transformer to select only numeric columns. + """ + def fit(self, X, y=None): + return self + + def transform(self, X, y=None): + # If the input is a Pandas DataFrame, drop the string/object columns + if isinstance(X, pd.DataFrame): + return X.select_dtypes(include=['number']) + return X + def get_model(): """ - Returns a model that automatically filters out string columns - to avoid ValueErrors and fits on numeric data only. + Returns a lightweight, extremely fast Random Forest for testing. """ - # 1. Define a transformer that ONLY picks numeric columns (float64, int64) - # This automatically ignores 'well_id_str' and 'date_dt' because they are strings/objects - numeric_transformer = Pipeline(steps=[ + preprocessor = Pipeline(steps=[ + ('selector', NumericSelector()), ('imputer', SimpleImputer(strategy='median')) ]) - preprocessor = ColumnTransformer( - transformers=[ - ('num', numeric_transformer, selector(dtype_include=['float64', 'int64'])) - ], - remainder='drop' # This explicitly drops anything that isn't a number - ) - - # 2. Create the full pipeline + # 2. Create the full pipeline with a "Fast" Random Forest model = Pipeline(steps=[ ('preprocessor', preprocessor), - ('regressor', RandomForestRegressor(n_estimators=50, max_depth=8, random_state=42)) + ('regressor', RandomForestRegressor( + n_estimators=10, # Reduced from 50 (Makes it 5x faster) + max_depth=5, # Reduced from 8 (Keeps trees shallow and quick) + n_jobs=-1, # CRITICAL: Forces Python to use all CPU cores! + random_state=42 + )) ]) return model diff --git a/tools/create_bundle.py b/tools/create_bundle.py index 3153973..53d265a 100644 --- a/tools/create_bundle.py +++ b/tools/create_bundle.py @@ -16,8 +16,8 @@ "pages": ROOT_DIR / "pages", "ingestion_program": ROOT_DIR / "ingestion_program", "scoring_program": ROOT_DIR / "scoring_program", - "dev_phase": ROOT_DIR / "dev_phase", - "final_phase": ROOT_DIR / "final_phase", + # "dev_phase": ROOT_DIR / "dev_phase", + # "final_phase": ROOT_DIR / "final_phase", } if __name__ == "__main__": diff --git a/tools/create_starting_kit.py b/tools/create_starting_kit.py index 312b1cf..987fbf4 100644 --- a/tools/create_starting_kit.py +++ b/tools/create_starting_kit.py @@ -18,7 +18,8 @@ ("solution/submission.py", "submission.py"), # Move to root as the template ("ingestion_program/ingestion.py", "ingestion_program/ingestion.py"), ("scoring_program/scoring.py", "scoring_program/scoring.py"), - ("dev_phase/input_data", "dev_phase/input_data"), # Include only input data + # ("dev_phase/input_data", "dev_phase/input_data"), # Include only input data + # ("final_phase/input_data", "final_phase/input_data") ] def build():