How to process the dataset for layoutLM3

[talhaanwarch]

Hi. I want to apply LayoutLMv3Processor on huggingface dataset.
This is the snapshot of how my huggingface dataset look like

Each feature is a list such as words is a list, bbox is a list of list, ner tag is a list of integers representing the labels and image is a string showing path of image.

This is how i am applying processor

# we need to define custom features
features = datasets.Features(
    {
        'pixel_values': datasets.Array3D(dtype="float32", shape=(3, 224, 224)),
        "input_ids": datasets.Sequence(datasets.Value(dtype="int64")),
        "attention_mask": datasets.Sequence(datasets.Value(dtype="int64")),
        #"token_type_ids": datasets.Sequence(datasets.Value(dtype="int64")),
        "bbox": datasets.Array2D(dtype="int64", shape=(512, 4)),
        "labels": datasets.Sequence(datasets.ClassLabel(names=labels)),
    }
)

# preprocess function to perpare into the correct format for the model
def process(sample, processor=None):
    
#     print('sample',sample)
    
    encoding = processor(
        Image.open(sample["image_path"]).convert("RGB"),
        sample["words"],
        boxes=sample["bboxes"],
        word_labels=sample["ner_tags"],
        padding="max_length",
        truncation=True,
    )
    
    #the encodings are set, i converted them to dictionary
    #https://github.com/huggingface/datasets/issues/5025
    new_encoding={}
    for k in encoding.items():
        new_encoding[k[0]]=k[1][0]
    
    
#     del encoding["image"]
#     print('encoding',encoding['pixel_values'][0].max(),encoding['pixel_values'][0].min())
    print(new_encoding)
    return new_encoding


# process the dataset and format it to pytorch
proc_dataset = raw_datasets.map(
    partial(process, processor=processor),
    remove_columns=["image_path", "words", "ner_tags",  "bboxes"],
#     features=features,
    batched=False,
).with_format("torch")

But it is throwing this error

TypeError: Couldn't cast array of type
int64
to
Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None)

Second I did not understand how Features work. Like Array3D knew that on which column it has to act, or on whiich column Sequence should be applied. In short how these features are mapped on original data columns

[Advait251206]

The error is most likely caused by a mismatch between the shape or type returned by processor and the schema declared in features.

In your case, the processor output is intended to be one encoded example per dataset row, so remove the processor’s leading batch dimension and declare the resulting fields using their actual shapes.

There is also an important label detail: token-classification encodings can contain -100 for tokens whose loss should be ignored. Because ClassLabel represents a fixed set of class IDs, use Value("int64") for the processed labels field when it may contain -100. The model expects token-level labels aligned with the token sequence.

1. Updated preprocessing code

from PIL import Image
from functools import partial
from datasets import (
    Features,
    Sequence,
    Value,
    Array2D,
    Array3D,
)
Schema for the NEW columns returned by process().
features = Features({

"pixel_values": Array3D(

dtype="float32",

shape=(3, 224, 224),

),

"input_ids": Sequence(Value("int64")),

"attention_mask": Sequence(Value("int64")),

"bbox": Array2D(

dtype="int64",

shape=(512, 4),

),

"labels": Sequence(Value("int64")),

})
def process(sample, processor):

image = Image.open(sample["image_path"]).convert("RGB")
encoding = processor(
    image,
    sample["words"],
    boxes=sample["bboxes"],
    word_labels=sample["ner_tags"],
    padding="max_length",
    truncation=True,
    max_length=512,
)

# Remove the leading batch dimension.
return {
    key: value[0]
    for key, value in encoding.items()
}

proc_dataset = raw_datasets.map(

partial(process, processor=processor),

remove_columns=["image_path", "words", "ner_tags", "bboxes"],

features=features,

)
proc_dataset = proc_dataset.with_format("torch")

If your processor returns a different image size or sequence length, adjust the declared Array3D and Array2D shapes accordingly.

You can inspect the output for one example before processing the entire dataset:

sample = raw_datasets["train"][0]

encoding = processor(

Image.open(sample["image_path"]).convert("RGB"),

sample["words"],

boxes=sample["bboxes"],

word_labels=sample["ner_tags"],

padding="max_length",

truncation=True,

max_length=512,

)
for key, value in encoding.items():

print(key, value.shape if hasattr(value, "shape") else type(value))

2. How does Features map to columns?

Features is a schema. Its dictionary keys are the column names, and each value specifies the expected type and shape of that column. It does not map features to the original columns by position.

Since your map() function returns a dictionary containing pixel_values, input_ids, attention_mask, bbox, and labels, those are the columns described by features. The original columns are removed using remove_columns.

For example:

Feature declaration	Meaning for each dataset row
pixel_values: Array3D((3, 224, 224))	One image tensor with channel, height, and width dimensions
input_ids: Sequence(Value("int64"))	One sequence of token IDs
attention_mask: Sequence(Value("int64"))	One sequence of attention-mask values
bbox: Array2D((512, 4))	One bounding box per token position, with four coordinates
labels: Sequence(Value("int64"))	One token label per sequence position, including possible -100 values

The reason Array2D is useful for bbox is that it preserves the intended two-dimensional array structure for formatting as tensors.

3. Why your original code may fail

Your original features declaration is broadly consistent with the expected output shapes, but the exception indicates that at least one returned column is not matching its declared Sequence type. The exception alone does not identify which column is responsible.

A useful debugging step is to compare the keys and shapes returned by process() with the keys and types in features.

Also, avoid declaring processed token labels as ClassLabel if the processor can include -100. That value is a loss-masking sentinel, not one of your named entity classes.

Finally, the features argument to map() describes the resulting dataset schema. It does not automatically transform or assign types to the original words, bboxes, ner_tags, or image_path columns. Those columns are inputs to your preprocessing function; the returned dictionary determines the new columns.

---

If this answer helped or pointed you in the right direction, I'd appreciate it if you could mark it as the accepted answer so it's easier for others with the same issue to find.

Also, if you found my contribution useful, I'd appreciate it if you could check out my GitHub profile, follow me, and star any repositories you find interesting.

GitHub: https://github.com/Advait251206