fix minimized demo

graphs/dataflow_robot_vlm_minimize.yml

@@ -0,0 +1,34 @@
+nodes:
+  - id: webcam
+    custom:
+      source: ../operators/opencv_stream.py
+      outputs:
+        - image
+  - id: idefics2
+    operator:
+      python:  ../operators/idefics2_op.py
+      inputs:
+        image: 
+          source: webcam/image
+          queue_size: 1
+      outputs:
+        - speak
+        - control
+  - id: robot
+    custom:
+      source: /home/peter/miniconda3/envs/robomaster/bin/python
+      args: ../operators/robot_minimize.py 
+      inputs:
+        control: idefics2/control
+  - id: parler
+    operator:
+      python:  ../operators/parler_op.py
+      inputs:
+        text: 
+          source: idefics2/speak
+          queue_size: 1
+  - id: plot_bot
+    operator:
+      python: ../operators/plot.py
+      inputs:
+        image: webcam/image

operators/idefics2_op.py

@@ -0,0 +1,125 @@
+from dora import DoraStatus
+import pyarrow as pa
+from transformers import AutoProcessor, AutoModelForVision2Seq, AwqConfig
+import torch
+import time
+
+CAMERA_WIDTH = 960
+CAMERA_HEIGHT = 540
+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)
+    return generated_texts[0].split("\nAssistant: ")[1]
+
+
+class Operator:
+    def __init__(self):
+        self.state = "person"
+        self.last_output = False
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            image = (
+                dora_event["value"].to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+            )
+
+            if self.state == "person":
+                output = ask_vlm(image, "Can you read the note?").lower()
+                print(output, flush=True)
+                if "coffee" in output or "tea" in output or "water" in output:
+                    send_output(
+                        "control",
+                        pa.array([-3.0, 0.0, 0.0, 0.8, 0.0, 10.0, 180.0]),
+                    )
+                    send_output(
+                        "speak",
+                        pa.array([output + ". Going to the kitchen."]),
+                    )
+                    time.sleep(10)
+                    self.state = "coffee"
+                    self.last_output = False
+                elif not self.last_output:
+                    self.last_output = True
+                    send_output(
+                        "speak",
+                        pa.array([output]),
+                    )
+                    time.sleep(4)
+
+            elif self.state == "coffee":
+                output = ask_vlm(image, "Is there a person with a hands up?").lower()
+                print(output, flush=True)
+                if "yes" in output:
+                    send_output(
+                        "speak",
+                        pa.array([output + ". Going to the office."]),
+                    )
+                    send_output(
+                        "control",
+                        pa.array([2.0, 0.0, 0.0, 0.8, 0.0, 10.0, 0.0]),
+                    )
+                    time.sleep(10)
+                    self.state = "person"
+                    self.last_output = False
+                elif not self.last_output:
+                    self.last_output = True
+                    send_output(
+                        "speak",
+                        pa.array([output]),
+                    )
+                    time.sleep(4)
+
+        return DoraStatus.CONTINUE

operators/parler_op.py

@@ -0,0 +1,46 @@
+from parler_tts import ParlerTTSForConditionalGeneration
+from transformers import AutoTokenizer
+import soundfile as sf
+import pygame
+from dora import DoraStatus
+
+model = ParlerTTSForConditionalGeneration.from_pretrained(
+    "parler-tts/parler_tts_mini_v0.1"
+).to("cuda:0")
+tokenizer = AutoTokenizer.from_pretrained("parler-tts/parler_tts_mini_v0.1")
+
+pygame.mixer.init()
+
+input_ids = tokenizer(
+    "A female speaker with a slightly low-pitched voice delivers her words quite expressively, in a very confined sounding environment with clear audio quality. She speaks very fast.",
+    return_tensors="pt",
+).input_ids.to("cuda:0")
+
+
+class Operator:
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ):
+        if dora_event["type"] == "INPUT":
+            generation = model.generate(
+                max_new_tokens=300,
+                input_ids=input_ids,
+                prompt_input_ids=tokenizer(
+                    dora_event["value"][0].as_py(), return_tensors="pt"
+                ).input_ids.to("cuda:0"),
+            )
+            print(dora_event["value"][0].as_py(), flush=True)
+            sf.write(
+                f"parler_tts_out.wav",
+                generation.cpu().numpy().squeeze(),
+                model.config.sampling_rate,
+            )
+
+            while pygame.mixer.get_busy():
+                pass
+            pygame.mixer.music.load(f"parler_tts_out.wav")
+            pygame.mixer.music.play()
+
+        return DoraStatus.CONTINUE

operators/robot_minimize.py

@@ -0,0 +1,30 @@
+from robomaster import robot
+from time import sleep
+
+
+def wait(event):
+    if event is not None and not (event._event.isSet() and event.is_completed):
+        sleep(1)
+
+
+ep_robot = robot.Robot()
+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()
+
+for dora_event in node:
+    if dora_event["type"] == "INPUT":
+        [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=50.0, yaw_speed=50.0
+        )
+        wait(event)
+        sleep(4)
+        event = ep_robot.chassis.move(x=x, y=y, z=z, xy_speed=xy_speed, z_speed=z_speed)
+        wait(event)
+        sleep(6)