diff --git a/.gitignore b/.gitignore index 9728749..c2c654c 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,5 @@ ingestion_res/* scoring_res/* dev_phase/* +test_notebook/* +raw_data/* 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. diff --git a/competition.yaml b/competition.yaml index 3a1e4de..16423d8 100755 --- a/competition.yaml +++ b/competition.yaml @@ -1,60 +1,66 @@ version: 2 -title: Templat competition - Dummy classification -description: Dummy classification task +title: "GEMS-GER Groundwater Level Prediction Challenge" +description: "Predict groundwater levels (GWL) across Germany." image: logo.png -registration_auto_approve: False # if True, do not require approval from admin to join the comp - +registration_auto_approve: True 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' - input_data: dev_phase/input_data/ - reference_data: dev_phase/reference_data/ + name: "Development Task" + # 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" 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 + max_submissions: 100 + max_submissions_per_day: 5 + starting_kit: starting_kit.zip + # public_data removed to prevent server crashes + tasks: [0] -phases: - - name: Development Phase - description: 'Development phase: tune your models.' - start: 10-07-2025 - end: 03-31-2026 - tasks: - - 0 + - index: 1 + name: "Final Phase" + start: 2026-04-15 00:00:00 # Added the required timestamp! + max_submissions: 1 + auto_migrate_to_this_phase: True + tasks: [1] leaderboards: - title: Results key: main columns: - - title: Test Accuracy - key: test + - title: RMSE + key: rmse index: 0 sorting: asc - - title: Private Test Accuracy - key: private_test - index: 1 - sorting: asc - hidden: True - - title: Train time + - title: Train Time (s) key: train_time - index: 2 + index: 1 sorting: desc - - title: Test time + - 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 f150b05..06da5c5 100755 --- a/ingestion_program/ingestion.py +++ b/ingestion_program/ingestion.py @@ -2,91 +2,96 @@ 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) - - -def get_train_data(data_dir): - 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") + 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): - # 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") + + # 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(Path(__file__).parent.resolve()) + sys.path.append(args.program_dir) main(Path(args.data_dir), Path(args.output_dir)) 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/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/metadata.yaml b/scoring_program/metadata.yaml index 1dfabf8..dd3ba2d 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 /app/program diff --git a/scoring_program/scoring.py b/scoring_program/scoring.py index 701f78f..958dad9 100755 --- a/scoring_program/scoring.py +++ b/scoring_program/scoring.py @@ -1,72 +1,77 @@ import json +import argparse 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_rmse(predictions, targets): + """ + Calculates the Root Mean Squared Error (RMSE) for the GWL column. + """ + # 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(y_true, y_pred)) + return float(rmse) -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 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' - -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' - ) + try: + # --- 1. Collect Predictions (from Ingestion) --- + pred_path = res_dir / "test_predictions.csv" + predictions = pd.read_csv(pred_path) - scores[eval_set] = float(compute_accuracy(predictions, targets)) + # --- 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 = ref_dir / "test_labels.csv" # Fallback + + targets = pd.read_csv(label_path) - # 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) + # --- 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 - # Write output scores - output_dir.mkdir(parents=True, exist_ok=True) - (output_dir / 'scores.json').write_text(json.dumps(scores)) + # --- 4. Collect Metadata (from Ingestion) --- + # This pulls your train_time, test_time, and duration into the leaderboard! + try: + metadata_path = res_dir / "metadata.json" + if metadata_path.exists(): + with open(metadata_path, "r") as f: + metadata = json.load(f) + scores.update(metadata) + except Exception as e: + print(f"Warning: Could not read metadata.json. {e}") + # --- 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 complete. RMSE: {scores.get('rmse', 'ERROR'):.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(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 a8076b0..959ff7a 100644 --- a/solution/submission.py +++ b/solution/submission.py @@ -1,7 +1,41 @@ -from sklearn.ensemble import RandomForestClassifier +import pandas as pd +from sklearn.base import BaseEstimator, TransformerMixin +from sklearn.ensemble import RandomForestRegressor +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 -# The submission here should simply be a function that returns a model -# compatible with scikit-learn API def get_model(): - return RandomForestClassifier() + """ + Returns a lightweight, extremely fast Random Forest for testing. + """ + + preprocessor = Pipeline(steps=[ + ('selector', NumericSelector()), + ('imputer', SimpleImputer(strategy='median')) + ]) + + # 2. Create the full pipeline with a "Fast" Random Forest + model = Pipeline(steps=[ + ('preprocessor', preprocessor), + ('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/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/tools/zip_submission.py b/starting_kit/tools/zip_submission.py new file mode 100644 index 0000000..c3fe5a8 --- /dev/null +++ b/starting_kit/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() diff --git a/template_starting_kit.ipynb b/template_starting_kit.ipynb index 7167a3a..a4b8c83 100644 --- a/template_starting_kit.ipynb +++ b/template_starting_kit.ipynb @@ -11,23 +11,79 @@ " \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 MOUAWAD
\n", + " Spyridon PAIPETIS
\n", + " Charles KARRER
\n", + " ClƩment DESTOUESSE
\n", + " Felix BLANCHARD
" ] }, { "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", + "* **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", - "Describe the challenge, in particular:\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", - "- Where the data comes from?\n", - "- What is the task this challenge aims to solve?\n", - "- Why does it matter?" + "### **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": 1, + "metadata": {}, + "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" ] }, { @@ -44,62 +100,2053 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading training data in chunks of 200000...\n" + ] + } + ], "source": [ "%matplotlib inline\n", "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": "iVBORw0KGgoAAAANSUhEUgAABKUAAAHqCAYAAADVi/1VAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASTNJREFUeJzt3Xm8l3P+P/7HOSctCBExGDPMx7GmtKkQNbYUJpks02fGGuWDxhYGYy/EJyI7YxuGsYQsM0Mz1oxoGD62QbLV0KKI6pzz+8Ov91dSWs5cJ537/XY7t9t5X9f1vq7ndZ1ncR69Xq93WU1NTU0AAAAAoEDldV0AAAAAAPWPUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAAAAACicUAoAAACAwgmlAIBlQk1NTV2XsMiWhVqXhRpYdugHAL6PhFIAsBT69u2bysrK7Lvvvgs8ZuDAgamsrMygQYNK2yorK3PppZfWah19+/attfN917UqKytLX5tssklat26dXr165aabbkpVVdVin/PNN9/MfvvtVyv1fb22ysrKbLbZZunQoUMOPPDA/PWvf53n2Pfeey+VlZW56667Fvn8I0aMyLXXXvudx3Xt2rX0M1+S6yzIRx99lH79+uX999//1msV5ayzzsrFF1+cJLnrrrtSWVmZc84551uPvfTSS1NZWVlkeUtkzJgxqayszJgxY5b4HHOfxYK+TjnllFqs+Ct33HFHhgwZUuvnXRrHHntsrrnmmrouA4BlXIO6LgAAvu/Ky8szbty4fPjhh1lnnXXm2Tdz5syMHj16vvfcfvvtWXvttWuthtNPP73WzrUoNttss9I1q6qqMm3atPz1r3/Nueeem7Fjx+biiy9OWVnZIp/vwQcfzAsvvFBr9fXu3Tv77LNPkmT27Nn597//nTvvvDOHHXZYTj311PziF79Ikqy11lq5/fbb88Mf/nCRz/2///u/OfLII7/zuOHDh2fllVdeshtYiKeeeiqjR4/Oqaee+h+/1oI888wzeeSRR/Lwww/Ps/2mm27KLrvskrZt2xZWS23afPPNc/vtt+cnP/nJUp9r+PDhWXPNNefbvsYaayz1ub9pxIgRad++fa2fd2mccMIJ6dmzZ3bcccdstNFGdV0OAMsooRQALKXNNtssb775Zh566KEceOCB8+x79NFH06hRozRt2nSe7a1atarVGmrjl+jFsfLKK893D127ds2Pf/zjnHfeeenatWv22GOPQmv6urXXXnu++nbbbbcMGDAggwcPzg477JD11lsvDRs2rPWfxVybbbbZf+S8dX2tJDnvvPPy3//931lxxRXn2d60adOcfPLJGTlyZBo3blxoTbXh2/p6SW266aZZb731auVc30ctWrRI9+7dc+GFF2bEiBF1XQ4AyyjT9wBgKa244orp0qVLHnzwwfn2jRo1KrvuumsaNJj334G+OX3vpptuyq677pott9wy2223XX77299mxowZpf1PPfVU+vTpk9atW6ddu3bp379/3nrrrdL+b07fq6yszC233JJTTjkl7du3T+vWrXPUUUfl448/nqeOa6+9Nt26dUvLli2z77775tFHH12q6Ut9+/bNWmutldtuu6207YsvvsjQoUOz8847Z4sttsjWW2+dAw88MP/3f/+X5KupXcOHD5/vuUyePDlnnHFGdtxxx2yxxRZp3759BgwYkPfee2+JaisrK8uxxx6b2bNn584770wy/7S66urqDBs2LF27ds0WW2yRrl275qKLLsrs2bNL9SVfjYKZ+/2ll16anXbaKcOHD0+HDh3y05/+NFOmTPnWKXUTJ05Mv3790rJly3Tp0iWXXHLJPNMdv+09c6eDvffee7nrrrty0kknJUm6detWOvab75s+fXrOO++8/PSnP82WW26ZHj16lO7569e65JJLMmTIkHTq1CktW7bMwQcfnLfffnuhz3H06NF57bXX0qNHj/n2nXjiiXn33Xdz0UUXLfQcC5rO9/Wf/9yfzcMPP5z+/funVatW6dSpUy6//PLMmDEjJ598ctq0aZNOnTrlggsumGdNpS+//DLnn39+unTpki222CI9e/bMqFGj5rv/c889N7/85S+z9dZb57TTTvvW6Xv//Oc/c8ghh6RNmzbZZpttMnDgwHz44YcLvb9F9frrr6dfv37Zeuuts/XWW2fAgAGZMGHCPMe8+uqrOfLII7PNNttk8803z3bbbZezzz47X3zxRek+3n///dx9993z9Mnc7795z9+cRjx8+PDsvffeadOmTS6//PIkyQcffJBf//rXad++fbbaaqv88pe/zCuvvDLPuUaNGpU99tgjLVu2zDbbbJPjjjsukyZNmueYPfbYI4899lhef/31WnleACx/hFIAUAu6d++ef/zjH/nggw9K22bMmJG//e1v3/rL+9c98MADGTJkSA444IBce+21GTBgQO69996cffbZSZIJEybkiCOOyOabb54RI0bk7LPPzltvvZXDDjss1dXVCzzvxRdfnOrq6lx00UU54YQTMnr06Jx77rml/cOHD8+FF16Y3XbbLZdffnm22mqrDBw4cKmeQ0VFRTp27JgXX3wxc+bMSfLVNJ65U+euu+66DBo0KK+//noGDhyYmpqa7LPPPundu3eSr6Y17rPPPqmpqUm/fv3y5JNP5thjj821116b/v3756mnnsppp522xPVttNFGWWeddTJ27Nhv3X/11VfnlltuyYABA3Lddddlv/32yzXXXJMrrriiVF/y1fTAud8nX/0S/6c//SkXXXRRjjnmmDRr1uxbz3/ppZdm9dVXz2WXXZa99947V1xxRS655JJFrn+HHXbIEUcckeSrn1///v3nO+aLL77I/vvvn5EjR+aggw7K5ZdfnjZt2uSUU04p3cdcN954Y956662cd955Ofvss/PPf/7zO9emGjlyZFq1ajXfVNUk2WabbdKnT5/cdNNNee655xb5vhbmlFNOycYbb5wRI0Zkm222ybBhw9K7d+80bty4FCBec801eeihh5J8teD3gAEDctttt+XAAw/MiBEj0rp16wwcODD33HPPPOe+5ZZbSkHYnnvuOd+1X3311ey3336ZOXNmBg8enDPPPDOvvPJKDjrooFJQuSDV1dWZM2fOPF9f//P69ttvZ999980nn3ySwYMH55xzzsmECROy33775ZNPPkmSTJo0KQcccEDp+ldffXV222233HTTTbnhhhuS/L9pgl26dMntt9+etdZaa7Ge74gRI7LLLrvkoosuSrdu3TJ58uTsu+++efnll3Pqqadm6NChqa6uzgEHHJB//etfSZKxY8fmuOOOy84775yrr746J510Up555pkce+yx85y7devWadGiRe6///7FqgmA+sP0PQCoBTvssENWXHHFPPTQQznooIOSJH/605+y+uqrp02bNgt975gxY7LuuuvmgAMOSHl5edq3b58VV1wxU6ZMSZK8+OKL+eKLL9KvX7+0aNEiSbLOOuvkL3/5Sz7//PMFriW08cYb57zzziu9fvHFF0u/uH/++ee5+uqrc8ABB+S4445Lkmy77baZOXPmPGHLkmjevHlmz56dqVOnZpVVVslnn32WU089Nd27d0+StG/fPp999lkGDx6cf//731l77bVL62vNnTo1ceLENGnSJCeeeGJpfaIOHTrkvffem2cU1pLW980RY3M9++yz2XzzzbP33nuXam3SpEnpGc+t75vTA+fMmZMTTzwxnTp1Wui1O3bsWPqZbLfddpkxY0ZuvPHGHHTQQVl11VW/s/bVV1+9tP7VgqaH3XXXXXn99ddz6623lnpvu+22y5w5c3L55Zdn3333zWqrrZYkWWWVVXL55ZenoqIiSfLuu+/m0ksvzZQpUxYYrD3zzDPZfffdF1jjCSeckMcffzynnHJK7r333qWexrfddtvlmGOOSfLVNNUHHngga6yxRimc7Ny5cx588ME8//zz2W233fLUU0/l8ccfz8UXX1zque222y4zZ87MhRdemB49epRGLq611loZNGhQysu/+nfab44QvPzyy7PqqqvmuuuuS6NGjZJ89bM/5phj8tprr2WLLbZYYN077bTTfNs6duw4T5jUuHHj3HDDDaX+6tixY37605/mmmuuyYknnpjXX389m266aYYNG1Y6plOnTnn66afz97//PYcffng222yzNGzYMKuvvvoSTT1s2bJlDjvssNLriy++OFOnTs3vf//7rLvuukmS7bffPt27d8+wYcNyySWXZOzYsWnUqFEOPfTQ0nNZbbXV8tJLL6Wmpqa0nlxZWVm22GKLPP3004tdFwD1g1AKAGpB48aN07Vr1zz44IOlUOqBBx5I9+7dv3PB72222Sa33357evXqlZ133jk77LBDevbsWXrfVlttlUaNGqV3797p3r17unTpkrZt26Zly5YLPe83f0Fde+21M3PmzCTJuHHj8sUXX2TXXXed55gePXosdSg1V1lZWRo2bFj6pLpJkyZl/Pjxeeutt/LYY48lyQJHm7Ro0SI33nhjkq9GIY0fPz7/+te/8vzzz3/nCJVFre3bdOjQIUOHDs3++++fnXbaKdtvv31pUfTvsvHGG3/nMXNDkrl23nnn/O53v8u4cePSpUuXRbrOd3n22Wez7rrrzheG7rHHHrnzzjvzj3/8o3StLbfcshRIJSmFgzNnzvzWUGrmzJn55JNPFrpW0korrZRzzjknv/rVr3LxxReXphsuqdatW5e+n7tw+FZbbVXaVlZWllVXXTXTp09Pkjz99NMpKytLly5dSqP1kq+mro0cOTJvvPFGNt100yRfjZybG0h9m7Fjx6ZLly6l4CX5KsR59NFHv7PuESNGzLfQ+dcD5GeeeSYdOnRI48aNS3WuvPLKadu2bZ566qkkXwXF2267bWbPnp23334777zzTl577bVMnjy5FCwurW/27dNPP51NN900LVq0KNVVXl6e7bffPiNHjkyStGvXLhdffHF69uyZ3XbbLdtvv3223Xbbb+3hddddN88//3yt1ArA8kcoBQC1ZO5C2u+9915WWmmlPP3006URHgvTvXv3VFdX59Zbb83w4cMzbNiwrLvuujn22GOz++67Z7311svNN9+cq666Kn/4wx9yww03ZJVVVsn++++fo48+eoG/VDdp0mSe1+Xl5aV1dyZPnpzkq5E3X9e8efMluPN5TZw4MY0bNy790vz444/n3HPPzVtvvZWVVloplZWVWWmllZJknnWAvmnkyJG56KKL8uGHH2a11VbLJptsUiuLZ0+cODH/9V//9a37DjnkkKy00kr54x//mCFDhmTw4MHZeOONc/LJJ6djx44LPe+iPLtvHjP3+U+bNm0Rq/9u06ZN+9Za5m779NNPS9u+rUeSLHBa6Nz3fnOB82/q2LFj+vTpkxtvvDG77LLLohf/Lb5tJOA36/66qVOnpqamJltvvfW37p80aVIplPqun9nUqVOX+NPyNt5444WGd1OnTs2oUaPmW+sq+X99MXf67S233JLPP/8866yzTlq2bDlPSLa0vvkMpk6dmvHjx2fzzTf/1uNnzpyZ1q1b56qrrsoNN9yQa6+9NldccUXWXHPNHHroofnlL385z/FNmjQpBYYA8E1CKQCoJdtvv32aNm2ahx9+OE2bNs1666230Ok9X9ejR4/06NEj06dPzxNPPJGrr746xx9/fNq2bZsWLVqkZcuWGT58eGbNmpWxY8fm9ttvzxVXXJHKysr5Rt8sirkjYiZPnpwNN9ywtH1uWLWkqqqq8uyzz2brrbdORUVF3n333QwYMCDdunXLlVdeWZp6dsstt+Txxx9f4Hmee+65nHjiifnFL36Rgw8+uFTv+eefv8D1oBbFv/71r0yaNCn777//t+4vLy/PAQcckAMOOCCffPJJ/vrXv+aKK67I//zP/+Spp55Kw4YNl/jaybyBUJLSNMKvBx9fX/g8+Wqq5eJYddVVM378+Pm2//vf/06SBU7LWxRz3/vN+/g2c6fxnXTSSfnpT386z765I9WqqqpKI7U+++yzJa7r65o2bZoVV1yxNNLumzbYYIPFOte3/Zn461//mk022aQ0nXZJ6+zUqdN8n9iZpDS9cG7w89vf/ja77LJL6VM8567BtiBzn+83w8VFecZNmzZN+/btc8IJJ3zr/rl/BrbbbrvStMhnnnkmN954Y84999y0atVqnpFsn3766VL1HADLNwudA0AtadiwYbp165ZHHnkkDz744ELX3fm6Y445JkceeWSSr34h3G233dK/f/9UVVVl0qRJueGGG9K1a9fMmjUrDRs2TMeOHXPWWWclyRJ/Ctgmm2ySpk2b5pFHHpln+8MPP7xE55vrtttuy6RJk7Lffvsl+eqTy7788sv069evFEglKQVSc0dKfXO01wsvvJDq6uocddRRpUCqqqqqNK1pYQu8L8wll1ySxo0b52c/+9m37t93331LC8yvscYa6dWrVw444IBMnz699GmIC5vu9V2+GcQ98MADadKkSemX+JVXXjkfffTRPMd8c+rTd12/Xbt2ef/99+cL70aOHJkVVljhO6d9LkzDhg2z5pprLlLfrbzyyjn77LPzzjvvzDcldO7op6+fp7ameLVv3z6ff/55ampqsuWWW5a+3njjjVx22WXzTOn7Lm3bts3jjz+eWbNmlba99tprOeyww/LSSy8tdZ1vvvlmNt1001KNW2yxRW644Yb86U9/SvLV9MGf/OQn6d27dymQmjhxYl5//fV5/gx8sye+7fm+9dZbmTp16iLV9fbbb+fHP/7xPM9v5MiRueOOO1JRUZEhQ4akd+/eqampSZMmTbLjjjvmxBNPnO+ac1/PXZsKAL7JSCkAqEXdu3dPv379Ul5ent/85jeL9J5tttkmp59+eoYMGZLtt98+n376aYYPH54f/ehH2WSTTbLCCivkwgsvzIABA/KLX/wiFRUVue2229KwYcPsuOOOS1TnyiuvnEMOOSSXXHJJmjRpkvbt2+fZZ5/N73//+yTfHXzMmDEj48aNS/JVQDRlypQ88cQTuf3227PHHntk5513TpJsvvnmadCgQS644IIcdNBBmTVrVu66666MHj06yf8bBbTKKqskSe6///5stdVWpeDkzDPPzN57751PP/00N998c1599dXS+xa0wHuSfPTRR6X65syZk4kTJ+buu+/OE088kTPPPLMUdH1Tu3btct1116V58+Zp3bp1Jk6cmOuvvz7t27cvTalaZZVV8sILL+Tvf/97aRH2RfXII4+kRYsW6dSpU+l5HX300aV72XHHHXPllVfmiiuuSKtWrTJ69Oj5Fome+6z+9Kc/Zfvtt89GG200z/5evXrl1ltvzZFHHpmjjjoq66+/fh599NH88Y9/zJFHHll6/5Lq3LnzIgdInTt3zj777JM77rhjnu1dunTJeeedl1NPPTWHHnpoPvroowwfPrw0rXNpdOnSJe3atUv//v3Tv3//bLTRRnnxxRdz6aWXZtttt51vyurC9O/fP3369ClNS5s1a1aGDRuWzTffPNtvv/1S1dm/f//su+++6devX/bbb780atQot99+e/785z+XPpGxZcuWufzyy3PVVVelVatWGT9+fK688srMmjWrtD5c8lVPvPLKK3n22WfTsmXLbLPNNmnSpEkGDx6cY445Jp999lmGDx++SOtQ/epXv8q9996bX/3qVznooIPSrFmzjBo1Kn/4wx9K64N17Ngx119/fQYNGpQ99tgjs2fPzjXXXJPVVlst22yzTelcNTU1eeGFF9K3b9+lelYALL+EUgBQizp16pRVVlkl66yzznxhwYLsu+++mT17dm677bbceuutady4cTp27Jjjjz8+K6ywQjbZZJNcccUVueyyy/LrX/86VVVV2WKLLXLdddfNM/VucfXr1y/V1dW5/fbbc+2112arrbbKcccdl/POO+871wx65ZVX0qdPnyRfBVhrrLFGfvzjH2fw4MHp2bNn6bgNNtggQ4cOzfDhw3PEEUdk1VVXTatWrXLTTTelb9++ee6551JZWZmdd9459957bwYNGpTevXvnt7/9bU477bRcf/31eeihh9K8efN06NAhw4cPz4ABA0oLUC/InXfemTvvvDNJssIKK2SttdbKFltskZtvvnmhQdLRRx+dhg0b5o9//GMuu+yyNG3aNF27dp3no+4PP/zwXH755Tn00EO/dT2ghRk0aFAeeuih3HDDDVlzzTVz0kknzbMGT79+/TJ58uRcd911mT17dnbYYYecc845OeKII0rHdOjQIZ06dcrQoUPz9NNP56qrrprnGk2aNMlNN92UoUOH5pJLLsmMGTOy4YYb5pxzzvnOaV+LYpdddsl9992XSZMmZa211lqke37iiSfmGUHz4x//OEOGDMmIESNy2GGHZaONNspZZ51VGgG4NMrLy3PVVVdl2LBhufLKK/PJJ5+kRYsW+dWvfpUBAwYs1rk222yz0rMcOHBgVlpppXTp0iXHHXfcUk/l3GSTTXLLLbfk4osvzgknnJCamppsvPHGueyyy9KtW7ckX/XDlClTcuONN+ayyy7LOuuskz333DNlZWW58sorM23atKy66qo56KCDcu655+bggw/O9ddfn7Zt2+aSSy7J0KFDM2DAgKy77ro58sgjc88993xnXS1atMhtt92WoUOH5re//W2+/PLL/OhHP5qnf7bffvtceOGFue6663LkkUemrKwsbdq0yY033jhP8PXiiy9m6tSp832gAgDMVVazsBVGAYDl0pw5c3L//fenQ4cOWWeddUrbb7nllpx99tkZM2bMUo+oYflUU1OTPffcM7vssstihzzULyeddFKmTZuWyy+/vK5LAWAZJZQCgHpq9913T8OGDXPEEUekWbNmefXVVzNs2LDstNNOOe+88+q6PJZhf/vb33LyySfnoYceWug0SuqvDz74ID179sytt96aysrKui4HgGWUUAoA6qkJEybkoosuypgxY/Lpp5/mBz/4QfbYY4/069cvK6ywQl2XxzLu9NNPzyqrrDLP1EaY69e//nUqKyvTr1+/ui4FgGWYUAoAAACAwi35ZxoDAAAAwBISSgEAAABQOKEUAAAAAIVrUNcFLC+qq6szZ86clJeXp6ysrK7LAQAAAKgTNTU1qa6uToMGDVJevuDxUEKpWjJnzpy89NJLdV0GAAAAwDJhyy23TMOGDRe4XyhVS+Ymf1tssUUaNPBYWf7V1NTk008/zSqrrGJ0IPWGvqe+0fPUN3qe+kjf859QVVWVl156aaGjpBKhVK2Z+4e3oqIiFRUVdVwN/OfV1NSkvLw8FRUV/uNFvaHvqW/0PPWNnqc+0vf8J31XT1noHAAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQCgAAAIDCCaUAAAAAKJxQClhiFRUVdV0CFE7fAwBA7WhQ1wUsb8rKyuq6BChEWVlZmjZtWtdlQKH0PcuF6uqk3L9LAgB1TyhV2+69LPn3+LquAgBgfs3XS/YeWNdVAAAkEUrVvk/eTz58q66rAAAAAFimGbsNAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOHqbSj1zjvv1HUJAAAAAPXWMhlKde3aNVtuuWVat26d1q1bp1WrVtlzzz1zxx131Mr5H3300Rx88MGl13379s2ll15aK+cGAAAA4Ls1qOsCFuSMM85Ir169kiSzZs3K6NGjc9JJJ2XKlCk57LDDlurcU6dOTU1NTW2UCQAAAMASWCZHSn1Tw4YNs/POO+fEE0/M8OHDM2PGjHz88cc57rjj0rlz52y77bY57bTTMmPGjCTJmDFjsv3222fYsGHp0KFDOnTokHPOOSezZs3KmDFjcvrpp+eDDz5I69atM3HixCTJ+PHjc9BBB6Vdu3bp1q1bHnroobq8ZQAAAIDl2vcilJprhx12yJdffpmxY8emf//+KS8vz8MPP5z77rsvkyZNymmnnVY6duLEiXn77bfzl7/8JbfffntGjx6dyy+/PB06dMgZZ5yRH/zgB3nhhRfSokWLJMmTTz6ZY489NmPGjEmvXr1y0kknZfbs2XV1qwAAAADLtWV2+t63adasWZLkpZdeyssvv5zrr78+K620UpLkxBNPzK677ppTTz01SVJWVpbTTz89K6+8clZeeeUccsghufLKK3PMMcd867m7d++ezTffvPT9JZdckk8++SRrr732f/7GAAAKVFVVtUjH1dTUpLq6OlVVVSkrK/sPVwV1T89TH+l7/hMW9f81vleh1OTJk5MkG264YaqqqtKlS5d59jds2DATJkxIkqy66qqlECtJ1llnnUyaNGmB515ttdVK36+wwgpJkjlz5tRW6QAAy4zXXnstM2fOrOsyAIB67nsVSj366KNZccUV07x58zRu3DhjxoxJRUVFkq8WQ58wYUI22GCDjB07NtOnT8/MmTPTpEmTJMl7772XH/zgB3VZPgDAMqGysnKRjqupqcmnn36aVVZZxb+eUy/oeeojfc9/QlVVVV566aXvPO57EUrNmjUrf/7zn3PRRRdl4MCB2XrrrbPBBhtk8ODBOeaYY1JRUZHBgwfnL3/5S/785z8n+eoBDBkyJCeddFLef//9XHvttenTp0+SpFGjRpk5c2bmzJmTBg2+F48AAKDWzP1Hve9SU1OT8vLyVFRU+EWFekHPUx/pe+rSMpvInH766TnrrLOSfBUibbjhhjnjjDPSvXv3JMmVV16ZIUOGZOedd86XX36Zli1b5vrrr0+jRo1K51h11VXTrVu3JMm+++6bQw45JEnSrl27rLHGGmnXrl1uu+22gu8MAAAAgLKampqaui6ito0ZMyb//d//nddee62wa1ZVVWXcuHFp9fwfUvH+64VdFwBgka2zYdJv6CIfXlNTk2nTpmXVVVf1r+fUC3qe+kjf859QykhatVroCO3yAmsCAAAAgCRCKQAAAADqwHIZSnXo0KHQqXsAAAAALJ7lMpQCAAAAYNkmlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcA3quoDlzhrrJtVz6roKAID5NV+vrisAACgRStW2PQckFRV1XQUAwLerrk7KDZYHAOqe/yOpZTU1NXVdAhSipqYm06dP1/PUK/qe5YJACgBYRvi/EmCJVVVV1XUJUDh9DwAAtUMoBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBQAAAEDhhFIAAAAAFE4oBSyxioqKui4BCqfvqW/0PPWNngcoToO6LmB5U1ZWVtclQCHKysrStGnTui4DCqXvqW/0PPXNctHz1dVJubEHwPeDUKq23XtZ8u/xdV0FAABQ3zRfL9l7YF1XAbDIhFK17ZP3kw/fqusqAAAAAJZpxnUCAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAUDihFAAAAACFE0oBAAAAULh6HUq98847dV0CAAAAQL202KHUtGnT8tvf/jZdunRJq1atsu222+bEE0/MRx99tNgXHzNmTCorKxf7fbXhlVdeSY8ePUqvBw0alEGDBtVJLQAAAAD1zWKHUgMHDsyUKVNy5513Zty4cbnnnnsya9asHHjggZkzZ85/osb/iOnTp2f27Nl1XQYAAABAvbTYodTYsWOz0047Zc0110ySNG/ePCeffHK22mqrfPrpp5k8eXKOO+64tGvXLh06dMjAgQMzbdq0JEllZWXOPvvsdOjQIYcffvh3XmvWrFkZNmxYunXrlvbt2+fQQw/N+PHjS/srKytz0003ZZdddknr1q2z77775rXXXivtf+qpp7LXXntl6623zr777psLLrggffv2zYQJE3LooYcmSVq3bp0XXnghSfLJJ5/kqKOOSocOHbLtttvm5ptvXtzHAwAAAMAiaLC4b9h9991z+umn57nnnkv79u2z1VZbZd11183gwYOTJH379s1KK62URx55JCussEKOPvronHHGGbnooouSJO+++25Gjx6d2bNn5//+7/8Weq2LL744zzzzTG644YastdZaufrqq3PQQQdl1KhRadSoUZLkgQceyM0335zGjRvnqKOOyvnnn59rr7027733Xg4//PCccsop2XvvvTNu3Lgcfvjh2XTTTbP++uvn6quvzn//93+XAqnbb789zzzzTK688soMGzYs99xzT0466aTstNNOadGixeI+JgAAgDpRVVVV1yXwPVJTU5Pq6upUVVWlrKysrsthObGofw8tdig1d6TTqFGjctppp2X69On54Q9/mP/5n/9JmzZt8uyzz+ahhx5Ks2bNkiSDBw/O1KlTS+/v0aNHmjRpkiZNmiz0OjU1NbnttttyySWXZP3110+SDBgwIH/4wx8yevTo7LLLLkm+CsHmjtrabbfdcuWVVyZJ7rvvvmy66abp06dPkqRt27b5+c9/npdeemmB1+zcuXM6deqU5KvwbdCgQZkwYYJQCgAA+N547bXXMnPmzLouA+A7LXYoVV5enj333DN77rlnampq8q9//Sv33ntvTjjhhBx99NFJknXXXbd0/JprrlkKjZJkrbXWWqTrTJ48OZ9//nmOPvrolJf/v1mGs2fPzvvvv1963bx58/93Mw0apKamJkny4YcfzlNHkqy//voLDaVWW2210vcNGzZM4l8ZAACA75e6+jApvp9qamry6aefZpVVVjFSilpTVVW10PxlrsUKpR5//PEcddRReeyxx7LaaqulrKwsP/nJT3LsscfmySefLAU4H3zwQX70ox8lSd58883cf//9OeaYY5JkkZu8WbNmadSoUa677rq0atWqtP2tt95apJFL6667bh577LF5tn3wwQeLdG0AAIDvq4qKirouge+RmpqalJeXp6KiQihF4RZrofN27dpljTXWyEknnZTXXnsts2fPzowZMzJy5Mi888472W233dK5c+ecf/75+fTTTzNjxoxccMEFmTBhwkLP+9FHH83zNWnSpJSXl6d3794ZOnRoPvroo1RXV+fuu+9Ojx495lnsfEH23HPP/N///V/uueeeVFVV5R//+Ef+8Ic/lPbPXZNq+vTpi/MIAAAAAKgFizVSqnHjxrn11lszfPjwHHHEEfnkk0+ywgorpFWrVrn++uuz0UYb5cILL8zgwYOz2267Zc6cOenatWtOOeWUhZ63S5cu87xu3rx5nnzyyZx44om59NJLs//++2fq1KlZf/31c8kll2SzzTb7zlrXXnvtXHLJJTn//PNzxhlnZNNNN822226bKVOmJEk23njjtGnTJtttt12GDRu2OI8BAAAAgKVUVjN3EablzIcffpgpU6bME2ANHjw4//73vzN06NBav15VVVXGjRuXVs//IRXvv17r5wcAAFiodTZM+tX+7zos32pqajJt2rSsuuqqpu9Ra0oZSatWC51SvFjT975PpkyZkv333z///Oc/kySvvvpqRo4cmR133LGOKwMAAABgsT997/tis802yymnnJJf//rX+fe//53mzZvnsMMOS48ePeq6NAAAAIB6b7kNpZJkn332yT777FPXZQAAAADwDcvt9D0AAAAAll1CKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAK16CuC1jurLFuUj2nrqsAAADqm+br1XUFAItFKFXb9hyQVFTUdRUAAEB9VF2dlJsQA3w/+NuqltXU1NR1CVCImpqaTJ8+Xc9Tr+h76hs9T32zXPS8QAr4HvE3FrDEqqqq6roEKJy+p77R89Q3eh6gOEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAKWWEVFRV2XAIXT99Q3ep76Rs9TH+l76kqDui5geVNWVlbXJUAhysrK0rRp07ouAwql76lv9Dz1jZ6nPtL3y4jq6qS8/o0bEkrVtnsvS/49vq6rAAAAAL4Pmq+X7D2wrquoE0Kp2vbJ+8mHb9V1FQAAAADLtPo3NgwAAACAOieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACldvQqkvv/wyH330UV2XAQAAAEDqIJSqrKzMmDFjlui9l156aTbddNO0bt16vq8JEyZk5MiR2X333ZMkY8aMSWVlZem9+++/f5566qlauQcAAAAAlk6Dui5gcbVt2zY33XTTt+5bf/31s8cee3zrvilTpvwnywIAAABgMSxz0/fuuOOO7L777tl6663Ts2fPjBw5cpHfe9ddd6Vr167zbT/ooIPywQcf5PTTT8+ZZ56ZJHn55ZfTt2/ftGvXLjvvvHNuuOGG1NTUJPlqRNZBBx2UvffeO+3bt8/f//732rk5AAAAAJIsYyOl7rrrrgwePDjDhw9P+/bt8+yzz+bII49MkyZNstNOOy3xea+77rp07do1Rx55ZHr16pWJEyfml7/8ZQYOHJjrrrsu48ePT//+/dO4cePsu+++SZKnn3461113XVq2bJlGjRrV1i0CAAAAkGUslPrjH/+YPn36pGPHjkmSjh07pk+fPrnttttKodTYsWPTtm3bed53wgkn5Oc///kiX2fkyJHZaKONcsABByRJfvKTn+Tggw/OzTffXAql1l9//VIdAAAAAP9JVVVVdV1CrVnUe1mmQqmPP/4466+//jzb1ltvvTz66KOl123atFngmlKL6v3338/LL788T7hVXV2dioqK0uu11lprqa4BAAAAsKhee+21zJw5s67LKNQyFUqtt956effdd+fZNmHChKy55pq1ep211147HTp0yLXXXlvaNmXKlHz22Wel12VlZbV6TQAAAIAFqaysrOsSak1VVVVeeuml7zyuThY6nzx5cj766KN5vubMmZPevXvn9ttvz9NPP52qqqo888wzuf3227P33nsv9TUbNmyY6dOnJ0l69uyZcePGZeTIkZkzZ04mTZqUww8/PIMHD17q6wAAAAAsroqKiuXqa1HUyUipY445Zr5to0aNym677ZYZM2bk7LPPzgcffJAWLVrkhBNOyF577bXU1+zdu3cuvvjivPTSS7nwwgtzzTXX5MILL8zZZ5+dioqK7LDDDjnllFOW+joAAAAAfLeympqamrouYnlQVVWVcePGpdXzf0jF+6/XdTkAAADA98E6Gyb9htZ1FbWqlJG0arXQUVN1Mn0PAAAAgPpNKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABROKAUAAABA4YRSAAAAABSuQV0XsNxZY92kek5dVwEAAAB8HzRfr64rqDNCqdq254CkoqKuqwAAAAC+L6qrk/L6N5mt/t3xf1hNTU1dlwCFqKmpyfTp0/U89Yq+p77R89Q3ep76SN8vI+phIJUIpYClUFVVVdclQOH0PfWNnqe+0fPUR/qeuiKUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQikAAAAACieUAgAAAKBwQilgiVVUVNR1CVA4fU99o+epb/Q89ZG+p640qOsCljdlZWV1XQIUoqysLE2bNq3rMqBQ+p76Rs9T3+h56iN9vwyprk7K69fYIaFUbbv3suTf4+u6CgAAAOD7ovl6yd4D67qKwgmlatsn7ycfvlXXVQAAAAAs0+rXuDAAAAAAlglCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKV29CqfHjx9d1CQAAAAD8/woLpbp27Zq77rprvu133XVXunbt+p3vHzNmTCorK9O6dev5vu6+++588MEHad26dT744IMkSWVlZcaMGZMkGTJkSEaMGFG7NwQAAADAEmtQ1wUsrhdeeGGx902ZMuU/VQ4AAAAAS2CZmb733nvvpbKyMjfddFM6d+6cNm3a5Pjjj8+MGTMW6/3vvffePNsvu+yy3Hfffbnvvvuyxx57JEk+/vjjHHfccencuXO23XbbnHbaaaXrjBkzJl26dMmxxx6btm3b5qqrrqrdGwUAAABg2Qml5nrkkUdy33335aGHHsr48eNzxhlnLNX5BgwYkJ49e6Znz54ZOXJkqqur079//5SXl+fhhx/Offfdl0mTJuW0004rveejjz7KhhtumKeffjr777//0t4SAAAAwHeqqqpabr4WxTI3fe+kk07K6quvniQ56qijcsQRR+Scc84p7W/btu08x3fr1i1DhgxZ5PP/85//zMsvv5zrr78+K620UpLkxBNPzK677ppTTz21dFzv3r2zwgorZIUVVlia2wEAAABYJK+99lpmzpxZ12UUprBQqmHDht+alFVVVaVhw4al1xtssEHp+3XWWSezZs3K1KlTS9uee+65parjvffeS1VVVbp06TJffRMmTCi9XmuttZbqOgAAAACLo7Kysq5LqBVVVVV56aWXvvO4wkKpddZZJ++///5828ePH59111239HrixInZcMMNk3wVIDVp0iTNmjXL22+/XSt1rL322mncuHHGjBmTioqKJMmsWbMyYcKEbLDBBhk7dmySpKysrFauBwAAALAo5uYU9UVha0rtueee+f3vf58nn3wy1dXVmTVrVv72t7/ljjvuSK9evUrHDR06NDNmzMjEiRNzySWXZM8991zqKXQNGzbM9OnTkyQtW7bMBhtskMGDB+ezzz7LF198kXPPPTe/+tWvFnnOIwAAAABLp7CRUnvttVdmz56dCy+8MO+++26qq6vz4x//OCeffHJ233330qfm/fCHP0yPHj0yc+bM9OzZM8cff/xSX7t79+4ZOHBgdthhh4wePTpXXnllhgwZkp133jlffvllWrZsmeuvvz6NGjVa6msBAAAA8N3Kampqauq6iOSrqXrdunXLX/7yl6y33np1Xc5iq6qqyrhx49Lq+T+k4v3X67ocAAAA4PtinQ2TfkPruopaU8pIWrVa6JTEwqbvAQAAAMBcQikAAAAAClfYmlLfZb311strr71W12UAAAAAUAAjpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMIJpQAAAAAonFAKAAAAgMI1qOsCljtrrJtUz6nrKgAAAIDvi+br1XUFdUIoVdv2HJBUVNR1FQAAAMD3SXV1Ul6/JrTVr7stQE1NTV2XAIWoqanJ9OnT9Tz1ir6nvtHz1Dd6nvpI3y9D6lkglQilgKVQVVVV1yVA4fQ99Y2ep77R89RH+p66IpQCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHBCKQAAAAAKJ5QCAAAAoHAN6rqA5UVNTU2SpKqqKmVlZXVcDfzn1dTUpLq6Ws9Tr+h76hs9T32j56mP9D3/CVVVVUn+X1ayIEKpWlJdXZ0k+ec//1nHlQAAAADUvblZyYKU1XxXbMUiqa6uzpw5c1JeXi5dBgAAAOqtuSPwGjRokPLyBa8cJZQCAAAAoHAWOgcAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEIpAAAAAAonlAIAAACgcEKpWvDJJ5+kf//+adu2bTp06JBzzjknc+bMqeuyoNZNnjw5O+20U8aMGVPa9o9//CP77LNPWrduna5du+aOO+6owwqhdrz66qs58MAD0759+3Tu3DknnHBCJk+enETPs/x6+umns88++2TrrbdO586dc9ZZZ+WLL75Iou9ZvlVVVaVv374ZNGhQaZueZ3k0atSobLbZZmndunXp6/jjj0+i56k7QqlacMwxx2TFFVfM448/njvvvDNPP/10brjhhrouC2rV2LFj06dPn7z77rulbdOmTcthhx2WvfbaK3//+99zzjnn5LzzzsuLL75Yh5XC0vniiy9yyCGHpHXr1nniiSdy//33Z+rUqTn55JP1PMutyZMnp1+/ftlvv/3y3HPP5e67786zzz6bq666St+z3Bs+fHiee+650ms9z/LqpZdeyp577pkXXnih9HXBBRfoeeqUUGopjR8/Ps8++2yOP/74NGnSJOuvv3769++fW265pa5Lg1pz991357jjjsvAgQPn2f7II49ktdVWywEHHJAGDRqkY8eO6dmzp/7ne+2DDz7IJptskgEDBqRhw4Zp1qxZ+vTpk7///e96nuXW6quvnqeeeiq9evVKWVlZpk6dmi+//DKrr766vme59vTTT+eRRx7JzjvvXNqm51levfTSS9liiy3m267nqUtCqaX0xhtvZLXVVkuLFi1K2zbaaKN88MEH+fTTT+uwMqg92267bf70pz+le/fu82x/4403svHGG8+z7Sc/+UleffXVIsuDWrXhhhvmmmuuSUVFRWnbww8/nM0331zPs1xbeeWVkyRdunRJz549s+aaa6ZXr176nuXWJ598klNOOSVDhw5NkyZNStv1PMuj6urqvPzyyxk9enR23HHHbL/99jn11FMzbdo0PU+dEkotpc8++2ye/4glKb3+/PPP66IkqHVrrrlmGjRoMN/2b+v/xo0b632WGzU1Nbn44ovz2GOP5ZRTTtHz1AuPPPJI/va3v6W8vDxHHXWUvme5VF1dneOPPz4HHnhgNtlkk3n26XmWR5MnT85mm22WXXbZJaNGjcptt92Wd955J8cff7yep04JpZbSiiuumJkzZ86zbe7rlVZaqS5KgsI0adKktAjuXF988YXeZ7kwY8aMHHXUUbnvvvty8803p7KyUs9TLzRu3DgtWrTI8ccfn8cff1zfs1y68sor07Bhw/Tt23e+fXqe5VHz5s1zyy23pHfv3mnSpEl+8IMf5Pjjj8/f/va31NTU6HnqjFBqKf3Xf/1Xpk6dmo8//ri07V//+lfWXnvtNG3atA4rg/+8jTfeOG+88cY82958883813/9Vx1VBLXj3Xffzd57750ZM2bkzjvvTGVlZRI9z/Lr+eefz6677ppZs2aVts2aNSsrrLBCfvKTn+h7ljv33ntvnn322bRt2zZt27bN/fffn/vvvz9t27b1dz3LpVdffTUXXnhhampqSttmzZqV8vLytGzZUs9TZ4RSS+lHP/pR2rRpk3PPPTczZszIhAkTcvnll6d37951XRr8x+200075+OOPc8MNN2T27Nl55plnct9992Xvvfeu69JgiU2bNi2//OUvs/XWW+faa6/N6quvXtqn51leVVZW5osvvsjQoUMza9asvP/++xkyZEh69+6dXXbZRd+z3HnooYfy/PPP57nnnstzzz2XHj16pEePHnnuuef8Xc9yabXVVsstt9ySa665JnPmzMkHH3yQCy64ID/72c/8PU+dKqv5elTKEvn4449z5plnZsyYMSkvL89ee+2V4447bp5FcmF5UVlZmRtvvDEdOnRI8tWneJxzzjl5/fXXs/rqq6d///7p1atXHVcJS+7666/P4MGD06RJk5SVlc2z74UXXtDzLLfefPPNnHvuuXnppZfStGnT9OzZs/QplPqe5d2gQYOSJIMHD07i/29YPj377LO56KKL8vrrr6dRo0bZfffdc/zxx6dRo0Z6njojlAIAAACgcKbvAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAAAAhRNKAQAAAFA4oRQAAPOZNGlSPv/887ouAwBYjgmlAIB6r7KyMpWVlXnrrbfm23f99densrIyl156aZLktNNOy2mnnbZU1zvkkENyxRVXLNU5FqSysjItW7ZM69at06pVq7Ru3Tp9+vTJn//850U+x8cff5xddtklkydPXuI6Zs+enf322y8TJkxIVVVVTjjhhGy99dbZdddd89xzz5WOmzBhQvbYY4/MmjVrnvefeuqpeeSRR5b4+gDAsk8oBQCQpFmzZrn77rvn237XXXdl5ZVXLr0+88wzc+aZZy7Vta655pocfvjhS3WOhbn66qvzwgsvZNy4cXnqqaey995755hjjskDDzywSO//4osvlnqU1GWXXZZ27dpl/fXXzxNPPJGxY8dm9OjR2X///XP++eeXjjv77LNz4oknpmHDhvO8/9e//nXOP//8pQrGAIBlm1AKACBJz549c++996a6urq07cUXX8ysWbOy2WablbYNGjQogwYNSpJMnDgxhxxySNq3b5/tt98+Rx55ZCZNmpQkeeONN3LAAQekXbt22XHHHXPiiSdmxowZSZK+ffuWRl4NGjQop512Wg4//PC0bt063bp1y4033li63pQpUzJw4MC0adMm3bp1y0033ZTNNtss77333iLdV5MmTfLzn/88Bx98cIYMGZKampokyaOPPpp99903HTt2zFZbbZVf/OIXeeedd1JVVZUePXokSXr06JFRo0Zl1qxZGTJkSHbbbbe0bt06HTt2zFlnnVU61zdNnjw5N954Yw444IAkSUVFRZKUji8v/+p/Qf/85z+nSZMm6dy583znaNasWTp37pxrrrlmke4TAPj+EUoBACTZYYcdMnv27Dz11FOlbXfeeWd69+69wPdcdNFFWXvttfPkk09m1KhR+fzzz3PVVVclSc4444x07Ngxzz77bP74xz/mlVdeyR133PGt57nrrrvSt2/f/P3vf8+hhx6awYMHZ+LEiUmS4447LtOnT89f/vKX3HHHHXnsscdSVVW1RPc3ceLEvPXWW/noo49y9NFH57DDDsvTTz+d0aNHp6amJpdddlkqKipy//33J0nuv//+dO/ePb/73e/y+OOP53e/+11eeOGFXH755bntttvyzDPPLPB+ttxyy7Ro0SJJ0qlTp3Tu3Dm77LJL/vjHP+bkk0/OzJkzM2zYsJx00kkLrLlHjx75wx/+kDlz5iz2/QIAyz6hFABAkgYNGqRnz56lKXxffPFFHn744ey1114LfE+jRo0yduzYPPDAA/nss89yzTXX5De/+U1p3+OPP56HHnoo5eXluffee3PggQd+63k6dOiQzp07p0GDBtl7771TVVWVd999NxMnTswTTzyRk08+OauttlpWX331nHzyyUt0f82aNUuSTJ06NauvvnoeeOCBdO3aNTNmzMhHH32UZs2alYKwb/r5z3+eG264IWuuuWYmTZqUL774IiuttNICj3/mmWfSunXr0uvy8vKceeaZeeaZZ3LvvfemZcuWGTFiRPbee+9MmTIlBxxwQHr16pXf//7385ynZcuW+fzzz/Pyyy8v0T0DAMs2oRQAwP+vV69e+fOf/5wZM2bkoYceytZbb50111xzgcf/5je/Sffu3XPttdemS5cu6dWrV2kR7//93//NVlttlYsvvjgdO3ZM375988Ybb3zreb5+jRVWWCFJUl1dnQ8//DBJst5665X2r7/++kt0b5988kmSZI011sgKK6yQ+++/P9tvv3123333XHTRRfnkk08WOB1v5syZOe2009K+ffscfPDBueeee1JTUzPPVMev+/DDD0ujpL7NW2+9lSeffDK/+MUvcsopp2S//fbL7373u1x66aV58803S8c1atQozZo1Kz0HAGD5IpQCAPj/bbLJJtlwww3z4IMP5q677lro1L0keeWVV9KnT5/cd999eeqpp9KmTZsceeSRqa6uziuvvJL/+Z//ySOPPJJHH300a6yxRmktqkX1gx/8IEny/vvvl7Z9/fvF8dhjj2XdddfNBhtskAcffDA333xzbrrppvz1r3/N1VdfPc+6Wd/0m9/8Jk2aNMkTTzyR++67L+edd94CA6nkq5FRC9t/9tln5+STT06DBg3yxhtvZPPNN0/Tpk3zwx/+cL7gbs6cOaU1qQCA5YtQCgDga3r16pUbbrghb7/9drp06bLQY6+44oqcddZZmTFjRlZZZZU0adIkzZo1S3l5ec4+++z87//+b7788susvvrqpVE/i2OttdbKjjvumAsuuCDTpk3LtGnT5vnkukXx+eef59Zbb81NN92Uk046KWVlZZk+fXrKy8vTuHHj1NTU5G9/+1vuueeezJ49O8lXI5SSlBZmnzFjRho1apTy8vLMmDEj559/fmbMmFE6/pt+8IMflBZ8/6ZRo0Zl7bXXTps2bZIkG2ywQV544YVMmTIlb7/9djbYYIPSsV9++WU+/fTTrLPOOot1zwDA94NQCgDga3r06JHx48dnjz32SIMGDRZ67Jlnnpnq6up069Yt7dq1yz/+8Y8MGzYsyVfT9/71r39l2223TadOnTJ9+vScddZZi13POeeck7Kysuywww752c9+VhrRNHea37c59NBD07p167Ru3To//elP85e//CUjRozITjvtlCT52c9+lk6dOmX33XfPNttskxEjRuSXv/xl3n777cyaNSvNmzfPTjvtlD59+uT3v/99fvOb3+TVV19N+/bts+uuu2bGjBnZbrvt8vrrr3/r9Tt37pyxY8fOt33GjBkZMWJEjjvuuNK2008/PVdccUV23XXX9O3bd54RW88//3xWX331hY7iAgC+v8pqFrR4AAAAde7JJ59MmzZt0rhx4yTJa6+9lr322ivjxo0rjWha1nz88cfZZZddMmrUqIWuLfVdTjvttKyyyirzhFgAwPLDSCkAgGXYkCFDMmLEiMyZM6c00qhTp07LbCCVJM2bN88vfvGL3HjjjUt8jsmTJ+evf/1rDjnkkFqsDABYlgilAACWYUOHDs24ceOyzTbbpGvXrqmoqFjsdaXqwoABA/Lcc8/l3XffXaL3Dx06NIMGDcpqq61Wu4UBAMsM0/cAAAAAKJyRUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAUTigFAAAAQOGEUgAAAAAU7v8DFXTYZZZAt+gAAAAASUVORK5CYII=", + "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": [ - "# Challenge evaluation\n", + "## 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", - "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." + "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": [ - "# Submission format\n", + "## 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", - "Here, you should describe the submission format. This is the format the participants should follow to submit their predictions on the codabench platform." + "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": {}, "source": [ - "## The submission file\n", + "# Challenge Evaluation\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." + "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": 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 +2167,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 +3506,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 +3536,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.10" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/tools/create_bundle.py b/tools/create_bundle.py index 9f612ec..53d265a 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..987fbf4 --- /dev/null +++ b/tools/create_starting_kit.py @@ -0,0 +1,77 @@ +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 + # ("final_phase/input_data", "final_phase/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 5bdc3a9..72e39eb 100644 --- a/tools/setup_data.py +++ b/tools/setup_data.py @@ -1,53 +1,95 @@ -# 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 numpy as np +import requests +import zipfile 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 = 1000000 +MAX_TEST_ROWS = 50000 # <--- Capping test size for efficiency -PHASE = 'dev_phase' +def run_setup(): + # 1. Directory Setup + 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) -DATA_DIR = Path(PHASE) / 'input_data' -REF_DIR = Path(PHASE) / 'reference_data' + # 2. Download & Extract (Skipped if exists) + zip_path = RAW_DIR / "GEMS-GER_data.zip" + if not zip_path.exists(): + 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) + + if not any(EXTRACT_DIR.iterdir()): + with zipfile.ZipFile(zip_path, 'r') as zip_ref: + zip_ref.extractall(EXTRACT_DIR) + # 3. Process Data + print("šŸ“Š Merging and optimizing memory...") + static_file = next(EXTRACT_DIR.rglob("*static*.csv")) + 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 = [] + 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.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']) -if __name__ == "__main__": + # 4. Strict Temporal Split + master_df = master_df.sort_values('date_dt') + unique_dates = sorted(master_df['date_dt'].unique()) + + # 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]] - 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 + # 5. Applying the Caps + if len(train_df) > MAX_TRAIN_ROWS: + train_df = train_df.tail(MAX_TRAIN_ROWS) + + # 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'] + 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!\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()