more

app.py

@@ -1,18 +1,62 @@
 import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import tempfile
 
-def process_text(text):
-    return text.upper()
 
-with gr.Blocks() as demo:
-    gr.Markdown("## 🔤 Text Uppercaserrrrr")
+def create_animation():
+    fig, ax = plt.subplots(figsize=(7, 7))
+    xdata, ydata = [], []
+    ln, = plt.plot([], [], 'b-', animated=True)
 
-    with gr.Row():
-        input_text = gr.Textbox(label="Enter your text")
-        output_text = gr.Textbox(label="Uppercased text", interactive=False)
+    def init():
+        ax.set_xlim(0, 2*np.pi)
+        ax.set_ylim(-1.1, 1.1)
+        return ln,
+
+    def update(frame):
+        xdata.append(frame)
+        ydata.append(np.sin(frame))
+        ln.set_data(xdata, ydata)
+        return ln,
+
+    ani = animation.FuncAnimation(
+        fig, update, frames=np.linspace(0, 2*np.pi, 100),
+        init_func=init, blit=True, repeat=False
+    )
+
+    # Save to MP4
+    temp_video = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+    ani.save(temp_video.name, writer='ffmpeg', fps=20)
+    plt.close(fig)
+
+    return temp_video.name
+
+
+
+def load_image_on_start():
+    return np.random.rand(700, 700)
+    # return None
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Agent Control with Language")
+    gr.Markdown('## Say the agent where to go and what to do')
 
     with gr.Row():
-        run_button = gr.Button("Convert to UPPERCASE")
+        with gr.Column():
+            request_audio = gr.Audio()
+            send_btn = gr.Button(value='Send Request')
+            request_text = gr.Textbox(label="Request:", lines=2, interactive=False)
+            request_target = gr.Textbox(label='Target:', lines=2)
+            request_plan = gr.Textbox(label='Plan status:', lines=2)
+        with gr.Column():
+            output_env = gr.Video(label="Env:", autoplay=True)
 
-    run_button.click(fn=process_text, inputs=input_text, outputs=output_text)
+    # EVENTS:
+    # gr.on(triggers=["load"], fn=load_image_on_start, outputs=output_env_image)
+    # demo.load(fn=load_image_on_start, outputs=output_env_image)
+    demo.load(fn=create_animation, outputs=output_env)
 
+    demo.launch()
 demo.launch()

draft_2.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+# angle_deg = 350  # for example
+# angle_rad = np.deg2rad(angle_deg)
+#
+# vector = np.array([np.cos(angle_rad), np.sin(angle_rad)])
+# print(vector)
+
+input_angle = 0.5
+angle_rad = 2 * np.pi * input_angle
+vector_2 = np.array([np.cos(angle_rad), np.sin(angle_rad)])
+print(vector_2)
+

draft_gradio_with_animation.py

@@ -0,0 +1,42 @@
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import numpy as np
+import gradio as gr
+import tempfile
+
+def create_animation():
+    fig, ax = plt.subplots()
+    xdata, ydata = [], []
+    ln, = plt.plot([], [], 'b-', animated=True)
+
+    def init():
+        ax.set_xlim(0, 2*np.pi)
+        ax.set_ylim(-1.1, 1.1)
+        return ln,
+
+    def update(frame):
+        xdata.append(frame)
+        ydata.append(np.sin(frame))
+        ln.set_data(xdata, ydata)
+        return ln,
+
+    ani = animation.FuncAnimation(
+        fig, update, frames=np.linspace(0, 2*np.pi, 100),
+        init_func=init, blit=True, repeat=False
+    )
+
+    # Save to MP4
+    temp_video = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+    ani.save(temp_video.name, writer='ffmpeg', fps=20)
+    plt.close(fig)
+
+    return temp_video.name
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        btn = gr.Button("Generate Animation")
+        vid = gr.Video(label="Animated Plot", autoplay=True)
+
+    btn.click(fn=create_animation, outputs=vid)
+
+demo.launch()

drafts_1.py

@@ -0,0 +1,37 @@
+import vmas
+
+# Create the environment
+env = vmas.make_env(
+    # scenario="waterfall", # can be scenario name or BaseScenario class
+    scenario="dropout",
+    # scenario="transport",
+    # scenario="wheel",
+    # scenario="drone",
+    # scenario="kinematic_bicycle",
+    # scenario="road_traffic",
+    # scenario="multi_give_way",
+    # scenario="football",
+    # scenario="give_way",
+    # scenario="simple",
+    # scenario="simple_adversary",
+    num_envs=1,
+    device="cpu", # Or "cuda" for GPU
+    continuous_actions=True,
+    max_steps=None, # Defines the horizon. None is infinite horizon.
+    seed=None, # Seed of the environment
+    n_agents=1  # Additional arguments you want to pass to the scenario
+)
+# Reset itr
+obs = env.reset()
+
+# Step it with deterministic actions (all agents take their maximum range action)
+for i in range(1000):
+    obs, rews, dones, info = env.step(env.get_random_actions())
+    print(i)
+    env.render(
+        # mode="rgb_array",  # "rgb_array" returns image, "human" renders in display
+        mode="human",  # "rgb_array" returns image, "human" renders in display
+        # agent_index_focus=4, # If None keep all agents in camera, else focus camera on specific agent
+        # index=0, # Index of batched environment to render
+        # visualize_when_rgb=True,  # Also run human visualization when mode=="rgb_array"
+    )

plot_functions.py

@@ -0,0 +1,24 @@
+import matplotlib.pyplot as plt
+import matplotlib
+
+
+
+
+def plot_env(ax, info):
+    ax.cla()
+    env = info['env']
+    ax.plot([1, 1], [1, 2], '.', color='b', alpha=0.5, linewidth=5, markersize=20)
+    # ax.set_xlim([min(n_agents_list) - 20, max(n_agents_list) + 20])
+    ax.set_xlim([0, 100])
+    ax.set_ylim([0, 100])
+    # ax.set_xticks(n_agents_list)
+    # ax.set_xlabel('N agents', fontsize=27)
+    # ax.set_ylabel('Success Rate', fontsize=27)
+    # ax.set_title(f'{img_dir[:-4]} Map | time limit: {time_to_think_limit} sec.')
+    # set_plot_title(ax, f'{img_dir[:-4]} Map | time limit: {time_to_think_limit} sec.', size=11)
+    ax.set_title(f'Warehouse', fontweight="bold", size=30)
+    # set_legend(ax, size=18)
+    # labelsize = 20
+    # ax.xaxis.set_tick_params(labelsize=labelsize)
+    # ax.yaxis.set_tick_params(labelsize=labelsize)
+    plt.tight_layout()

warehouse_env.py

@@ -0,0 +1,147 @@
+import math
+import gymnasium as gym
+import numpy as np
+from gymnasium import spaces
+from stable_baselines3.common.env_checker import check_env
+from stable_baselines3 import PPO
+from stable_baselines3.common.env_util import make_vec_env
+from plot_functions import *
+
+
+class WarehouseEnv(gym.Env):
+    """
+    WarehouseEnv Environment that follows gym interface.
+    No inertia.
+    State:
+    x_a, y_a - current position [0, 100], [0, 100]
+    x_rel, y_rel - relative to target position [0, 100], [0, 100]
+    Action:
+    alpha - an angle (direction) [0, 1]
+    v - velocity [0, 1]
+    Reward:
+    -1 -> not in target radius
+    10 -> in target radius
+    """
+
+    metadata = {"render_modes": ["human"], "render_fps": 30}
+
+    def __init__(self, render_mode):
+        super().__init__()
+        self.render_mode = render_mode
+        self.to_render = self.render_mode == 'human'
+        self.ACTIONS: int = 2
+        self.N_CHANNELS: int = 4
+        self.SIDE: int = 100
+        self.RADIUS_COVERAGE: int = 5
+        self.MAX_STEPS: int = 200
+        self.DIAG: float = math.sqrt(self.SIDE ** 2 + self.SIDE ** 2)
+        self.action_space = spaces.Box(low=-1.0, high=1.0, shape=(self.ACTIONS,), dtype=np.float32)
+        self.observation_space = spaces.Box(low=-1, high=1, shape=(self.N_CHANNELS,), dtype=np.float64)
+        self.field = np.zeros((self.SIDE, self.SIDE))
+
+        # Agent
+        self.agent_x = None
+        self.agent_y = None
+        self.goal_x = None
+        self.goal_y = None
+        self.step_counter = None
+        self.terminated = True
+        self.truncated = True
+
+        # to render
+        if self.to_render:
+            self.fig, self.ax = plt.subplots(2, 2, figsize=(17, 10))
+
+    @property
+    def rel_x(self) -> int:
+        return self.agent_x - self.goal_x
+
+    @property
+    def rel_y(self) -> int:
+        return self.agent_y - self.goal_y
+
+    def reset(self, seed=None, options=None):
+        self.agent_x = np.random.uniform(0, self.SIDE)
+        self.agent_y = np.random.uniform(0, self.SIDE)
+        self.goal_x = np.random.uniform(0, self.SIDE)
+        self.goal_y = np.random.uniform(0, self.SIDE)
+        self.step_counter = 0
+        self.terminated = False
+        self.truncated = False
+        observation = np.array([self.agent_x / self.SIDE, self.agent_y / self.SIDE, self.rel_x / self.SIDE, self.rel_y / self.SIDE])
+        info = {}
+        return observation, info
+
+    def step(self, action):
+        if self.terminated:
+            raise RuntimeError('reset the env')
+
+        # --- execute action ---
+        input_angle, input_vel = action
+        # reshape between 0 and 1
+        input_angle = (input_angle + 1) / 2
+        input_vel = (input_vel + 1) / 2
+        # execute
+        angle_rad = 2 * np.pi * input_angle
+        mov_x, mov_y = np.array([np.cos(angle_rad), np.sin(angle_rad)])
+        self.agent_x += input_vel * mov_x
+        self.agent_y += input_vel * mov_y
+
+        rel_x, rel_y = self.rel_x, self.rel_y
+        distance = math.sqrt(rel_x**2 + rel_y**2)
+
+        # obs
+        observation = np.array([self.agent_x / self.SIDE, self.agent_y / self.SIDE, rel_x / self.SIDE, rel_y / self.SIDE])
+
+
+        # terminated + reward
+        if not (0 <= self.agent_x < self.SIDE) or not (0 <= self.agent_y < self.SIDE):
+            self.terminated = True
+            reward = -10
+        elif distance < self.RADIUS_COVERAGE:
+            self.terminated = True
+            reward = 10
+        else:
+            reward =  - (distance / self.DIAG)
+
+        # truncated
+        if self.step_counter > self.MAX_STEPS:
+            self.truncated = True
+        self.step_counter += 1
+
+        # info
+        info = {}
+        return observation, reward, self.terminated, self.truncated, info
+
+    def render(self):
+        plot_env(self.ax[0, 0], info={'env': self})
+        plt.tight_layout()
+        plt.pause(0.01)
+
+    def close(self):
+        pass
+
+
+def main():
+    env = WarehouseEnv(render_mode='human')
+    # It will check your custom environment and output additional warnings if needed
+    # check_env(env)
+
+    # vec_env = make_vec_env(env, n_envs=4)
+    # model = PPO("MlpPolicy", env, verbose=1)
+    # model.learn(total_timesteps=25000)
+    # model.save("ppo_warehouse")
+    #
+    # del model  # remove to demonstrate saving and loading
+
+    model = PPO.load("ppo_warehouse")
+    vec_env = model.get_env()
+    obs, info = env.reset()
+    while True:
+        action, _states = model.predict(obs)
+        obs, rewards, done, trunc, info = env.step(action)
+        env.render()
+
+
+if __name__ == '__main__':
+    main()