dslighting 1.3.9__py3-none-any.whl → 1.7.6__py3-none-any.whl

dslighting/registry/bike-sharing-demand/report.md

@@ -0,0 +1,179 @@
+# Predictive Analysis of Bike Sharing Demand Patterns and Environmental Influences
+
+This study presents a comprehensive analysis of bike-sharing demand patterns using a dataset spanning 8,708 hourly records from January 2011 to December 2012. The investigation reveals significant temporal patterns, environmental dependencies, and user behavior characteristics that collectively explain 191.6±181.0 daily rentals. Key findings demonstrate strong seasonal variations, temperature optimization effects, and distinct user segmentation between casual and registered riders.
+
+## 1. Materials and Processing
+
+### 1.1 Dataset Profile
+| Metric | Value |
+|--------|-------|
+| Total Records | 8,708 |
+| Date Range | 2011-01-01 to 2012-12-19 |
+| Features | 12 (datetime, weather, temporal, user metrics) |
+| Missing Values | 0% |
+| Target Variable | Count (bike rentals per hour) |
+
+### 1.2 Feature Engineering Strategy
+- **Temporal Decomposition**: Extracted hour, dayofweek, month, year from datetime
+- **Temperature Optimization**: Binned temperature into optimal ranges (32.96-36.98°C)
+- **User Segmentation**: Separated casual vs registered user patterns
+- **Weather Classification**: Categorized weather conditions (1-4 scale)
+- **Log Transformation**: Applied to target variable to address right-skewness (skewness reduced from 1.24 to -0.85)
+
+## 2. Results and Analysis
+
+### 2.1 Exploratory Visualizations
+
+![Figure 1: Temporal Demand Patterns](./visualizations/temporal_patterns.png)
+
+> **Insight 1:** Temporal analysis reveals pronounced diurnal patterns with peak demand at 17:00 (462.2 rentals) and minimum at 04:00 (6.5 rentals), representing a 455.7-bike amplitude. Monthly patterns show summer peak (June: 242.0 rentals) and winter trough (January: 91.6 rentals). Year-over-year growth of 65.0% indicates rapid system adoption (2011: 144.5 vs 2012: 238.4 rentals).
+
+![Figure 2: Weather Impact Analysis](./visualizations/weather_impact.png)
+
+> **Insight 2:** Environmental factors demonstrate significant predictive power. Temperature shows moderate positive correlation (r=0.390) with optimal range of 32.96-36.98°C yielding 347.1 rentals. Humidity exhibits negative correlation (r=-0.318) with demand reduction of 72.8% above 80% humidity. Weather condition 1 (clear) generates 205.6 rentals versus 118.5 for condition 3 (light rain/snow), representing a 42.3% reduction.
+
+![Figure 3: Correlation Structure](./visualizations/correlation_matrix.png)
+
+> **Insight 3:** Correlation analysis identifies registered users as the strongest predictor (r=0.971), highlighting the importance of user segmentation. High multicollinearity exists between temperature and apparent temperature (r=0.985), suggesting feature reduction potential. The weak windspeed correlation (r=0.099) indicates limited predictive value for this variable.
+
+![Figure 4: User Behavior Patterns](./visualizations/workday_holiday_analysis.png)
+
+> **Insight 4:** User segmentation reveals distinct behavioral patterns. Registered users dominate overall composition (81.2%) with peak usage at 17:00 (386.7 users). Casual users show 132.0% weekend growth versus registered users' 23.2% decline, indicating complementary usage patterns. Workdays exhibit registered user dominance (168.2 vs 25.1 casual), while weekends show more balanced distribution.
+
+## 3. Discussion and Insights
+
+The analysis reveals three critical demand drivers: (1) temporal patterns accounting for commuting behaviors, (2) environmental optimization with temperature thresholds, and (3) user segmentation explaining 97.1% of variance through registered user patterns. The right-skewed distribution (mean: 191.6, std: 181.0) suggests zero-inflated or Poisson regression approaches may be appropriate.
+
+Notable anomalies include the unexpected performance of weather condition 4 (164.0 rentals) exceeding condition 3 (118.5 rentals), potentially indicating data quality issues or special circumstances. The weekend vs weekday similarity (188.5 vs 192.8 rentals) masks important compositional differences revealed through user segmentation.
+
+## 4. Recommendations
+
+1. **Modeling Strategy**: Implement gradient boosting with temporal features, temperature optimization bins, and user segmentation as primary predictors
+2. **Feature Selection**: Exclude windspeed due to weak correlation (r=0.099) and address temperature/apparent temperature multicollinearity
+3. **Data Transformation**: Apply log transformation to target variable to normalize distribution
+4. **Validation Approach**: Use temporal cross-validation to account for seasonality and growth trends
+5. **Business Applications**: Optimize bike redistribution based on time-of-day patterns and weather forecasts, with special attention to temperature and humidity thresholds
+
+
+# Technical Solution Report: bike-sharing-demand
+
+## 1. Performance Statistics
+
+| Attribute | Result Value | Unit/Type |
+| :--- | :--- | :--- |
+| **Evaluation Score** | **0.3482** | Metric-Specific |
+| **Compute Resources** | `$0.0245` | USD |
+
+## 2. Methodology and Implementation Details
+
+Ensemble-Free Random Forest Regression with Temporal Feature Engineering for Bike-Sharing Demand Forecasting
+
+This study presents a predictive modeling approach for the bike-sharing demand forecasting task, utilizing a single Random Forest Regressor. The core methodological contributions are the comprehensive engineering of temporal features from datetime stamps and the application of cyclical encoding to capture periodic patterns. The model is trained to predict the total hourly rental count, with predictions post-processed to ensure non-negativity and integer values. Validation results indicate a baseline level of performance, establishing a foundation for more complex ensemble methods.
+
+The data preprocessing pipeline begins by parsing datetime strings into a structured format, enabling the extraction of fundamental temporal components including hour, day, month, year, and day of the week. A key innovation is the application of cyclical encoding to the hour and month variables, transforming them into sine and cosine components to preserve the continuous, periodic nature of these features and mitigate the arbitrary discontinuity inherent in their raw integer forms. Additional engineered features include a binary indicator for weekends. The pipeline handles both training and test sets identically, utilizing features such as season, weather conditions, and temperature without any explicit handling of missing data, suggesting the dataset is presumed complete.
+
+The model architecture employs a single Random Forest Regressor, an ensemble method based on bagging decision trees. The hyperparameters were specified with a focus on regularization to prevent overfitting: 100 estimators, a maximum tree depth of 15, a minimum of 5 samples required to split an internal node, and a minimum of 5 samples required to be at a leaf node. The model operates natively as a regressor predicting continuous values. Notably, the approach is an ensemble only in the context of the Random Forest algorithm itself and does not implement a broader ensemble strategy combining multiple, diverse model types.
+
+The validation strategy utilizes a standard holdout method, partitioning the training data via an 80-20 split with a fixed random state. The primary evaluation metric is the Root Mean Squared Logarithmic Error (RMSLE), chosen for its sensitivity to relative errors and appropriateness for predicting count data that can span several orders of magnitude. A critical post-processing step is applied to validation and test predictions, clamping all negative values to zero using `np.maximum` to align with the non-negative domain of the target variable, followed by rounding to the nearest integer for the final submission.
+
+## 3. Appendix: Source Code
+
+```python
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import mean_squared_log_error
+import warnings
+warnings.filterwarnings('ignore')
+
+# Load data
+train_df = pd.read_csv('train.csv')
+test_df = pd.read_csv('test.csv')
+
+# Preprocessing function
+def preprocess_data(df):
+    df = df.copy()
+    df['datetime'] = pd.to_datetime(df['datetime'])
+    
+    # Extract time-based features
+    df['hour'] = df['datetime'].dt.hour
+    df['day'] = df['datetime'].dt.day
+    df['month'] = df['datetime'].dt.month
+    df['year'] = df['datetime'].dt.year
+    df['dayofweek'] = df['datetime'].dt.dayofweek
+    
+    # Cyclical encoding for hour and month
+    df['hour_sin'] = np.sin(2 * np.pi * df['hour']/24)
+    df['hour_cos'] = np.cos(2 * np.pi * df['hour']/24)
+    df['month_sin'] = np.sin(2 * np.pi * df['month']/12)
+    df['month_cos'] = np.cos(2 * np.pi * df['month']/12)
+    
+    # Weekend feature
+    df['is_weekend'] = (df['dayofweek'] >= 5).astype(int)
+    
+    return df
+
+# Preprocess both datasets
+train_processed = preprocess_data(train_df)
+test_processed = preprocess_data(test_df)
+
+# Define features and target
+features = ['season', 'holiday', 'workingday', 'weather', 'temp', 'atemp', 
+            'humidity', 'windspeed', 'hour', 'day', 'month', 'year', 
+            'dayofweek', 'hour_sin', 'hour_cos', 'month_sin', 'month_cos', 'is_weekend']
+
+X = train_processed[features]
+y = train_processed['count']
+
+X_test = test_processed[features]
+
+# Split training data for validation
+X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Random Forest model
+rf_model = RandomForestRegressor(
+    n_estimators=100,
+    max_depth=15,
+    min_samples_split=5,
+    min_samples_leaf=5,
+    random_state=42,
+    n_jobs=-1
+)
+
+# Train model
+rf_model.fit(X_train, y_train)
+
+# Validation predictions
+val_pred = rf_model.predict(X_val)
+val_pred = np.maximum(0, val_pred)  # Ensure non-negative predictions
+
+# Calculate RMSLE on validation set
+val_rmsle = np.sqrt(mean_squared_log_error(y_val, val_pred))
+print(f"Validation RMSLE: {val_rmsle:.4f}")
+
+# Feature importance
+importance_df = pd.DataFrame({
+    'feature': features,
+    'importance': rf_model.feature_importances_
+}).sort_values('importance', ascending=False)
+
+print("\nTop 10 Feature Importances:")
+print(importance_df.head(10))
+
+# Final predictions on test set
+test_pred = rf_model.predict(X_test)
+test_pred = np.maximum(0, test_pred)  # Ensure non-negative predictions
+
+# Create submission file
+submission_df = pd.DataFrame({
+    'datetime': test_df['datetime'],
+    'count': test_pred.round().astype(int)  # Round to integer counts
+})
+
+# Save submission file
+submission_df.to_csv('submission_bike-sharing-demand_152d17.csv', index=False)
+print(f"\nSubmission file saved successfully with {len(submission_df)} predictions")
+```
+---
+*Report automatically generated by DSLighting Lead Researcher Tool.*

dslighting/registry/billion-word-imputation/checksums.yaml

@@ -0,0 +1,5 @@
+private:
+  sample_submission.csv: b734f937cbff4fbc88b2cfccc5d12d58
+  test.csv: 5340d30e22b84bf14de19b9c877b16e3
+public: {}
+zip: 70a08536f59df46f1d2c9d4bfeae4b0b

dslighting/registry/billion-word-imputation/config.yaml

@@ -0,0 +1,16 @@
+id: billion-word-imputation
+name: Billion Word Imputation
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/billion-word-imputation/description.md
+
+dataset:
+  answers: billion-word-imputation/prepared/private/test.csv
+  sample_submission: billion-word-imputation/prepared/private/sample_submission.csv
+
+grader:
+  name: levenshtein-distance
+  grade_fn: mlebench.competitions.billion-word-imputation.grade:grade
+
+preparer: mlebench.competitions.billion-word-imputation.prepare:prepare

dslighting/registry/billion-word-imputation/description.md

@@ -0,0 +1,52 @@
+# Overview
+
+## Overview
+
+### Description
+
+![corpus](https://storage.googleapis.com/kaggle-media/competitions/kaggle/3927/media/corpus.png)This competition uses the billion-word benchmark corpus provided by [Chelba et al.](http://arxiv.org/abs/1312.3005) for language modeling. Rather than ask participants to create a classic language model and evaluate sentence probabilities -- a task which is difficult to faithfully score in Kaggle's supervised ML setting -- we have introduced a variation on the language modeling task.
+
+For each sentence in the test set, we have removed exactly one word. Participants must create a model capable of inserting back the correct missing word at the correct location in the sentence. Submissions are scored using an edit distance to allow for partial credit.
+
+We extend our thanks to authors who created this corpus and shared it for the research community to use. Please cite this paper if you use this dataset in your research: *Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn: One Billion Word Benchmark for Measuring Progress in Statistical Language Modeling, CoRR, 2013.*
+
+Note: the train/test split used in this competition is different than the published version used for language modeling. If you are creating full language models and scoring perplexity, you should download the official version of the corpus from the authors' website.
+
+### Evaluation
+
+Submissions are evaluated on the mean [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance) between the sentences you submit and the original sentences in the test set.
+
+*Note: due to the size and computations necessary to score submissions for this competition, scoring may take 5-10 minutes, and possibly longer if there are other submissions in front of yours. Please be patient!*
+
+#### Submission File
+
+Your submission file should contain the sentence id and a predicted sentence. To prevent parsing issues, you should use double quotes to escape the sentence text and two double quotes ("") for double quotes within a sentence. Note that test.csv is a valid submission file itself.
+
+The file should contain a header and have the following format:
+
+```
+id,"sentence"
+1,"Former Dodgers manager , the team 's undisputed top ambassador , is going strong at 83 and serving up one great story after another ."
+2,"8 parliamentary elections meant to restore democracy in this nuclear armed nation , a key ally against Islamic ."
+3,"Sales of drink are growing 37 per cent month-on-month from a small base ."
+etc...
+```
+
+### Citation
+
+Will Cukierski. (2014). Billion Word Imputation. Kaggle. https://kaggle.com/competitions/billion-word-imputation
+
+# Data
+
+## Dataset Description
+
+The data for this competition is a large corpus of English language sentences. You should use only the sentences in the training set to build you model.
+
+We have removed one word from each sentence in the test set. The location of the removed word was chosen uniformly randomly and is never the first or last word of the sentence (in this dataset, the last word is always a period). You must attempt to submit the sentences in the test set with the correct missing word located in the correct location. 
+
+Note: the train/test split used in this competition is different than the published version used for language modeling. If you are creating full language models and scoring perplexity, you should download the official version of the corpus from the authors' website.
+
+## File descriptions
+
+- **train.txt** - the training set, contains a large collection of English language sentences
+- **test.txt** - the test set, contains a large number of sentences where one word has been removed

dslighting/registry/billion-word-imputation/description_obfuscated.md

@@ -0,0 +1,32 @@
+# Overview
+
+Given sentences with one word removed, create a model capable of inserting back the correct missing word at the correct location in the sentence.
+
+# Task
+
+Levenshtein distance between submitted sentences and the original sentences.
+
+# Submission Format
+
+Your submission file should contain the sentence id and a predicted sentence. Use double quotes to escape the sentence text and two double quotes ("") for double quotes within a sentence.
+
+The file should contain a header and have the following format:
+
+```
+id,"sentence"
+1,"Former Dodgers manager , the team 's undisputed top ambassador , is going strong at 83 and serving up one great story after another ."
+2,"8 parliamentary elections meant to restore democracy in this nuclear armed nation , a key ally against Islamic ."
+3,"Sales of drink are growing 37 per cent month-on-month from a small base ."
+etc...
+```
+
+# Dataset
+
+You should use only the sentences in the training set to build you model.
+
+We have removed one word from each sentence in the test set. The location of the removed word was chosen uniformly randomly and is never the first or last word of the sentence (in this dataset, the last word is always a period). You must attempt to submit the sentences in the test set with the correct missing word located in the correct location. 
+
+## File descriptions
+
+- **train.txt** - the training set, contains a large collection of English language sentences
+- **test.txt** - the test set, contains a large number of sentences where one word has been removed

dslighting/registry/billion-word-imputation/grade.py

@@ -0,0 +1,37 @@
+import numpy as np
+import pandas as pd
+from Levenshtein import distance
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame) -> None:
+    id_col = "id"
+    target_col = "sentence"
+
+    assert id_col in answers.columns, f"Missing {id_col} column in answers"
+    assert target_col in answers.columns, f"Missing {target_col} column in answers"
+
+    if id_col not in submission.columns:
+        raise InvalidSubmissionError(f"Missing {id_col} column in submission")
+    if target_col not in submission.columns:
+        raise InvalidSubmissionError(f"Missing {target_col} column in submission")
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission and answers have different lengths: {len(submission)} vs {len(answers)}"
+        )
+
+    submission = submission.sort_values(id_col).reset_index(drop=True)
+    answers = answers.sort_values(id_col).reset_index(drop=True)
+
+    if (submission[id_col].values != answers[id_col].values).any():
+        raise InvalidSubmissionError("Submission and answers should contain the same IDs")
+
+    return submission[target_col], answers[target_col]
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    y_pred, y_true = prepare_for_metric(submission, answers)
+    mean_levenshtein = np.mean([distance(a, b) for a, b in zip(y_true, y_pred)])
+    return mean_levenshtein

dslighting/registry/billion-word-imputation/prepare.py

@@ -0,0 +1,107 @@
+import os
+import shutil
+import zipfile
+from pathlib import Path
+
+import numpy as np
+from tqdm.auto import tqdm
+
+from mlebench.utils import extract, get_logger
+
+np_rng = np.random.RandomState(0)
+
+logger = get_logger(__name__)
+
+
+def count_lines_in_file(file_path):
+    line_count = 0
+    with open(file_path, "r") as file:
+        for _line in file:
+            line_count += 1
+    return line_count
+
+
+def compress_file_to_zip(src_file: Path, zip_file: Path):
+    with zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED) as zipf:
+        zipf.write(src_file, arcname=src_file.name)
+
+
+def remove_random_word(sentence: str) -> str:
+    """
+    Remove a random 'word' (sequence of characters, delimited by whitespace) from a sentence.
+    Does not remove first or last words.
+
+    Punctuation counts as a word, and is already separated by whitespace.
+    """
+    words = sentence.split()
+    index = np_rng.randint(1, len(words) - 1)
+    return " ".join(words[:index] + words[index + 1 :])
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    logger.info("Extracting raw / train_v2.txt.zip")
+    extract(raw / "train_v2.txt.zip", raw)
+
+    # computed this ahead of time
+    total_lines = 30301028
+
+    with (
+        open(raw / "train_v2.txt", "r") as old_train,
+        open(public / "train_v2.txt", "w") as public_train,
+        open(public / "test_v2.txt", "w") as public_test,
+        open(private / "test.csv", "w") as private_test,
+    ):
+        public_test.write('"id","sentence"\n')
+        private_test.write('"id","sentence"\n')
+        line_count = 0
+        test_count = 0
+        train_count = 0
+        # there is one sentence per line
+        for sentence in tqdm(old_train, desc="Processing data", total=total_lines):
+            # we will put ~0.01 of the data in test, the rest in train, matching kaggle's original split
+            # some sentences only have 2 words, so can't remove a word -- keep them in train
+            if np_rng.uniform() <= 0.01 and len(sentence.strip().split()) > 2:
+                # get rid of linebreak and escape quotes
+                sentence = sentence.strip().replace('"', '""')
+                removed_word_sentence = remove_random_word(sentence)
+                private_test.write(f'{test_count},"{sentence}"\n')
+                public_test.write(f'{test_count},"{removed_word_sentence}"\n')
+                test_count += 1
+            else:
+                public_train.write(sentence)
+                train_count += 1
+            line_count += 1
+            if line_count >= total_lines:
+                break
+
+    # we will be compressing the public files (to match what's on kaggle.com)
+    # so copy our sample submission to private so we have access to it
+    shutil.copy(public / "test_v2.txt", private / "sample_submission.csv")
+
+    # compress the public files
+    logger.info("Compressing train_v2.txt")
+    compress_file_to_zip(public / "train_v2.txt", public / "train_v2.txt.zip")
+    logger.info("Compressing test_v2.txt")
+    compress_file_to_zip(public / "test_v2.txt", public / "test_v2.txt.zip")
+    # remove the original files
+    (public / "train_v2.txt").unlink()
+    (public / "test_v2.txt").unlink()
+
+    # Checks
+    assert not (public / "train_v2.txt").exists(), "public / 'train_v2.txt' should not exist"
+    assert (public / "train_v2.txt.zip").exists(), "public / 'train_v2.txt.zip' should exist"
+    assert not (public / "test_v2.txt").exists(), "public / 'test_v2.txt' should not exist"
+    assert (public / "test_v2.txt.zip").exists(), "public / 'test_v2.txt.zip' should exist"
+
+    private_test_line_count = count_lines_in_file(private / "test.csv")
+    assert (
+        # minus 2 to exclude header
+        private_test_line_count - 1
+        == test_count
+    ), "private / 'test.csv' has incorrect number of lines"
+    assert (
+        count_lines_in_file(private / "sample_submission.csv") == private_test_line_count
+    ), "private / 'sample_submission.csv' has incorrect number of lines"
+    assert (
+        test_count + train_count == total_lines
+    ), "Expected the number of test samples and train samples to sum to the total number of samples in the original train file"

dslighting/registry/billion-word-imputation/prepare_val.py

@@ -0,0 +1,179 @@
+import os
+import shutil
+import zipfile
+from pathlib import Path
+
+import numpy as np
+from tqdm.auto import tqdm
+
+from mlebench.utils import extract, get_logger
+
+np_rng = np.random.RandomState(0)
+
+logger = get_logger(__name__)
+
+
+def count_lines_in_file(file_path):
+    line_count = 0
+    with open(file_path, "r", encoding="utf-8") as file:
+        for _line in file:
+            line_count += 1
+    return line_count
+
+
+def compress_file_to_zip(src_file: Path, zip_file: Path):
+    with zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED) as zipf:
+        zipf.write(src_file, arcname=src_file.name)
+
+
+def remove_random_word(sentence: str) -> str:
+    """
+    Remove a random 'word' (sequence of characters, delimited by whitespace) from a sentence.
+    Does not remove first or last words.
+
+    Punctuation counts as a word, and is already separated by whitespace.
+    """
+    words = sentence.split()
+    index = np_rng.randint(1, len(words) - 1)
+    return " ".join(words[:index] + words[index + 1 :])
+
+
+def _split_and_process_data(
+    input_file: Path,
+    output_train_file: Path,
+    output_public_test_file: Path,
+    output_private_test_file: Path,
+    total_lines: int,
+) -> tuple[int, int]:
+    """
+    Helper function to perform the core data splitting and processing logic.
+
+    Reads from an input file and splits it into a train and test set based on a
+    probabilistic condition, writing them to the specified output files.
+    """
+    with (
+        open(input_file, "r", encoding="utf-8") as old_train,
+        open(output_train_file, "w", encoding="utf-8") as public_train,
+        open(output_public_test_file, "w", encoding="utf-8") as public_test,
+        open(output_private_test_file, "w", encoding="utf-8") as private_test,
+    ):
+        public_test.write('"id","sentence"\n')
+        private_test.write('"id","sentence"\n')
+        test_count = 0
+        train_count = 0
+        # there is one sentence per line
+        for sentence in tqdm(old_train, desc=f"Processing {input_file.name}", total=total_lines):
+            # we will put ~0.01 of the data in test, the rest in train, matching kaggle's original split
+            # some sentences only have 2 words, so can't remove a word -- keep them in train
+            if np_rng.uniform() <= 0.01 and len(sentence.strip().split()) > 2:
+                # get rid of linebreak and escape quotes
+                sentence_clean = sentence.strip().replace('"', '""')
+                removed_word_sentence = remove_random_word(sentence_clean)
+                private_test.write(f'{test_count},"{sentence_clean}"\n')
+                public_test.write(f'{test_count},"{removed_word_sentence}"\n')
+                test_count += 1
+            else:
+                public_train.write(sentence)
+                train_count += 1
+    return train_count, test_count
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    logger.info("Extracting raw / train_v2.txt.zip")
+    extract(raw / "train_v2.txt.zip", raw)
+
+    # Define and create the new validation directories
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+    public_val.mkdir(exist_ok=True, parents=True)
+    private_val.mkdir(exist_ok=True, parents=True)
+
+    # --- 1. Original Split (raw -> train/test) ---
+    logger.info("--- Generating original train/test split ---")
+    # computed this ahead of time
+    total_lines = 30301028
+    original_train_count, original_test_count = _split_and_process_data(
+        input_file=raw / "train_v2.txt",
+        output_train_file=public / "train_v2.txt",
+        output_public_test_file=public / "test_v2.txt",
+        output_private_test_file=private / "test.csv",
+        total_lines=total_lines,
+    )
+    assert (
+        original_train_count + original_test_count == total_lines
+    ), "Sum of train and test samples must equal total samples for original split."
+
+    # --- 2. Second Split (train -> train_val/test_val) ---
+    logger.info("--- Generating validation split from the new training set ---")
+    # The input for the second split is the training set from the first split.
+    val_split_input_file = public / "train_v2.txt"
+    val_split_total_lines = original_train_count
+    val_train_count, val_test_count = _split_and_process_data(
+        input_file=val_split_input_file,
+        output_train_file=public_val / "train_v2.txt",
+        output_public_test_file=public_val / "test_v2.txt",
+        output_private_test_file=private_val / "test.csv",
+        total_lines=val_split_total_lines,
+    )
+    assert (
+        val_train_count + val_test_count == val_split_total_lines
+    ), "Sum of train_val and test_val samples must equal total samples for validation split."
+
+    # --- 3. Process and Compress Original public/private directories ---
+    logger.info("--- Compressing and cleaning up original public/private directories ---")
+    # we will be compressing the public files (to match what's on kaggle.com)
+    # so copy our sample submission to private so we have access to it
+    shutil.copy(public / "test_v2.txt", private / "sample_submission.csv")
+
+    # compress the public files
+    logger.info("Compressing train_v2.txt")
+    compress_file_to_zip(public / "train_v2.txt", public / "train_v2.txt.zip")
+    logger.info("Compressing test_v2.txt")
+    compress_file_to_zip(public / "test_v2.txt", public / "test_v2.txt.zip")
+    # remove the original files
+    (public / "train_v2.txt").unlink()
+    (public / "test_v2.txt").unlink()
+
+    # --- 4. Process and Compress New public_val/private_val directories ---
+    logger.info("--- Compressing and cleaning up validation public_val/private_val directories ---")
+    # Replicate the process for the validation set
+    shutil.copy(public_val / "test_v2.txt", private_val / "sample_submission.csv")
+
+    # compress the public_val files
+    logger.info("Compressing validation train_v2.txt")
+    compress_file_to_zip(public_val / "train_v2.txt", public_val / "train_v2.txt.zip")
+    logger.info("Compressing validation test_v2.txt")
+    compress_file_to_zip(public_val / "test_v2.txt", public_val / "test_v2.txt.zip")
+    # remove the original files
+    (public_val / "train_v2.txt").unlink()
+    (public_val / "test_v2.txt").unlink()
+
+    # --- 5. Final Checks ---
+    logger.info("--- Running final checks ---")
+    # Original Checks
+    assert not (public / "train_v2.txt").exists(), "public / 'train_v2.txt' should not exist"
+    assert (public / "train_v2.txt.zip").exists(), "public / 'train_v2.txt.zip' should exist"
+    assert not (public / "test_v2.txt").exists(), "public / 'test_v2.txt' should not exist"
+    assert (public / "test_v2.txt.zip").exists(), "public / 'test_v2.txt.zip' should exist"
+
+    private_test_line_count = count_lines_in_file(private / "test.csv")
+    assert (
+        private_test_line_count - 1 == original_test_count
+    ), "private / 'test.csv' has incorrect number of lines"
+    assert (
+        count_lines_in_file(private / "sample_submission.csv") == private_test_line_count
+    ), "private / 'sample_submission.csv' has incorrect number of lines"
+
+    # New Checks for Validation Set
+    assert not (public_val / "train_v2.txt").exists(), "public_val / 'train_v2.txt' should not exist"
+    assert (public_val / "train_v2.txt.zip").exists(), "public_val / 'train_v2.txt.zip' should exist"
+    assert not (public_val / "test_v2.txt").exists(), "public_val / 'test_v2.txt' should not exist"
+    assert (public_val / "test_v2.txt.zip").exists(), "public_val / 'test_v2.txt.zip' should exist"
+
+    private_val_test_line_count = count_lines_in_file(private_val / "test.csv")
+    assert (
+        private_val_test_line_count - 1 == val_test_count
+    ), "private_val / 'test.csv' has incorrect number of lines"
+    assert (
+        count_lines_in_file(private_val / "sample_submission.csv") == private_val_test_line_count
+    ), "private_val / 'sample_submission.csv' has incorrect number of lines"

dslighting/registry/bms-molecular-translation/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: 9d0cf13e5b604a31bb4dd77faaead8ae
+public:
+  extra_approved_InChIs.csv: 24301ba135996bd369cc83740e01f8c8
+  sample_submission.csv: fb64d50adadf358d780b001dc14daa47
+  train_labels.csv: 35513e9a1d7f42bfa97f93b0476abc4c
+zip: b8268fc1e7d4be3b172fb7d90a86bdf6

dslighting/registry/bms-molecular-translation/config.yaml

@@ -0,0 +1,22 @@
+id: bms-molecular-translation
+name: Bristol-Myers Squibb - Molecular Translation
+competition_type: simple
+awards_medals: true
+prizes:
+  - position: 1
+    value: 25000
+  - position: 2
+    value: 15000
+  - position: 3
+    value: 10000
+description: mlebench/competitions/bms-molecular-translation/description.md
+
+dataset:
+  answers: bms-molecular-translation/prepared/private/test.csv
+  sample_submission: bms-molecular-translation/prepared/public/sample_submission.csv
+
+grader:
+  name: levenshtein-distance
+  grade_fn: mlebench.competitions.bms-molecular-translation.grade:grade
+
+preparer: mlebench.competitions.bms-molecular-translation.prepare:prepare