Adding couple of working nodes

graphs/dataflow_vlm_basic.yml

@@ -1,45 +1,54 @@
 nodes:
-  ### Camera
-  - id: plot_bot
-    operator:
-      python: ../operators/plot.py
+  - id: plot
+    custom:
+      source: dora-rerun
       inputs:
         image: webcam/image
-        user_message: whisper/text
-        assistant_message: vlm/assistant_message
-        bbox: object_detection/bbox
+        textlog_whisper: whisper/text
+        textlog_vlm: idefics2/speak
+      envs:
+        IMAGE_WIDTH: 1280
+        IMAGE_HEIGHT: 720
+        IMAGE_DEPTH: 3
+        RERUN_MEMORY_LIMIT: 10%
 
-  - id: vlm
+  - id: idefics2
     operator:
-      python: ../operators/idefics2_op.py
+      python: ../operators/idefics2_op_demo.py
       inputs: 
         image:
           source: webcam/image
           queue_size: 1
-        instruction: whisper/text
+        text: whisper/text
       outputs:
-        - assistant_message
+        - speak
+        - control
   
-  - id: webcam
-    operator:
-      python: ../operators/webcam.py
+  - id: robot
+    custom:
+      source: /home/peter/miniconda3/envs/robomaster/bin/python
+      args: ../operators/robot_minimize.py 
       inputs:
-        tick: dora/timer/millis/50
+        control: idefics2/control
+
+  - id: webcam
+    custom:
+      source: ../operators/opencv_stream.py
       outputs:
         - image
 
   - id: whisper
-    operator:
-      python: ../operators/whisper_op.py
+    custom:
+      source: ../operators/whisper_op.py
       inputs:
         audio: dora/timer/millis/1000
       outputs:
         - text
 
-  - id: object_detection
+  - id: parler
     operator:
-      python: ../operators/object_detection.py
+      python:  ../operators/parler_op.py
       inputs:
-        image: webcam/image
-      outputs:
-        - bbox
+        text: 
+          source: idefics2/speak
+          queue_size: 1

graphs/dataflow_vlm_policy.yml

@@ -0,0 +1,58 @@
+nodes:
+  - id: plot
+    custom:
+      source: dora-rerun
+      inputs:
+        image: webcam/image
+        textlog_whisper: whisper/text
+      envs:
+        IMAGE_WIDTH: 1280
+        IMAGE_HEIGHT: 720
+        IMAGE_DEPTH: 3
+        RERUN_MEMORY_LIMIT: 10%
+
+  - id: policy
+    operator:
+      python: ../operators/policy.py
+      inputs: 
+        init: llm/init
+        reached_kitchen: robot/reached_kitchen
+        reached_living_room: robot/reached_living_room
+        reached_office: robot/reached_office
+      outputs:
+        - go_to
+  
+  - id: llm
+    operator:
+      python: ../operators/llm_op.py
+      inputs:
+        text: whisper/text
+      outputs:
+        - init
+  
+  - id: robot
+    custom:
+      source: /home/peter/miniconda3/envs/robomaster/bin/python
+      args: ../operators/robot_minimize.py 
+      inputs:
+        # control: idefics2/control
+        go_to: policy/go_to
+      outputs:
+        - reached_kitchen
+        - reached_living_room
+        - reached_office
+
+  - id: webcam
+    custom:
+      source: ../operators/opencv_stream.py
+      outputs:
+        - image
+
+  - id: whisper
+    custom:
+      source: ../operators/whisper_op.py
+      inputs:
+        audio: dora/timer/millis/1000
+      outputs:
+        - text
+

operators/idefics2_op_demo.py

@@ -0,0 +1,107 @@
+from dora import DoraStatus
+import pyarrow as pa
+from transformers import AutoProcessor, AutoModelForVision2Seq, AwqConfig
+import torch
+import gc
+
+CAMERA_WIDTH = 1280
+CAMERA_HEIGHT = 720
+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]
+model = AutoModelForVision2Seq.from_pretrained(
+    "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,
+        },
+    ),
+    trust_remote_code=True,
+).to("cuda")
+
+
+def reset_awq_cache(model):
+    """
+    Simple method to reset the AWQ fused modules cache
+    """
+    from awq.modules.fused.attn import QuantAttentionFused
+
+    for name, module in model.named_modules():
+        if isinstance(module, QuantAttentionFused):
+            module.start_pos = 0
+
+
+def ask_vlm(image, instruction):
+    global model
+    prompts = [
+        "User:",
+        image,
+        f"{instruction}.<end_of_utterance>\n",
+        "Assistant:",
+    ]
+    inputs = {k: torch.tensor(v).to("cuda") for k, v in PROCESSOR(prompts).items()}
+
+    generated_ids = model.generate(
+        **inputs,
+        bad_words_ids=BAD_WORDS_IDS,
+        max_new_tokens=25,
+        repetition_penalty=1.2,
+    )
+    generated_texts = PROCESSOR.batch_decode(generated_ids, skip_special_tokens=True)
+    reset_awq_cache(model)
+
+    gc.collect()
+    torch.cuda.empty_cache()
+    return generated_texts[0].split("\nAssistant: ")[1]
+
+
+class Operator:
+    def __init__(self):
+        self.image = None
+        self.text = None
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            if dora_event["id"] == "image":
+                self.image = (
+                    dora_event["value"]
+                    .to_numpy()
+                    .reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+                )
+            elif dora_event["id"] == "text":
+                self.text = dora_event["value"][0].as_py()
+                output = ask_vlm(self.image, self.text).lower()
+                send_output(
+                    "speak",
+                    pa.array([output]),
+                )
+                """
+                if "sofa" in output:
+                    send_output(
+                        "control",
+                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 50.0, 50.0]),
+                    )
+                elif "back" in self.text:
+                    send_output(
+                        "control",
+                        pa.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+                    )
+                """
+
+        return DoraStatus.CONTINUE

operators/llm_op.py

@@ -5,6 +5,7 @@ import pyarrow as pa
 from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
 
+import gc  # garbage collect library
 import re
 import time
 
@@ -136,6 +137,8 @@ def replace_code_in_source(source_code, replacement_block: str):
 
 
 class Operator:
+    def __init__(self) -> None:
+        self.policy_init = False
 
     def on_event(
         self,
@@ -168,18 +171,13 @@ class Operator:
             print("response: ", output, flush=True)
             with open(path, "w") as file:
                 file.write(source_code)
-            del model
-            del tokenizer
-            # model will still be on cache until its place is taken by other objects so also execute the below lines
-            import gc  # garbage collect library
 
             gc.collect()
             torch.cuda.empty_cache()
-            time.sleep(9)
-            send_output("init", pa.array([]))
-
-            ## Stopping to liberate GPU space
-            return DoraStatus.STOP
+            time.sleep(6)
+            if not self.policy_init:
+                send_output("init", pa.array([]))
+                self.policy_init = True
 
         return DoraStatus.CONTINUE
 
@@ -230,7 +228,7 @@ if __name__ == "__main__":
                 [
                     {
                         "path": path,
-                        "user_message": "go to the living room, ask the model if there is people, if there is, say i'm going to go get coffee for you, then go to the kitchen, when you reach the kitchen, check with the model if there is a person and say can i have a coffee please, then wait 10 sec and go back to the living room",
+                        "user_message": "go to the office, and then, say I know that you work hard, so I brought some a chocolate, wait for 10 seconds, and then play the office song and then go to the kitchen,",
                     },
                 ]
             ),

operators/policy.py

@@ -1,32 +1,29 @@
 import pyarrow as pa
 from dora import DoraStatus
-from utils import ask_vlm, speak
+from utils import speak, play
 from time import sleep
 
 
 class Operator:
     def __init__(self):
-        self.location = ["KITCHEN", "LIVING_ROOM"]
-        pass
-
-    def ask_model(self, image, text: str) -> str:
-        text = ask_vlm(image, text).lower()
-        return text
+        self.location = ["KITCHEN", "OFFICE"]
+        self.music = ["office.mp3"]
 
     def speak(self, text: str):
         speak(text)
 
+    def play(self, file: str):
+        play(file)
+
     def on_event(self, event: dict, send_output) -> DoraStatus:
         if event["type"] == "INPUT":
             id = event["id"]
             # On initialization
             if id == "init":
                 send_output("go_to", pa.array([""]))
-            elif id == "reached_living_room":
-                image = event["value"].to_numpy().reshape((540, 960, 3))
+            elif id == "reached_office":
                 pass
             elif id == "reached_kitchen":
-                image = event["value"].to_numpy().reshape((540, 960, 3))
                 pass
 
         return DoraStatus.CONTINUE

operators/robot_minimize.py

@@ -1,5 +1,8 @@
 from robomaster import robot
 from time import sleep
+from dora import Node
+import numpy as np
+import pyarrow as pa
 
 
 def wait(event):
@@ -12,19 +15,58 @@ assert ep_robot.initialize(conn_type="ap"), "Could not initialize ep_robot"
 assert ep_robot.camera.start_video_stream(display=False), "Could not start video stream"
 ep_robot.gimbal.recenter().wait_for_completed()
 
-from dora import Node
 
 node = Node()
 
+current_location = "HOME"
+LOCATION = {
+    "HOME": {
+        "KITCHEN": np.array([[0.5, 0.0, 0.0, 0.8, 0.0, 0.0, 0.0]]),
+        "OFFICE": np.array([[0.5, 0.0, 0.0, 0.8, 0.0, 0.0, 0.0]]),
+    },
+    "KITCHEN": {
+        "OFFICE": np.array([[-0.5, 0.0, 0.0, 0.8, 0.0, 0.0, -180.0]]),
+    },
+    "OFFICE": {
+        "KITCHEN": np.array([[-0.5, 0.0, 0.0, 0.8, 0.0, 0.0, -180.0]]),
+    },
+}
+
 for dora_event in node:
-    if dora_event["type"] == "INPUT":
+    if dora_event["type"] == "INPUT" and dora_event["id"] == "control":
         [x, y, z, xy_speed, z_speed, pitch, yaw] = dora_event["value"].to_numpy()
-        print(dora_event["value"].to_numpy())
-        event = ep_robot.gimbal.moveto(
-            pitch=pitch, yaw=yaw, pitch_speed=60.0, yaw_speed=50.0
-        )
-        wait(event)
-        sleep(2)
-        event = ep_robot.chassis.move(x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed)
-        wait(event)
-        sleep(6)
+        print(dora_event["value"].to_numpy(), flush=True)
+
+        if any([pitch, yaw]):
+            event = ep_robot.gimbal.moveto(
+                pitch=pitch, yaw=yaw, pitch_speed=60.0, yaw_speed=50.0
+            )
+            wait(event)
+            sleep(2)
+        if any([x, y, z]):
+            event = ep_robot.chassis.move(
+                x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
+            )
+            wait(event)
+            sleep(6)
+    if dora_event["type"] == "INPUT" and dora_event["id"] == "go_to":
+        destination = dora_event["value"][0].as_py()
+        commands = LOCATION[current_location][destination]
+        for command in commands:
+
+            [x, y, z, xy_speed, z_speed, pitch, yaw] = command
+
+            if any([pitch, yaw]):
+                event = ep_robot.gimbal.moveto(
+                    pitch=pitch, yaw=yaw, pitch_speed=60.0, yaw_speed=50.0
+                )
+                wait(event)
+                sleep(2)
+            if any([x, y, z]):
+                event = ep_robot.chassis.move(
+                    x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed
+                )
+                wait(event)
+                sleep(3)
+        node.send_output(f"reached_{destination.lower()}", pa.array([]))
+        current_location = destination