'NoneType' object is not callable

Beginners
1

This is my Space

I modified a little code from the tutorial which includes:

  1. change task to VQA
  2. use the internVL2 model

but it keeps throwing ❌'NoneType' object is not callable

I tried a lot but cant fix it.
Plz any help will be helpful

More information:

if I delete mode=“InternVL2” which leads to use the default model in VQA task
the ’NoneType’ object is not callable gone

1 Like
2

same error! Have you save your issue?

1 Like
3

It seems that the issue arises when you’re specifying model="InternVL2", which might not be properly recognized or initialized in your code. The 'NoneType' object is not callable error typically indicates that a function or object you’re trying to call is actually None, which can happen if the model isn’t loaded properly.

Check Model Initialization:

  • Ensure that the InternVL2 model is correctly loaded or defined in the code. If the model isn’t available in your current environment, the program might be returning None instead of a callable model. You might need to import the model or specify the correct path to the model if you’re loading it from a local file or external source.

For example:

from transformers import AutoModelForVisualQuestionAnswering
model = AutoModelForVisualQuestionAnswering.from_pretrained("path_to_internVL2_model")

If you’re still encountering issues, please provide the specific code or error trace you’re seeing, and I’ll be happy to help you further!
Hope this help!

1 Like
4

The model can be loaded with that, but it seems that the Transformers pipeline does not yet support IntenVLM. (InternLM is supprted)
However, the lmdeploy in the sample does not work well with Zero GPU space, so I think it will work if you write the inference code without relying on the pipeline…:cold_face:

Edit:
I worked.

import spaces
import torch
import gradio as gr
import subprocess
import torchvision.transforms as T
from PIL import Image
from torchvision.transforms.functional import InterpolationMode
from transformers import AutoModel, AutoTokenizer, pipeline

DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
DTYPE = torch.bfloat16 if torch.cuda.is_available() else torch.float16

IMAGENET_MEAN = (0.485, 0.456, 0.406)
IMAGENET_STD = (0.229, 0.224, 0.225)

def build_transform(input_size):
    MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
    transform = T.Compose([
        T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
        T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
        T.ToTensor(),
        T.Normalize(mean=MEAN, std=STD)
    ])
    return transform

def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
    best_ratio_diff = float('inf')
    best_ratio = (1, 1)
    area = width * height
    for ratio in target_ratios:
        target_aspect_ratio = ratio[0] / ratio[1]
        ratio_diff = abs(aspect_ratio - target_aspect_ratio)
        if ratio_diff < best_ratio_diff:
            best_ratio_diff = ratio_diff
            best_ratio = ratio
        elif ratio_diff == best_ratio_diff:
            if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
                best_ratio = ratio
    return best_ratio

def dynamic_preprocess(image, min_num=1, max_num=12, image_size=448, use_thumbnail=False):
    orig_width, orig_height = image.size
    aspect_ratio = orig_width / orig_height

    # calculate the existing image aspect ratio
    target_ratios = set(
        (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
        i * j <= max_num and i * j >= min_num)
    target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])

    # find the closest aspect ratio to the target
    target_aspect_ratio = find_closest_aspect_ratio(
        aspect_ratio, target_ratios, orig_width, orig_height, image_size)

    # calculate the target width and height
    target_width = image_size * target_aspect_ratio[0]
    target_height = image_size * target_aspect_ratio[1]
    blocks = target_aspect_ratio[0] * target_aspect_ratio[1]

    # resize the image
    resized_img = image.resize((target_width, target_height))
    processed_images = []
    for i in range(blocks):
        box = (
            (i % (target_width // image_size)) * image_size,
            (i // (target_width // image_size)) * image_size,
            ((i % (target_width // image_size)) + 1) * image_size,
            ((i // (target_width // image_size)) + 1) * image_size
        )
        # split the image
        split_img = resized_img.crop(box)
        processed_images.append(split_img)
    assert len(processed_images) == blocks
    if use_thumbnail and len(processed_images) != 1:
        thumbnail_img = image.resize((image_size, image_size))
        processed_images.append(thumbnail_img)
    return processed_images

def load_image(image_file, input_size=448, max_num=12):
    image = Image.open(image_file).convert('RGB')
    transform = build_transform(input_size=input_size)
    images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
    pixel_values = [transform(image) for image in images]
    pixel_values = torch.stack(pixel_values)
    return pixel_values

def image_to_pixel_values(image: Image.Image, input_size=448, max_num=12):
    if not image: return None
    image.convert("RGB")
    transform = build_transform(input_size=input_size)
    images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
    pixel_values = [transform(image) for image in images]
    pixel_values = torch.stack(pixel_values)
    return pixel_values

# from issue: https://discuss.huggingface.co/t/how-to-install-flash-attention-on-hf-gradio-space/70698/2
# InternVL2 needs flash_attn
subprocess.run(
    "pip install flash-attn --no-build-isolation",
    env={"FLASH_ATTENTION_SKIP_CUDA_BUILD": "TRUE"},
    shell=True,
)
try:
    model_name = "OpenGVLab/InternVL2-8B"
    # model: <class 'transformers_modules.OpenGVLab.InternVL2-8B.0e6d592d957d9739b6df0f4b90be4cb0826756b9.modeling_internvl_chat.InternVLChatModel'>
    model = AutoModel.from_pretrained(
            model_name,
            torch_dtype=DTYPE,
            # low_cpu_mem_usage=True,
            trust_remote_code=True,
        ).to(DEVICE).eval()

    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True, use_fast=False)
    # pipeline: <class 'transformers.pipelines.visual_question_answering.VisualQuestionAnsweringPipeline'>
    #inference = pipeline(
    #    task="visual-question-answering", model=model, tokenizer=tokenizer
    #)

except Exception as error:
    raise gr.Error("👌" + str(error), duration=30)


@spaces.GPU
def predict(input_img, questions):
    try:
        #gr.Info("pipeline: " + str(type(inference)))
        #gr.Info("model: " + str(type(model)))
        #predictions = inference(question=questions, image=input_img)
        generation_config = dict(max_new_tokens=1024, do_sample=True)
        pixel_values = image_to_pixel_values(input_img, max_num=12).to(DTYPE).to(DEVICE) if input_img else None
        predictions, history = model.chat(tokenizer, pixel_values, questions, generation_config, history=None, return_history=True)
        return str(predictions)
    except Exception as e:
        error_message = "❌" + str(e)
        raise gr.Error(error_message, duration=25)


gradio_app = gr.Interface(
    predict,
    inputs=[
        gr.Image(label="Select A Image", sources=["upload", "webcam"], type="pil"),
        "text",
    ],
    outputs="text",
    title='ask me anything',
)

if __name__ == "__main__":
    gradio_app.launch(show_error=True, debug=True)
1 Like