initial commit

.gitignore

@@ -0,0 +1 @@
+venv

App/model/pick_and_place_dense.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56b4fdc265a5eb383726ce1dfee323ae99b489b4383cadd6dc0336e126caf2ed
+size 3377664

App/model/pick_and_place_her.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab787b78fb54a6ee447bfd046248a1217a6e3207633e6753a2824282af3c08ad
+size 3379264

App/model/push.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9953fc1dfd1c19b9faa56d898cbc985790468b41c46c530f797e5b7f56106715
+size 3377665

App/model/reach.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51a4a2ae881f240be42ff6cae71e54c2a0487d5b083cacd52e346359d6fbb139
+size 3207511

README copy.md

@@ -0,0 +1,13 @@
+---
+title: Fetch-Reinforcement Learning Project
+emoji: 🐠
+colorFrom: yellow
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.27.1
+app_file: app.py
+pinned: false
+short_description: Final RL Project Using Gymnasium Robotics Fetch Environments
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,108 @@
+import os
+import gradio as gr
+import numpy as np
+import torch
+import imageio
+from stable_baselines3 import SAC
+from custom_env import create_env
+
+# Update your run function to accept a model_name
+def run_model_episode(x_start, y_start, x_targ, y_targ, z_targ, model_name, random_coords):
+    
+    # map the radio‐choice to the actual checkpoint on disk
+    model_paths = {
+        "Pick & Place (HER)": "App/model/pick_and_place_her.zip",
+        "Pick & Place (Dense)":        "App/model/pick_and_place_dense.zip",
+        "Push":         "App/model/push.zip",
+        "Reach":         "App/model/reach.zip",
+    }
+    checkpoint_path = model_paths[model_name]
+
+    # map the radio‐choice to the actual environment name
+    environments = {
+        "Pick & Place (HER)": "FetchPickAndPlace-v3",
+        "Pick & Place (Dense)":        "FetchPickAndPlaceDense-v3",
+        "Push":         "FetchPush-v3",
+        "Reach":         "FetchReach-v3",
+    }
+    environment = environments[model_name]
+
+    # Handle environment coordinates
+    if(environment == "FetchPush-v3"):
+        z_targ = 0.0
+
+    block_xy=(x_start, y_start),
+    goal_xyz=(x_targ, y_targ, z_targ)
+
+    if random_coords:
+        block_xy = None
+        goal_xyz = None
+        
+    # create the env
+    env = create_env(
+        render_mode="rgb_array",
+        block_xy=block_xy,
+        goal_xyz=goal_xyz,
+        environment=environment
+    )
+
+    # load the selected model
+    model = SAC.load(checkpoint_path, env=env, verbose=0)
+
+    frames = []
+    obs, info = env.reset()
+    for _ in range(200):
+        action, _ = model.predict(obs, deterministic=True)
+        obs, reward, done, trunc, info = env.step(action)
+        frames.append(env.render())
+        if done or trunc:
+            obs, info = env.reset()
+    env.close()
+
+    video_path = "run_video.mp4"
+    imageio.mimsave(video_path, frames, fps=30)
+    return video_path
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Fetch Robot: Model Demo App")
+    gr.Markdown("Enter coordinates, pick a model, then click **Run Model**.")
+    gr.Markdown("Coordinates are relative to the center of the table.")
+
+    # 1) add a radio (or gr.Dropdown) for model selection
+    model_selector = gr.Radio(
+        choices=["Pick & Place (HER)", "Pick & Place (Dense)", "Push", "Reach"],
+        value="Pick & Place (HER)",
+        label="Select a model/environment"
+    )
+
+    # Randomize coordinates
+    randomize = gr.Checkbox(
+        label="Use randomized coordinates?",
+        value=False
+    )
+
+    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()
+
+    # 2) include the selector as an input to your click callback
+    run_button.click(
+        fn=run_model_episode,
+        inputs=[x_start, y_start, x_targ, y_targ, z_targ, model_selector, randomize],
+        outputs=output_video
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",   # bind to all interfaces
+        server_port=7860,        # default HF Spaces port
+    )

custom_env.py

@@ -0,0 +1,127 @@
+# <-- this must come first, before any mujoco / gym imports
+# import os
+# os.environ["MUJOCO_GL"] = "egl"
+
+import numpy as np
+import gymnasium as gym
+import gymnasium_robotics
+import mujoco
+
+class CustomFetchWrapper(gym.Wrapper):
+    def __init__(self, env, block_xy=None, goal_xyz=None, object=True):
+        super().__init__(env)
+        self.u = env.unwrapped  # MujocoFetchPickAndPlaceEnv
+        # stash your fixed coords (or None to randomize)
+        self.default_block_xy = (np.array(block_xy, dtype=float)
+                                 if block_xy is not None else None)
+        self.default_goal_xyz = (np.array(goal_xyz, dtype=float)
+                                 if goal_xyz is not None else None)
+        self.object = object
+
+    def reset(self, *args, **kwargs):
+        # 1) do the normal reset — gets you a random goal in obs
+        obs, info = super().reset(*args, **kwargs)
+        u     = self.unwrapped
+        model = u.model
+        data  = u.data
+        utils = u._utils
+        rng   = u.np_random
+
+        # 2) reset the robot slides to your home pose
+        for name, val in zip(
+            ["robot0:slide0","robot0:slide1","robot0:slide2"],
+            [0.405,       0.48,        0.0],
+        ):
+            utils.set_joint_qpos(model, data, name, val)
+
+        # pull out the actual goal so we can avoid it
+        goal_pos = obs["desired_goal"][:2].copy()
+
+        if (self.object==True):
+            # 3) pick block position
+            if self.default_block_xy is None:
+                home_xy  = u.initial_gripper_xpos[:2]
+                obj_range = u.obj_range
+                min_dist  = u.distance_threshold
+
+                while True:
+                    offset = rng.uniform(-obj_range, obj_range, size=2)
+                    # 3a) must be outside the “too-close to gripper” zone
+                    if np.linalg.norm(offset) < min_dist:
+                        continue
+                    candidate_xy = home_xy + offset
+                    # 3b) must be outside the “too-close to goal” zone
+                    if np.linalg.norm(candidate_xy - goal_pos) < min_dist:
+                        continue
+                    # if we get here, both checks passed
+                    break
+
+                block_xy = candidate_xy
+                
+            else:
+                block_xy = self.default_block_xy
+
+            # place the block
+            blk_qpos = utils.get_joint_qpos(model, data, "object0:joint")
+            blk_qpos[0:2] = block_xy
+            blk_qpos[2]    = 0.42  # table height
+            utils.set_joint_qpos(model, data, "object0:joint", blk_qpos)
+
+        # 4) pick goal position
+        if self.default_goal_xyz is not None:
+            new_goal = self.default_goal_xyz
+
+            # override the goal both in the env and in the MuJoCo site
+            u.goal = new_goal
+            sid = mujoco.mj_name2id(model,
+                                    mujoco.mjtObj.mjOBJ_SITE,
+                                    "target0")
+            data.site_xpos[sid] = new_goal
+
+        # 5) forward‐kinematics + fresh obs
+        u._mujoco.mj_forward(model, data)
+        obs = u._get_obs()
+
+        return obs, info
+
+
+def create_env(render_mode=None, block_xy=None, goal_xyz=None, environment = "FetchPickAndPlace-v3"):
+    gym.register_envs(gymnasium_robotics)
+
+    if(environment == "FetchReach-v3"):
+        object = False
+    else:
+        object = True
+
+    base_env = gym.make(environment, render_mode=render_mode)
+    u = base_env.unwrapped
+
+    # 1) compute table center in world coords
+    #    – X,Y: same as the gripper’s initial XY (over table center)
+    #    – Z: the table‐top height the wrapper uses (0.42 m)
+    center_xy = u.initial_gripper_xpos[:2]        # e.g. [1.366, 0.750]
+    table_z   = 0.42                              # match blk_qpos[2] in your wrapper
+    table_center = np.array([*center_xy, table_z])
+
+    # 2) turn your “relative” block_xy into an absolute XY
+    if block_xy is not None:
+        rel = np.array(block_xy, dtype=float)
+        abs_block_xy = center_xy + rel
+    else:
+        abs_block_xy = None
+
+    # 3) turn your “relative” goal_xyz into an absolute XYZ
+    if goal_xyz is not None:
+        rel = np.array(goal_xyz, dtype=float)
+        abs_goal_xyz = table_center + rel
+    else:
+        abs_goal_xyz = None
+
+    # 4) build the wrapped env with those absolutes
+    env = CustomFetchWrapper(
+        base_env,
+        block_xy=abs_block_xy,
+        goal_xyz=abs_goal_xyz,
+        object=object
+    )
+    return env

dockerfile

@@ -0,0 +1,18 @@
+# Use a lightweight Python base
+FROM python:3.10-slim
+
+# Set working directory in container
+WORKDIR /app
+
+# Copy and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy your app code
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Run your app
+CMD ["python", "app.py"]

old_apps/app_test_2.py

@@ -0,0 +1,94 @@
+# <-- this must come first, before any mujoco / gym imports
+import os
+os.environ["MUJOCO_GL"] = "osmesa"
+
+
+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)

old_apps/app_test_3.py

@@ -0,0 +1,68 @@
+# <-- this must come first, before any mujoco / gym imports
+import os
+os.environ["MUJOCO_GL"] = "osmesa"
+
+
+import gradio as gr
+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)

old_apps/app_test_4.py

@@ -0,0 +1,50 @@
+# <-- this must come first, before any mujoco / gym imports
+import os
+os.environ["MUJOCO_GL"] = "osmesa"
+
+
+import gradio as gr
+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)