Update: cem better, could follow velocity zero when only action penal

logs/run-20250920_181129-yzvsgbbo/checkpoint_step_210000_20250920_213035.pth

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

logs/run-20250920_181129-yzvsgbbo/config.yaml

@@ -0,0 +1,238 @@
+_wandb:
+    value:
+        cli_version: 0.21.0
+        e:
+            cqtawjq7q302hpygmjq82o2rncafbv67:
+                args:
+                    - --config
+                    - ICLR/config/bb6_reduced/bb6_v2.yaml
+                    - --gpu_id
+                    - "3"
+                codePath: main_cheetah.py
+                codePathLocal: main_cheetah.py
+                cpu_count: 128
+                cpu_count_logical: 255
+                cudaVersion: "12.6"
+                disk:
+                    /:
+                        total: "6598647398400"
+                        used: "2398938734592"
+                email: sangliteng@gmail.com
+                executable: /home/sangliteng/miniconda3/envs/learning-hybrid-systems/bin/python3
+                git:
+                    commit: e65e9632c7a9d9bc1847e0a5a83e8e29db0ac56e
+                    remote: git@github.com:SangliTeng/Leaning-Hybrid-Systems.git
+                gpu: NVIDIA RTX 6000 Ada Generation
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-45d30378-435b-de16-3aea-9fc48527fe61
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-19a03a90-a9e0-a194-8d43-c2dcb7925140
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-ea5b1c7d-baf5-6bcb-1ce1-0ee9ca4b5c8f
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-b1a2e98c-e563-a0fe-47ce-cfa29028d5c7
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-208eeaba-0174-d4e0-bc7a-2eb5f7983a6e
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-81a0e787-8873-418d-6ff3-e3f59deb75a0
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-8619099e-16b4-d667-b97f-518c3954df8c
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-8042fac2-fd28-c8e9-668b-ceb33605fb49
+                host: hr-6000ada
+                memory:
+                    total: "811164614656"
+                os: Linux-5.15.0-143-generic-x86_64-with-glibc2.35
+                program: /home/sangliteng/Research/Leaning-Hybrid-Systems/main_cheetah.py
+                python: CPython 3.12.11
+                root: ./ICLR/bb6_reduced
+                startedAt: "2025-09-20T18:11:29.437216Z"
+                writerId: cqtawjq7q302hpygmjq82o2rncafbv67
+        m: []
+        python_version: 3.12.11
+        t:
+            "1":
+                - 1
+            "2":
+                - 1
+            "3":
+                - 2
+                - 13
+                - 15
+                - 16
+            "4": 3.12.11
+            "5": 0.21.0
+            "12": 0.21.0
+            "13": linux-x86_64
+anti_collapse_weight:
+    value: 1000
+batch_size:
+    value: 4096
+data_path_test:
+    value: None
+data_path_train:
+    value: /home/sangliteng/Research/DynaTraj/dataset/bb/bb_ball_reduced.npz
+decoder_batch_size:
+    value: 131072
+decoder_finetune_steps:
+    value: 200000
+decoder_lr:
+    value: 0.01
+default_activation:
+    value: ReLU
+dim_linear_in_decoder:
+    value:
+        - 0
+        - 0
+dim_linear_in_encoder:
+    value:
+        - 0
+        - 0
+dim_linear_in_vec_field:
+    value:
+        - 0
+        - 0
+dim_linear_out_decoder:
+    value: 0
+dim_linear_out_encoder:
+    value: 0
+dim_linear_out_vec_field:
+    value: 0
+dynamics_init_scale:
+    value: 0.005
+dynamics_loss_type:
+    value: l2
+dynamics_weight:
+    value: 10
+encoder_lr:
+    value: 0.01
+eval_batch_size:
+    value: 64
+eval_every:
+    value: 2.5e+22
+eval_trajectory_length:
+    value: 500
+except_features:
+    value: []
+external_input_dim:
+    value: 6
+hidden_dim_linear_decoder:
+    value: []
+hidden_dim_linear_encoder:
+    value: []
+hidden_dim_linear_vec_field:
+    value: []
+hidden_dims_dec:
+    value:
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+hidden_dims_enc:
+    value:
+        - 64
+        - 64
+        - 64
+hidden_dims_vector_field:
+    value:
+        - 128
+        - 128
+input_dim:
+    value: 12
+is_lagrangian_system:
+    value: true
+isometry_loss_weight:
+    value: 1
+latent_dim:
+    value: 18
+learning_rate:
+    value: 0.0005
+log_interval:
+    value: 50
+loss_mode:
+    value: z
+max_iso_samples:
+    value: 16384
+min_covariance_threshold:
+    value: 0.09
+model_type:
+    value: hybrid
+normalize_data:
+    value: false
+ode_method:
+    value: euler
+project_name:
+    value: debug architecture
+reconstruction_loss_type:
+    value: l2
+run_name:
+    value: bb reduced
+save_checkpoint_every:
+    value: 250
+smooth_budget:
+    value: 0.0001
+smooth_weight:
+    value: 0
+steps_per_length:
+    value: 2000
+switching_threshold_scale:
+    value: 1.5
+switching_weight_multiplier:
+    value: 2
+test_info:
+    value: same profile as bb, much larger network
+time_step:
+    value: 0.01
+train_test_ratio:
+    value: 0.95
+trajectory_lengths:
+    value:
+        - 80
+        - 150
+        - 200
+        - 200
+        - 200
+use_switching_weights:
+    value: true
+use_weight_smoothing:
+    value: false
+vector_field_lr:
+    value: 0.01
+viz_interval:
+    value: 50
+wandb_base_dir:
+    value: ./ICLR/bb6_reduced
+weight_smoothing_window:
+    value: 0
+z_continuity_weight:
+    value: 10

mppi/mppi/mppi.py

@@ -1,346 +1,274 @@
-import logging
-import time
-import typing
-
+import argparse
+import os
 import torch
-from torch.distributions.multivariate_normal import MultivariateNormal
-from functorch import vmap
-
-logger = logging.getLogger(__name__)
-
-
-def _ensure_non_zero(cost, beta, factor):
-    return torch.exp(-factor * (cost - beta))
-
-
-class SpecificActionSampler:
-    def __init__(self):
-        self.start_idx = 0
-        self.end_idx = 0
-        self.slice = slice(0, 0)
-
-    def sample_trajectories(self, state, info):
-        raise NotImplementedError
-
-    def specific_dynamics(self, next_state, state, action, t):
-        """Handle dynamics in a specific way for the specific action sampler; defaults to using default dynamics"""
-        return next_state
-
-    def register_sample_start_end(self, start_idx, end_idx):
-        self.start_idx = start_idx
-        self.end_idx = end_idx
-        self.slice = slice(start_idx, end_idx)
-
-class MPPI():
-    """
-    Model Predictive Path Integral control
-    This implementation batch samples the trajectories and so scales well with the number of samples K.
-
-    Implemented according to algorithm 2 in Williams et al., 2017
-    'Information Theoretic MPC for Model-Based Reinforcement Learning',
-    based off of https://github.com/ferreirafabio/mppi_pendulum
-    """
-
-    def __init__(self, dynamics, running_cost, nx, noise_sigma, num_samples=100, horizon=15, device="cpu",
-                 terminal_state_cost=None,
-                 lambda_=1,
-                 noise_mu=None,
-                 u_min=None,
-                 u_max=None,
-                 u_init=None,
-                 U_init=None,
-                 u_scale=1,
-                 u_per_command=1,
-                 step_dependent_dynamics=False,
-                 rollout_samples=1,
-                 rollout_var_cost=0,
-                 rollout_var_discount=0.95,
-                 sample_null_action=False,
-                 specific_action_sampler: typing.Optional[SpecificActionSampler] = None,
-                 noise_abs_cost=False):
-        """
-        :param dynamics: function(state, action) -> next_state (K x nx) taking in batch state (K x nx) and action (K x nu)
-        :param running_cost: function(state, action) -> cost (K) taking in batch state and action (same as dynamics)
-        :param nx: state dimension
-        :param noise_sigma: (nu x nu) control noise covariance (assume v_t ~ N(u_t, noise_sigma))
-        :param num_samples: K, number of trajectories to sample
-        :param horizon: T, length of each trajectory
-        :param device: pytorch device
-        :param terminal_state_cost: function(state) -> cost (K x 1) taking in batch state
-        :param lambda_: temperature, positive scalar where larger values will allow more exploration
-        :param noise_mu: (nu) control noise mean (used to bias control samples); defaults to zero mean
-        :param u_min: (nu) minimum values for each dimension of control to pass into dynamics
-        :param u_max: (nu) maximum values for each dimension of control to pass into dynamics
-        :param u_init: (nu) what to initialize new end of trajectory control to be; defeaults to zero
-        :param U_init: (T x nu) initial control sequence; defaults to noise
-        :param step_dependent_dynamics: whether the passed in dynamics needs horizon step passed in (as 3rd arg)
-        :param rollout_samples: M, number of state trajectories to rollout for each control trajectory
-            (should be 1 for deterministic dynamics and more for models that output a distribution)
-        :param rollout_var_cost: Cost attached to the variance of costs across trajectory rollouts
-        :param rollout_var_discount: Discount of variance cost over control horizon
-        :param sample_null_action: Whether to explicitly sample a null action (bad for starting in a local minima)
-        :param specific_action_sampler: Function to explicitly sample actions to use instead of sampling from noise from
-            nominal trajectory, may output a number of action trajectories fewer than horizon
-        :param noise_abs_cost: Whether to use the absolute value of the action noise to avoid bias when all states have the same cost
-        """
-        self.d = device
-        self.dtype = noise_sigma.dtype
-        self.K = num_samples  # N_SAMPLES
-        self.T = horizon  # TIMESTEPS
-
-        # dimensions of state and control
-        self.nx = nx
-        self.nu = 1 if len(noise_sigma.shape) == 0 else noise_sigma.shape[0]
-        self.lambda_ = lambda_
-
-        if noise_mu is None:
-            noise_mu = torch.zeros(self.nu, dtype=self.dtype)
-
-        if u_init is None:
-            u_init = torch.zeros_like(noise_mu)
-
-        # handle 1D edge case
-        if self.nu == 1:
-            noise_mu = noise_mu.view(-1)
-            noise_sigma = noise_sigma.view(-1, 1)
-
-        # bounds
-        self.u_min = u_min
-        self.u_max = u_max
-        self.u_scale = u_scale
-        self.u_per_command = u_per_command
-        # make sure if any of them is specified, both are specified
-        if self.u_max is not None and self.u_min is None:
-            if not torch.is_tensor(self.u_max):
-                self.u_max = torch.tensor(self.u_max)
-            self.u_min = -self.u_max
-        if self.u_min is not None and self.u_max is None:
-            if not torch.is_tensor(self.u_min):
-                self.u_min = torch.tensor(self.u_min)
-            self.u_max = -self.u_min
-        if self.u_min is not None:
-            self.u_min = self.u_min.to(device=self.d)
-            self.u_max = self.u_max.to(device=self.d)
-
-        self.noise_mu = noise_mu.to(self.d)
-        self.noise_sigma = noise_sigma.to(self.d)
-        self.noise_sigma_inv = torch.inverse(self.noise_sigma)
-        self.noise_dist = MultivariateNormal(self.noise_mu, covariance_matrix=self.noise_sigma)
-        # T x nu control sequence
-        self.U = U_init
-        self.u_init = u_init.to(self.d)
-
-        if self.U is None:
-            self.U = self.noise_dist.sample((self.T,))
-
-        self.step_dependency = step_dependent_dynamics
-        self.F = dynamics
-        self.running_cost = running_cost
-        self.terminal_state_cost = terminal_state_cost
-        self.sample_null_action = sample_null_action
-        self.specific_action_sampler = specific_action_sampler
-        self.noise_abs_cost = noise_abs_cost
-        self.state = None
-        self.info = None
-
-        # handling dynamics models that output a distribution (take multiple trajectory samples)
-        self.M = rollout_samples
-        self.rollout_var_cost = rollout_var_cost
-        self.rollout_var_discount = rollout_var_discount
-
-        # sampled results from last command
-        self.cost_total = None
-        self.cost_total_non_zero = None
-        self.omega = None
-        self.states = None
-        self.actions = None
-
-    def get_params(self):
-        return f"K={self.K} T={self.T} M={self.M} lambda={self.lambda_} noise_mu={self.noise_mu.cpu().numpy()} noise_sigma={self.noise_sigma.cpu().numpy()}".replace(
-            "\n", ",")
-
-    def _dynamics(self, state, u):
-        return self.F(state, u)
-
-    def _running_cost(self, state, u):
-        return self.running_cost(state, u)
-
-    def get_action_sequence(self):
-        return self.U
-
-    def shift_nominal_trajectory(self):
-        """
-        Shift the nominal trajectory forward one step
-        """
-        # shift command 1 time step
-        self.U = torch.roll(self.U, -1, dims=0)
-        self.U[-1] = self.u_init
-
-    def command(self, state, shift_nominal_trajectory=True, info=None):
-        """
-        :param state: (nx) or (K x nx) current state, or samples of states (for propagating a distribution of states)
-        :param shift_nominal_trajectory: Whether to roll the nominal trajectory forward one step. This should be True
-            if the command is to be executed. If the nominal trajectory is to be refined then it should be False.
-        :param info: Optional dictionary to store context information
-        :returns action: (nu) best action
-        """
-        self.info = info
-        if shift_nominal_trajectory:
-            self.shift_nominal_trajectory()
-
-        return self._command(state)
-
-    def _compute_weighting(self, cost_total):
-        beta = torch.min(cost_total)
-        self.cost_total_non_zero = _ensure_non_zero(cost_total, beta, 1 / self.lambda_)
-        eta = torch.sum(self.cost_total_non_zero)
-        self.omega = (1. / eta) * self.cost_total_non_zero
-        return self.omega
-
-    def _command(self, state):
-        if not torch.is_tensor(state):
-            state = torch.tensor(state)
-        self.state = state.to(dtype=self.dtype, device=self.d)
-        cost_total = self._compute_total_cost_batch()
-
-        self._compute_weighting(cost_total)
-        perturbations = torch.sum(self.omega.view(-1, 1, 1) * self.noise, dim=0)
+import yaml
+import numpy as np
+import datetime
+import matplotlib
+import sys
+import os
+import time
 
-        self.U = self.U + perturbations
-        action = self.get_action_sequence()[:self.u_per_command]
-        # reduce dimensionality if we only need the first command
-        if self.u_per_command == 1:
-            action = action[0]
-        return action
 
-    def change_horizon(self, horizon):
-        if horizon < self.U.shape[0]:
-            # truncate trajectory
-            self.U = self.U[:horizon]
-        elif horizon > self.U.shape[0]:
-            # extend with u_init
-            self.U = torch.cat((self.U, self.u_init.repeat(horizon - self.U.shape[0], 1)))
-        self.T = horizon
 
-    def reset(self):
+class MPPIController:
+    """Placeholder MPPI controller for model predictive control."""
+    
+    def __init__(self,  
+                action_dim: int, 
+                horizon: int = 10, 
+                num_samples: int = 1024, 
+                num_elites: int = 64,
+                temperature: float = 1.0, 
+                max_std: float = 10.0, 
+                min_std: float = 0.1, 
+                iterations: int = 3,
+                smoothness_weight: float = 0,
+                device: str = 'cuda',):
+        self.action_dim = action_dim
+        self.horizon = horizon
+        self.num_samples = num_samples
+        self.temperature = temperature
+        self.max_std = max_std
+        self.min_std = min_std
+        self.device = device
+        self.iterations = iterations
+        self.num_elites = num_elites
+        self.smoothness_weight = smoothness_weight
+
+        # Pre-allocate all tensors for performance optimization
+        self._mean_buf = torch.zeros(self.horizon, self.action_dim, device=self.device)
+        self._last_mean_buf = torch.zeros(self.horizon, self.action_dim, device=self.device)
+        self._std_buf = torch.full((self.horizon, self.action_dim), self.max_std, dtype=torch.float, device=self.device)
+        
+        
+        # Pre-allocate tensors for MPPI iterations
+        self._actions_buffer = torch.empty(self.horizon, self.num_samples, self.action_dim, device=self.device)
+        self._actions_sample_buffer = torch.empty(self.horizon, self.num_samples, self.action_dim, device=self.device)
+        self._noise_buffer = torch.empty(self.horizon, self.num_samples, self.action_dim, device=self.device)
+        self._elite_actions_buffer = torch.empty(self.horizon, self.num_elites, self.action_dim, device=self.device)
+        self._elite_value_buffer = torch.empty(self.num_elites, 1, device=self.device)
+        self._elite_idxs_buffer = torch.empty(self.num_elites, dtype=torch.long, device=self.device)
+        self._score_buffer = torch.empty(self.num_elites, 1, device=self.device)
+        self._value_buffer = torch.empty(self.num_samples, 1, device=self.device)
+        
+        # Pre-allocate tensors for working copies of mean and std
+        self._mean_work = torch.empty(self.horizon, self.action_dim, device=self.device)
+        self._std_work = torch.empty(self.horizon, self.action_dim, device=self.device)
+        self._iteration_std_buffer = torch.empty(self.horizon, self.action_dim, device=self.device)
+        
+        # Pre-allocate tensors for smoothness penalty calculations
+        self._ref_penalty_buffer = torch.empty(self.horizon, self.num_samples, device=self.device)
+        self._action_diff_buffer = torch.empty(self.horizon-1, self.num_samples, self.action_dim, device=self.device)
+        self._smoothness_penalty_buffer = torch.empty(self.horizon-1, self.num_samples, device=self.device)
+        self._total_penalty_buffer = torch.empty(self.num_samples, 1, device=self.device)
+        
+        # Pre-allocate tensors for weighted calculations
+        self._weighted_actions_buffer = torch.empty(self.horizon, self.num_elites, self.action_dim, device=self.device)
+        self._action_diff_squared_buffer = torch.empty(self.horizon, self.num_elites, self.action_dim, device=self.device)
+        
+        # Pre-allocate constants for efficiency
+        self._ones_elites = torch.ones(self.num_elites, 1, device=self.device)
+        self._eps = torch.tensor(1e-9, device=self.device)
+        self._decay_factors = torch.tensor([0.8 ** i for i in range(self.iterations)], device=self.device)
+        self._discount = torch.tensor(0.99, device=self.device)
+        
+        # Pre-allocate buffers for value estimation rollout
+        self._G_buffer = torch.empty(self.num_samples, 1, device=self.device)
+        self._termination_buffer = torch.empty(self.num_samples, 1, device=self.device)
+        self._discount_factor_buffer = torch.empty(self.num_samples, 1, device=self.device)
+        self._not_terminated_buffer = torch.empty(self.num_samples, device=self.device)
+        self._qvalue_pred_buffer = torch.empty(self.num_samples, device=self.device)
+        self._reward_pred_buffer = torch.empty(self.num_samples, device=self.device)
+        
+        # Pre-allocate buffers for _maxq method
+        self._maxq_mean = torch.zeros(self.action_dim, device=self.device)
+        self._maxq_std = torch.full((self.action_dim,), self.max_std, dtype=torch.float, device=self.device)
+        self._maxq_noise = torch.empty(self.num_samples, self.action_dim, device=self.device)
+        self._maxq_actions_sample = torch.empty(self.num_samples, self.action_dim, device=self.device)
+        self._maxq_qvalues = torch.empty(self.num_samples, 1, device=self.device)
+        self._maxq_elite_qvalues = torch.empty(self.num_elites, 1, device=self.device)
+        self._maxq_elite_actions = torch.empty(self.num_elites, self.action_dim, device=self.device)
+        self._maxq_score = torch.empty(self.num_elites, device=self.device)
+        self._maxq_weighted_actions = torch.empty(self.num_elites, self.action_dim, device=self.device)
+        self._maxq_action_diff = torch.empty(self.num_elites, self.action_dim, device=self.device)
+
+        # Add step counter and save directory for Q-value visualization
+        self.step_count = 0
+        
+        # Initialize action sequence with zeros (will be updated during planning)
+        self.action_sequence = torch.zeros(horizon, action_dim, device=device)
+        
+        # Placeholders for dynamics and cost function (will be set externally)
+        self.dynamics = None
+        self.cost_function = None
+
+    
+    def _plan(self, obs: torch.Tensor, ext_obs: torch.Tensor, t0: bool = False, ) -> torch.Tensor:
         """
-        Clear controller state after finishing a trial
+        Plan actions using MPPI with world model.
+        
+        Args:
+            obs: Current observations [B, obs_dim]
+            ext_obs: External observations (same as obs for now)
+            t0: Whether this is the first timestep
+            
+        Returns:
+            actions: Planned actions [B, action_dim]
         """
-        self.U = self.noise_dist.sample((self.T,))
-
-    def _compute_rollout_costs(self, perturbed_actions):
-        K, T, nu = perturbed_actions.shape
-        assert nu == self.nu
-
-        cost_total = torch.zeros(K, device=self.d, dtype=self.dtype)
-        cost_samples = cost_total.repeat(self.M, 1)
-        cost_var = torch.zeros_like(cost_total)
-
-        # allow propagation of a sample of states (ex. to carry a distribution), or to start with a single state
-        if self.state.shape == (K, self.nx):
-            state = self.state
-        else:
-            state = self.state.view(1, -1).repeat(K, 1)
-
-        # rollout action trajectory M times to estimate expected cost
-
-        actions = self.u_scale * perturbed_actions[:, :]
-        states = self._dynamics(state.unsqueeze(1), actions)
-        c = self._running_cost(states, actions)
-
-        # Actions is K x T x nu
-        # States is K x T x nx
-        # actions = torch.stack(actions, dim=-2)
-        # states = torch.stack(states, dim=-2)
-
-        # action perturbation cost
-        if self.terminal_state_cost:
-            c = self.terminal_state_cost(states, actions)
-            cost_samples = cost_samples + c
-        # cost_total = cost_total + cost_samples.mean(dim=0)
-        # cost_total = cost_total + cost_var * self.rollout_var_cost
-        cost_total = c.mean(dim=-1)
-        return cost_total, states, actions
-
-    def _compute_perturbed_action_and_noise(self):
-        # parallelize sampling across trajectories
-        # resample noise each time we take an action
-        noise = self.noise_dist.rsample((self.K, self.T))
-        # broadcast own control to noise over samples; now it's K x T x nu
-        perturbed_action = self.U + noise
-        perturbed_action = self._sample_specific_actions(perturbed_action)
-        # naively bound control
-        self.perturbed_action = self._bound_action(perturbed_action)
-        # bounded noise after bounding (some got cut off, so we don't penalize that in action cost)
-        self.noise = self.perturbed_action - self.U
-
-    def _sample_specific_actions(self, perturbed_action):
-        # specific sampling of actions (encoding trajectory prior and domain knowledge to create biases)
-        i = 0
-        if self.sample_null_action:
-            perturbed_action[i] = 0
-            i += 1
-        if self.specific_action_sampler is not None:
-            actions = self.specific_action_sampler.sample_trajectories(self.state, self.info)
-            # check how long it is
-            actions = actions.reshape(-1, self.T, self.nu)
-            perturbed_action[i:i + actions.shape[0]] = actions
-            self.specific_action_sampler.register_sample_start_end(i, i + actions.shape[0])
-            i += actions.shape[0]
-        return perturbed_action
-
-    def _sample_specific_dynamics(self, next_state, state, u, t):
-        if self.specific_action_sampler is not None:
-            next_state = self.specific_action_sampler.specific_dynamics(next_state, state, u, t)
-        return next_state
-
-    def _compute_total_cost_batch(self):
-        self._compute_perturbed_action_and_noise()
-        if self.noise_abs_cost:
-            action_cost = self.lambda_ * torch.abs(self.noise) @ self.noise_sigma_inv
-            # NOTE: The original paper does self.lambda_ * torch.abs(self.noise) @ self.noise_sigma_inv, but this biases
-            # the actions with low noise if all states have the same cost. With abs(noise) we prefer actions close to the
-            # nomial trajectory.
-        else:
-            action_cost = self.lambda_ * self.noise @ self.noise_sigma_inv  # Like original paper
-
-        rollout_cost, self.states, actions = self._compute_rollout_costs(self.perturbed_action)
-        self.actions = actions / self.u_scale
-
-        # action perturbation cost
-        perturbation_cost = torch.sum(self.U * action_cost, dim=(1, 2))
-        self.cost_total = rollout_cost + perturbation_cost
-        return self.cost_total
-
-    def _bound_action(self, action):
-        if self.u_max is not None:
-            return torch.max(torch.min(action, self.u_max), self.u_min)
-        return action
-
-    def _slice_control(self, t):
-        return slice(t * self.nu, (t + 1) * self.nu)
-
-    def get_rollouts(self, state, num_rollouts=1, U=None):
+        env_size = obs.shape[0]
+
+        for i in range(env_size):
+            # Use pre-allocated working copies instead of cloning
+            self._mean_work.copy_(self._mean_buf)
+            self._std_work.copy_(self._std_buf)
+            mean = self._mean_work
+            std = self._std_work
+            
+            if not t0:
+                # Shift previous solution: [a1, a2, ..., aH] -> [a2, a3, ..., aH, 0]
+                if self.horizon > 1:
+                    mean[:-1].copy_(self._mean_buf[1:])
+                    mean[-1].zero_()
+                    std[:-1].copy_(self._std_buf[1:])
+                    std[-1].fill_(self.max_std)
+                else:
+                    mean.copy_(self._mean_buf)
+                    std.copy_(self._std_buf)
+            
+            # Use pre-allocated actions buffer
+            actions = self._actions_buffer
+
+            # Iterate MPPI
+            for iter_idx in range(self.iterations):
+                # Gradually reduce sampling variance across iterations
+                decay_factor = self._decay_factors[iter_idx]
+                torch.mul(std, decay_factor, out=self._iteration_std_buffer)
+                self._iteration_std_buffer.clamp_(self.min_std, self.max_std)
+
+                # Sample actions with reduced std over iterations
+                if iter_idx == 0:
+                    # First iteration: fresh random sampling
+                    torch.randn(self.horizon, self.num_samples, self.action_dim, 
+                              device=self.device, out=self._noise_buffer)
+                else:
+                    # Subsequent iterations: add smaller perturbations around current mean
+                    torch.randn(self.horizon, self.num_samples, self.action_dim, 
+                              device=self.device, out=self._noise_buffer)
+                    self._noise_buffer *= 0.5
+                
+                # Compute actions_sample in-place
+                torch.addcmul(mean.unsqueeze(1), self._iteration_std_buffer.unsqueeze(1), 
+                            self._noise_buffer, out=self._actions_sample_buffer)
+                self._actions_sample_buffer.clamp_(-1, 1)
+                actions.copy_(self._actions_sample_buffer)
+
+                # Compute costs for all action samples
+                self._estimate_cost(obs[i:i+1], actions, mean, self._value_buffer)
+                self._value_buffer.nan_to_num_(0)
+                
+                # Detach gradients before topk since we don't need gradients for MPPI
+                value_detached = self._value_buffer.detach()
+                
+                # Get elite indices using pre-allocated buffer (note: we want minimum cost)
+                torch.topk(-value_detached.squeeze(1), self.num_elites, dim=0, 
+                         out=(self._elite_value_buffer.squeeze(1), self._elite_idxs_buffer))
+                
+                # Extract elite actions using advanced indexing into pre-allocated buffer
+                self._elite_actions_buffer.copy_(actions[:, self._elite_idxs_buffer].detach())
+                self._elite_value_buffer.copy_(self._value_buffer[self._elite_idxs_buffer].detach())
+
+                # Update parameters using pre-allocated buffers
+                min_value = self._elite_value_buffer.min()
+                
+                # Compute scores in-place (lower cost = higher score)
+                torch.sub(min_value, self._elite_value_buffer, out=self._score_buffer)
+                self._score_buffer.mul_(self.temperature)
+                self._score_buffer.exp_()
+                
+                # Normalize scores
+                score_sum = self._score_buffer.sum() + self._eps
+                self._score_buffer.div_(score_sum)
+                
+                # Weighted average of elite actions using pre-allocated buffer
+                torch.mul(self._score_buffer.unsqueeze(0), self._elite_actions_buffer, out=self._weighted_actions_buffer)
+                torch.sum(self._weighted_actions_buffer, dim=1, out=mean)
+                self._last_mean_buf.copy_(mean)
+                
+                # Compute std as weighted variance using pre-allocated buffers
+                torch.sub(self._elite_actions_buffer, mean.unsqueeze(1), out=self._action_diff_squared_buffer)
+                self._action_diff_squared_buffer.pow_(2)
+                torch.mul(self._score_buffer.unsqueeze(0), self._action_diff_squared_buffer, 
+                         out=self._weighted_actions_buffer)
+                torch.sum(self._weighted_actions_buffer, dim=1, out=std)
+                std.sqrt_()
+                std.clamp_(self.min_std, self.max_std)
+
+            # Use mean directly for the first action
+            action_t = mean[0]
+            
+            # Update buffers for next planning step
+            self._mean_buf.copy_(mean)
+            self._std_buf.copy_(std)
+
+            # TODO: for now just assume one env
+            break 
+
+        # repeat action for each env
+        actions = action_t.repeat(env_size, 1) # size [env_size, act_dims]
+
+        return actions
+
+    def _estimate_cost(self, obs, actions, mean, value_buffer) -> torch.Tensor:
         """
-            :param state: either (nx) vector or (num_rollouts x nx) for sampled initial states
-            :param num_rollouts: Number of rollouts with same action sequence - for generating samples with stochastic
-                                 dynamics
-            :returns states: num_rollouts x T x nx vector of trajectories
-
+        Estimate cost using dynamics rollout and cost function.
+        
+        Args:
+            obs: Current observation [1, obs_dim]
+            actions: Action sequences [horizon, num_samples, action_dim]
+            mean: Current mean actions [horizon, action_dim]
+            value_buffer: Buffer to store costs [num_samples, 1]
+            
+        Returns:
+            values: Costs for each action sequence [num_samples, 1]
         """
-        state = state.view(-1, self.nx)
-        if state.size(0) == 1:
-            state = state.repeat(num_rollouts, 1)
-
-        if U is None:
-            U = self.get_action_sequence()
-        T = U.shape[0]
-        states = torch.zeros((num_rollouts, T + 1, self.nx), dtype=U.dtype, device=U.device)
-        states[:, 0] = state
-        for t in range(T):
-            next_state = self._dynamics(states[:, t].view(num_rollouts, -1),
-                                        self.u_scale * U[t].tile(num_rollouts, 1), t)
-            # dynamics may augment state; here we just take the first nx dimensions
-            states[:, t + 1] = next_state[:, :self.nx]
-
-        return states[:, 1:]
+        # Transpose actions to [num_samples, horizon, action_dim] for dynamics rollout
+        actions_transposed = actions.transpose(0, 1)  # [num_samples, horizon, action_dim]
+        
+        # Expand initial state to match number of samples
+        state0_expanded = obs.expand(self.num_samples, -1).unsqueeze(1)  # [num_samples, 1, obs_dim]
+        
+        # Rollout dynamics to get predicted states (detach to avoid gradients)
+        with torch.no_grad():
+            predicted_states = self.dynamics.rollout_steps(state0_expanded, actions_transposed)  # [num_samples, horizon, state_dim]
+        
+        # Compute costs using the cost function
+        costs = self.cost_function(predicted_states.detach(), actions_transposed.detach())  # [num_samples, horizon]
+        
+        # Sum costs over horizon to get total cost for each trajectory
+        total_costs = torch.sum(costs, dim=1, keepdim=True)  # [num_samples, 1]
+        
+        # Add action smoothness penalty using pre-allocated buffers
+        smoothness_weight = self.smoothness_weight
+        
+        # Penalty for deviation from reference (previous optimal) actions
+        torch.sub(actions, self._last_mean_buf.unsqueeze(1), out=self._actions_sample_buffer)
+        self._actions_sample_buffer.pow_(2)
+        torch.sum(self._actions_sample_buffer, dim=2, out=self._ref_penalty_buffer)
+        ref_penalty_sum = torch.sum(self._ref_penalty_buffer, dim=0, keepdim=True).T
+        
+        # Penalty for action changes within the trajectory
+        torch.sub(actions[1:], actions[:-1], out=self._action_diff_buffer)
+        self._action_diff_buffer.pow_(2)
+        torch.sum(self._action_diff_buffer, dim=2, out=self._smoothness_penalty_buffer)
+        smoothness_penalty_sum = torch.sum(self._smoothness_penalty_buffer, dim=0, keepdim=True).T
+        
+        # Combine penalties
+        torch.add(ref_penalty_sum, smoothness_penalty_sum, out=self._total_penalty_buffer)
+        self._total_penalty_buffer.mul_(smoothness_weight)
+        
+        # Combine base cost with penalties
+        value_buffer.copy_(total_costs)
+        value_buffer.add_(self._total_penalty_buffer)
+        
+        return value_buffer

mppi/task/bb_track.py

@@ -22,7 +22,7 @@ import sys
 import os
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
 from bb_collect import PingPongEnv, PingPongDummyController, Config
-from mppi.mppi.mppi import MPPI
+from mppi.mppi.mppi import MPPIController
 from models import create_model, interpolate_trajectory
 
 class NeuralHybridDynamics:
@@ -171,7 +171,8 @@ class NeuralHybridDynamics:
         at_batch[:, 0, 1:] = action[:, 0, :]  # use only the first frame to init the encoder
 
         # Inference on the model's internal eval grid, then decode to x_trajectory
-        out = self.model.inference(xt_batch, at_batch, infer_x=True)
+        out = self.model.inference(xt_batch.to(torch.float32), at_batch.to(torch.float32), infer_x=True)
+
         t_eval = out.get('t_eval', t_batch)        # [B, Te] or [Te]
         x_traj = out['x_trajectory']               # [B, Te, Dx]
 
@@ -183,12 +184,13 @@ class BBTrack:
     def __init__(self):
         self.parser = self.parse_bb_track_args()
         self.control_dt = 1/50 # 50Hz
-        self.horizon = 4
-        self.iterations = 6
+        self.horizon = 20
+        self.iterations = 4
         self.state_dims = 33
-        self.num_samples = 100
+        self.num_samples = 1000
+        self.num_elites = 10
         self.device = "cuda:0"
-        self.noise_sigma = torch.diag(torch.tensor([1., 1., 1., 0.2, 0.2, 0.2], dtype=torch.float32, device=self.device))
+        self.noise_sigma = torch.diag(torch.tensor([1., 1., 1., 1, 1, 1], dtype=torch.float32, device=self.device))
         self.current_simulation_time = 0 
         # Objective
         self.omega = 0.5
@@ -204,11 +206,21 @@ class BBTrack:
         self.dynamics = NeuralHybridDynamics(self.parser.weights_dir, self.control_dt, self.horizon, self.device)      
 
         print("\n=======Loading Controller=======")
-        self.controller = MPPI(self.dynamics.rollout_steps, self.cost_function, 
-                                self.state_dims, self.noise_sigma, self.num_samples, self.horizon, self.device,
-                                u_min = torch.tensor([-2,-2,-2, -0.2,-0.2,-0.2], device=self.device), 
-                                u_max = torch.tensor([2,2,2, 0.2,0.2,0.2], device=self.device),
-                                step_dependent_dynamics=False,)
+        self.controller = MPPIController(
+            action_dim=6,  # 6D action: vx,vy,vz,wx,wy,wz
+            horizon=self.horizon,
+            num_samples=self.num_samples,
+            num_elites=self.num_elites,
+            temperature=1.0,
+            max_std=1.0,
+            min_std=0.1,
+            iterations=self.iterations,
+            smoothness_weight=0.1,
+            device=self.device
+        )
+        # Set dynamics and cost function for the controller
+        self.controller.dynamics = self.dynamics
+        self.controller.cost_function = self.cost_function
 
     def parse_bb_track_args(self):
         """Parse command line arguments for data collection"""
@@ -278,8 +290,8 @@ class BBTrack:
         control_cost = torch.sum(action ** 2, dim=-1)
         
         # Combine costs with weights
-        tracking_weight = 0.0
-        control_weight = 10
+        tracking_weight = 10
+        control_weight = 1
         
 
         total_cost = tracking_weight * pos_cost + control_weight * control_cost
@@ -300,11 +312,18 @@ class BBTrack:
             # update simulation time
             self.current_simulation_time = self.env.data.time
 
-            # Get action from mppi, control frequency 50hz, smaller than simulation frequency 1000hz
             if step % (1/self.control_dt) == 0:
-                # for i in range(self.iterations):
-                #     self.controller.command(obs, shift_nominal_trajectory=False)
-                action = self.controller.command(obs, shift_nominal_trajectory=True)
+                # Convert obs to torch tensor if needed
+                if isinstance(obs, np.ndarray):
+                    obs_tensor = torch.from_numpy(obs).float().to(self.device).unsqueeze(0)  # Add batch dim
+                else:
+                    obs_tensor = obs
+                
+                # Call the MPPI controller
+                action_tensor = self.controller._plan(obs_tensor, obs_tensor, t0=(step==0))
+                action = action_tensor.cpu().numpy().flatten()  # Convert back to numpy
+
+            
 
             obs, reward, done, info = self.env.step(action)