tencent

/

HunyuanOCR

like 751

Follow

Tencent 10.3k

add Monkeypatch for ValueError: only one element tensors can be converted to Python scalars

# --- Monkeypatch Start ---
def _preprocess_patched(
    self,
    images,
    videos=None,
    do_resize=None,
    size=None,
    min_pixels=None,
    max_pixels=None,
    resample=None,
    do_rescale=None,
    rescale_factor=None,
    do_normalize=None,
    image_mean=None,
    image_std=None,
    patch_size=None,
    temporal_patch_size=None,
    merge_size=None,
    do_convert_rgb=None,
    return_tensors=None,
    data_format=None,
    input_data_format=None,
):
    # Imports from the module
    smart_resize = image_processing_hunyuan_vl.smart_resize
    make_list_of_images = image_processing_hunyuan_vl.make_list_of_images
    convert_to_rgb = image_processing_hunyuan_vl.convert_to_rgb

    images = make_list_of_images(images)

    if do_convert_rgb:
        images = [convert_to_rgb(image) for image in images]

    width, height = images[0].width, images[0].height
    resized_width, resized_height = width, height
    processed_images = []
    for image in images:
        if do_resize:
            resized_width, resized_height = smart_resize(
                width,
                height,
                factor=patch_size * merge_size,
                min_pixels=size["shortest_edge"],
                max_pixels=size["longest_edge"],
            )
            image = image.resize((resized_width, resized_height))

        if do_normalize:
            image = transforms.Compose([
                transforms.ToTensor(),
                transforms.Normalize(self.image_mean, self.image_std)
            ])(image)
        processed_images.append(image)

    # FIX: Convert tensors to numpy arrays before creating the main array
    # Check if elements are tensors and convert if so
    if processed_images and isinstance(processed_images[0], torch.Tensor):
        patches = np.array([img.numpy() for img in processed_images])
    else:
        patches = np.array(processed_images)
    
    channel = patches.shape[1]
    grid_t = patches.shape[0] // temporal_patch_size
    grid_h, grid_w = resized_height // patch_size, resized_width // patch_size
    patches = patches.reshape(
        1,
        channel,
        grid_h // merge_size,
        merge_size,
        patch_size,
        grid_w // merge_size,
        merge_size,
        patch_size,
    )
    patches = patches.transpose(0, 2, 3, 5, 6, 1, 4, 7)
    flatten_patches = patches.reshape( 1 * grid_h * grid_w, channel * patch_size * patch_size)

    return flatten_patches, (grid_t, grid_h, grid_w)

print("Applying monkeypatch to HunYuanVLImageProcessor._preprocess...")
image_processing_hunyuan_vl.HunYuanVLImageProcessor._preprocess = _preprocess_patched
# --- Monkeypatch End ---