Commands to Run

# Commands to Run

Just so everything is here in one place, here are all the commands I use for
experiments, for data generation and training / loading policies, complete with
dates + commits used.

- Maybe keep 240Hz for the cables tasks?
- Definitely 480Hz for the fabrics + bags tasks.
- Make sure `main.py` will allow for 1000 demonstrations to be created.
  However, since my code will exit out of all of these, then we need one
  "extra" command to generate the data first.
- Generate data without camera noise (to start) and with camera noise for
  later.

# (1) Data Generation

For this the `agent` and `num_demos` don't matter. The Hz does matter, quite a
lot. I don't think the GPU matters but maybe it's OK to leave the argument
there. **After running 1K demos, save them as tar.gz files and store them**.
Save (a) the date, (b) num demos, (c) Hz value, and (d) whether there's noise
in camera images. For (d), this will probably not be a command line argument.

**Double check `data/` to make sure there is no data.**

Here are the cables data generation (+ insertion goal):

```
python main.py --gpu=0 --agent=dummy --hz=240 --task=cable-shape
python main.py --gpu=0 --agent=dummy --hz=240 --task=cable-ring
python main.py --gpu=0 --agent=dummy --hz=240 --task=cable-ring-notarget
python main.py --gpu=0 --agent=dummy --hz=240 --task=cable-shape-notarget
python main.py --gpu=0 --agent=dummy --hz=240 --task=cable-line-notarget
python main.py --gpu=0 --agent=dummy --hz=240 --task=insertion-goal
```

Then fabrics/ bags tasks:

```
python main.py --gpu=0 --agent=dummy --hz=480 --task=cloth-cover
python main.py --gpu=0 --agent=dummy --hz=480 --task=cloth-flat
python main.py --gpu=0 --agent=dummy --hz=480 --task=cloth-flat-notarget
python main.py --gpu=0 --agent=dummy --hz=480 --task=bag-alone-open
python main.py --gpu=0 --agent=dummy --hz=480 --task=bag-items-easy
python main.py --gpu=0 --agent=dummy --hz=480 --task=bag-items-hard
python main.py --gpu=0 --agent=dummy --hz=480 --task=bag-color-goal
```

# (1B) Generating Goals (if necessary) for loading goal-conditioned

This is pretty simple. However, be careful about Hz as usual.

```
python generate_goals.py --hz=240 --task=insertion-goal       --num_goals=20
python generate_goals.py --hz=240 --task=cable-shape-notarget --num_goals=20
python generate_goals.py --hz=240 --task=cable-line-notarget  --num_goals=20
python generate_goals.py --hz=480 --task=cloth-flat-notarget  --num_goals=20
python generate_goals.py --hz=480 --task=bag-color-goal       --num_goals=20
```

# (2) Training

Here the Hz does not matter. *However, the agent and GPU ID* definitely
matter. By default we do 20K iterations (saving snapshots every 1K iters) and
perform 3 training runs.

Also, for all tasks *other* than `bag-items-hard`, we really don't need the
extra rotations (24) but having those there should be harmless if all labels
have rotation 0, and including those rotations makes it helpful to understand
how rotations impact Transporters (e.g., with cloth).

If GPU memory is an issue (e.g., running into "Blas SGEMM launch failed"
errors) then use `--gpu_mem_limit` and set it to be less than the GB of RAM
that the target GPU has. The units of `--gpu_mem_limit` are in GB.

For baseline methods, use `gt_state` and `gt_state_2_step`. Any others?

### Non-goal conditioned

Can ablate over crop query ordering, which is 1 by default but we should
consider 0 as default as that's what goal conditioned Transporters does.

```
TASK=cable-shape   # cable-shape, cable-ring, cable-ring-notarget, cloth-cover, cloth-flat, bag-alone-open, bag-items-easy, bag-items-hard
AGENT=transporter  # transporter, gt_state, gt_state_2_step

python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=1
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=10
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=100
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=1000

python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --crop_bef_q=0 --num_demos=1
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --crop_bef_q=0 --num_demos=10
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --crop_bef_q=0 --num_demos=100
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --crop_bef_q=0 --num_demos=1000
```

### Goal-conditioned

We could ablate over `subsamp_g` to test different training procedures, but
probably not worth it.

```
TASK=cable-shape-notarget  # cable-shape-notarget, cable-line-notarget, insertion-goal, cloth-flat-notarget
AGENT=transporter-goal     # transporter-goal, transporter-goal-snaive, gt_state, gt_state_2_step

python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=1
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=10
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=100
python main.py --gpu=0 --task=${TASK} --agent=${AGENT} --num_demos=1000
```


# (3) Loading

Both the Hz and agent definitely matter, as well as the GPU if running on a
multi-GPU system. If we do 3x training runs, then use `train_run` to
distinguish among the seeds.

### Loading Cables (non goals)

```
HZ=240
ROTS=1
AGENT=transporter   # transporter, gt_state, gt_state_2_step
TASK=cable-shape    # cable-shape, cable-ring, cable-ring-notarget

for tr in 0 1 2; do
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=10
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=100
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1000
done

for tr in 0 1 2; do
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=1
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=10
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=100
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=1000
done
```

### Loading Cables + Insertion (with goals)

```
HZ=240
ROTS=1
AGENT=transporter-goal     # transporter-goal, transporter-goal-snaive, gt_state, gt_state_2_step
TASK=cable-shape-notarget  # cable-shape-notarget, cable-line-notarget, insertion-goal

for tr in 0 1 2; do
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=10
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=100
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1000
done
```

### Loading Fabrics/Bags (non goals)

Now it's 480 Hz. **Note: if the task is `bag-items-hard` we should definitely
use 24 rotations (or however many we set during training). However, all other
tasks use 1 rotation during inference time**.

```
HZ=480
ROTS=1             # CHANGE TO 24 IF LOADING bag-items-hard
AGENT=transporter  # transporter, gt_state, gt_state_2_step
TASK=cloth-flat    # cloth-flat, cloth-cover bag-alone-open, bag-items-easy, bag-items-hard

for tr in 0 1 2; do
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=10
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=100
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1000
done

for tr in 0 1 2; do
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=1
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=10
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=100
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --crop_bef_q=0 --num_demos=1000
done
```

### Loading Fabrics/Bags (with goals)

Only `cloth-flat-target` and `bag-color-goal` apply here.

```
HZ=480
ROTS=1
AGENT=transporter-goal    # transporter-goal, transporter-goal-snaive, gt_state, gt_state_2_step
TASK=cloth-flat-notarget  # bag-color-goal

for tr in 0 1 2; do
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=10
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=100
    python load.py --gpu=0 --agent=${AGENT} --hz=${HZ} --task=${TASK} --num_rots_inf=${ROTS} --train_run=${tr} --num_demos=1000
done
```