Adding policy node for controlling the robot

README.md

@@ -51,7 +51,7 @@ dora up
 dora start graphs/dataflow_robot_vlm.yml --attach --hot-reload
 ```
 
-Current way to interact is by typing a question to the VLM
+Current way to interact is by press up arrow key on laptop to record a message and send to the VLM
 
 ## Running the demo without robot
 
@@ -64,4 +64,12 @@ dora up
 dora start graphs/dataflow_vlm_basic.yml --attach --hot-reload
 ```
 
-Current way to interact is by typing a question to the VLM
+Current way to interact is by press up arrow key on laptop to record a message and send to the VLM
+
+## Kill process in case of failure
+
+Due to a Python GIL issue, we currently meed to kill processes manually. You can use the following command to do so:
+
+```bash
+pkill -f 'import dora;'
+```

graphs/dataflow_robot_vlm.yml

@@ -5,20 +5,8 @@ nodes:
       python: ../operators/plot.py
       inputs:
         image: webcam/image
-        assistant_message: vlm/assistant_message
         user_message: whisper/text
-
-  - id: vlm
-    operator:
-      python: ../operators/idefics2_op.py
-      inputs: 
-        image:
-          source: webcam/image
-          queue_size: 1
-        instruction: whisper/text
-        control_reply: robot/control_reply
-      outputs:
-        - assistant_message
+        position: robot/position
 
   - id: robot
     operator:
@@ -27,10 +15,10 @@ nodes:
         conda_env: robomaster
       inputs:
         tick: dora/timer/millis/750
-        control: whisper/text 
-        assistant_message: vlm/assistant_message
+        planning_control: planning/control
       outputs:
         - control_reply
+        - position
 
   - id: webcam
     custom:
@@ -42,6 +30,40 @@ nodes:
     operator:
       python: ../operators/whisper_op.py
       inputs:
-        audio: dora/timer/millis/500
+        audio: dora/timer/millis/1000
       outputs:
-        - text
+        - text
+
+  - id: llm
+    operator:
+      python: ../operators/llm_op.py
+      inputs:
+        text: whisper/text
+        reloaded: policy/reloaded
+      outputs:
+        - init
+
+  - id: policy
+    operator:
+      python: ../operators/policy.py
+      inputs: 
+        init: llm/init
+        goal_reached: planning/goal_reached
+      outputs:
+        - set_goal
+        - reloaded
+
+  - id: planning
+    operator:
+      python: ../operators/planning_op.py
+      inputs:
+        position: robot/position
+        control_reply: robot/control_reply
+        set_goal: policy/set_goal
+        image: webcam/image
+      outputs:
+        - control
+        - goal_reached
+
+  
+      

graphs/dataflow_vlm_basic.yml

@@ -5,9 +5,9 @@ nodes:
       python: ../operators/plot.py
       inputs:
         image: webcam/image
-        keyboard_buffer: keyboard/buffer
-        user_message: keyboard/submitted
+        user_message: whisper/text
         assistant_message: vlm/assistant_message
+        bbox: object_detection/bbox
 
   - id: vlm
     operator:
@@ -16,7 +16,7 @@ nodes:
         image:
           source: webcam/image
           queue_size: 1
-        instruction: keyboard/submitted
+        instruction: whisper/text
       outputs:
         - assistant_message
   
@@ -28,9 +28,18 @@ nodes:
       outputs:
         - image
 
-  - id: keyboard
-    custom:
-      source: ../operators/keyboard_op.py
+  - id: whisper
+    operator:
+      python: ../operators/whisper_op.py
+      inputs:
+        audio: dora/timer/millis/1000
+      outputs:
+        - text
+
+  - id: object_detection
+    operator:
+      python: ../operators/object_detection.py
+      inputs:
+        image: webcam/image
       outputs:
-        - buffer
-        - submitted
+        - bbox

operators/llm_op.py

@@ -0,0 +1,228 @@
+from dora import DoraStatus
+import pylcs
+import os
+import pyarrow as pa
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+import re
+import time
+
+CHATGPT = False
+MODEL_NAME_OR_PATH = "TheBloke/deepseek-coder-6.7B-instruct-GPTQ"
+
+CODE_MODIFIER_TEMPLATE = """
+### Instruction
+Respond with one block of modified code only in ```python block. No explaination.
+
+```python
+{code}
+```
+
+{user_message}
+
+### Response:
+"""
+
+
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME_OR_PATH,
+    device_map="auto",
+    trust_remote_code=True,
+    revision="main",
+).to("cuda:0")
+
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME_OR_PATH, use_fast=True)
+
+
+def extract_python_code_blocks(text):
+    """
+    Extracts Python code blocks from the given text that are enclosed in triple backticks with a python language identifier.
+
+    Parameters:
+    - text: A string that may contain one or more Python code blocks.
+
+    Returns:
+    - A list of strings, where each string is a block of Python code extracted from the text.
+    """
+    pattern = r"```python\n(.*?)\n```"
+    matches = re.findall(pattern, text, re.DOTALL)
+    if len(matches) == 0:
+        pattern = r"```python\n(.*?)(?:\n```|$)"
+        matches = re.findall(pattern, text, re.DOTALL)
+        if len(matches) == 0:
+            return [text]
+        else:
+            matches = [remove_last_line(matches[0])]
+
+    return matches
+
+
+def remove_last_line(python_code):
+    """
+    Removes the last line from a given string of Python code.
+
+    Parameters:
+    - python_code: A string representing Python source code.
+
+    Returns:
+    - A string with the last line removed.
+    """
+    lines = python_code.split("\n")  # Split the string into lines
+    if lines:  # Check if there are any lines to remove
+        lines.pop()  # Remove the last line
+    return "\n".join(lines)  # Join the remaining lines back into a string
+
+
+def calculate_similarity(source, target):
+    """
+    Calculate a similarity score between the source and target strings.
+    This uses the edit distance relative to the length of the strings.
+    """
+    edit_distance = pylcs.edit_distance(source, target)
+    max_length = max(len(source), len(target))
+    # Normalize the score by the maximum possible edit distance (the length of the longer string)
+    similarity = 1 - (edit_distance / max_length)
+    return similarity
+
+
+def find_best_match_location(source_code, target_block):
+    """
+    Find the best match for the target_block within the source_code by searching line by line,
+    considering blocks of varying lengths.
+    """
+    source_lines = source_code.split("\n")
+    target_lines = target_block.split("\n")
+
+    best_similarity = 0
+    best_start_index = 0
+    best_end_index = -1
+
+    # Iterate over the source lines to find the best matching range for all lines in target_block
+    for start_index in range(len(source_lines) - len(target_lines) + 1):
+        for end_index in range(start_index + len(target_lines), len(source_lines) + 1):
+            current_window = "\n".join(source_lines[start_index:end_index])
+            current_similarity = calculate_similarity(current_window, target_block)
+            if current_similarity > best_similarity:
+                best_similarity = current_similarity
+                best_start_index = start_index
+                best_end_index = end_index
+
+    # Convert line indices back to character indices for replacement
+    char_start_index = len("\n".join(source_lines[:best_start_index])) + (
+        1 if best_start_index > 0 else 0
+    )
+    char_end_index = len("\n".join(source_lines[:best_end_index]))
+
+    return char_start_index, char_end_index
+
+
+def replace_code_in_source(source_code, replacement_block: str):
+    """
+    Replace the best matching block in the source_code with the replacement_block, considering variable block lengths.
+    """
+    replacement_block = extract_python_code_blocks(replacement_block)[0]
+    start_index, end_index = find_best_match_location(source_code, replacement_block)
+    if start_index != -1 and end_index != -1:
+        # Replace the best matching part with the replacement block
+        new_source = (
+            source_code[:start_index] + replacement_block + source_code[end_index:]
+        )
+        return new_source
+    else:
+        return source_code
+
+
+class Operator:
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT" and dora_event["id"] == "text":
+            input = dora_event["value"][0].as_py()
+            # 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 + "/policy.py"
+
+            with open(path, "r", encoding="utf8") as f:
+                code = f.read()
+
+            user_message = input
+            start_llm = time.time()
+
+            output = self.ask_llm(
+                CODE_MODIFIER_TEMPLATE.format(code=code, user_message=user_message)
+            )
+
+            source_code = replace_code_in_source(code, output)
+            print("response time:", time.time() - start_llm, flush=True)
+
+            print("response: ", output, flush=True)
+            with open(path, "w") as file:
+                file.write(source_code)
+            time.sleep(10)
+            send_output("init", pa.array([]))
+
+        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.cuda()
+
+        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) :]
+
+
+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 + "/policy.py"
+    with open(path, "r", encoding="utf8") as f:
+        raw = f.read()
+
+    op.on_event(
+        {
+            "type": "INPUT",
+            "id": "text",
+            "value": pa.array(
+                [
+                    {
+                        "path": path,
+                        "user_message": "set the goal to kitchen. When you are in the kitchen ask the model if there is someone with blue shirt, if there is speak and say can I have coffee, if there is no one set the goal to home ",
+                    },
+                ]
+            ),
+            "metadata": [],
+        },
+        print,
+    )

operators/planning_op.py

@@ -0,0 +1,194 @@
+import time
+import numpy as np
+import pyarrow as pa
+from dora import DoraStatus
+
+GOAL = np.array([10, 20])
+
+HOME_TO_KITCHEN = np.array([[0.5, 0], [0.5, -5.0], [1.0, 7.0]])
+KITCHEN_TO_HOME = np.array([[2.0, 0.0], [0.0, 0.0]])
+
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+
+
+def check_clear_road(bboxes, image_width, goal_x):
+    """
+    Find the x-coordinate of the midpoint of the largest gap along the x-axis where no bounding boxes overlap.
+
+    Parameters:
+    - bboxes (np.array): A numpy array where each row represents a bounding box with
+                         the format [min_x, min_y, max_x, max_y, confidence, label].
+    - image_width (int): The width of the image in pixels.
+
+    Returns:
+    - int: The x-coordinate of the midpoint of the largest gap where no bounding boxes overlap.
+    """
+    if bboxes.size == 0:
+        # No bounding boxes, return the midpoint of the image as the largest gap
+        return goal_x
+
+    events = []
+    for bbox in bboxes:
+        min_x, max_x = bbox[0], bbox[2]
+        events.append((min_x, "enter"))
+        events.append((max_x, "exit"))
+
+    # Include image boundaries as part of the events
+    events.append(
+        (0, "exit")
+    )  # Start of the image, considered an 'exit' point for logic simplicity
+    events.append(
+        (image_width, "enter")
+    )  # End of the image, considered an 'enter' point
+
+    # Sort events, with exits before enters at the same position to ensure gap calculation correctness
+    events.sort(key=lambda x: (x[0], x[1] == "enter"))
+
+    # Sweep line algorithm to find the largest gap
+    current_boxes = 1
+    last_x = 0
+    largest_gap = 0
+    gap_start_x = None
+    largest_gap_mid = None  # Midpoint of the largest gap
+
+    for x, event_type in events:
+        if current_boxes == 0 and gap_start_x is not None:
+            # Calculate gap
+            gap = x - gap_start_x
+            gap_end_x = gap_start_x + x
+            if goal_x < gap_end_x and goal_x > gap_start_x:
+                return True
+            elif goal_x < gap_start_x:
+                return False
+        if event_type == "enter":
+            current_boxes += 1
+            if current_boxes == 1:
+                gap_start_x = None  # No longer in a gap
+        elif event_type == "exit":
+            current_boxes -= 1
+            if current_boxes == 0:
+                gap_start_x = x  # Start of a potential gap
+
+    return False
+
+
+class Operator:
+    def __init__(self):
+        self.bboxs = None
+        self.time = time.time()
+        self.position = [0, 0, 0]
+        self.waypoints = None
+        self.tf = np.array([[1, 0], [0, 1]])
+        self.count = 0
+        self.completed = True
+        self.image = None
+
+    def on_event(
+        self,
+        dora_event: dict,
+        send_output,
+    ) -> DoraStatus:
+        global POSITION_GOAL, GIMBAL_GOAL
+        if dora_event["type"] == "INPUT":
+            id = dora_event["id"]
+            if id == "tick":
+                self.time = time.time()
+            elif id == "image":
+                value = dora_event["value"].to_numpy()
+
+                self.image = value.reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+            elif id == "control_reply":
+                value = dora_event["value"].to_numpy()[0]
+                if value == self.count:
+                    self.completed = True
+            elif id == "set_goal":
+                print("got goal:", dora_event["value"], flush=True)
+
+                if len(dora_event["value"]) > 0:
+                    self.waypoints = dora_event["value"].to_numpy().reshape((-1, 2))
+            elif id == "position":
+                ## No bounding box yet
+                if self.waypoints is None or len(self.waypoints) == 0:
+                    print("no waypoint", flush=True)
+                    return DoraStatus.CONTINUE
+                if self.completed == False:
+                    print("not completed", flush=True)
+                    return DoraStatus.CONTINUE
+                value = dora_event["value"].to_numpy()
+                [x, y, z] = value
+                self.position = [x, y, z]
+
+                # Remove waypoints if completed
+                if (
+                    len(self.waypoints) > 0
+                    and np.linalg.norm(self.waypoints[0] - [x, y]) < 0.2
+                ):
+                    self.waypoints = self.waypoints[1:]
+                    print("removing waypoints", flush=True)
+                    if len(self.waypoints) == 0:
+                        print("no waypoint", flush=True)
+                        send_output("goal_reached", pa.array(self.image.ravel()))
+                        return DoraStatus.CONTINUE
+
+                z = np.deg2rad(z)
+                self.tf = np.array([[np.cos(z), -np.sin(z)], [np.sin(z), np.cos(z)]])
+                goal = self.tf.dot(self.waypoints[0])
+                goal_camera_x = (
+                    CAMERA_WIDTH * np.arctan2(goal[1], goal[0]) / np.pi
+                ) + CAMERA_WIDTH / 2
+                goal_angle = np.arctan2(goal[1], goal[0]) * 180 / np.pi
+                print(
+                    "position",
+                    [x, y],
+                    "goal:",
+                    goal,
+                    "Goal angle: ",
+                    np.arctan2(goal[1], goal[0]) * 180 / np.pi,
+                    "z: ",
+                    np.rad2deg(z),
+                    "x: ",
+                    goal_camera_x,
+                    "count: ",
+                    self.count,
+                    flush=True,
+                )
+
+                if True:  # check_clear_road(self.bboxs, CAMERA_WIDTH, goal_camera_x):
+                    self.count += 1
+                    self.completed = False
+                    send_output(
+                        "control",
+                        pa.array(
+                            [
+                                {
+                                    "action": "gimbal",
+                                    "value": [0.0, goal_angle],
+                                    "count": self.count,
+                                },
+                                # {
+                                # "value": [
+                                # 0.0,
+                                # 0.0,
+                                # -goal_angle,
+                                # 0.0,
+                                # 50,
+                                # ],
+                                # "action": "control",
+                                # },
+                                {
+                                    "value": [
+                                        goal[0],
+                                        goal[1],
+                                        0.0,  # -goal_angle,
+                                        0.6,
+                                        0.0,  # 50,
+                                    ],
+                                    "action": "control",
+                                },
+                            ]
+                        ),
+                        dora_event["metadata"],
+                    )
+
+        return DoraStatus.CONTINUE

operators/policy.py

@@ -0,0 +1,44 @@
+from dora import DoraStatus
+import numpy as np
+import pyarrow as pa
+from idefics2_utils import ask_vlm
+import pyttsx3
+
+
+KITCHEN = np.array([[0.5, 0], [0.5, -0.5], [1.0, -1.0]]).ravel()
+HOME = np.array([[0.5, -0.5], [0, 0]]).ravel()
+
+
+## Policy Operator
+class Operator:
+    def __init__(self):
+        engine = pyttsx3.init("espeak")
+        voices = engine.getProperty("voices")
+        engine.setProperty("voice", voices[3].id)
+        self.engine = engine
+
+    def speak(self, text: str):
+        self.engine.say(text)
+
+    # Ask vision model for information
+    def ask_model(self, image: np.ndarray, text: str) -> str:
+        text = ask_vlm(image, text)
+        return "Yes, " in text
+
+    def on_event(
+        self,
+        dora_event: dict,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            id = dora_event["id"]
+            # On initialization
+            if id == "init":
+                send_output("set_goal", pa.array([]))
+
+            # On destination goal reached
+            elif id == "goal_reached":
+                image = dora_event["value"].to_numpy().reshape((540, 960, 3))
+                pass
+
+        return DoraStatus.CONTINUE

operators/robot.py

@@ -3,6 +3,7 @@ from typing import Callable, Optional, Union
 from enum import Enum
 from dora import DoraStatus
 
+import numpy as np
 import pyarrow as pa
 
 
@@ -86,6 +87,8 @@ class Operator:
         )
         self.backlog = []
         self.last_control = ""
+        self.position = np.array([0, 0, 0])
+        self.count = -1
 
     def execute_backlog(self):
         if len(self.backlog) > 0:
@@ -96,6 +99,8 @@ class Operator:
                 self.event = self.ep_robot.chassis.move(
                     x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
                 )
+                self.position = np.array([x, y, z])
+
             elif command["action"] == "gimbal":
                 [pitch, yaw] = command["value"]
                 print(command, flush=True)
@@ -111,6 +116,7 @@ class Operator:
         event_type = dora_event["type"]
         if event_type == "INPUT":
             if dora_event["id"] == "tick":
+
                 if not (
                     self.event is not None
                     and not (self.event._event.isSet() and self.event.is_completed)
@@ -119,7 +125,11 @@ class Operator:
                         self.execute_backlog()
                     else:
                         print(f"sending control reply: {self.last_control}", flush=True)
-                        send_output("control_reply", pa.array([self.last_control]))
+                        send_output("position", pa.array(self.position))
+                        send_output("control_reply", pa.array([self.count]))
+                elif self.event is None:
+                    send_output("position", pa.array(self.position))
+
             elif dora_event["id"] == "control":
                 raw_command = dora_event["value"][0].as_py()
                 print(raw_command, flush=True)
@@ -151,8 +161,13 @@ class Operator:
                     cmd = Command.NOD_YES
                 else:
                     cmd = Command.UNKNOWN
-                if len(self.backlog) == 0:
                     self.backlog += cmd.value
                     self.execute_backlog()
+            elif dora_event["id"] == "planning_control":
+                command = dora_event["value"].to_pylist()
+                self.count = command[0]["count"]
+                if len(self.backlog) == 0:
+                    self.backlog += command
+                    self.execute_backlog()
 
         return DoraStatus.CONTINUE

operators/whisper_op.py

@@ -11,7 +11,7 @@ import sounddevice as sd
 model = whisper.load_model("base")
 
 SAMPLE_RATE = 16000
-MAX_DURATION = 5
+MAX_DURATION = 15
 
 
 class Operator: