Hugging Face's logo

Datasets:
EHTB
/
erp-classifier-dataset

Tasks:
Text Classification
Tabular Classification
Modalities:
Tabular
Text
Formats:
parquet
Languages:
English
German
French
Size:
< 1K
Tags:
erp
accounting
gl-classification
multimodal
synthetic-data
Libraries:
Datasets
pandas
Polars
License:
Dataset card Data Studio Files
xet
 Community
erp-classifier-dataset / README.md
EHTB's picture
EHTB
Add clear source vs. derived data distinction in file descriptions
84896f6 verified
preview code
|
Raw History Blame Contribute Delete
10.8 kB
metadata 
license: mit
task_categories:
  - text-classification
  - tabular-classification
language:
  - en
  - de
  - fr
tags:
  - erp
  - accounting
  - gl-classification
  - multimodal
  - synthetic-data
size_categories:
  - n<1K

ERP GL Account Classifier - Dataset

Synthetic ERP transaction data for training multimodal GL account classifiers.

Dataset Details

  • Total samples: 942 (659 train / 141 val / 142 test)
  • Classes: 8 GL accounts
  • Features: Text (vendor + description), Numerical (amount + log amount), Categorical (department)
  • Generated using: AWS Bedrock (Amazon Nova Pro)
  • Cost: $1.40
  • Quality: 94% pass rate through zero-shot critic

Quick Start 

from datasets import load_dataset
import json
from huggingface_hub import hf_hub_download

# Load dataset
dataset = load_dataset("EHTB/erp-classifier-dataset")

# Load auxiliary files for decoding
scaler_path = hf_hub_download(repo_id="EHTB/erp-classifier-dataset", filename="scaler.json", repo_type="dataset")
vocab_path = hf_hub_download(repo_id="EHTB/erp-classifier-dataset", filename="dept_vocab.json", repo_type="dataset")

with open(scaler_path) as f:
    scaler = json.load(f)
with open(vocab_path) as f:
    dept_vocab = json.load(f)

print(dataset['train'][0])

Schema Documentation

Each record contains 4 fields:

1. text (string)

Format: "[VENDOR] {vendor_name} [DESC] {description}"

Example: "[VENDOR] Amazon Services Europe [DESC] Dell UltraSharp U2723DE 27 USB-C Monitor"

Note: Price and department are intentionally excluded from text. The model must learn to use numerical and categorical features for classification.

2. num_features (list of 2 floats)

Format: [normalized_amount, normalized_log_amount]

What it contains:

  • num_features[0]: StandardScaler-normalized net_amount_eur
  • num_features[1]: StandardScaler-normalized log1p(net_amount_eur)

Derivation:

import numpy as np

# Original transaction
net_amount_eur = 57.33  # EUR

# Create raw features
raw_features = [
    net_amount_eur,           # 57.33
    np.log1p(net_amount_eur)  # 4.0661
]

# Normalize using scaler fitted on TRAINING data only
# (Download scaler.json from this dataset)
mean = [345.43, 5.08]
std = [508.62, 1.22]
num_features = (raw_features - mean) / std
# Result: [-0.566, -0.831]

Why two features?

  • Feature 0: Direct amount for learning absolute thresholds (800 EUR boundary)
  • Feature 1: Log-transformed amount for balanced gradient descent across price ranges
    • Without log: 2000 EUR has 200× more signal than 10 EUR
    • With log: log1p(10)=2.40, log1p(500)=6.22, log1p(2000)=7.60 (compressed scale)

To denormalize (get original EUR amount):

import numpy as np

normalized = [-0.566, -0.831]
mean = [345.43, 5.08]
std = [508.62, 1.22]

denormalized = (np.array(normalized) * std) + mean
net_amount_eur = denormalized[0]  # 57.33 EUR

3. dept_id (integer)

Department category encoded as integer.

Mapping (see dept_vocab.json):

{
  "0": "UNK",          // Unknown department
  "1": "ENG",          // Engineering
  "2": "FACILITIES",   // Facilities management
  "3": "HR",           // Human Resources
  "4": "IT_OPS",       // IT Operations
  "5": "MARKETING"     // Marketing
}

Example: dept_id: 4 → IT_OPS

4. label (integer)

GL account class (target variable).

Mapping:

{
  "0": "GL_6220_IT_PERIPHERALS_OPEX",           // IT hardware < 800 EUR
  "1": "GL_1400_IT_HARDWARE_CAPEX",             // IT hardware >= 800 EUR
  "2": "GL_6400_OFFICE_CONSUMABLES",            // Office supplies
  "3": "GL_6410_FACILITY_PANTRY",               // Coffee, snacks
  "4": "GL_6150_MARKETING_PROMO",               // Promotional materials
  "5": "GL_6310_WORKPLACE_SAFETY_ERGONOMICS",   // Ergonomic equipment
  "6": "GL_6250_TECH_BOOKS_TRAINING",           // Books, training
  "7": "GL_6450_CLEANING_MAINTENANCE"           // Cleaning supplies
}

Example: label: 6 → GL_6250_TECH_BOOKS_TRAINING

Complete Example: Decoding a Record 

from datasets import load_dataset
import numpy as np
import json
from huggingface_hub import hf_hub_download

# Load dataset
dataset = load_dataset("EHTB/erp-classifier-dataset")
sample = dataset['train'][0]

# Load scaler and vocabularies
scaler_path = hf_hub_download(repo_id="EHTB/erp-classifier-dataset", filename="scaler.json", repo_type="dataset")
vocab_path = hf_hub_download(repo_id="EHTB/erp-classifier-dataset", filename="dept_vocab.json", repo_type="dataset")

with open(scaler_path) as f:
    scaler = json.load(f)
with open(vocab_path) as f:
    dept_vocab = json.load(f)

# GL account mapping
LABEL_MAP = {
    0: "GL_6220_IT_PERIPHERALS_OPEX",
    1: "GL_1400_IT_HARDWARE_CAPEX",
    2: "GL_6400_OFFICE_CONSUMABLES",
    3: "GL_6410_FACILITY_PANTRY",
    4: "GL_6150_MARKETING_PROMO",
    5: "GL_6310_WORKPLACE_SAFETY_ERGONOMICS",
    6: "GL_6250_TECH_BOOKS_TRAINING",
    7: "GL_6450_CLEANING_MAINTENANCE"
}

# Decode the record
print("Raw sample:")
print(sample)

# Denormalize amount
normalized = np.array(sample['num_features'])
denormalized = (normalized * np.array(scaler['scale'])) + np.array(scaler['mean'])
net_amount_eur = denormalized[0]

# Decode department
id2dept = {int(k): v for k, v in dept_vocab['id2dept'].items()}
department = id2dept[sample['dept_id']]

# Decode GL account
gl_account = LABEL_MAP[sample['label']]

print("\nDecoded sample:")
print(f"  Text: {sample['text']}")
print(f"  Amount: {net_amount_eur:.2f} EUR")
print(f"  Department: {department}")
print(f"  GL Account: {gl_account}")

Files in This Dataset

📊 Derived Data (Machine Learning Ready)

Use these for training models. Features are pre-processed, normalized, and split.

File Records Description
train.jsonl 659 Training split (70%) - normalized features, integer labels
validation.jsonl 141 Validation split (15%) - for hyperparameter tuning
test.jsonl 142 Test split (15%) - for final evaluation

Format: Each record contains:

  • text: "[VENDOR] ... [DESC] ..."
  • num_features: [normalized_amount, normalized_log_amount] (requires scaler.json to denormalize)
  • dept_id: Integer (requires dept_vocab.json to decode)
  • label: Integer 0-7 (see schema documentation for GL account mapping)

📁 Source Data (Human Readable)

Use this for exploration, debugging, or regenerating features with different preprocessing.

File Records Description
03_filtered.jsonl 942 All data before train/val/test split - human-readable strings, raw EUR amounts

Format: Each record contains:

  • vendor: String (e.g., "AMZN Mktp DE")
  • description: String (full product description)
  • department: String (e.g., "MARKETING", "IT_OPS")
  • net_amount_eur: Float (raw amount, e.g., 483.77)
  • gl_account: String (e.g., "GL_6150_MARKETING_PROMO")
  • language: String ("EN", "DE", "FR")
  • text_style: String (generation style)
  • corrupted: Boolean (whether ERP corruption was applied)
  • corruption_types: List of corruption types applied
  • critic_confidence: String ("high", "medium")
  • critic_reasoning: String (critic's explanation)
  • Plus: seed_id, base_category, title, asin, predicted_gl, matches_label

🔧 Auxiliary Files

File Description
scaler.json StandardScaler parameters (mean=[345.43, 5.08], std=[508.62, 1.22]) fitted on training data only
dept_vocab.json Department string ↔ integer mapping (6 departments)
evaluation/confusion_matrix.png Test set confusion matrix (90.8% accuracy)
evaluation/evaluation_summary.json Per-class precision, recall, F1 scores

🔄 Source vs. Derived: When to Use Each

Use SOURCE (03_filtered.jsonl) when you want to:

  • 🔍 Explore the data ("What does a typical MARKETING_PROMO item look like?")
  • 🐛 Debug data quality issues
  • 🔄 Regenerate features with different normalization (MinMaxScaler, RobustScaler, etc.)
  • 📊 Analyze original EUR amounts without denormalization
  • 📚 Study data generation metadata (language, style, critic scores)
  • 🎯 Create custom train/val/test splits (e.g., 80/10/10 instead of 70/15/15)
  • 🔬 Filter by language, corruption type, or critic confidence

Use DERIVED (train/val/test.jsonl) when you want to:

  • 🤖 Train a model immediately (features are pre-processed)
  • 🔬 Reproduce published results (exact splits used in paper)
  • 📦 Use HuggingFace datasets library directly
  • ⚡ Fast iteration (no preprocessing pipeline needed)
  • 🎓 Follow standard ML workflow (pre-split, normalized data)

GL Accounts (8 Classes)

The dataset covers 8 GL accounts with a special 800 EUR capitalization threshold for IT hardware:

GL Code Category Rule
GL_6220 IT Peripherals (OPEX) IT hardware < 800 EUR
GL_1400 IT Hardware (CAPEX) IT hardware ≥ 800 EUR
GL_6400 Office Consumables Toner, paper, binders, office supplies
GL_6410 Facility Pantry Coffee, snacks, beverages
GL_6150 Marketing Promo Promotional materials, swag
GL_6310 Workplace Safety/Ergonomics Ergonomic equipment, safety gear
GL_6250 Tech Books/Training Books, courses, training materials
GL_6450 Cleaning/Maintenance Cleaning supplies, maintenance items

The 800 EUR problem: A €750 monitor and an €850 monitor are the same item, but different accounting treatment. This is why the model needs direct access to numerical features—text classifiers cannot learn mathematical thresholds from tokens.

Model Performance

A multimodal classifier (DistilBERT + numerical projection + dept embeddings) trained on this dataset achieves:

  • Test accuracy: 90.8%
  • Test F1: 90.6%
  • 800 EUR threshold accuracy: 73.5% (GL_6220 classification for items < 800 EUR)

See EHTB/erp-classifier for the trained model.

Data Generation Process

  1. Seed Generation: Combinatorial specs (vendor × dept × language × style × price)
  2. Verbalization: Amazon Nova Pro generates realistic product descriptions
  3. Corruption: SAP 40-char truncation, PO prefixes, OCR errors
  4. Critic: Zero-shot quality filter (94% pass rate)
  5. Multimodal Transformation: Extract text, normalize numerical features, encode departments

Citation 

@misc{erp-classifier-dataset,
  title={ERP GL Account Classifier Dataset},
  author={EHTB},
  year={2024},
  publisher={HuggingFace},
  howpublished={\url{https://huggingface.co/datasets/EHTB/erp-classifier-dataset}}
}

License

MIT