Datasets:

EHTB
/

erp-classifier-dataset

---
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

```python
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**:
```python
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):
```python
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`):
```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**:
```json
{
  "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
```python
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](https://huggingface.co/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
```bibtex
@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

	---
	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

	```python
	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:
	```python
	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):
	```python
	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`):
	```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:
	```json
	{
	"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

	```python
	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](https://huggingface.co/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

	```bibtex
	@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