Moved files into new repository

app.py

@@ -4,28 +4,26 @@ import numpy as np
 import torch
 import imageio
 from stable_baselines3 import SAC
-from custom_env import create_env
+from create_env import create_env
 
 # Define the function that runs the model and outputs a video
-def run_model_episode(x_start, y_start, x_targ, y_targ, z_targ):
-    # Create environment with user inputs
-    env = create_env(render_mode="rgb_array",
-                     block_xy=(x_start, y_start),
-                     goal_xyz=(x_targ, y_targ, z_targ))
+def run_model_episode():
+    # 1. Create environment with render_mode="rgb_array" (needed to capture frames)
+    env = create_env(render_mode="rgb_array")
 
-    # Load your trained model
-    checkpoint_path = os.path.join("App", "model", "model.zip")
+    # 2. Load your trained model
+    checkpoint_path = os.path.join("models", "test", "model.zip")
     model = SAC.load(checkpoint_path, env=env, verbose=1)
 
-    # Rollout the episode
+    # 3. Rollout the episode
     frames = []
     obs, info = env.reset()
 
-    for _ in range(200):  # Shorter rollout
+    for _ in range(200):  # Shorter rollout to avoid giant videos
         action, _ = model.predict(obs, deterministic=True)
         obs, reward, done, trunc, info = env.step(action)
 
-        frame = env.render()
+        frame = env.render()  # Get current frame as image (rgb_array)
         frames.append(frame)
 
         if done or trunc:
@@ -33,10 +31,11 @@ def run_model_episode(x_start, y_start, x_targ, y_targ, z_targ):
 
     env.close()
 
-    # Save frames into a video
+    # 4. Save the frames into a video
     video_path = "run_video.mp4"
     imageio.mimsave(video_path, frames, fps=30)
 
+    # 5. Return path to Gradio to display
     return video_path
 
 # --------------------------------------
@@ -44,29 +43,13 @@ def run_model_episode(x_start, y_start, x_targ, y_targ, z_targ):
 # --------------------------------------
 
 with gr.Blocks() as demo:
-    gr.Markdown("## Fetch Robot: Model Demo App")
-    gr.Markdown("Enter start and target coordinates, then click 'Run Model' to watch the robot!")
-    gr.Markdown("Coordinates are relative to the center of the table.")
-    gr.Markdown("X and Y coordinates are in meters, Z coordinate is height in meters.") 
-    gr.Markdown("0,0,0 is the center of the table.")
-
-    with gr.Row():
-        x_start = gr.Number(label="Start X", value=0.0)
-        y_start = gr.Number(label="Start Y", value=0.0)
-
-    with gr.Row():
-        x_targ = gr.Number(label="Target X", value=0.1)
-        y_targ = gr.Number(label="Target Y", value=0.1)
-        z_targ = gr.Number(label="Target Z", value=0.1)
+    gr.Markdown("# 🤖 Fetch Robot: Model Demo App")
+    gr.Markdown("Click 'Run Model' to watch the SAC agent interact with the FetchPickAndPlace environment.")
 
     run_button = gr.Button("Run Model")
     output_video = gr.Video()
 
-    run_button.click(
-        fn=run_model_episode,
-        inputs=[x_start, y_start, x_targ, y_targ, z_targ],
-        outputs=output_video
-    )
+    run_button.click(fn=run_model_episode, inputs=[], outputs=output_video)
 
 demo.launch(share=True)
 

app_test_2.py

@@ -0,0 +1,89 @@
+import gradio as gr
+import wandb
+import requests
+from PIL import Image
+from io import BytesIO
+
+# Connect to W&B
+api = wandb.Api()
+
+# Replace this with your correct run path
+ENTITY = "jarrett-defreitas-university-of-rhode-island"  # your wandb username or team
+PROJECT = "pickup-and-place"
+RUN_ID = "trr5oagz"  # NOT the display name; the ID like "3xi2sld8"
+
+run = api.run(f"{ENTITY}/{PROJECT}/{RUN_ID}")
+
+# Collect all images and metrics
+logged_images = []
+logged_scalars = []
+
+# Scan all rows of logged history
+for row in run.scan_history():
+    for key, val in row.items():
+        # Handle images correctly
+        if isinstance(val, list):
+            for item in val:
+                if isinstance(item, wandb.data_types.Image):
+                    logged_images.append((key, item.url))
+        elif isinstance(val, wandb.data_types.Image):
+            logged_images.append((key, val.url))
+        
+        # Handle scalars (numbers like loss, accuracy)
+        if isinstance(val, (int, float)):
+            logged_scalars.append((key, val))
+
+# Debug: show what was found
+print("Logged Images:", logged_images)
+print("Logged Scalars:", logged_scalars)
+
+# --------------------------------------
+# 3. Prepare Dropdown Choices
+# --------------------------------------
+
+image_keys = [key for key, _ in logged_images]
+scalar_keys = [key for key, _ in logged_scalars]
+
+# --------------------------------------
+# 4. Define viewer functions
+# --------------------------------------
+
+# View image by selected key
+def view_image(selected_key):
+    for key, url in logged_images:
+        if key == selected_key:
+            response = requests.get(url)
+            if response.status_code == 200:
+                return Image.open(BytesIO(response.content))
+            else:
+                return None
+    return None
+
+# View scalar (number) by selected key
+def view_scalar(selected_key):
+    for key, value in logged_scalars:
+        if key == selected_key:
+            return f"{key}: {value}"
+    return "Not found"
+
+# --------------------------------------
+# 5. Build the Gradio App
+# --------------------------------------
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 📈 WandB Run Viewer")
+    gr.Markdown("View images and metrics logged to a specific W&B run.")
+
+    with gr.Tab("Logged Images"):
+        img_selector = gr.Dropdown(choices=image_keys, label="Select an Image Key")
+        img_display = gr.Image()
+
+        img_selector.change(fn=view_image, inputs=img_selector, outputs=img_display)
+
+    with gr.Tab("Logged Scalars"):
+        scalar_selector = gr.Dropdown(choices=scalar_keys, label="Select a Scalar Metric")
+        scalar_display = gr.Textbox()
+
+        scalar_selector.change(fn=view_scalar, inputs=scalar_selector, outputs=scalar_display)
+
+demo.launch(share=True)

app_test_3.py

@@ -0,0 +1,64 @@
+import gradio as gr
+import os
+import numpy as np
+import torch
+import imageio
+from stable_baselines3 import SAC
+from custom_env import create_env
+
+# Define the function that runs the model and outputs a video
+def run_model_episode():
+    # 1. Create environment with render_mode="rgb_array" (needed to capture frames)
+    # e.g. user inputs:
+    # Relative to center of table
+    x_start, y_start = 0.0, 0.0
+    x_targ, y_targ, z_targ = 0.1, 0.1, 0.1
+
+    env = create_env(render_mode="rgb_array",
+                    block_xy=(x_start, y_start),
+                    goal_xyz=(x_targ, y_targ, z_targ))
+
+    # 2. Load your trained model
+    checkpoint_path = os.path.join("model", "model.zip")
+    model = SAC.load(checkpoint_path, env=env, verbose=1)
+
+    # 3. Rollout the episode
+    frames = []
+    obs, info = env.reset()
+
+    for _ in range(200):  # Shorter rollout to avoid giant videos
+        action, _ = model.predict(obs, deterministic=True)
+        obs, reward, done, trunc, info = env.step(action)
+
+        frame = env.render()  # Get current frame as image (rgb_array)
+        frames.append(frame)
+
+        if done or trunc:
+            obs, info = env.reset()
+
+    env.close()
+
+    # TODO This will probably need to save into a unique directory 
+    # so it doesnt override when multiple people are running the app
+
+    # 4. Save the frames into a video
+    video_path = "run_video_2.mp4"
+    imageio.mimsave(video_path, frames, fps=30)
+
+    # 5. Return path to Gradio to display
+    return video_path
+
+# --------------------------------------
+# Build the Gradio App
+# --------------------------------------
+
+with gr.Blocks() as demo:
+    gr.Markdown("Fetch Robot: Model Demo App")
+    gr.Markdown("Click 'Run Model' to watch the SAC agent interact with the FetchPickAndPlace environment.")
+
+    run_button = gr.Button("Run Model")
+    output_video = gr.Video()
+
+    run_button.click(fn=run_model_episode, inputs=[], outputs=output_video)
+
+demo.launch(share=True)

app_test_4.py

@@ -0,0 +1,46 @@
+import gradio as gr
+import os
+import numpy as np
+import torch
+import imageio
+import time
+from stable_baselines3 import SAC
+from custom_env import create_env
+
+def stream_frames():
+    x_start, y_start = 0.0, 0.0
+    x_targ, y_targ, z_targ = 0.1, 0.1, 0.1
+
+    env = create_env(render_mode="rgb_array",
+                     block_xy=(x_start, y_start),
+                     goal_xyz=(x_targ, y_targ, z_targ))
+
+    checkpoint_path = os.path.join("App", "model", "model.zip")
+    model = SAC.load(checkpoint_path, env=env, verbose=1)
+
+    obs, info = env.reset()
+
+    while True:
+        action, _ = model.predict(obs, deterministic=True)
+        obs, reward, done, trunc, info = env.step(action)
+
+        frame = env.render()  # Grab RGB frame
+        yield frame  # Yield this frame to Gradio
+
+        if done or trunc:
+            obs, info = env.reset()
+
+        time.sleep(0.033)  # ~30 FPS (1/30 seconds)
+
+    env.close()
+
+# Build Gradio app
+with gr.Blocks() as demo:
+    gr.Markdown("Fetch Robot: Live Model Demo App")
+    frame_output = gr.Image()
+    start_button = gr.Button("Start Streaming")
+
+    start_button.click(fn=stream_frames, inputs=[], outputs=frame_output)
+
+demo.queue()
+demo.launch(share=True)

app_test_5.py

@@ -0,0 +1,72 @@
+import gradio as gr
+import os
+import numpy as np
+import torch
+import imageio
+from stable_baselines3 import SAC
+from custom_env import create_env
+
+# Define the function that runs the model and outputs a video
+def run_model_episode(x_start, y_start, x_targ, y_targ, z_targ):
+    # Create environment with user inputs
+    env = create_env(render_mode="rgb_array",
+                     block_xy=(x_start, y_start),
+                     goal_xyz=(x_targ, y_targ, z_targ))
+
+    # Load your trained model
+    checkpoint_path = os.path.join("App", "model", "model.zip")
+    model = SAC.load(checkpoint_path, env=env, verbose=1)
+
+    # Rollout the episode
+    frames = []
+    obs, info = env.reset()
+
+    for _ in range(200):  # Shorter rollout
+        action, _ = model.predict(obs, deterministic=True)
+        obs, reward, done, trunc, info = env.step(action)
+
+        frame = env.render()
+        frames.append(frame)
+
+        if done or trunc:
+            obs, info = env.reset()
+
+    env.close()
+
+    # Save frames into a video
+    video_path = "run_video.mp4"
+    imageio.mimsave(video_path, frames, fps=30)
+
+    return video_path
+
+# --------------------------------------
+# Build the Gradio App
+# --------------------------------------
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Fetch Robot: Model Demo App")
+    gr.Markdown("Enter start and target coordinates, then click 'Run Model' to watch the robot!")
+    gr.Markdown("Coordinates are relative to the center of the table.")
+    gr.Markdown("X and Y coordinates are in meters, Z coordinate is height in meters.") 
+    gr.Markdown("0,0,0 is the center of the table.")
+
+    with gr.Row():
+        x_start = gr.Number(label="Start X", value=0.0)
+        y_start = gr.Number(label="Start Y", value=0.0)
+
+    with gr.Row():
+        x_targ = gr.Number(label="Target X", value=0.1)
+        y_targ = gr.Number(label="Target Y", value=0.1)
+        z_targ = gr.Number(label="Target Z", value=0.1)
+
+    run_button = gr.Button("Run Model")
+    output_video = gr.Video()
+
+    run_button.click(
+        fn=run_model_episode,
+        inputs=[x_start, y_start, x_targ, y_targ, z_targ],
+        outputs=output_video
+    )
+
+demo.launch(share=True)
+