Adding latest `WIP`

.gitignore

@@ -3,4 +3,9 @@ graphs/yolov5n.pt
 operators/__pycache__/
 __pycache__/
 *.avi
-*.txt
+*.txt
+
+
+## TODO:
+- [ ] Make human direct using voice
+# - [ ] Make robot talk

README.md

@@ -0,0 +1,21 @@
+# Getting Started
+
+Create a new conda environment for robomaster
+
+```bash
+conda create -n robomaster python=3.8
+pip install robomaster dora-rs
+```
+
+Create a new conda environment for idefics2. This requirements file suppose that your using cu122.
+
+```bash
+conda create -n idefics2 python=3.10
+pip install -r requirements.txt
+```
+
+```bash
+export HF_TOKEN=<TOKEN>
+dora up
+dora start graphs/dataflow_robot_vlm.yml --attach --hot-reload
+```

graphs/dataflow_robot_vlm.yml

@@ -11,25 +11,26 @@ nodes:
 
   - id: vlm
     operator:
-      python: ../operators/chatgpt_op.py
+      python: ../operators/idefics2_op.py
       inputs: 
         image:
           source: webcam/image
           queue_size: 1
         instruction: keyboard/submitted
+        control_reply: robot/control_reply
       outputs:
         - assistant_message
 
   - id: robot
     operator:
-      python: ../operators/robot.py
+      python: 
+        source: ../operators/robot.py
+        conda_env: robomaster
       inputs:
-        tick:
-          source: dora/timer/millis/2000
-          queue_size: 1
-        control:
-          source: vlm/assistant_message
-          queue_size: 1
+        tick: dora/timer/millis/750
+        control: keyboard/submitted
+      outputs:
+        - control_reply
 
   - id: webcam
     custom:
@@ -43,3 +44,19 @@ nodes:
       outputs:
         - buffer
         - submitted
+
+  - id: whisper
+    operator:
+      python: ../operators/whisper_op.py
+      inputs:
+        audio: microphone/audio
+      outputs:
+        - text
+
+  - id: microphone
+    operator:
+      python: ../operators/microphone_op.py
+      inputs:
+        record: keyboard/submitted
+      outputs:
+        - audio

operators/chatgpt_op.py

@@ -1,159 +0,0 @@
-from dora import DoraStatus
-import os
-import pyarrow as pa
-
-
-import requests
-
-import os
-
-import base64
-import requests
-from io import BytesIO
-import numpy as np
-import cv2
-
-
-def encode_numpy_image(np_image):
-    # Convert the NumPy array to a PIL Image
-    cv2.resize(np_image, (512, 512))
-    _, buffer = cv2.imencode(
-        ".png", np_image
-    )  # You can change '.png' to another format if needed
-
-    # Convert the buffer to a byte stream
-    byte_stream = BytesIO(buffer)
-
-    # Encode the byte stream to base64
-    base64_encoded_image = base64.b64encode(byte_stream.getvalue()).decode("utf-8")
-    return base64_encoded_image
-
-
-CAMERA_WIDTH = 640
-CAMERA_HEIGHT = 480
-
-API_KEY = os.getenv("OPENAI_API_KEY")
-
-
-MESSAGE_SENDER_TEMPLATE = """
-You control a robot. Don't get too close to objects.
-
-{user_message}
-
-Respond with only one of the following actions:
-- FORWARD
-- BACKWARD
-- TURN_RIGHT
-- TURN_LEFT
-- NOD_YES
-- NOD_NO
-- STOP
-
-You're last 5 actions where: 
-{actions}
-"""
-
-
-import time
-
-
-def understand_image(image, user_message, actions):
-    # Getting the base64 string
-    base64_image = encode_numpy_image(image)
-    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {API_KEY}"}
-
-    now = time.time()
-    payload = {
-        "model": "gpt-4-vision-preview",
-        "messages": [
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": MESSAGE_SENDER_TEMPLATE.format(
-                            user_message="\n".join(user_message),
-                            actions="\n".join(actions[:-5]),
-                        ),
-                    },
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/jpeg;base64,{base64_image}",
-                            "detail": "low",
-                        },
-                    },
-                ],
-            }
-        ],
-        "max_tokens": 50,
-    }
-
-    response = requests.post(
-        "https://api.openai.com/v1/chat/completions", headers=headers, json=payload
-    )
-
-    print("resp:", time.time() - now)
-    return response.json()["choices"][0]["message"]["content"]
-
-
-class Operator:
-    def __init__(self):
-        self.actions = []
-        self.instruction = []
-
-    def on_event(
-        self,
-        dora_event,
-        send_output,
-    ) -> DoraStatus:
-        if dora_event["type"] == "INPUT":
-            if dora_event["id"] == "image":
-                image = (
-                    dora_event["value"]
-                    .to_numpy()
-                    .reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
-                    .copy()
-                )
-                output = understand_image(image, self.instruction, self.actions)
-                self.actions.append(output)
-                print("response: ", output, flush=True)
-
-                send_output(
-                    "assistant_message",
-                    pa.array([f"{output}"]),
-                    dora_event["metadata"],
-                )
-            elif dora_event["id"] == "instruction":
-                self.instruction.append(dora_event["value"][0].as_py())
-                print("instructions: ", self.instruction, flush=True)
-        return DoraStatus.CONTINUE
-
-
-if __name__ == "__main__":
-    op = Operator()
-
-    # Path to the current file
-    current_file_path = __file__
-
-    # Directory of the current file
-    current_directory = os.path.dirname(current_file_path)
-
-    path = current_directory + "/test_image.jpg"
-
-    op.on_event(
-        {
-            "type": "INPUT",
-            "id": "code_modifier",
-            "value": pa.array(
-                [
-                    {
-                        "path": path,
-                        "user_message": "change planning to make gimbal follow bounding box ",
-                    },
-                ]
-            ),
-            "metadata": [],
-        },
-        print,
-    )

operators/idefics2_op.py

@@ -0,0 +1,97 @@
+from dora import DoraStatus
+import os
+import pyarrow as pa
+
+
+import cv2
+
+from idefics2_utils import ask_vlm
+
+
+from RealtimeTTS import TextToAudioStream, SystemEngine
+
+engine = SystemEngine()
+stream = TextToAudioStream(engine)
+
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+
+
+FONT = cv2.FONT_HERSHEY_SIMPLEX
+
+import pyttsx3
+
+engine = pyttsx3.init("espeak")
+voices = engine.getProperty("voices")
+engine.setProperty("voice", voices[11].id)  # English
+
+
+def speak(text):
+    engine.say(text)
+    engine.runAndWait()
+
+
+class Operator:
+    def __init__(self):
+        self.completed = True
+        self.instruction = "What is in the image?"
+        self.last_message = ""
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            if dora_event["id"] == "image":
+                if True:
+                    image = (
+                        dora_event["value"]
+                        .to_numpy()
+                        .reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+                        .copy()
+                    )
+                    cv2.imshow("frame2", image)
+                    if cv2.waitKey(1) & 0xFF == ord("q"):
+                        return DoraStatus.CONTINUE
+                    output = ask_vlm(image, self.instruction)
+                    cv2.putText(
+                        image,
+                        output,
+                        (20, 14 + 15 * 25),
+                        FONT,
+                        0.5,
+                        (190, 250, 0),
+                        2,
+                    )
+
+                    if self.last_message != output:
+                        speak(output)
+                        print("response: ", output, flush=True)
+                        send_output(
+                            "assistant_message",
+                            pa.array([output]),
+                            dora_event["metadata"],
+                        )
+
+                    # stream.feed(output)
+
+                    # stream.play()
+                    self.last_message = output
+                    self.completed = False
+                else:
+                    print("Command not complete", flush=True)
+            elif dora_event["id"] == "instruction":
+                self.instruction = dora_event["value"][0].as_py()
+                print("instructions: ", self.instruction, flush=True)
+            elif dora_event["id"] == "control_reply":
+                control_reply = dora_event["value"][0].as_py()
+
+                if self.last_message == control_reply:
+                    self.completed = True
+                else:
+                    print(
+                        f"expected: {self.last_message}, but got: {control_reply}",
+                        flush=True,
+                    )
+        return DoraStatus.CONTINUE

operators/idefics2_utils.py

@@ -0,0 +1,69 @@
+import requests
+import torch
+from PIL import Image
+from io import BytesIO
+
+from transformers import AutoProcessor, AutoModelForVision2Seq, AwqConfig
+
+
+MODE = "quantized"
+DEVICE = "cuda"
+PROCESSOR = AutoProcessor.from_pretrained("HuggingFaceM4/idefics2-tfrm-compatible")
+BAD_WORDS_IDS = PROCESSOR.tokenizer(
+    ["<image>", "<fake_token_around_image>"], add_special_tokens=False
+).input_ids
+EOS_WORDS_IDS = PROCESSOR.tokenizer(
+    "<end_of_utterance>", add_special_tokens=False
+).input_ids + [PROCESSOR.tokenizer.eos_token_id]
+
+# Load model
+if MODE == "regular":
+    model = AutoModelForVision2Seq.from_pretrained(
+        "HuggingFaceM4/idefics2-tfrm-compatible",
+        torch_dtype=torch.float16,
+        trust_remote_code=True,
+        _attn_implementation="flash_attention_2",
+        revision="3dc93be345d64fb6b1c550a233fe87ddb36f183d",
+    ).to(DEVICE)
+elif MODE == "quantized":
+    quant_path = "HuggingFaceM4/idefics2-tfrm-compatible-AWQ"
+    model = AutoModelForVision2Seq.from_pretrained(
+        quant_path, trust_remote_code=True
+    ).to(DEVICE)
+elif MODE == "fused_quantized":
+    quant_path = "HuggingFaceM4/idefics2-tfrm-compatible-AWQ"
+    quantization_config = AwqConfig(
+        bits=4,
+        fuse_max_seq_len=4096,
+        modules_to_fuse={
+            "attention": ["q_proj", "k_proj", "v_proj", "o_proj"],
+            "mlp": ["gate_proj", "up_proj", "down_proj"],
+            "layernorm": ["input_layernorm", "post_attention_layernorm", "norm"],
+            "use_alibi": False,
+            "num_attention_heads": 32,
+            "num_key_value_heads": 8,
+            "hidden_size": 4096,
+        },
+    )
+    model = AutoModelForVision2Seq.from_pretrained(
+        quant_path, quantization_config=quantization_config, trust_remote_code=True
+    ).to(DEVICE)
+else:
+    raise ValueError("Unknown mode")
+
+
+def ask_vlm(image, instruction):
+    prompts = [
+        "User:",
+        image,
+        f"{instruction}.<end_of_utterance>\n",
+        "Assistant:",
+    ]
+    inputs = PROCESSOR(prompts)
+    inputs = {k: torch.tensor(v).to(DEVICE) for k, v in inputs.items()}
+
+    generated_ids = model.generate(
+        **inputs, bad_words_ids=BAD_WORDS_IDS, max_new_tokens=10
+    )
+    generated_texts = PROCESSOR.batch_decode(generated_ids, skip_special_tokens=True)
+    return generated_texts[0].split("\nAssistant: ")[1]

operators/opencv_stream.py

@@ -7,8 +7,9 @@ node = Node()
 TCP_STREAM_URL = "tcp://192.168.2.1:40921"
 # Global variables, change it to adapt your needs
 
-CAMERA_WIDTH = 640
-CAMERA_HEIGHT = 480
+
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
 
 # Create a VideoCapture object using the TCP stream URL
 cap = cv2.VideoCapture(TCP_STREAM_URL)

operators/plot.py

@@ -4,15 +4,15 @@ import cv2
 from dora import DoraStatus
 
 
-CAMERA_WIDTH = 640
-CAMERA_HEIGHT = 480
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
 
 FONT = cv2.FONT_HERSHEY_SIMPLEX
 
 writer = cv2.VideoWriter(
     "output01.avi",
     cv2.VideoWriter_fourcc(*"MJPG"),
-    30,
+    60,
     (CAMERA_WIDTH, CAMERA_HEIGHT),
 )
 
@@ -41,9 +41,10 @@ class Operator:
                 image = (
                     value.to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3)).copy()
                 )
+                cv2.resize(image, (CAMERA_HEIGHT * 2, CAMERA_WIDTH * 2))
 
                 cv2.putText(
-                    image, self.buffer, (20, 14 + 15 * 25), FONT, 0.8, (190, 250, 0), 2
+                    image, self.buffer, (20, 14 + 15 * 25), FONT, 0.5, (190, 250, 0), 2
                 )
 
                 i = 0
@@ -61,12 +62,13 @@ class Operator:
                             14 + (13 - i) * 25,
                         ),
                         FONT,
-                        0.8,
+                        0.5,
                         color,
                         2,
                     )
                     i += 1
                 writer.write(image)
+                cv2.resize(image, (CAMERA_HEIGHT * 3, CAMERA_WIDTH * 3))
                 cv2.imshow("frame", image)
                 if cv2.waitKey(1) & 0xFF == ord("q"):
                     return DoraStatus.STOP
@@ -76,7 +78,10 @@ class Operator:
                 self.submitted += [
                     {
                         "role": id,
-                        "content": value[0].as_py(),
+                        "content": value[0]
+                        .as_py()
+                        .replace("\n", " ")
+                        .replace("- ", ""),
                     }
                 ]
 

operators/robot.py

@@ -12,12 +12,12 @@ CONN = "ap"
 class Command(Enum):
     NOD_YES = [
         {"action": "gimbal", "value": [20.0, 0.0]},
-        {"action": "gimbal", "value": [0.0, 0.0]},
+        {"action": "gimbal", "value": [-5.0, 0.0]},
     ]
     NOD_NO = [
-        {"action": "gimbal", "value": [0.0, -20.0]},
-        {"action": "gimbal", "value": [0.0, 20.0]},
-        {"action": "gimbal", "value": [0.0, 0.0]},
+        {"action": "gimbal", "value": [-5, -55.0]},
+        {"action": "gimbal", "value": [-5, 55.0]},
+        {"action": "gimbal", "value": [-5.0, 0.0]},
     ]
     FORWARD = [
         {
@@ -28,29 +28,38 @@ class Command(Enum):
     BACKWARD = [
         {
             "action": "control",
-            "value": [-0.5, 0.0, 0.0, 0.6, 0],
-        }
+            "value": [-0.5, 0, 180.0, 0.6, 30],
+        },
     ]
-    TURN_LEFT = [
-        {"action": "gimbal", "value": [0.0, -45.0]},
+    LEFT = [
+        {"action": "gimbal", "value": [-5, -30.0]},
         {
             "action": "control",
-            "value": [0.0, 0.0, 45.0, 0.0, 50],
+            "value": [0.2, -0.2, 30.0, 0.6, 30],
         },
     ]
-    TURN_RIGHT = [
-        {"action": "gimbal", "value": [0.0, 45.0]},
+    SLIGHT_LEFT = [
+        {"action": "gimbal", "value": [-0.0, -15.0]},
         {
-            "value": [0.0, 0.0, -45.0, 0.0, 50],
             "action": "control",
+            "value": [0.3, -0.1, 15.0, 0.6, 50],
         },
     ]
-    UNKNOWN = [
+    RIGHT = [
+        {"action": "gimbal", "value": [-5, 30.0]},
         {
-            "value": [0.0, 0.0, 0.0, 0.0, 0],
+            "value": [0.2, 0.2, -30.0, 0.6, 30],
             "action": "control",
-        }
+        },
     ]
+    SLIGHT_RIGHT = [
+        {"action": "gimbal", "value": [-20.0, 15.0]},
+        {
+            "value": [0.3, 0.1, -15.0, 0.6, 50],
+            "action": "control",
+        },
+    ]
+    UNKNOWN = []
     # STOP = [0, 0, 0, 0]
     # COMPLETED = [0, 0, 0, 0]
 
@@ -72,40 +81,63 @@ class Operator:
         ), "Could not start video stream"
 
         self.ep_robot.gimbal.recenter().wait_for_completed()
+        self.event = self.ep_robot.gimbal.moveto(
+            pitch=-5, yaw=0, pitch_speed=50.0, yaw_speed=50.0
+        )
         self.backlog = []
-        self.event = None
+        self.last_control = ""
+
+    def execute_backlog(self):
+        if len(self.backlog) > 0:
+            command = self.backlog.pop(0)
+            if command["action"] == "control":
+                [x, y, z, xy_speed, z_speed] = command["value"]
+                print(command, flush=True)
+                self.event = self.ep_robot.chassis.move(
+                    x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
+                )
+            elif command["action"] == "gimbal":
+                [pitch, yaw] = command["value"]
+                print(command, flush=True)
+                self.event = self.ep_robot.gimbal.moveto(
+                    pitch=pitch, yaw=yaw, pitch_speed=50.0, yaw_speed=50.0
+                )
 
     def on_event(
         self,
         dora_event: str,
-        send_output: Callable[[str, Union[bytes, pa.UInt8Array], Optional[dict]], None],
+        send_output: Callable[[str, pa.Array, Optional[dict]], None],
     ) -> DoraStatus:
         event_type = dora_event["type"]
         if event_type == "INPUT":
-            if not (
-                self.event is not None
-                and not (self.event._event.isSet() and self.event.is_completed)
-            ):
-                if dora_event["id"] == "tick":
+            if dora_event["id"] == "tick":
+                if not (
+                    self.event is not None
+                    and not (self.event._event.isSet() and self.event.is_completed)
+                ):
                     if len(self.backlog) > 0:
-                        command = self.backlog.pop(0)
-                        print(command, flush=True)
-                        if command["action"] == "control":
-                            [x, y, z, xy_speed, z_speed] = command["value"]
-                            print(command, flush=True)
-                            self.event = self.ep_robot.chassis.move(
-                                x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
-                            )
-                        elif command["action"] == "gimbal":
-                            [pitch, yaw] = command["value"]
-                            print(command, flush=True)
-                            self.event = self.ep_robot.gimbal.moveto(
-                                pitch=pitch, yaw=yaw, pitch_speed=0.0, yaw_speed=50.0
-                            )
-                elif dora_event["id"] == "control":
-                    raw_command = dora_event["value"][0].as_py()
-                    print(raw_command, flush=True)
-                    cmd = Command.parse(raw_command)
+                        self.execute_backlog()
+                    else:
+                        print(f"sending control reply: {self.last_control}", flush=True)
+                        send_output("control_reply", pa.array([self.last_control]))
+            elif dora_event["id"] == "control":
+                raw_command = dora_event["value"][0].as_py()
+                print(raw_command, flush=True)
+                self.last_control = raw_command
+                if "but" in raw_command:
+                    cmd = Command.NOD_NO
+                elif "right" in raw_command:
+                    cmd = Command.RIGHT
+                elif "left" in raw_command:
+                    cmd = Command.LEFT
+                elif "forward" in raw_command:
+                    cmd = Command.FORWARD
+                elif "behind" in raw_command:
+                    cmd = Command.BACKWARD
+                else:
+                    cmd = Command.UNKNOWN
+                if len(self.backlog) == 0:
                     self.backlog += cmd.value
+                    self.execute_backlog()
 
         return DoraStatus.CONTINUE

tests/test_idefics2.py

@@ -0,0 +1,110 @@
+import requests
+import torch
+from PIL import Image
+from io import BytesIO
+
+from transformers import AutoProcessor, AutoModelForVision2Seq, AwqConfig
+
+
+MODE = "quantized"
+DEVICE = "cuda"
+PROCESSOR = AutoProcessor.from_pretrained("HuggingFaceM4/idefics2-tfrm-compatible")
+BAD_WORDS_IDS = PROCESSOR.tokenizer(
+    ["<image>", "<fake_token_around_image>"], add_special_tokens=False
+).input_ids
+EOS_WORDS_IDS = PROCESSOR.tokenizer(
+    "<end_of_utterance>", add_special_tokens=False
+).input_ids + [PROCESSOR.tokenizer.eos_token_id]
+
+# Load model
+if MODE == "regular":
+    model = AutoModelForVision2Seq.from_pretrained(
+        "HuggingFaceM4/idefics2-tfrm-compatible",
+        torch_dtype=torch.float16,
+        trust_remote_code=True,
+        _attn_implementation="flash_attention_2",
+        revision="3dc93be345d64fb6b1c550a233fe87ddb36f183d",
+    ).to(DEVICE)
+elif MODE == "quantized":
+    quant_path = "HuggingFaceM4/idefics2-tfrm-compatible-AWQ"
+    model = AutoModelForVision2Seq.from_pretrained(
+        quant_path, trust_remote_code=True
+    ).to(DEVICE)
+elif MODE == "fused_quantized":
+    quant_path = "HuggingFaceM4/idefics2-tfrm-compatible-AWQ"
+    quantization_config = AwqConfig(
+        bits=4,
+        fuse_max_seq_len=4096,
+        modules_to_fuse={
+            "attention": ["q_proj", "k_proj", "v_proj", "o_proj"],
+            "mlp": ["gate_proj", "up_proj", "down_proj"],
+            "layernorm": ["input_layernorm", "post_attention_layernorm", "norm"],
+            "use_alibi": False,
+            "num_attention_heads": 32,
+            "num_key_value_heads": 8,
+            "hidden_size": 4096,
+        },
+    )
+    model = AutoModelForVision2Seq.from_pretrained(
+        quant_path,
+        quantization_config=quantization_config,
+        trust_remote_code=True,
+    ).to(DEVICE)
+else:
+    raise ValueError("Unknown mode")
+
+
+def download_image(url):
+    try:
+        # Send a GET request to the URL to download the image
+        response = requests.get(url)
+        # Check if the request was successful (status code 200)
+        if response.status_code == 200:
+            # Open the image using PIL
+            image = Image.open(BytesIO(response.content))
+            # Return the PIL image object
+            return image
+        else:
+            print(f"Failed to download image. Status code: {response.status_code}")
+            return None
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None
+
+
+# Create inputs
+image1 = download_image(
+    "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
+)
+
+
+def ask_vlm(image, instruction):
+    prompts = [
+        "User:",
+        image,
+        f"{instruction}.<end_of_utterance>\n",
+        "Assistant:",
+    ]
+    inputs = PROCESSOR(prompts)
+    inputs = {k: torch.tensor(v).to(DEVICE) for k, v in inputs.items()}
+    generated_ids = model.generate(
+        **inputs,
+        bad_words_ids=BAD_WORDS_IDS,
+        max_new_tokens=100,
+    )
+    generated_texts = PROCESSOR.batch_decode(generated_ids, skip_special_tokens=True)
+    return generated_texts
+
+
+import time
+
+model.eval()
+now = time.time()
+print(ask_vlm(image1, "What is this?")[0].split("\nAssistant: ")[1])
+
+print("resp:", time.time() - now)
+import time
+
+now = time.time()
+
+print(ask_vlm(image1, "What is this?")[0].split("\nAssistant: ")[1])

tests/test_idefix2.py

@@ -1,154 +0,0 @@
-import os
-import torch
-import requests
-
-from io import BytesIO
-from PIL import Image
-from transformers import AutoModelForCausalLM, AutoProcessor
-
-from transformers.image_utils import (
-    to_numpy_array,
-    PILImageResampling,
-    ChannelDimension,
-)
-from transformers.image_transforms import resize, to_channel_dimension_format
-
-
-API_TOKEN = os.getenv("HF_TOKEN")
-
-DEVICE = torch.device("cuda")
-PROCESSOR = AutoProcessor.from_pretrained(
-    "HuggingFaceM4/tr_272_bis_opt_step_15000_merge",
-    token=API_TOKEN,
-)
-MODEL = AutoModelForCausalLM.from_pretrained(
-    "HuggingFaceM4/tr_272_bis_opt_step_15000_merge",
-    token=API_TOKEN,
-    trust_remote_code=True,
-    torch_dtype=torch.bfloat16,
-).to(DEVICE)
-image_seq_len = MODEL.config.perceiver_config.resampler_n_latents
-BOS_TOKEN = PROCESSOR.tokenizer.bos_token
-BAD_WORDS_IDS = PROCESSOR.tokenizer(
-    ["<image>", "<fake_token_around_image>"], add_special_tokens=False
-).input_ids
-
-
-def convert_to_rgb(image):
-    # `image.convert("RGB")` would only work for .jpg images, as it creates a wrong background
-    # for transparent images. The call to `alpha_composite` handles this case
-    if image.mode == "RGB":
-        return image
-
-    image_rgba = image.convert("RGBA")
-    background = Image.new("RGBA", image_rgba.size, (255, 255, 255))
-    alpha_composite = Image.alpha_composite(background, image_rgba)
-    alpha_composite = alpha_composite.convert("RGB")
-    return alpha_composite
-
-
-# The processor is the same as the Idefics processor except for the BILINEAR interpolation,
-# so this is a hack in order to redefine ONLY the transform method
-def custom_transform(x):
-    x = convert_to_rgb(x)
-    x = to_numpy_array(x)
-
-    height, width = x.shape[:2]
-    aspect_ratio = width / height
-    if width >= height and width > 980:
-        width = 980
-        height = int(width / aspect_ratio)
-    elif height > width and height > 980:
-        height = 980
-        width = int(height * aspect_ratio)
-    width = max(width, 378)
-    height = max(height, 378)
-
-    x = resize(x, (height, width), resample=PILImageResampling.BILINEAR)
-    x = PROCESSOR.image_processor.rescale(x, scale=1 / 255)
-    x = PROCESSOR.image_processor.normalize(
-        x,
-        mean=PROCESSOR.image_processor.image_mean,
-        std=PROCESSOR.image_processor.image_std,
-    )
-    x = to_channel_dimension_format(x, ChannelDimension.FIRST)
-    x = torch.tensor(x)
-    return x
-
-
-def download_image(url):
-    try:
-        # Send a GET request to the URL to download the image
-        response = requests.get(url)
-        # Check if the request was successful (status code 200)
-        if response.status_code == 200:
-            # Open the image using PIL
-            image = Image.open(BytesIO(response.content))
-            # Return the PIL image object
-            return image
-        else:
-            print(f"Failed to download image. Status code: {response.status_code}")
-            return None
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        return None
-
-
-# Create text token inputs
-image_seq = "<image>" * image_seq_len
-
-instruction = "What is this?"
-# Create pixel inputs
-image = download_image(
-    "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
-)
-
-
-def ask_vlm(instruction, image):
-
-    inputs = PROCESSOR.tokenizer(
-        [
-            f"{BOS_TOKEN}<fake_token_around_image>{image_seq}<fake_token_around_image>{instruction}",
-        ],
-        return_tensors="pt",
-        add_special_tokens=False,
-        padding=True,
-    )
-
-    raw_images = [
-        [image],
-    ]
-    output_images = [
-        [PROCESSOR.image_processor(img, transform=custom_transform) for img in img_list]
-        for img_list in raw_images
-    ]
-    total_batch_size = len(output_images)
-    max_num_images = max([len(img_l) for img_l in output_images])
-    max_height = max([i.size(2) for img_l in output_images for i in img_l])
-    max_width = max([i.size(3) for img_l in output_images for i in img_l])
-    padded_image_tensor = torch.zeros(
-        total_batch_size, max_num_images, 3, max_height, max_width
-    )
-    padded_pixel_attention_masks = torch.zeros(
-        total_batch_size, max_num_images, max_height, max_width, dtype=torch.bool
-    )
-    for batch_idx, img_l in enumerate(output_images):
-        for img_idx, img in enumerate(img_l):
-            im_height, im_width = img.size()[2:]
-            padded_image_tensor[batch_idx, img_idx, :, :im_height, :im_width] = img
-            padded_pixel_attention_masks[batch_idx, img_idx, :im_height, :im_width] = (
-                True
-            )
-
-    inputs["pixel_values"] = padded_image_tensor
-    inputs["pixel_attention_mask"] = padded_pixel_attention_masks
-    inputs = {k: v.to(DEVICE) for k, v in inputs.items()}
-
-    generated_ids = MODEL.generate(
-        **inputs, bad_words_ids=BAD_WORDS_IDS, max_new_tokens=10
-    )
-    generated_texts = PROCESSOR.batch_decode(generated_ids, skip_special_tokens=True)
-    return generated_texts
-
-
-print(ask_vlm(instruction, image))