Fix demo testing

graphs/dataflow_robot_vlm.yml

@@ -50,7 +50,7 @@ nodes:
         init: llm/init
         goal_reached: planning/goal_reached
       outputs:
-        - set_goal
+        - go_to
         - reloaded
 
   - id: planning
@@ -59,7 +59,7 @@ nodes:
       inputs:
         position: robot/position
         control_reply: robot/control_reply
-        set_goal: policy/set_goal
+        set_goal: policy/go_to
         image: webcam/image
       outputs:
         - control

operators/llm_op.py

@@ -30,6 +30,7 @@ model = AutoModelForCausalLM.from_pretrained(
     device_map="auto",
     trust_remote_code=True,
     revision="main",
+    max_length=1024,
 ).to("cuda:0")
 
 
@@ -166,9 +167,12 @@ class Operator:
             print("response: ", output, flush=True)
             with open(path, "w") as file:
                 file.write(source_code)
-            time.sleep(10)
+            time.sleep(8)
             send_output("init", pa.array([]))
 
+            ## Stopping to liberate GPU space
+            return DoraStatus.STOP
+
         return DoraStatus.CONTINUE
 
     def ask_llm(self, prompt):
@@ -218,7 +222,7 @@ if __name__ == "__main__":
                 [
                     {
                         "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 ",
+                        "user_message": "Ask model if there is someone with a red shirt, if there is, say I'm bringing coffee, and go to the kitchen, if no one go home",
                     },
                 ]
             ),

operators/planning_op.py

@@ -109,7 +109,7 @@ class Operator:
                     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:
+                if self.waypoints is None:
                     print("no waypoint", flush=True)
                     return DoraStatus.CONTINUE
                 if self.completed == False:
@@ -126,10 +126,11 @@ class Operator:
                 ):
                     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
+                if len(self.waypoints) == 0:
+                    print("goal reached", flush=True)
+                    send_output("goal_reached", pa.array(self.image.ravel()))
+                    self.waypoints = None
+                    return DoraStatus.CONTINUE
 
                 z = np.deg2rad(z)
                 self.tf = np.array([[np.cos(z), -np.sin(z)], [np.sin(z), np.cos(z)]])
@@ -178,8 +179,8 @@ class Operator:
                                 # },
                                 {
                                     "value": [
-                                        goal[0],
-                                        goal[1],
+                                        self.waypoints[0][0],
+                                        self.waypoints[0][1],
                                         0.0,  # -goal_angle,
                                         0.6,
                                         0.0,  # 50,

operators/plot.py

@@ -1,5 +1,5 @@
 import cv2
-
+import numpy as np
 
 from dora import DoraStatus
 
@@ -16,6 +16,78 @@ writer = cv2.VideoWriter(
     (CAMERA_WIDTH, CAMERA_HEIGHT),
 )
 
+GOAL_OBJECTIVES = [10, 0]
+
+import numpy as np
+
+
+def find_largest_gap_midpoint(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 image_width // 2
+
+    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
+            if gap > largest_gap:
+                largest_gap = gap
+                gap_end_x = gap_start_x + x
+                largest_gap_mid = (gap_start_x + x) // 2
+                if goal_x < gap_end_x and goal_x > gap_start_x:
+                    return goal_x
+                return largest_gap_mid
+                # elif goal_x > gap_end_x:
+                # return max(gap_end_x - 50, largest_gap_mid)
+                # elif goal_x < gap_start_x:
+                # return min(gap_start_x + 50, largest_gap_mid)
+
+        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 largest_gap_mid
+
 
 class Operator:
     """
@@ -27,6 +99,8 @@ class Operator:
         self.buffer = ""
         self.submitted = []
         self.lines = []
+        self.gap_x = CAMERA_WIDTH // 2
+        self.position = [0, 0, 0]
 
     def on_event(
         self,
@@ -36,6 +110,13 @@ class Operator:
         if dora_event["type"] == "INPUT":
             id = dora_event["id"]
             value = dora_event["value"]
+
+            if id == "position":
+
+                value = dora_event["value"].to_numpy()
+                [x, y, z] = value
+                self.position = [x, y, z]
+
             if id == "image":
 
                 image = (
@@ -74,6 +155,12 @@ class Operator:
                     return DoraStatus.STOP
             elif id == "keyboard_buffer":
                 self.buffer = value[0].as_py()
+            elif id == "bbox":
+                self.bboxs = value.to_numpy().reshape((-1, 6))
+
+                self.gap_x = find_largest_gap_midpoint(
+                    self.bboxs, image_width=CAMERA_WIDTH, goal_x=10
+                )
             elif "message" in id:
                 self.submitted += [
                     {
@@ -86,3 +173,8 @@ class Operator:
                 ]
 
         return DoraStatus.CONTINUE
+
+
+## Angle = Arctan Proj Object y / x
+
+## Relation linearire 0 - 60 ; 0 - CAMERA_WIDTH

operators/policy.py

@@ -1,42 +1,27 @@
-from dora import DoraStatus
 import numpy as np
 import pyarrow as pa
-from idefics2_utils import ask_vlm
-import pyttsx3
-
+from dora import DoraStatus
+from utils import ask_vlm, speak
 
-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()
+COUCH = np.array([[0.5, 0], [0.5, 0.5]]).ravel()
+KITCHEN = np.array([[0.5, 0.0], [1.0, -1.0]]).ravel()
+HOME = np.array([[0.5, 0.0], [0.0, 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(text: str):
+        speak(text)
 
-    def speak(self, text: str):
-        self.engine.say(text)
-
-    # Ask vision model for information
-    def ask_model(self, image: np.ndarray, text: str) -> str:
+    def ask_model(self, image, text: str) -> bool:
         text = ask_vlm(image, text)
         return "Yes, " in text
 
-    def on_event(
-        self,
-        dora_event: dict,
-        send_output,
-    ) -> DoraStatus:
+    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
+                send_output("go_to", pa.array([]))
             elif id == "goal_reached":
                 image = dora_event["value"].to_numpy().reshape((540, 960, 3))
                 pass

operators/utils.py

@@ -0,0 +1,85 @@
+import torch
+
+
+from transformers import AutoProcessor, AutoModelForVision2Seq, AwqConfig
+
+import numpy as np
+import pyttsx3
+
+
+START_TO_COUCH = np.array([[0.5, 0], [0.5, 0.5]]).ravel()
+COUCH_TO_KITCHEN = np.array([[0.5, -0.5], [1.0, -1.0]]).ravel()
+KITCHEN_TO_START = np.array([[0.5, -0.5], [0, 0]]).ravel()
+
+engine = pyttsx3.init("espeak")
+voices = engine.getProperty("voices")
+engine.setProperty("voice", voices[3].id)
+
+
+def speak(text):
+    print(f"said {text}", flush=True)
+    engine.say(text)
+    engine.runAndWait()
+
+
+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]