Use whisper instead of keyboard

graphs/dataflow_robot_vlm.yml

@@ -6,8 +6,7 @@ nodes:
       inputs:
         image: webcam/image
         assistant_message: vlm/assistant_message
-        keyboard_buffer: keyboard/buffer
-        user_message: keyboard/submitted
+        user_message: whisper/text
 
   - id: vlm
     operator:
@@ -16,7 +15,7 @@ nodes:
         image:
           source: webcam/image
           queue_size: 1
-        instruction: keyboard/submitted
+        instruction: whisper/text
         control_reply: robot/control_reply
       outputs:
         - assistant_message
@@ -28,7 +27,8 @@ nodes:
         conda_env: robomaster
       inputs:
         tick: dora/timer/millis/750
-        control: keyboard/submitted
+        control: whisper/text 
+        assistant_message: vlm/assistant_message
       outputs:
         - control_reply
 
@@ -38,25 +38,10 @@ nodes:
       outputs:
         - image
   
-  - id: keyboard
-    custom:
-      source: ../operators/keyboard_op.py
-      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
+        audio: dora/timer/millis/500
       outputs:
-        - audio
+        - text

operators/idefics2_op.py

@@ -27,9 +27,9 @@ def speak(text):
 
 class Operator:
     def __init__(self):
-        self.completed = True
         self.instruction = "What is in the image?"
         self.last_message = ""
+        self.image = None
 
     def on_event(
         self,
@@ -38,54 +38,24 @@ class Operator:
     ) -> 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)
+                self.image = (
+                    dora_event["value"]
+                    .to_numpy()
+                    .reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+                )
             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,
+
+                if self.image is not None:
+                    output = ask_vlm(self.image, self.instruction)
+                    speak(output)
+                    print("response: ", output, flush=True)
+                    send_output(
+                        "assistant_message",
+                        pa.array([output]),
+                        dora_event["metadata"],
                     )
+
+                    self.last_message = output
         return DoraStatus.CONTINUE

operators/keyboard_op.py

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

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

@@ -12,50 +12,50 @@ CONN = "ap"
 class Command(Enum):
     NOD_YES = [
         {"action": "gimbal", "value": [20.0, 0.0]},
-        {"action": "gimbal", "value": [-5.0, 0.0]},
+        {"action": "gimbal", "value": [0.0, 0.0]},
     ]
     NOD_NO = [
-        {"action": "gimbal", "value": [-5, -55.0]},
-        {"action": "gimbal", "value": [-5, 55.0]},
-        {"action": "gimbal", "value": [-5.0, 0.0]},
+        {"action": "gimbal", "value": [0, -55.0]},
+        {"action": "gimbal", "value": [0.0, 0.0]},
     ]
     FORWARD = [
         {
             "action": "control",
-            "value": [0.5, 0.0, 0.0, 0.6, 0],
+            "value": [2.0, 0.0, 0.0, 0.8, 0],
         }
     ]
     BACKWARD = [
+        {"action": "gimbal", "value": [0, -180.0]},
         {
             "action": "control",
-            "value": [-0.5, 0, 180.0, 0.6, 30],
+            "value": [-2.0, 0, 180.0, 0.8, 50],
         },
     ]
     LEFT = [
-        {"action": "gimbal", "value": [-5, -30.0]},
+        {"action": "gimbal", "value": [0, -90.0]},
         {
             "action": "control",
-            "value": [0.2, -0.2, 30.0, 0.6, 30],
+            "value": [0.0, -1.0, 90.0, 0.6, 50],
         },
     ]
     SLIGHT_LEFT = [
-        {"action": "gimbal", "value": [-0.0, -15.0]},
+        {"action": "gimbal", "value": [0.0, -30.0]},
         {
             "action": "control",
-            "value": [0.3, -0.1, 15.0, 0.6, 50],
+            "value": [1.0, -0.5, 30.0, 0.6, 50],
         },
     ]
     RIGHT = [
-        {"action": "gimbal", "value": [-5, 30.0]},
+        {"action": "gimbal", "value": [0.0, 90.0]},
         {
-            "value": [0.2, 0.2, -30.0, 0.6, 30],
+            "value": [0.0, 1.0, -90.0, 0.6, 50],
             "action": "control",
         },
     ]
     SLIGHT_RIGHT = [
-        {"action": "gimbal", "value": [-20.0, 15.0]},
+        {"action": "gimbal", "value": [0.0, 30.0]},
         {
-            "value": [0.3, 0.1, -15.0, 0.6, 50],
+            "value": [1.0, 0.5, -30.0, 0.6, 50],
             "action": "control",
         },
     ]
@@ -124,20 +124,35 @@ class Operator:
                 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
+                if "slight right" in raw_command:
+                    cmd = Command.BACKWARD
+                elif "slight left" in raw_command:
+                    cmd = Command.BACKWARD
                 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:
+                elif "backward" in raw_command:
                     cmd = Command.BACKWARD
                 else:
                     cmd = Command.UNKNOWN
                 if len(self.backlog) == 0:
                     self.backlog += cmd.value
                     self.execute_backlog()
+            elif dora_event["id"] == "assistant_message":
+                raw_command = dora_event["value"][0].as_py()
+                print(raw_command, flush=True)
+                self.last_control = raw_command
+                if "No, " in raw_command:
+                    cmd = Command.NOD_NO
+                elif "Yes, " in raw_command:
+                    cmd = Command.NOD_YES
+                else:
+                    cmd = Command.UNKNOWN
+                if len(self.backlog) == 0:
+                    self.backlog += cmd.value
+                    self.execute_backlog()
 
         return DoraStatus.CONTINUE

operators/vlm_op.py

@@ -1,273 +0,0 @@
-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 copy.py

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

operators/whisper_op.py

@@ -1,11 +1,18 @@
 import pyarrow as pa
 import whisper
-
+from pynput import keyboard
+from pynput.keyboard import Key
 from dora import DoraStatus
 
+import numpy as np
+import pyarrow as pa
+import sounddevice as sd
 
 model = whisper.load_model("base")
 
+SAMPLE_RATE = 16000
+MAX_DURATION = 5
+
 
 class Operator:
     """
@@ -18,8 +25,26 @@ class Operator:
         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"])
+            ## Check for keyboard event
+            with keyboard.Events() as events:
+                event = events.get(1.0)
+                if event is not None and event.key == Key.up:
+
+                    ## Microphone
+                    audio_data = sd.rec(
+                        int(SAMPLE_RATE * MAX_DURATION),
+                        samplerate=SAMPLE_RATE,
+                        channels=1,
+                        dtype=np.int16,
+                        blocking=True,
+                    )
+
+                    audio = audio_data.ravel().astype(np.float32) / 32768.0
+
+                    ## Speech to text
+                    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