Main article text.
"],
return_tensors="np",
padding=True,
)
input_ids = mx.array(inputs["input_ids"])
attention_mask = mx.array(inputs["attention_mask"])
logits = model(input_ids, attention_mask)
mx.eval(logits)
print(logits.shape) # batch, tokens, 2
```
Minimal Pulpie-style extraction:
```python
import numpy as np
import mlx.core as mx
from pulpie.chunker import extract_blocks, pack_chunks, tokenize_blocks
from pulpie.model_utils import extract_item_ids, predictions_to_labels
from pulpie.reconstruct import extract_main_html
from pulpie.simplify import simplify
html = (
"Apple MLX conversion
"
"This article explains how to convert a EuroBERT content extraction "
"model to MLX format.
"
)
simplified, map_html = simplify(html)
blocks = extract_blocks(simplified)
item_ids = extract_item_ids(blocks)
sep_id = tokenizer.convert_tokens_to_ids("<|sep|>")
chunks = pack_chunks(
tokenize_blocks(blocks, tokenizer),
max_tokens=8192,
sep_token_id=sep_id,
bos_token_id=tokenizer.bos_token_id,
eos_token_id=tokenizer.eos_token_id,
)
predictions = [0] * len(blocks)
for chunk_ids, block_indices in chunks:
ids = mx.array([chunk_ids])
mask = mx.ones_like(ids)
logits = model(ids, mask)
mx.eval(logits)
logits_np = np.array(logits.astype(mx.float32))[0]
sep_positions = np.where(np.array(chunk_ids) == sep_id)[0]
preds = logits_np[sep_positions].argmax(axis=-1).tolist()
for i, block_idx in enumerate(block_indices):
predictions[block_idx] = int(preds[i])
labels = predictions_to_labels(item_ids, predictions)
print(extract_main_html(map_html, labels))
```
## Conversion Methodology
1. Downloaded `feyninc/pulpie-orange-small` from the Hugging Face Hub.
2. Inspected `config.json`, `configuration_eurobert.py`, and
`modeling_eurobert.py`.
3. Confirmed the model is `EuroBertForTokenClassification` with 12 layers,
hidden size 768, 12 attention heads, head dim 64, max length 8192, BF16
source weights, and 2 output labels.
4. Confirmed current MLX can be installed on Linux with `mlx[cpu]`, so no cloud
Mac was required for conversion or load verification.
5. Implemented a custom MLX EuroBERT token-classification module with matching
state-dict keys and the source architecture behavior.
6. Saved the BF16 MLX weights with `mlx.core.save_safetensors`.
7. Created 8-bit and 4-bit variants with `mlx.nn.quantize`, using affine
weight quantization, group size 64, over MLX `Linear` and `Embedding`
modules.
8. Verified each variant with `scripts/verify_mlx.py`.
## Verification Results
Verification was run on Linux x86_64 using `mlx[cpu]`. The PyTorch reference was
the original source checkpoint loaded in float32 with eager attention. The BF16
variant is expected to have small dtype-level differences versus that float32
reference; quantized variants have larger differences.
### Load Checks
| Variant | Load result | Test logits shape | Test logits dtype |
| --- | --- | --- | --- |
| BF16 | Pass | `[1, 3, 2]` | `mlx.core.bfloat16` |
| 8-bit | Pass | `[1, 3, 2]` | `mlx.core.bfloat16` |
| 4-bit | Pass | `[1, 3, 2]` | `mlx.core.bfloat16` |
### Numerical Accuracy
Test inputs: `["A", "B", "C"]`, token shape `[3, 2]`.
| Variant | Max abs diff vs PyTorch fp32 | Mean abs diff | MLX CPU latency |
| --- | ---: | ---: | ---: |
| BF16 | 0.0452327728 | 0.0191817340 | 716.88 ms |
| 8-bit | 1.2797489166 | 0.5423613191 | 9380.58 ms |
| 4-bit | 2.2551989555 | 1.1897996664 | 9323.18 ms |
PyTorch fp32 eager latency on the same input was 50.09 ms on this Linux CPU.
The quantized MLX CPU path is slow on this host and should not be read as an
Apple Silicon benchmark.
### End-to-End Extraction
Sample HTML:
```html