initial commit

.gitattributes

@@ -0,0 +1,5 @@
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.mkv filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+graphs/out/**/*.txt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+graphs/yolov5n.pt
+*.pt
+operators/__pycache__/
+__pycache__/
+*.avi
+*.txt

graphs/dataflow_basic.yml

@@ -0,0 +1,34 @@
+nodes:
+  - id: robot
+    operator:
+      python: ../operators/robot.py
+      inputs:
+        control:
+          source: keyboard/submitted
+          queue_size: 1
+        tick:
+          source: dora/timer/millis/200
+          queue_size: 1
+
+  - id: bot_webcam
+    custom:
+      source: ../operators/opencv_stream.py
+      outputs:
+        - image
+
+  ### Camera
+  - id: plot_bot
+    operator:
+      python: ../operators/plot.py
+      inputs:
+        image: bot_webcam/image
+        keyboard_buffer: keyboard/buffer
+        user_message: keyboard/submitted
+
+  - id: keyboard
+    custom:
+      source: ../operators/keyboard_op.py
+      outputs:
+        - buffer
+        - submitted
+

graphs/dataflow_robot_vlm.yml

@@ -0,0 +1,45 @@
+nodes:
+   ### Camera
+  - id: plot_bot
+    operator:
+      python: ../operators/plot.py
+      inputs:
+        image: webcam/image
+        assistant_message: vlm/assistant_message
+        keyboard_buffer: keyboard/buffer
+        user_message: keyboard/submitted
+
+  - id: vlm
+    operator:
+      python: ../operators/chatgpt_op.py
+      inputs: 
+        image:
+          source: webcam/image
+          queue_size: 1
+        instruction: keyboard/submitted
+      outputs:
+        - assistant_message
+
+  - id: robot
+    operator:
+      python: ../operators/robot.py
+      inputs:
+        tick:
+          source: dora/timer/millis/2000
+          queue_size: 1
+        control:
+          source: vlm/assistant_message
+          queue_size: 1
+
+  - id: webcam
+    custom:
+      source: ../operators/opencv_stream.py
+      outputs:
+        - image
+  
+  - id: keyboard
+    custom:
+      source: ../operators/keyboard_op.py
+      outputs:
+        - buffer
+        - submitted

graphs/dataflow_vlm_basic.yml

@@ -0,0 +1,28 @@
+nodes:
+  ### Camera
+  - id: plot_bot
+    operator:
+      python: ../operators/plot.py
+      inputs:
+        image: webcam/image
+        # keyboard_buffer: keyboard/buffer
+        # user_message: keyboard/submitted
+        assistant_message: vlm/assistant_message
+
+  - id: vlm
+    operator:
+      python: ../operators/chatgpt_op.py
+      inputs: 
+        image:
+          source: webcam/image
+          queue_size: 1
+      outputs:
+        - assistant_message
+  
+  - id: webcam
+    operator:
+      python: ../operators/webcam.py
+      inputs:
+        tick: dora/timer/millis/500
+      outputs:
+        - image

operators/chatgpt_op.py

@@ -0,0 +1,159 @@
+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/keyboard_op.py

@@ -0,0 +1,65 @@
+from pynput import keyboard
+from pynput.keyboard import Key, Events
+import pyarrow as pa
+from dora import Node
+
+
+node = Node()
+buffer_text = ""
+ctrl = False
+submitted_text = []
+cursor = 0
+
+NODE_TOPIC = ["record", "send", "ask", "change"]
+
+with keyboard.Events() as events:
+    while True:
+        dora_event = node.next(0.01)
+        if (
+            dora_event is not None
+            and dora_event["type"] == "INPUT"
+            and dora_event["id"] == "recording"
+        ):
+            buffer_text += dora_event["value"][0].as_py()
+            node.send_output("buffer", pa.array([buffer_text]))
+            continue
+
+        event = events.get(1.0)
+        if event is not None and isinstance(event, Events.Press):
+            if hasattr(event.key, "char"):
+                cursor = 0
+                buffer_text += event.key.char
+                node.send_output("buffer", pa.array([buffer_text]))
+            else:
+                if event.key == Key.backspace:
+                    buffer_text = buffer_text[:-1]
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.esc:
+                    buffer_text = ""
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.enter:
+                    node.send_output("submitted", pa.array([buffer_text]))
+                    first_word = buffer_text.split(" ")[0]
+                    if first_word in NODE_TOPIC:
+                        node.send_output(first_word, pa.array([buffer_text]))
+                    submitted_text.append(buffer_text)
+                    buffer_text = ""
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.ctrl:
+                    ctrl = True
+                elif event.key == Key.space:
+                    buffer_text += " "
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.up:
+                    if len(submitted_text) > 0:
+                        cursor = max(cursor - 1, -len(submitted_text))
+                        buffer_text = submitted_text[cursor]
+                        node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.down:
+                    if len(submitted_text) > 0:
+                        cursor = min(cursor + 1, 0)
+                        buffer_text = submitted_text[cursor]
+                        node.send_output("buffer", pa.array([buffer_text]))
+        elif event is not None and isinstance(event, Events.Release):
+            if event.key == Key.ctrl:
+                ctrl = False

operators/microphone_op.py

@@ -0,0 +1,32 @@
+import numpy as np
+import pyarrow as pa
+import sounddevice as sd
+
+from dora import DoraStatus
+
+SAMPLE_RATE = 16000
+MAX_DURATION = 5
+
+
+class Operator:
+    """
+    Microphone operator that records the audio
+    """
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            audio_data = sd.rec(
+                int(SAMPLE_RATE * MAX_DURATION),
+                samplerate=SAMPLE_RATE,
+                channels=1,
+                dtype=np.int16,
+                blocking=True,
+            )
+
+            audio_data = audio_data.ravel().astype(np.float32) / 32768.0
+            send_output("audio", pa.array(audio_data), dora_event["metadata"])
+        return DoraStatus.CONTINUE

operators/opencv_stream.py

@@ -0,0 +1,32 @@
+import cv2
+import pyarrow as pa
+from dora import Node
+
+node = Node()
+# TCP stream URL (replace with your stream URL)
+TCP_STREAM_URL = "tcp://192.168.2.1:40921"
+# Global variables, change it to adapt your needs
+
+CAMERA_WIDTH = 640
+CAMERA_HEIGHT = 480
+
+# Create a VideoCapture object using the TCP stream URL
+cap = cv2.VideoCapture(TCP_STREAM_URL)
+
+# Check if the VideoCapture object opened successfully
+assert cap.isOpened(), "Error: Could not open video capture."
+
+while True:
+    # Read a frame from the stream
+    ret, frame = cap.read()
+
+    if not ret:
+        break  # Break the loop when no more frames are available
+    frame = cv2.resize(frame, (CAMERA_WIDTH, CAMERA_HEIGHT))
+
+    node.send_output("image", pa.array(frame.ravel()))
+
+
+# Release the VideoCapture object and any OpenCV windows
+cap.release()
+cv2.destroyAllWindows()

operators/plot.py

@@ -0,0 +1,83 @@
+import cv2
+
+
+from dora import DoraStatus
+
+
+CAMERA_WIDTH = 640
+CAMERA_HEIGHT = 480
+
+FONT = cv2.FONT_HERSHEY_SIMPLEX
+
+writer = cv2.VideoWriter(
+    "output01.avi",
+    cv2.VideoWriter_fourcc(*"MJPG"),
+    30,
+    (CAMERA_WIDTH, CAMERA_HEIGHT),
+)
+
+
+class Operator:
+    """
+    Plot image and bounding box
+    """
+
+    def __init__(self):
+        self.bboxs = []
+        self.buffer = ""
+        self.submitted = []
+        self.lines = []
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ):
+        if dora_event["type"] == "INPUT":
+            id = dora_event["id"]
+            value = dora_event["value"]
+            if id == "image":
+
+                image = (
+                    value.to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3)).copy()
+                )
+
+                cv2.putText(
+                    image, self.buffer, (20, 14 + 15 * 25), FONT, 0.8, (190, 250, 0), 2
+                )
+
+                i = 0
+                for text in self.submitted[::-1]:
+                    color = (
+                        (0, 255, 190)
+                        if text["role"] == "user_message"
+                        else (0, 190, 255)
+                    )
+                    cv2.putText(
+                        image,
+                        text["content"],
+                        (
+                            20,
+                            14 + (13 - i) * 25,
+                        ),
+                        FONT,
+                        0.8,
+                        color,
+                        2,
+                    )
+                    i += 1
+                writer.write(image)
+                cv2.imshow("frame", image)
+                if cv2.waitKey(1) & 0xFF == ord("q"):
+                    return DoraStatus.STOP
+            elif id == "keyboard_buffer":
+                self.buffer = value[0].as_py()
+            elif "message" in id:
+                self.submitted += [
+                    {
+                        "role": id,
+                        "content": value[0].as_py(),
+                    }
+                ]
+
+        return DoraStatus.CONTINUE

operators/robot.py

@@ -0,0 +1,111 @@
+from robomaster import robot
+from typing import Callable, Optional, Union
+from enum import Enum
+from dora import DoraStatus
+
+import pyarrow as pa
+
+
+CONN = "ap"
+
+
+class Command(Enum):
+    NOD_YES = [
+        {"action": "gimbal", "value": [20.0, 0.0]},
+        {"action": "gimbal", "value": [0.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]},
+    ]
+    FORWARD = [
+        {
+            "action": "control",
+            "value": [0.5, 0.0, 0.0, 0.6, 0],
+        }
+    ]
+    BACKWARD = [
+        {
+            "action": "control",
+            "value": [-0.5, 0.0, 0.0, 0.6, 0],
+        }
+    ]
+    TURN_LEFT = [
+        {"action": "gimbal", "value": [0.0, -45.0]},
+        {
+            "action": "control",
+            "value": [0.0, 0.0, 45.0, 0.0, 50],
+        },
+    ]
+    TURN_RIGHT = [
+        {"action": "gimbal", "value": [0.0, 45.0]},
+        {
+            "value": [0.0, 0.0, -45.0, 0.0, 50],
+            "action": "control",
+        },
+    ]
+    UNKNOWN = [
+        {
+            "value": [0.0, 0.0, 0.0, 0.0, 0],
+            "action": "control",
+        }
+    ]
+    # STOP = [0, 0, 0, 0]
+    # COMPLETED = [0, 0, 0, 0]
+
+    @classmethod
+    def parse(cls, value):
+        for k, v in cls.__members__.items():
+            if k == value:
+                return v
+        return cls.UNKNOWN
+
+
+class Operator:
+    def __init__(self):
+        self.ep_robot = robot.Robot()
+        print("Initializing robot...")
+        assert self.ep_robot.initialize(conn_type=CONN), "Could not initialize ep_robot"
+        assert self.ep_robot.camera.start_video_stream(
+            display=False
+        ), "Could not start video stream"
+
+        self.ep_robot.gimbal.recenter().wait_for_completed()
+        self.backlog = []
+        self.event = None
+
+    def on_event(
+        self,
+        dora_event: str,
+        send_output: Callable[[str, Union[bytes, pa.UInt8Array], 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 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.backlog += cmd.value
+
+        return DoraStatus.CONTINUE

operators/vlm_op.py

@@ -0,0 +1,273 @@
+from dora import DoraStatus
+import pylcs
+import os
+import pyarrow as pa
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import json
+
+import re
+import time
+
+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
+
+
+CHATGPT = True
+MODEL_NAME_OR_PATH = "TheBloke/deepseek-coder-6.7B-instruct-GPTQ"
+
+MESSAGE_SENDER_TEMPLATE = """
+### Instruction
+You're a json expert. Format your response as a json with a topic and a data field in a ```json block.  No explaination needed. No code needed.
+The schema for those json are:
+- forward
+- backward
+- left
+- right 
+
+The response should look like this: 
+```json
+
+ [
+  {{ "topic": "control", "data": "forward" }},
+]
+```
+
+{user_message}
+
+### Response:
+"""
+
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME_OR_PATH,
+    device_map="auto",
+    trust_remote_code=True,
+    revision="main",
+)
+
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME_OR_PATH, use_fast=True)
+
+
+def extract_json_code_blocks(text):
+    """
+    Extracts json code blocks from the given text that are enclosed in triple backticks with a json language identifier.
+
+    Parameters:
+    - text: A string that may contain one or more json code blocks.
+
+    Returns:
+    - A list of strings, where each string is a block of json code extracted from the text.
+    """
+    pattern = r"```json\n(.*?)\n```"
+    matches = re.findall(pattern, text, re.DOTALL)
+    if len(matches) == 0:
+        pattern = r"```json\n(.*?)(?:\n```|$)"
+        matches = re.findall(pattern, text, re.DOTALL)
+        if len(matches) == 0:
+            return [text]
+
+    return matches
+
+
+from openai import OpenAI
+import os
+
+import base64
+import requests
+
+API_TOKEN = os.getenv("HF_TOKEN")
+
+
+# Function to encode the image
+def encode_image(image_path):
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("utf-8")
+
+
+def understand_image(image_path):
+
+    # Getting the base64 string
+    base64_image = encode_image(image_path)
+
+    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
+
+    payload = {
+        "model": "gpt-4-vision-preview",
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "What’s in this image? Describe it in a short sentence",
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
+                    },
+                ],
+            }
+        ],
+        "max_tokens": 300,
+    }
+
+    response = requests.post(
+        "https://api.openai.com/v1/chat/completions", headers=headers, json=payload
+    )
+
+    print(response.json()["choices"][0]["message"]["content"])
+
+
+class Operator:
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT" and dora_event["id"] == "message_sender":
+            user_message = dora_event["value"][0].as_py()
+            output = self.ask_llm(
+                MESSAGE_SENDER_TEMPLATE.format(user_message=user_message)
+            )
+            outputs = extract_json_code_blocks(output)[0]
+            print("response: ", output, flush=True)
+            try:
+                outputs = json.loads(outputs)
+                if not isinstance(outputs, list):
+                    outputs = [outputs]
+                for output in outputs:
+                    if not isinstance(output["data"], list):
+                        output["data"] = [output["data"]]
+
+                    if output["topic"] in ["led", "blaster"]:
+                        send_output(
+                            output["topic"],
+                            pa.array(output["data"]),
+                            dora_event["metadata"],
+                        )
+
+                        send_output(
+                            "assistant_message",
+                            pa.array([f"sent: {output}"]),
+                            dora_event["metadata"],
+                        )
+                    else:
+                        send_output(
+                            "assistant_message",
+                            pa.array(
+                                [f"Could not send as topic was not available: {output}"]
+                            ),
+                            dora_event["metadata"],
+                        )
+            except:
+                send_output(
+                    "assistant_message",
+                    pa.array([f"Could not parse json: {outputs}"]),
+                    dora_event["metadata"],
+                )
+            # if data is not iterable, put data in a list
+        return DoraStatus.CONTINUE
+
+    def ask_llm(self, prompt):
+
+        # Generate output
+        # prompt = PROMPT_TEMPLATE.format(system_message=system_message, prompt=prompt))
+        input = tokenizer(prompt, return_tensors="pt")
+        input_ids = input.input_ids.cuda()
+
+        # add attention mask here
+        attention_mask = input["attention_mask"]
+
+        output = model.generate(
+            inputs=input_ids,
+            temperature=0.7,
+            do_sample=True,
+            top_p=0.95,
+            top_k=40,
+            max_new_tokens=512,
+            attention_mask=attention_mask,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+        # Get the tokens from the output, decode them, print them
+
+        # Get text between im_start and im_end
+        return tokenizer.decode(output[0], skip_special_tokens=True)[len(prompt) :]
+
+    def ask_chatgpt(self, prompt):
+        from openai import OpenAI
+
+        client = OpenAI()
+        print("---asking chatgpt: ", prompt, flush=True)
+        response = client.chat.completions.create(
+            model="gpt-4-turbo-preview",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt},
+            ],
+        )
+        answer = response.choices[0].message.content
+
+        print("Done", flush=True)
+        return answer
+
+
+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 + "/planning_op.py"
+    with open(path, "r", encoding="utf8") as f:
+        raw = f.read()
+
+    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/whisper_op.py

@@ -0,0 +1,25 @@
+import pyarrow as pa
+import whisper
+
+from dora import DoraStatus
+
+
+model = whisper.load_model("base")
+
+
+class Operator:
+    """
+    Transforming Speech to Text using OpenAI Whisper model
+    """
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            audio = dora_event["value"].to_numpy()
+            audio = whisper.pad_or_trim(audio)
+            result = model.transcribe(audio, language="en")
+            send_output("text", pa.array([result["text"]]), dora_event["metadata"])
+        return DoraStatus.CONTINUE

tests/test_idefix2.py

@@ -0,0 +1,154 @@
+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))

tests/test_robomaster.py

@@ -0,0 +1,7 @@
+from robomaster import robot, blaster, led
+
+CONN = "ap"
+ep_robot = robot.Robot()
+print("Initializing robot...")
+assert ep_robot.initialize(conn_type=CONN), "Could not initialize ep_robot"
+event = ep_robot.chassis.move(x=0, y=0, z=-90.0, xy_speed=0, z_speed=50)