'NoneType' object is not callable
This is my Spacehuggingface.coapp.py · YaphetYan/MyDemoSpace at mainWe’re on a journey to advance and democratize artificial intelligence through open source and open science.I modified a little code from the tutorial which includes:change task to VQAuse the internVL2 modelbut it keeps throwing❌'NoneType' object is not callableI tried a lot but cant fix it.Plz any help will be helpfulMore information:if I delete mode=“InternVL2” which leads to use the default model in VQA taskthe’NoneType’ object is not callablegone
2025-01-07T01:58:47Z
same error! Have you save your issue?
2025-01-07T02:10:47Z
It seems that the issue arises when you’re specifyingmodel="InternVL2", which might not be properly recognized or initialized in your code. The'NoneType' object is not callableerror typically indicates that a function or object you’re trying to call is actuallyNone, which can happen if the model isn’t loaded properly.Check Model Initialization:Ensure that theInternVL2model is correctly loaded or defined in the code. If the model isn’t available in your current environment, the program might be returningNoneinstead 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!
2025-01-07T04:03:39Z
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…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)