EHTB/erp-classifier-dataset

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