Instructions to use hchen657Naza/PWM with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Diffusers
How to use hchen657Naza/PWM with Diffusers:
pip install -U diffusers transformers accelerate
import torch from diffusers import DiffusionPipeline # switch to "mps" for apple devices pipe = DiffusionPipeline.from_pretrained("hchen657Naza/PWM", dtype=torch.bfloat16, device_map="cuda") prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" image = pipe(prompt).images[0] - Notebooks
- Google Colab
- Kaggle
Download PWM_code/policy_rl/open_drawer_image_dataset.py from hchen657Naza/PWM: direct link, hf CLI and curl.
- Browser
- Download file 3.22 kB
-
https://huggingface.co/hchen657Naza/PWM/resolve/main/PWM_code/policy_rl/open_drawer_image_dataset.py
- Command line
-
hf download hf://hchen657Naza/PWM/PWM_code/policy_rl/open_drawer_image_dataset.py
-
curl -L -o open_drawer_image_dataset.py https://huggingface.co/hchen657Naza/PWM/resolve/main/PWM_code/policy_rl/open_drawer_image_dataset.py
3.22 kB
| """ | |
| Diffusion Policy image dataset for Open-Drawer demos. | |
| Follows the PushTImageDataset pattern. | |
| """ | |
| from typing import Dict | |
| import copy | |
| import numpy as np | |
| import torch | |
| from diffusion_policy.common.pytorch_util import dict_apply | |
| from diffusion_policy.common.replay_buffer import ReplayBuffer | |
| from diffusion_policy.common.sampler import ( | |
| SequenceSampler, get_val_mask, downsample_mask, | |
| ) | |
| from diffusion_policy.common.normalize_util import get_image_range_normalizer | |
| from diffusion_policy.model.common.normalizer import LinearNormalizer | |
| from diffusion_policy.dataset.base_dataset import BaseImageDataset | |
| class OpenDrawerImageDataset(BaseImageDataset): | |
| def __init__( | |
| self, | |
| zarr_path: str, | |
| horizon: int = 16, | |
| pad_before: int = 0, | |
| pad_after: int = 0, | |
| seed: int = 42, | |
| val_ratio: float = 0.0, | |
| max_train_episodes=None, | |
| ): | |
| super().__init__() | |
| self.replay_buffer = ReplayBuffer.copy_from_path( | |
| zarr_path, keys=["image", "proprio", "action"] | |
| ) | |
| val_mask = get_val_mask( | |
| n_episodes=self.replay_buffer.n_episodes, | |
| val_ratio=val_ratio, seed=seed, | |
| ) | |
| train_mask = ~val_mask | |
| train_mask = downsample_mask( | |
| mask=train_mask, max_n=max_train_episodes, seed=seed, | |
| ) | |
| self.sampler = SequenceSampler( | |
| replay_buffer=self.replay_buffer, | |
| sequence_length=horizon, | |
| pad_before=pad_before, | |
| pad_after=pad_after, | |
| episode_mask=train_mask, | |
| ) | |
| self.train_mask = train_mask | |
| self.horizon = horizon | |
| self.pad_before = pad_before | |
| self.pad_after = pad_after | |
| def get_validation_dataset(self): | |
| val_set = copy.copy(self) | |
| val_set.sampler = SequenceSampler( | |
| replay_buffer=self.replay_buffer, | |
| sequence_length=self.horizon, | |
| pad_before=self.pad_before, | |
| pad_after=self.pad_after, | |
| episode_mask=~self.train_mask, | |
| ) | |
| val_set.train_mask = ~self.train_mask | |
| return val_set | |
| def get_normalizer(self, mode="limits", **kwargs): | |
| data = { | |
| "action": self.replay_buffer["action"], | |
| "proprio": self.replay_buffer["proprio"], | |
| } | |
| normalizer = LinearNormalizer() | |
| normalizer.fit(data=data, last_n_dims=1, mode=mode, **kwargs) | |
| normalizer["image"] = get_image_range_normalizer() | |
| return normalizer | |
| def __len__(self) -> int: | |
| return len(self.sampler) | |
| def _sample_to_data(self, sample): | |
| image = sample["image"].astype(np.float32) / 255.0 # (T, 3, H, W) | |
| proprio = sample["proprio"].astype(np.float32) # (T, 50) | |
| action = sample["action"].astype(np.float32) # (T, 38) | |
| return { | |
| "obs": { | |
| "image": image, | |
| "proprio": proprio, | |
| }, | |
| "action": action, | |
| } | |
| def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]: | |
| sample = self.sampler.sample_sequence(idx) | |
| data = self._sample_to_data(sample) | |
| return dict_apply(data, torch.from_numpy) | |