# フィジカルAI研究室を作る Log#11 | Physical Intelligence の π0.5 は「待ち時間」まで覚えた

- 記録: LOG358（フィジカルAI研究室）
- 公開: 2026/10/21
- 記事のページ: https://pixelstomotors.com/record/pi05-learned-the-pauses
- サイト: Pixels to Motors（ADAPT DESIGN / 島津 栄一） https://pixelstomotors.com/
- 要約: Physical Intelligenceのπ0.5は、お手本の中の止まっている時間まで覚えていた。停止を詰めて学習し直すと、mechArm 270はブロックをつかんで箱まで運んだが、持ち上げずに箱の外で離した。

> AI が読むための記事の全文です（コード・実行ログを含む）。引用するときは上の「記事のページ」の住所を使ってください。

---

Physical Intelligence の π0.5 は、お手本の動きと一緒に、お手本の中でアームが止まっていた待ち時間まで覚えていました。止まっている時間を詰めて学習し直すと、mechArm 270 はブロックをつかんで箱まで運びましたが、持ち上げずに箱の外で離しました。

机の上の小さなロボットアームに、AI の指示で赤いブロックを白い箱へ入れさせようとしています。朝、学習し直した AI でアームを動かすと、腕はブロックの方へまっすぐ伸び、すぐ近くまで来たところで止まりました。そのあと13回続けて AI に「次の1秒でどう動くか」を聞いても、返ってくる答えは「ほとんど動かない」でした。朝の回でアームが実際に動いたのは、最初の1分ほどです。

原因は AI の性能ではなく、AI に見せたお手本の中にありました。お手本は、人が手でアームを動かして教えた要所の姿勢を、アームに再生させて録ったものです。再生の途中で、アームは「指定の姿勢に着いたか」を確かめたり、グリッパーが落ち着くのを待ったりするために、何度も止まっていました。止まっている時間はお手本全体の 40%。ブロックの真上に着いたところでは、毎回 1.5〜2 秒、まったく動いていません。**AI は、お手本の動きと一緒に、この待ち時間まで「その場面でやるべき動き」として覚えていました。**

使った AI は、米国の [Physical Intelligence](https://www.pi.website/) 社が公開しているロボット用のモデル [π0.5](https://www.pi.website/blog/pi05)（パイレイテンゴ）です。上のカメラの画像と関節の角度を受け取り、次の1秒の動きを返します。アームが止まっている間は、画像も関節の角度も変わりません。お手本の中に「1秒先までずっと止まっている」場面が続くと、AI はその場面で「止まる」以外の答えを持てなくなります。お手本を見せて動きをまねさせるやり方（模倣学習）では、人の目には「ただ待っているだけ」の時間も、まねする対象に入ります。

調べていくと、原因はもう1つありました。上のカメラ（普段使いの iPhone を毎回付け外ししています）の写り方が、実機を動かした回だけ、お手本の画像より下に大きくずれていました。AI は、学習で見たことのない写り方の画像を見ながら動いていたことになります。

止まっている時間を詰めたお手本で学習し直し、夕方にもう一度動かしました。今度は8回とも止まらず、2回はブロックをつかみ、1回は箱の位置まで運んで離しています。ただ、運ぶ間にブロックを持ち上げられず、マットの上を引きずったまま箱の壁に当て、箱の外に落としました。肩で腕を上げた分を、手首が爪先を下げる向きに動いて打ち消していたためです。

やったことの全体は次のとおりです。

| やったこと | なぜ | 結果 |
|---|---|---|
| 学習したモデル（約6GB）を、推論（学習したモデルに画像と角度を渡して、次の動きを答えさせること）用に借りた GPU へ送った | AI を動かすには GPU が要り、Mac では動かせない | 40分以上かかり、その間に Mac のターミナルが2回固まった |
| 実機のアームを π0.5 で動かした | 置き場所を5か所に変えたお手本で学習したモデルを試すため | 7回の指令でブロックの近くまで来て、そこから動かなくなった |
| お手本のデータを数えた | 止まった理由を調べるため | 止まっている時間が 40%。ブロックの真上で毎回 1.5〜2 秒止まっていた |
| 止まっている時間を縮めたお手本を作り、外部の AI（codex）に確かめてもらった | 「止まる」を覚えさせないため | 1回目は NG（削った継ぎ目で、学習の正解が崩れていた）。直した版で 2,717 ステップ |
| 上のカメラの画像を、お手本と並べた | 写り方の違いを確かめるため | 実機を動かした回だけ、画像が下に約18〜37ピクセルずれていた |
| 直したお手本で学習し直した | 止まらない AI を作るため | A40 で 7時間22分。loss（学習で使う、お手本とのずれを表す値。小さいほどお手本に近い）は 0.1104 から 0.0021 へ |
| 学習の前と実機の前に、問題を見つける道具を足した | 8時間学習して実機で動かすまで、原因が分からない作りだったため | お手本の点検・お手本との答え合わせ・肩の角度の上限・カメラの写り方の確認 |
| 夕方、学習し直したモデルで実機を8回動かした | 止まらなくなったかを確かめるため | 8回とも止まらなかった。2回つかみ、1回は箱の位置まで運んだが、持ち上げが足りず箱の外で離した |

この回の作業も、Claude（この記事の手順とプログラムを一緒に組み立てた AI）と進めました。手順・分析・プログラムの一部は Claude、データを作り直すプログラムとアームを動かすプログラムの変更は Claude Code、その確認は [codex](https://github.com/openai/codex)（別の AI）が行い、アームの操作と目で見た判断はこちらで行っています。ここから下は、使ったコマンド・コード・出力を全量で載せた作業ログです。ログの中の Pod（借りた GPU マシン）の IP アドレスとポート番号は、`<POD_IP>` と `<SSH_PORT>` に置き換えています。費用の円は 1ドル＝158円 で計算しています。


## 作業ログ ― 推論用の Pod に openpi を入れ直し、mechArm 用の設定を2つ登録した

前の回で学習したモデルは、Mac につないだ外付け SSD（KIOXIA）の `checkpoints/pi05_mecharm_teach_lora_v1/3999/` に持ち帰ってあります。推論に使うのは、その中の `params/`（重み 6.0GB）と `assets/`（正規化の値 1.6MB）です。正規化の値は、関節の角度を学習しやすい範囲の数に直すための目安の値で、学習に使ったお手本から計算してあります。

学習に使った Pod は削除してあるので、推論用に新しく Pod を借りました。推論だけなら学習ほど GPU のメモリは要らないので、24GB 以上の GPU を選んでいます。この Pod も使い終わってすぐ削除したため、GPU の型番と料金は記録を残せていません。

Pod に入り、[tmux](https://github.com/tmux/tmux)（接続が切れても作業が続く画面）の中で、[openpi](https://github.com/Physical-Intelligence/openpi)（π0.5 を動かすための公開コード）を前回と同じ版で取り直しました。`uv sync` の最後の部分です。

```
 + tyro==0.9.22
 + tzdata==2025.2
 + urllib3==2.4.0
 + virtualenv==20.31.2
 + wadler-lindig==0.1.6
 + wandb==0.19.11
 + wcwidth==0.2.13
 + websockets==15.0.1
 + werkzeug==3.1.3
 + widgetsnbextension==4.0.14
 + wrapt==1.14.1
 + xxhash==3.5.0
 + yarl==1.20.0
 + zarr==3.0.8
 + zipp==3.22.0
root@7f6b9147d13a:/workspace/openpi#
```

Mac から、mechArm 用のスクリプトと、前の回（[LOG355](https://pixelstomotors.com/record/pi05-retrain-five-positions)）で作った学習設定の追加スクリプト `add_teach_config.py` を送り、openpi に登録しました。推論サーバーを起動するときも、学習のときと同じ設定名（`pi05_mecharm_teach_lora`）が要るためです。

```
install_addon.py /workspace/openpi
python3 /workspace/r2r2r/add_teach_config.py /workspace/openpi
installed: policies/mecharm_policy.py + config.py (pi05_mecharm_lora)
installed: pi05_mecharm_teach_lora (repo_id=local/mecharm_redblock_box_teach_v1, 4,000 steps)
root@7f6b9147d13a:/workspace/openpi#
```


## モデル 6GB を8本同時に送り始めたら、Mac のターミナルが固まった

[LOG345](https://pixelstomotors.com/record/pi05-mecharm-first-real-run) の経験から、1本の接続で送ると1秒に約1MB しか出ないことが分かっていました。そこで、大きいファイルから順に8本同時に送る形にしました。

```
Last login: Wed Oct 21 07:35:07 on ttys002
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % P=<SSH_PORT>; IP=<POD_IP>; K=~/.ssh/id_ed25519
scp -P $P -i $K -r ~/r2r2r-scripts/pi05 root@$IP:/workspace/r2r2r/
scp -P $P -i $K /Volumes/KIOXIA/r2r2r-data/lab/Log10/pod/add_teach_config.py root@$IP:/workspace/r2r2r/
cd /Volumes/KIOXIA/r2r2r-data/checkpoints/pi05_mecharm_teach_lora_v1/3999
find . -type d | ssh -p $P -i $K root@$IP "mkdir -p /workspace/ckpt/3999 && cd /workspace/ckpt/3999 && xargs mkdir -p"
find . -type f -exec stat -f '%z %N' {} + | sort -rn | cut -d' ' -f2- | xargs -P 8 -I{} scp -q -P $P -i $K {} root@$IP:/workspace/ckpt/3999/{}
convert_to_lerobot.py                         100% 2873    10.5KB/s   00:00    
run_policy_client.py                          100%   13KB  36.8KB/s   00:00    
build_demo_episodes.py.bak_pre_LOG352_2026101 100%   11KB  40.9KB/s   00:00    
RUNPOD_TRAIN.md                               100% 9229    33.6KB/s   00:00    
install_addon.py                              100% 4786    17.1KB/s   00:00    
mecharm_policy.py                             100% 2321     8.5KB/s   00:00    
build_demo_episodes.cpython-310.pyc           100%   11KB  39.9KB/s   00:00    
build_demo_episodes.cpython-312.pyc           100%   20KB  75.6KB/s   00:00    
policy_ws.cpython-312.pyc                     100% 4580    16.7KB/s   00:00    
build_demo_episodes.py                        100%   15KB  43.6KB/s   00:00    
policy_ws.py                                  100% 2778    10.2KB/s   00:00    
add_teach_config.py                           100% 1906     6.9KB/s   00:00
```

最後の行の送信は `-q` で進み具合の表示を消しているので、送っている間は何も出ません。この状態を見て、ターミナルが固まったように感じました。そこで別のウインドウを開こうとしたところ、今度は本当にターミナル全体が反応しなくなりました。メニューを選べず、⌘N も、貼り付けも、キーの入力も効きません。Dock のアイコンの右クリックから新しいウインドウは開けたものの、そこでも入力ができませんでした。

ターミナルを強制終了すると、Mac から送っていた `scp` も止まります。それでも困らないのは、Pod 側に届いたファイルは残っていて、大きさを比べれば「届いていないファイル」と「途中で切れたファイル」だけを送り直せるからです。強制終了して開き直し、大きさが合わないファイルだけを送り直しました。

```
Last login: Wed Oct 21 07:47:28 on ttys006
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % P=<SSH_PORT>; IP=<POD_IP>; K=~/.ssh/id_ed25519
cd /Volumes/KIOXIA/r2r2r-data/checkpoints/pi05_mecharm_teach_lora_v1/3999
ssh -p $P -i $K root@$IP "cd /workspace/ckpt/3999 && find . -type f -printf '%s %p\n'" > /tmp/remote_3999.txt
find . -type f | while read f; do s=$(stat -f %z "$f"); grep -qx "$s $f" /tmp/remote_3999.txt || echo "$f"; done > /tmp/todo_3999.txt
wc -l < /tmp/todo_3999.txt
cat /tmp/todo_3999.txt | xargs -P 8 -I{} scp -q -P $P -i $K {} root@$IP:/workspace/ckpt/3999/{}
echo "送信おわり"
      28
```

29ファイルのうち 28 が、大きさの合わないファイルでした。最初の送信で、合っていたのは1つだけです。

送っている間に、別のウインドウから Pod に届いた量を見ました。

```
Last login: Wed Oct 21 07:48:29 on ttys001
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % ssh -p <SSH_PORT> -i ~/.ssh/id_ed25519 root@<POD_IP> "du -sh /workspace/ckpt/3999"
2.9G /workspace/ckpt/3999
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ %
```

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % ssh -p <SSH_PORT> -i ~/.ssh/id_ed25519 root@<POD_IP> "du -sh /workspace/ckpt/3999"
3.3G /workspace/ckpt/3999
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ %
```

3分で 0.4GB、1分に約130MB です。前の回に6本同時で送ったときは1分に約400MB だったので、3分の1ほどの速さでした。上書き中のファイルは一度0から数え直されるため、この数字は実際の進み具合より小さめに出ます。

```
wc -l < /tmp/todo_3999.txt
cat /tmp/todo_3999.txt | xargs -P 8 -I{} scp -q -P $P -i $K {} root@$IP:/workspace/ckpt/3999/{}
echo "送信おわり"
      28
送信おわり
(base) shimazueiichi@shimadzueiichinoMacBook-Pro 3999 %
```

送り終わったのは 8:18 です。送り直しを始めた 7:50 から28分、最初に送り始めた 7:38 から数えると40分かかりました。最後に、29ファイルすべての大きさを Mac と Pod で比べました。前の回は「全体の大きさが 6.0G 前後になったら送り終わり」と判断して、途中で切れたファイルを見落としています。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro 3999 % ssh -p $P -i $K root@$IP "cd /workspace/ckpt/3999 && find . -type f -printf '%s %p\n'" > /tmp/remote_3999.txt
find . -type f | while read f; do s=$(stat -f %z "$f"); grep -qx "$s $f" /tmp/remote_3999.txt || echo "不一致: $f"; done; echo "確認おわり"
確認おわり
(base) shimazueiichi@shimadzueiichinoMacBook-Pro 3999 %
```


## 推論サーバーは、teach_v1 の正規化の値を読み込んで起動した

Pod に入り直し、tmux の画面に戻ってサーバーを起動しました。

```
cd /workspace/openpi
mkdir -p assets/pi05_mecharm_teach_lora/local && cp -r /workspace/ckpt/3999/assets/local/mecharm_redblock_box_teach_v1 assets/pi05_mecharm_teach_lora/local/
uv run scripts/serve_policy.py policy:checkpoint --policy.config=pi05_mecharm_teach_lora --policy.dir=/workspace/ckpt/3999 2>&1 | tee /workspace/logs/serve.log
```

KIOXIA の `lab/Log11/serve.log` に持ち帰ったサーバーのログです。

```
INFO:root:Loading model...
INFO:2026-10-20 23:20:06,662:jax._src.xla_bridge:925: Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'
INFO:jax._src.xla_bridge:Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'
INFO:2026-10-20 23:20:06,664:jax._src.xla_bridge:925: Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory
INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory
INFO:absl:orbax-checkpoint version: 0.11.13
INFO:absl:Created BasePyTreeCheckpointHandler: use_ocdbt=True, use_zarr3=False, pytree_metadata_options=PyTreeMetadataOptions(support_rich_types=False), array_metadata_store=<orbax.checkpoint._src.metadata.array_metadata_store.Store object at 0x7c58b1a64910>
INFO:absl:Restoring checkpoint from /workspace/ckpt/3999/params.
INFO:absl:[thread=MainThread] Failed to get flag value for EXPERIMENTAL_ORBAX_USE_DISTRIBUTED_PROCESS_ID.
INFO:absl:[process=0] /jax/checkpoint/read/bytes_per_sec: 1.2 GiB/s (total bytes: 6.3 GiB) (time elapsed: 5 seconds) (per-host)
INFO:absl:Finished restoring checkpoint in 5.23 seconds from /workspace/ckpt/3999/params.
INFO:openpi.shared.download:Downloading gs://big_vision/paligemma_tokenizer.model to /root/.cache/openpi/big_vision/paligemma_tokenizer.model
INFO:tqdm_loggable.tqdm_logging:Progress on: -/4264023 rate:- remaining:? elapsed:00:00 postfix:-
INFO:tqdm_loggable.tqdm_logging:Progress on: 4.07MiB/4.07MiB rate:4,260,583.5iB/s remaining:00:00 elapsed:00:01 postfix:-
INFO:root:Loaded norm stats from /workspace/openpi/assets/pi05_mecharm_teach_lora/local/mecharm_redblock_box_teach_v1
INFO:root:Loaded norm stats from /workspace/ckpt/3999/assets/local/mecharm_redblock_box_teach_v1
INFO:root:Creating server (host: 7f6b9147d13a, ip: 172.16.48.2)
INFO:websockets.server:server listening on 0.0.0.0:8000
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 40588) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 40588) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 34182) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 34182) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 39180) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 39180) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 39460) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 39460) closed
```

`Loaded norm stats from …/mecharm_redblock_box_teach_v1` の2行で、今回のお手本（teach_v1）から計算した正規化の値（関節の角度を学習しやすい範囲に直すための平均と幅）を読んだことが分かります。後半の `connection open` と `closed` の組は、Mac のクライアントが1回つなぐたびに出る行です。


## 安全範囲を今回のお手本から作るように、`--raw-dir` を付けた

Mac 側のクライアント `run_policy_client.py` は、アームへ送る角度を「学習データで通った関節の範囲 ±10°」に収めます（安全範囲）。この範囲を作るお手本のフォルダは、何も付けないと、前の回のお手本（scripted_v1）になっていました。前の回のお手本はブロックがほぼ同じ場所にあるので、土台 j0 の範囲が狭く、今回のお手本（j0 を −61.7° まで使う）の動きが途中で切られてしまいます。2つのお手本で範囲を計算して比べました。

```
mecharm_redblock_box_scripted_v1 20
  min [-42.4   1.3 -42.2 -13.7 -90.9 -40.6]
  max [ 85.8  89.2  20.4  22.5  57.3 -28.9]
mecharm_redblock_box_teach_v1 19
  min [-61.7   1.3 -35.7  -7.8 -88.2 -40.6]
  max [ 44.7  87.9  31.4  17.    0.4 -23.6]
```

前のお手本で作ると j0 の下限は −52°、今回のお手本なら −72° です。そのため `--raw-dir` に今回のお手本を指定して動かしました。下のログの最初の `[SAFE]` の行が、今回のお手本で作った範囲です。


## たたんだ姿勢のままのドライランでは、予測はほとんど0だった

Pi（アームの中の小さなコンピュータ）でアームを動かす常駐プログラム（デーモン）を起動し、まずアームに何も送らない「ドライラン」で予測だけを見ました。ここから実機でアームを動かすまでのターミナルの記録です。

```
Last login: Wed Oct 21 08:21:34 on ttys005
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 'ss -ltn | grep 5555' || { ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 "setsid nohup python3 /home/ubuntu/mecharm_daemon.py </dev/null >>/home/ubuntu/daemon.log 2>&1 &"; sleep 5; ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 'tail -3 ~/daemon.log; ss -ltn | grep 5555'; }
[DAEMON 15:24:04] ✓ MyCobot 初期化完了
[DAEMON 15:24:04] startup_warmup angles=[-0.08, 92.54, 1.14, 1.75, -95.97, -29.26]
[DAEMON 15:24:04] ポート 5555 で待ち受け中...
LISTEN0      1                                 0.0.0.0:5555        0.0.0.0:*    
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % cd ~/r2r2r-scripts
R=/Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1/raw_episodes 
python3 pi05/run_policy_client.py --raw-dir $R --max-chunks 5
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+98]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[MODE  ] DRY-RUN (アームには送らない)  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_082212
[POLICY] 接続 ws://localhost:8000  metadata={}
[WARN  ] HOME から離れています (max|Δ|=96.0°). 学習データは HOME から始まっています
         現在角: j0=-0.1 j1=+92.5 j2=+1.1 j3=+1.8 j4=-96.0 j5=-29.3
[000] 推論 57049ms  5ステップ先  Δ= -0.2  +1.4  -1.0  -0.0  +6.0  -0.0
       [LIMIT] j4 安全範囲でクランプ -95.9→-90.0
[001] 推論 875ms  4ステップ先  Δ= +0.2  +0.1  -0.1  +0.1  +6.0  -0.0  グリッパー→閉
       [LIMIT] j4 安全範囲でクランプ -96.0→-90.0
[002] 推論 804ms  5ステップ先  Δ= -0.0  +0.1  -0.1  +0.0  +6.0  -0.0
       [LIMIT] j4 安全範囲でクランプ -95.8→-90.0
[003] 推論 2696ms  5ステップ先  Δ= +0.0  +0.2  -0.1  -0.0  +6.0  -0.0  グリッパー→閉
       [LIMIT] j4 安全範囲でクランプ -96.1→-90.0
[004] 推論 1140ms  3ステップ先  Δ= +0.0  +0.2  -0.0  -0.0  +6.0  -0.0  グリッパー→閉
       [LIMIT] j4 安全範囲でクランプ -96.0→-90.0
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_082212
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $R --execute --max-chunks 1
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+98]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[MODE  ] EXECUTE  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_082423
[POLICY] 接続 ws://localhost:8000  metadata={}
[WARN  ] HOME から離れています (max|Δ|=96.0°). 学習データは HOME から始まっています
         現在角: j0=-0.1 j1=+92.5 j2=+1.1 j3=+1.8 j4=-96.0 j5=-29.3
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[000] 推論 1098ms  5ステップ先  Δ= +0.1  +0.3  -0.3  -0.0  +6.0  -0.0
       [LIMIT] j4 安全範囲でクランプ -96.0→-90.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=95.97°, post-send timeout 16.4s)
[SEND] arrival OK: max|Δ|=1.75° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_082423
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $R --max-chunks 5
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+98]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[MODE  ] DRY-RUN (アームには送らない)  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_082512
[POLICY] 接続 ws://localhost:8000  metadata={}
[000] 推論 1158ms  5ステップ先  Δ= -4.8  +8.3  -0.1  +1.3 -10.5  -0.4
[001] 推論 982ms  5ステップ先  Δ= -2.6  +4.5  -0.1  +0.7  -5.3  -0.3
[002] 推論 814ms  5ステップ先  Δ= -3.8  +6.7  +0.1  +1.1  -8.7  -0.2
[003] 推論 1062ms  5ステップ先  Δ= -0.1  +0.0  -0.1  +0.0  +0.2  +0.0
[004] 推論 1069ms  5ステップ先  Δ= -0.6  +0.9  -0.1  +0.2  -1.0  -0.1
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_082512
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $R --execute
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+98]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[MODE  ] EXECUTE  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_082645
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[000] 推論 2440ms  5ステップ先  Δ= -2.1  +3.8  -0.0  +0.7  -4.8  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk000: send_angles (single) [  -2.16,   +5.13,   +1.74,   +0.98,   -5.03,  -29.98]  speed=20 wait=1.0s  (pre max|Δ|=4.77°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.08° (tol 3.0°)
[001] 推論 860ms  5ステップ先  Δ= -5.3 +10.9  +2.1  +1.3 -14.5  +0.4
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk001: send_angles (single) [  -7.76,  +16.90,   +4.66,   +1.55,  -18.48,  -29.30]  speed=20 wait=1.0s  (pre max|Δ|=13.65°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.94° (tol 3.0°)
[002] 推論 942ms  5ステップ先  Δ= -6.7 +10.4  +2.5  +0.9 -15.0  +0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -14.72,  +28.28,   +7.72,   +2.72,  -32.98,  -29.37]  speed=20 wait=1.0s  (pre max|Δ|=14.97°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.98° (tol 3.0°)
[003] 推論 2261ms  5ステップ先  Δ= -7.1 +11.1  +3.1  +0.6 -16.0  +0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk003: send_angles (single) [ -21.75,  +40.39,  +11.41,   +4.14,  -49.17,  -29.61]  speed=20 wait=1.0s  (pre max|Δ|=15.95°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.83° (tol 3.0°)
[004] 推論 837ms  5ステップ先  Δ= -6.6 +10.7  +2.8  -0.6 -15.6  +0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk004: send_angles (single) [ -28.16,  +51.95,  +14.71,   +3.21,  -64.38,  -29.64]  speed=20 wait=1.0s  (pre max|Δ|=15.61°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.87° (tol 3.0°)
[005] 推論 806ms  5ステップ先  Δ= -5.8  +9.0  +1.7  +0.6 -10.9  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk005: send_angles (single) [ -34.26,  +61.83,  +16.87,   +4.25,  -75.09,  -29.71]  speed=20 wait=1.0s  (pre max|Δ|=10.93°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.01° (tol 3.0°)
[006] 推論 934ms  5ステップ先  Δ= -0.1  +0.9  -0.2  -0.1  -0.3  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk006: send_angles (single) [ -33.91,  +63.71,  +16.70,   +4.18,  -75.10,  -29.68]  speed=20 wait=1.0s  (pre max|Δ|=0.87°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.97° (tol 3.0°)
[007] 推論 881ms  5ステップ先  Δ= +0.0  +0.1  -0.1  -0.0  -0.1  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[008] 推論 2387ms  5ステップ先  Δ= +0.0  +0.2  -0.1  -0.1  -0.2  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[009] 推論 917ms  5ステップ先  Δ= +0.0  +1.0  -0.1  -0.2  -0.4  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk009: send_angles (single) [ -33.90,  +65.68,  +16.72,   +4.10,  -75.74,  -29.68]  speed=20 wait=1.0s  (pre max|Δ|=1.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.94° (tol 3.0°)
[010] 推論 2530ms  5ステップ先  Δ= +0.0  +0.0  -0.1  -0.0  -0.1  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[011] 推論 1412ms  5ステップ先  Δ= +0.1  +0.1  -0.0  -0.0  -0.2  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[012] 推論 1260ms  5ステップ先  Δ= +0.0  +0.1  -0.0  -0.0  -0.2  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[013] 推論 1229ms  5ステップ先  Δ= +0.1  +0.2  -0.1  -0.0  -0.3  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[014] 推論 878ms  5ステップ先  Δ= +0.0  +0.1  -0.1  -0.0  -0.1  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
```

最初のドライラン（`pi05_20261021_082212`）は、アームが電源を入れたときのたたんだ姿勢（肩 j1 +92.5°、手首 j4 −96.0°）のままでした。お手本はすべて HOME（たたまずに立てた待機姿勢）から始まっているので、この姿勢は学習で見たことがありません。予測は手首を安全範囲の端まで戻す +6.0° のほかはほとんど0で、[LOG341](https://pixelstomotors.com/record/pi05-mecharm-lora-2000-steps) と同じでした。1回目の推論は、サーバー側のコンパイルで 57 秒かかっています。

`--execute --max-chunks 1` で起動し、最初の確認で `h` を押して HOME に戻しました。HOME からのドライラン（`pi05_20261021_082512`）では、土台 j0 を −方向に回し、肩 j1 を前に倒し、手首 j4 を下げる、ブロックへ腕を伸ばす向きの予測が出ています。ドライランではアームが動かないので、5回とも同じ画像と角度から予測しています。それでも予測の大きさが回ごとに違うのは、π0.5 の出力に毎回ばらつきがあるためです。


## 実機では7回の指令でブロックの近くまで来て、そこから動かなくなった

`--execute` で、1チャンク（1回の予測）ごとに Enter で確かめながら動かしました。チャンク 00〜05 の6回で、j1 は +5.1° から +61.8° まで、j4 は −5.0° から −75.1° まで進みました。1回の移動はどれも 3° 以内の誤差で届いています（`arrival OK`）。

チャンク 06 で動きが 1° 未満に落ち、そこから先は予測がほとんど0になりました。チャンク 09 で j1 が 1° 動いたのを最後に、指令は「動かす必要なし」（0.5° 未満）が続いています。ターミナルの記録はチャンク 14 までですが、`log.jsonl` にはチャンク 19 まで残っていて、最後に `h` で HOME に戻しています。チャンク 15〜19 の記録です（state はそのチャンクの予測を求めたときの実測角）。

| チャンク | state（j0〜j5） | 送った目標（j0〜j5） | 実行 | 届いたか |
|---|---|---|---|---|
| 15 | -33.9 +66.6 +16.9 +4.3 -75.8 -29.7 | -33.9 +66.7 +16.8 +4.2 -76.0 -29.7 | Enter（差が 0.5° 未満なので送らず） | — |
| 16 | -33.9 +66.6 +16.9 +4.3 -75.8 -29.7 | -33.9 +66.8 +16.8 +4.2 -76.1 -29.7 | Enter（差が 0.5° 未満なので送らず） | — |
| 17 | -33.9 +66.6 +16.9 +4.3 -75.8 -29.7 | -33.8 +66.6 +16.8 +4.2 -76.0 -29.7 | Enter（差が 0.5° 未満なので送らず） | — |
| 18 | -33.9 +66.6 +16.9 +4.3 -75.8 -29.7 | -33.9 +66.7 +16.8 +4.3 -76.0 -29.7 | Enter（差が 0.5° 未満なので送らず） | — |
| 19 | -33.9 +66.6 +16.9 +4.3 -75.8 -29.7 | -33.9 +66.7 +16.8 +4.3 -76.1 -29.7 | h（HOME に戻して終了） | — |

上のカメラが、各チャンクで AI に渡した画像を並べました。チャンク 06 以降、アームはブロックのすぐ近くで止まったままです。

![π0.5 に渡した上カメラの画像20枚。チャンク00〜05でアームがブロックへ伸び、06以降は同じ姿勢のまま止まっている](https://pixelstomotors.com/media/LOG358_01_top_camera_20_chunks.jpg)


## お手本では、ブロックの真上に着いてから 1.5〜2 秒止まっていた

止まった姿勢（j0 −33.9°、j1 +65.7°、j2 +16.7°、j3 +4.1°、j4 −75.7°）が、お手本のどこに当たるかを調べました。19本それぞれで、この姿勢にいちばん近い瞬間（`near t`）と、その姿勢との差（`dist`、関節ごとの差の最大）を出しています。`still` はその瞬間から動かずにいたステップ数で、どの1本も 0 でした。いちばん近い瞬間は、どれも止まる直前のまだ動いているコマだったためで、止まっている区間は次の表で見ています。

```
# 実機で止まった姿勢に、お手本のどの瞬間がいちばん近いか (LOG358)
import numpy as np, glob, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/datasets/mecharm_redblock_box_teach_v1/raw_episodes")
cur = np.array([-33.90, 65.68, 16.72, 4.10, -75.74])   # 実機で止まった姿勢 j0..j4
for p in sorted(glob.glob("*/episode.npz")):
    d = np.load(p); s = d["state"]
    dist = np.abs(s[:, :5] - cur).max(1); i = dist.argmin()
    mv = np.abs(np.diff(s[:, :6], axis=0)).max(1)
    j = i
    while j < len(mv) and mv[j] < 0.3: j += 1
    g = s[:, 6]; gc = np.where(np.diff(g) != 0)[0]
    print(os.path.dirname(p)[-15:], "len", len(s), "near t", i, "dist %.1f" % dist[i], np.round(s[i, :5], 1), "g", g[i], "still", j - i, "gchg", gc[:3])
```

```
20261019_183454 len 208 near t 38 dist 4.6 [-33.8  61.1  14.2   4.3 -79. ] g 0.0 still 0 gchg [ 83 162]
20261019_191257 len 205 near t 124 dist 27.5 [ -8.   61.7 -10.8  11.2 -54.6] g 1.0 still 0 gchg [ 66 165]
20261019_191347 len 208 near t 125 dist 27.4 [ -7.7  61.8 -10.7  11.1 -54.8] g 1.0 still 0 gchg [ 67 165]
20261019_191441 len 241 near t 158 dist 27.6 [ -8.6  62.  -10.9  10.8 -54.9] g 1.0 still 0 gchg [ 94 199]
20261019_191541 len 211 near t 132 dist 27.3 [ -6.7  61.6 -10.5  11.2 -54.6] g 1.0 still 0 gchg [ 77 172]
20261019_191635 len 214 near t 135 dist 27.3 [ -6.6  61.5 -10.6  11.2 -54.8] g 1.0 still 0 gchg [ 74 175]
20261019_192343 len 200 near t 64 dist 7.2 [-27.6  58.5  19.3  -3.  -69.8] g 0.0 still 0 gchg [ 83 160]
20261019_192438 len 202 near t 58 dist 7.4 [-27.8  58.6  19.1  -3.3 -69.8] g 0.0 still 0 gchg [ 77 159]
20261019_192539 len 203 near t 54 dist 7.3 [-28.3  58.4  19.3  -3.2 -69.8] g 0.0 still 0 gchg [ 74 160]
20261019_192633 len 198 near t 54 dist 7.3 [-28.2  58.5  19.3  -3.2 -69.8] g 0.0 still 0 gchg [ 73 159]
20261019_193404 len 228 near t 135 dist 11.4 [-43.4  54.2  20.4   4.4 -74. ] g 1.0 still 0 gchg [ 91 186]
20261019_193459 len 234 near t 120 dist 11.2 [-45.   54.5  20.6   4.1 -73.8] g 1.0 still 0 gchg [ 83 191]
20261019_193617 len 216 near t 121 dist 11.2 [-44.6  54.4  20.6   4.1 -73.7] g 1.0 still 0 gchg [ 84 173]
20261019_193825 len 245 near t 150 dist 11.2 [-44.8  54.5  20.6   4.4 -73.8] g 1.0 still 0 gchg [ 94 202]
20261019_193932 len 212 near t 117 dist 11.2 [-44.7  54.5  20.6   4.  -73.6] g 1.0 still 0 gchg [ 80 169]
20261019_194818 len 183 near t 24 dist 41.2 [  7.3  25.9  18.   -2.7 -37.2] g 0.0 still 0 gchg [ 73 140]
20261019_194913 len 183 near t 24 dist 40.8 [  6.6  24.9  17.4  -3.9 -35.8] g 0.0 still 0 gchg [ 74 140]
20261019_195023 len 180 near t 24 dist 40.5 [  6.5  25.2  17.5  -3.2 -36.1] g 0.0 still 0 gchg [ 71 137]
20261019_195120 len 178 near t 23 dist 41.0 [  6.6  24.7  17.2  -2.8 -35.4] g 0.0 still 0 gchg [ 70 136]
```

いちばん近いのは 183454 の t=38（差 4.6°）と、192343〜192633 の4本（差 7.2〜7.4°）です。どちらもブロックの真上に来たあたりで、つかむ前です。その前後の動きを 0.3 秒おきに並べました。

```
# 真上に着いたあたりの動きを 0.3 秒おきに並べる (LOG358)
import numpy as np, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/datasets/mecharm_redblock_box_teach_v1/raw_episodes")
for r in ["run_0001_20261019_192343", "run_0001_20261019_183454"]:
    d = np.load(r + "/episode.npz"); s = d["state"]; a = d["actions"]
    print(r)
    for t in range(30, 95, 3):
        print(t, np.round(s[t, :6], 1), "g", s[t, 6], " a-s max %.2f" % np.abs(a[t, :6] - s[t, :6]).max())
```

```
run_0001_20261019_192343
30 [-10.   22.7   7.8  -2.7 -26.5 -28.7] g 0.0  a-s max 2.83
33 [-14.4  29.7   9.9  -3.1 -35.5 -28.6] g 0.0  a-s max 3.07
36 [-17.9  36.6  12.1  -2.5 -44.5 -28.5] g 0.0  a-s max 2.99
39 [-20.8  43.6  14.2  -2.6 -53.5 -28.4] g 0.0  a-s max 3.01
42 [-24.2  50.5  16.2  -3.  -62.5 -28.3] g 0.0  a-s max 2.96
45 [-26.8  55.8  18.2  -2.8 -68.1 -28.3] g 0.0  a-s max 1.32
48 [-27.6  58.1  19.6  -2.4 -69.3 -28.3] g 0.0  a-s max 0.05
51 [-27.6  58.1  19.7  -2.4 -69.3 -28.3] g 0.0  a-s max 0.03
54 [-27.6  58.1  19.7  -2.4 -69.3 -28.2] g 0.0  a-s max 0.03
57 [-27.6  58.1  19.7  -2.5 -69.4 -28.2] g 0.0  a-s max 0.03
60 [-27.6  58.1  19.7  -2.5 -69.5 -28.2] g 0.0  a-s max 0.27
63 [-27.6  58.1  19.7  -2.6 -70.3 -28.1] g 0.0  a-s max 0.52
66 [-27.6  59.6  18.2  -3.9 -68.1 -28.1] g 0.0  a-s max 0.87
69 [-27.6  61.2  16.7  -5.3 -65.5 -28. ] g 0.0  a-s max 0.87
72 [-27.7  62.8  15.1  -6.7 -62.9 -28. ] g 0.0  a-s max 0.87
75 [-27.7  63.7  14.2  -7.5 -61.3 -27.9] g 0.0  a-s max 0.00
78 [-27.7  63.7  14.2  -7.5 -61.3 -27.9] g 0.0  a-s max 0.03
81 [-27.7  63.7  14.2  -7.6 -61.2 -27.9] g 0.0  a-s max 0.02
84 [-27.7  63.7  14.1  -7.6 -61.2 -27.9] g 1.0  a-s max 0.04
87 [-27.7  63.7  14.1  -7.6 -61.3 -27.9] g 1.0  a-s max 0.04
90 [-27.7  63.7  14.1  -7.6 -61.4 -27.9] g 1.0  a-s max 0.04
93 [-27.7  63.7  14.   -7.6 -61.6 -27.9] g 1.0  a-s max 0.04
run_0001_20261019_183454
30 [-23.1  43.7  10.6   4.6 -56.2 -29.1] g 0.0  a-s max 3.01
33 [-26.9  50.3  12.    3.7 -65.2 -29.1] g 0.0  a-s max 2.94
36 [-31.2  56.7  13.4   3.9 -73.9 -29.1] g 0.0  a-s max 2.82
39 [-34.9  63.2  14.6   4.5 -81.2 -29.2] g 0.0  a-s max 2.23
42 [-36.4  66.4  15.8   4.6 -84.  -29.2] g 0.0  a-s max 0.45
45 [-36.4  66.7  16.5   4.4 -84.  -29.2] g 0.0  a-s max 0.03
48 [-36.4  66.7  16.5   4.3 -84.  -29.2] g 0.0  a-s max 0.00
51 [-36.4  66.7  16.5   4.3 -84.  -29.2] g 0.0  a-s max 0.03
54 [-36.4  66.7  16.5   4.3 -84.1 -29.2] g 0.0  a-s max 0.00
57 [-36.4  66.7  16.5   4.3 -84.1 -29.2] g 0.0  a-s max 0.00
60 [-36.4  66.7  16.5   4.3 -84.3 -29.2] g 0.0  a-s max 0.49
63 [-36.4  66.7  16.5   4.3 -85.7 -29.2] g 0.0  a-s max 1.25
66 [-36.4  70.8  14.2   4.1 -86.2 -29.2] g 0.0  a-s max 1.41
69 [-36.4  75.   11.7   3.9 -86.8 -29.2] g 0.0  a-s max 1.41
72 [-36.4  79.2   9.3   3.6 -87.4 -29.2] g 0.0  a-s max 1.41
75 [-36.4  81.6   7.9   3.5 -87.7 -29.3] g 0.0  a-s max 0.00
78 [-36.4  81.6   7.9   3.5 -87.7 -29.3] g 0.0  a-s max 0.00
81 [-36.4  81.6   7.9   3.5 -87.7 -29.3] g 0.0  a-s max 0.03
84 [-36.4  81.6   7.9   3.5 -87.7 -29.4] g 1.0  a-s max 0.02
87 [-36.4  81.6   7.9   3.5 -87.8 -29.4] g 1.0  a-s max 0.02
90 [-36.4  81.6   7.9   3.5 -87.9 -29.4] g 1.0  a-s max 0.02
93 [-36.4  81.6   7.9   3.5 -87.9 -29.5] g 1.0  a-s max 0.02
```

192343 では、t=45 から t=60 まで、関節の角度がまったく変わっていません（`a-s max` は、そのステップの目標と実測の差の最大。0.05° 前後）。その後 t=63〜72 で下ろし、t=75〜84 でまた止まってからグリッパーを閉じています（`g` が 0 から 1 へ）。183454 も、t=45〜57 で止まってから下ろしています。

π0.5 は1回に10ステップ（1秒）先までの動きを返します。真上での停止は 1.5〜2 秒あり、1秒より長いので、停止の途中のコマから見た「1秒先の正解」は、ずっと止まったままです。しかも停止の間は、上カメラの画像も関節の角度も変わりません。同じ入力に対して、正解が「止まる」になっているコマが何枚も続き、「下ろし始める」になっているコマはその最後の数枚だけです。実機のアームは真上に着いたあと、その「止まる」側の答えを返し続けたことになります。

この関係を、お手本1本で動かして見られるようにしました。つまみを動かすと、その位置から1秒先までの枠が出ます。

[図解: LOG358_pauses_in_demo.html](https://pixelstomotors.com/embeds/LOG358_pauses_in_demo.html)


## 止まっているステップは、お手本全体の 40% だった

19本全体で、止まっているステップ（6関節すべてで目標と実測の差が 0.3° 未満、かつグリッパーの状態が変わらない）を数えました。

```
# お手本 19 本の「止まっているステップ」の割合と、5 ステップ以上続く停止の長さ (LOG358)
import numpy as np, glob, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/datasets/mecharm_redblock_box_teach_v1/raw_episodes")
tot = still = 0; runs = []
for p in sorted(glob.glob("*/episode.npz")):
    d = np.load(p); s = d["state"]; a = d["actions"]
    m = (np.abs(a[:, :6] - s[:, :6]).max(1) < 0.3) & (a[:, 6] == s[:, 6])
    tot += len(s); still += m.sum()
    r = 0; best = []
    for x in m:
        if x: r += 1
        else:
            if r >= 5: best.append(r)
            r = 0
    if r >= 5: best.append(r)
    runs.append(best)
print("still steps", still, "/", tot, "%.0f%%" % (100 * still / tot))
for p, b in zip(sorted(glob.glob("*/episode.npz")), runs):
    print(os.path.dirname(p), "still runs (>=5 steps):", b)
```

```
still steps 1594 / 3949 40%
run_0001_20261019_183454 still runs (>=5 steps): [10, 17, 9, 20, 10, 10]
run_0001_20261019_191257 still runs (>=5 steps): [10, 10, 19, 16, 10, 10]
run_0001_20261019_191347 still runs (>=5 steps): [10, 10, 9, 19, 14, 10, 10]
run_0001_20261019_191441 still runs (>=5 steps): [10, 20, 10, 9, 19, 6, 10, 10, 10]
run_0001_20261019_191541 still runs (>=5 steps): [10, 20, 9, 19, 12, 10, 10]
run_0001_20261019_191635 still runs (>=5 steps): [10, 19, 10, 19, 16, 10, 10]
run_0001_20261019_192343 still runs (>=5 steps): [10, 16, 9, 20, 10, 10]
run_0001_20261019_192438 still runs (>=5 steps): [10, 16, 9, 20, 7, 10, 10]
run_0001_20261019_192539 still runs (>=5 steps): [10, 16, 10, 19, 7, 10, 10]
run_0001_20261019_192633 still runs (>=5 steps): [10, 12, 9, 20, 6, 10, 10]
run_0001_20261019_193404 still runs (>=5 steps): [10, 19, 9, 19, 5, 10, 10]
run_0001_20261019_193459 still runs (>=5 steps): [10, 20, 9, 19, 7, 20, 10]
run_0001_20261019_193617 still runs (>=5 steps): [10, 20, 9, 19, 10, 10]
run_0001_20261019_193825 still runs (>=5 steps): [10, 19, 10, 9, 19, 19, 10, 10]
run_0001_20261019_193932 still runs (>=5 steps): [10, 19, 9, 19, 10, 10]
run_0001_20261019_194818 still runs (>=5 steps): [10, 16, 9, 20, 10, 10]
run_0001_20261019_194913 still runs (>=5 steps): [10, 16, 9, 19, 10, 10]
run_0001_20261019_195023 still runs (>=5 steps): [10, 13, 10, 19, 10, 10]
run_0001_20261019_195120 still runs (>=5 steps): [10, 13, 10, 19, 10, 10]
```

3,949 ステップのうち 1,594（40%）が止まっていて、1本の中に 1〜2 秒の停止が 6〜9 回あります。お手本を作るスクリプト `build_demo_episodes.py` には、もともと止まっている区間を詰める処理がありました。ただし条件が「2.0 秒以上」だったため、1.5〜2 秒の停止はすべて残っていました（あとで Claude Code が報告した内容）。

手で教えた要所を再生してお手本を録る方法（[LOG349](https://pixelstomotors.com/record/drag-teach-waypoint-replay)・[LOG352](https://pixelstomotors.com/record/teach-replay-19-demos)）では、アームは要所ごとに「着いたか」を確かめ、グリッパーの開け閉めのあとは2秒待ちます。再生を確実にするための待ちが、そのままお手本の中身になっていました。


## 止まっている時間を詰める1回目（trim）は、codex のレビューで NG になった

直し方は、お手本から途中の停止を「先頭の2ステップだけ残して」削り、同じ条件で学習し直すことにしました。「止まっていたら少し押し出す」のような、推論の側での手当てはしていません。

データを作り直すプログラムは Claude Code が `build_demo_episodes.py` に足しました（オプション `--trim-mid-idle`）。元のお手本（teach_v1）は読むだけで、新しい名前（teach_v1_trim）で出しています。Claude Code の報告です。

```
データ作成まで完了しました。学習設定には手を付けていません。

  1. 修正内容

  pi05/build_demo_episodes.py に --trim-mid-idle を追加（既定では何もしない）。

  - MID_IDLE_EPS_DEG = 0.3 / MID_IDLE_KEEP_STEPS = 2
  - mid_idle_keep_mask(state, actions) — 停止ステップ = 6関節すべて abs(action - 
  state) < 0.3 かつ action[6] == state[6]。連続する停止は先頭2ステップだけ残す
  - 既存トリムの直後、フレーム抽出の前に適用。frames/ はトリム後の t
  に対して選ぶので枚数は常にステップ数と一致（連番も振り直し）
  - グリッパー切替ステップは action[6] != state[6]
  なので、定義上そもそも削除対象に入りません
  - 各エピソードの先頭・末尾は明示的に残す（両端の state を変えないため）

  原因について1点補足です。既存の停止詰め処理は前からありましたが、しきい値が
  IDLE_MAX_SEC = 2.0 秒で、今回の 1.5〜2 秒の停止（19〜20ステップ）がしきい値のす
  ぐ下に収まって残っていたのが実態でした。

  2. 出力

  datasets/mecharm_redblock_box_teach_v1_trim/（19本 + index.json +
  README.md）。teach_v1 は読み取りのみで、mtime も Oct 19
  のまま・3,949ステップ・19本のままです。

  3. 確かめた結果

  ┌────────────────┬────────────────┬─────────────────────────────┐
  │      項目      │       前       │             後              │
  ├────────────────┼────────────────┼─────────────────────────────┤
  │ 合計ステップ   │ 3,949          │ 2,635（66.7%、1,314削除）   │
  ├────────────────┼────────────────┼─────────────────────────────┤
  │ 停止の割合     │ 1,594（40.4%） │ 280（10.6%）                │
  ├────────────────┼────────────────┼─────────────────────────────┤
  │ 再生時間       │ 394.9秒        │ 263.5秒                     │
  ├────────────────┼────────────────┼─────────────────────────────┤
  │ 停止の最長連続 │ 20             │ 2                           │
  ├────────────────┼────────────────┼─────────────────────────────┤
  │ グリッパー切替 │ 各2回          │ 各2回（19本すべて一致）     │
  ├────────────────┼────────────────┼─────────────────────────────┤
  │ 両端の state   │ —              │ 19本すべて完全一致（7次元） │
  └────────────────┴────────────────┴─────────────────────────────┘

  エピソードごとのステップ数は README の表に全19本入れました（例: 208→144,
  245→155, 178→118）。停止が3ステップ以上続く箇所は0件（最長2 = 設定どおり）。

  action の整合性（max abs(action[t] - state[t+1])）は、全体の最大が 2.275 → 
  2.275 deg で変わりません。最悪値は元データ由来の1本（191441）で、詰めたことで悪
  化していません。ただしエピソード単位では停止の継ぎ目で最大 0.7 deg
  ほど増えます（例: 0.55→1.26）。停止区間中の微小ドリフトが継ぎ目で1ステップに集
  まるためで、これは仕様上避けられない分です。気になる水準なら MID_IDLE_EPS_DEG
  を下げる余地があります。

  4. 変更していないこと

  - 既定動作の非改変を実測で確認: オプション未指定で1本再生成し、t / state /
  actions が完全一致、frames 208枚の md5 も全一致（確認用データセットは削除済み）
  - meta.json の steps_before_mid_trim が teach_v1 の元ステップ数と19本すべて一致
  → 詰める前の段階までは teach_v1
  と同一に再生成できており、前後比較の土台が妥当であることの裏付けになっています
  - 既存の IDLE_* 定数とロジック、FPS / IMG_LONG / 採否ゲート（LOG352分）は非改変
  - 関節・グリッパー・姿勢・実機制御フローには触っていません（Mac側オフラインのデ
  ータ生成のみで、実機へ指令を出す経路を含まない）ため、物理リスクは低と判断して
  います
  - send_coords() 不使用、FKテーブル非参照、台帳CSV非改変、git commit/push なし

  作業ログ: ~/r2r2r-scripts/logs/20261021_0839.md

  なお git diff には私の変更以外に**既存の未コミット分（LOG352 
  の採否ゲート関連）**も含まれています。これは私がファイルを開いた時点で作業ツリ
  ーにあったもので、今回は触っていません。コミットする際は個別ファイル指定でも混
  ざるのでご注意ください。
```

Claude 側でも、削ったあとの 2,635 ステップが元のどのステップに当たるかを調べ、関節の角度と画像（MD5 という中身から計算する値）が19本すべてで一致することを確かめました。

```
# trim の 19 本が、元のお手本のどのステップを残したかを確かめる (state・actions・画像の MD5) (LOG358)
import numpy as np, os, hashlib
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/datasets")
A = "mecharm_redblock_box_teach_v1/raw_episodes"; B = "mecharm_redblock_box_teach_v1_trim/raw_episodes"
def md5(p): return hashlib.md5(open(p, 'rb').read()).hexdigest()
bad = 0; tot_o = tot_t = 0
for r in sorted(os.listdir(A)):
    if not os.path.exists(f"{A}/{r}/episode.npz"): continue
    o = np.load(f"{A}/{r}/episode.npz"); t = np.load(f"{B}/{r}/episode.npz")
    fo = sorted(os.listdir(f"{A}/{r}/frames")); ft = sorted(os.listdir(f"{B}/{r}/frames"))
    assert len(ft) == len(t["t"]), (r, len(ft), len(t["t"]))
    idx = [int(np.argmin(np.abs(o["t"] - x))) for x in t["t"]]
    ok_state = np.allclose(o["state"][idx], t["state"]) and np.allclose(o["actions"][idx], t["actions"])
    ho = {md5(f"{A}/{r}/frames/{f}"): i for i, f in enumerate(fo)}
    fm = [ho.get(md5(f"{B}/{r}/frames/{f}"), -1) for f in ft]
    ok_frames = fm == idx
    s = t["state"]; a = t["actions"]
    m = (np.abs(a[:, :6] - s[:, :6]).max(1) < 0.3) & (a[:, 6] == s[:, 6])
    run = 0; mx = 0
    for x in m:
        run = run + 1 if x else 0; mx = max(mx, run)
    tot_o += len(o["t"]); tot_t += len(t["t"])
    if not (ok_state and ok_frames): bad += 1
    print(r[-15:], len(o["t"]), "->", len(t["t"]), "state一致", ok_state, "画像一致", ok_frames, "停止最長", mx, "grip変化", int((np.diff(s[:, 6]) != 0).sum()))
print("total", tot_o, "->", tot_t, "不一致エピソード", bad)
```

```
20261019_183454 208 -> 144 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_191257 205 -> 142 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_191347 208 -> 140 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_191441 241 -> 155 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_191541 211 -> 135 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_191635 214 -> 134 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_192343 200 -> 137 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_192438 202 -> 134 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_192539 203 -> 135 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_192633 198 -> 135 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_193404 228 -> 160 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_193459 234 -> 153 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_193617 216 -> 150 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_193825 245 -> 155 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_193932 212 -> 147 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_194818 183 -> 120 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_194913 183 -> 121 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_195023 180 -> 120 state一致 True 画像一致 True 停止最長 2 grip変化 2
20261019_195120 178 -> 118 state一致 True 画像一致 True 停止最長 2 grip変化 2
total 3949 -> 2635 不一致エピソード 0
```

ここで学習に進むつもりでした。ただ、この確認は「どのステップを残したか」を見ただけで、Claude Code の報告と同じ観点です。学習には8時間と約5ドル（約790円）かかるので、別の AI の codex に、実装とデータを読んでもらいました。結果は NG でした。

```
**現状のまま約8時間の学習へ進むのは勧めません。** 画像の対応は正しい一方、削除した継ぎ目の action 不整合と、グリッパー切替直前の削除を実データで確認しました。

コード・README・`convert_to_lerobot.py` を読み、元データと trim データ19本を読み取り専用で比較しました。ファイルの変更・再生成はしていません。README の「すべて満たしている」は検証対象の記述として扱いました。

以下、行番号は `build_demo_episodes.py` のものです。

| 項目 | 判定 | 確認結果・修正案 |
|---|---|---|
| **A1 画像と state・action の対応** | ✅ OK | 289・297行で同じマスクを適用し、300〜305行で残った時刻から画像を選んでいます。19本すべてで state・actions が元データの保持行と完全一致し、画像も対応する元JPEGと全枚ハッシュ一致しました。 |
| **A2 action[t] ≈ state[t+1]** | ❌ NG | **297行**で削除前の action をそのまま保持しています。削除後の127継ぎ目のうち80箇所で誤差が0.3°以上、19箇所で1°超。最大2.275°です。**最終マスク適用後に `actions = np.concatenate([state[1:], state[-1:]], axis=0)` として再計算**してください。継ぎ目の移動量自体が適切かも確認が必要です。 |
| **A3 ゆっくりした動き出しの保護** | ⚠️ 要注意 | **187〜198行**は指定された停止定義には忠実ですが、微小な移動と本当の停止を区別できません。再現例では、毎ステップ0.2°ずつ動く12ステップが `[0,1,11]` の3ステップまで削られます。実データでも新しい継ぎ目の最大累積ずれは2.275°でした。連続区間内の姿勢の変動幅にも上限を設けるなど、追加条件が必要です。 |
| **A4 グリッパー切替前後** | ❌ NG | 切替ステップそのものは38回すべて保持。しかし**198行**で、**38回すべての切替直前の1ステップが削除**されています。直後は保持されています。切替行 `i` と `i-1, i+1` を明示的に保護してください。既存の停止処理にも同じ保護が必要です。 |
| **A5 最初・最後の保持** | ✅ OK※ | 202〜204行で保護され、19本すべてで teach_v1 の先頭・末尾 state と完全一致。ただし、保護対象は**既存の停止処理を通過した後の両端**です。生の記録の末尾は既存処理で失われる可能性があります。 |
| **A6 既存処理との二重削除** | ⚠️ 要注意 | **273〜297行**で二段階に削ります。既存処理は両端専用ではなく、途中の停止も対象です。長い停止は「先頭10ステップ→先頭2ステップ」とさらに短縮されます。重複した行の削除ではありませんが、境界保護や action 再計算は両処理をまとめて考える必要があります。 |
| **B1 未指定時の互換性** | ⚠️ 要注意 | 今回の停止オプションだけなら、未指定時は配列・画像の処理を変えません。ただし**342〜344・354〜355行**でメタデータと index に項目が増えるため、出力全体の完全一致ではありません。また Git HEAD との差分には採否条件の変更もあり、「変更前」との全面的な互換性は断言できません。 |
| **B2 teach_v1 の保護** | ⚠️ 要注意 | README の作成コマンドなら出力先は trim で、teach_v1 への書き込みはありません。そもそも入力は teach_v1 ではなく元の run 記録です。ただし**371行**に出力先の保護がなく、`--dataset mecharm_redblock_box_teach_v1 --force` なら**311行**で元エピソードを削除します。trim 指定時は元データセット名・同一パスを拒否するガードを追加してください。 |
| **B3 後段の読み込み形式** | ✅ OK | 19本すべてで `t[N]`、`state[N,7]`、`actions[N,7]`、画像枚数、`meta.steps` の整合を確認しました。変換コードはこのキーと形を読みます。LeRobot 環境での変換実行は未実施です。 |
| **D6 マウント確認** | ❌ NG | 書き込み前の呼び出しはありますが、**82〜84行**は `DATA_ROOT.exists()` だけです。未マウントでもローカルに同名ディレクトリが残れば通過します。**`Path("/Volumes/KIOXIA").is_mount()` などでマウント自体を確認し、失敗時に終了**してください。 |

README の「全体の最大値が2.275°で変わらないので、悪化していない」という評価には注意が必要です。新しい継ぎ目127箇所のうち、**113箇所で、その元の隣接関係より誤差が増加**しています。例えば `run_0001_20261019_191441` の元インデックス69→78の継ぎ目は、0°から2.275°に増えています。全体最大値だけでは、この悪化が隠れます。

また、**337行の `t` は削除前の時間間隔を残します**。後段の変換コードは `t` を使わず10Hzで並べるため読み込みはできますが、圧縮後の時刻として扱うなら `np.arange(N) / FPS` に振り直し、元の時刻は別キーで保存するのが明確です。

学習前に、少なくとも次を直してください。

- 削除後の action を再計算し、継ぎ目の移動量を検証する。
- グリッパー切替前後を保護する。
- 微小移動を削りすぎない条件を追加する。
- マウント確認と teach_v1 の出力先保護を追加する。

**修正後に19本を再生成・再検証してから学習へ進む**のが妥当です。画像対応と形式は確認できていますが、現状は action の意味が継ぎ目で崩れています。
```

いちばん重いのは A2 です。お手本の「正解（action）」は、もともと「0.1 秒後の実測の角度」です。停止の途中を削ると、削った区間の前のステップの正解は、削られた先の角度のままになり、次に残ったステップの角度と食い違います。停止中にもアームはわずかにずれ続けていたので（A3）、その分が継ぎ目の1か所にまとまり、最大 2.3° の食い違いになっていました。Claude の確認は、対応関係だけを見ていて、継ぎ目での正解の意味までは見ていませんでした。

直す内容は次のとおりにしました。A2 の直し方だけ codex の案から変えています。codex は action の7列すべてを state から作り直す案でしたが、関節の6列だけを作り直し、グリッパーの列は元のまま残しました。グリッパーを開け閉めするタイミングを、1ステップでも動かさないためです。

| 指摘 | 直し方 |
|---|---|
| A2 継ぎ目で action が「0.1 秒後の state」とずれる | 削ったあとに `actions[t, :6] = state[t+1, :6]` で作り直す（グリッパーの列は元のまま） |
| A3 ゆっくり動いている区間まで削る | 停止区間の最初の角度から 0.5° 以上ずれたら、そこで区間を切る |
| A4 グリッパーを切り替える直前の1ステップを削る | 切り替えのステップ i の前後（i−1, i, i+1）を必ず残す |
| D6 マウントの確認が「フォルダがあるか」だけ | `Path("/Volumes/KIOXIA").is_mount()` で確かめる |
| B2 元のデータセットを上書きできてしまう | 出力先が既存のデータセットなら拒否する |
| t（時刻）が削る前の間隔のまま | `np.arange(N) / FPS` に振り直し、元の時刻は `t_orig` に残す |


## 直した版 trim2 は、全ステップで action が「次のステップの state」になった

Claude Code の報告です。前の版（trim）は消さずに、teach_v1_trim2 という新しい名前で出しています。

```
6件すべて直して teach_v1_trim2 を作りました。trim は消していません。

  修正内容

  ┌─────┬─────────────────────┬───────────────────────────────────────────────┐
  │  #  │        指摘         │                     対応                      │
  ├─────┼─────────────────────┼───────────────────────────────────────────────┤
  │     │ 低速移動を停止と誤  │ MID_IDLE_DRIFT_DEG = 0.5。区間先頭 state      │
  │ R1  │ 判定                │ からのずれが0.5°超で区間を切り、新しい区間と  │
  │     │                     │ して数え直す                                  │
  ├─────┼─────────────────────┼───────────────────────────────────────────────┤
  │     │ グリッパー切替前後  │ gripper_guard_mask で i-1, i, i+1             │
  │ R2  │ の保護              │ を保護。既存 IDLE_* 処理にも keep |= guard    │
  │     │                     │ で適用                                        │
  ├─────┼─────────────────────┼───────────────────────────────────────────────┤
  │     │                     │ actions[:-1,:6] = state[1:,:6] /              │
  │ R3  │ action の作り直し   │ actions[-1,:6] =                              │
  │     │                     │ state[-1,:6]。gripper列は非改変               │
  ├─────┼─────────────────────┼───────────────────────────────────────────────┤
  │ R4  │ t の振り直し        │ t = np.arange(N)/FPS、元時刻は t_orig キー    │
  ├─────┼─────────────────────┼───────────────────────────────────────────────┤
  │ R5  │ マウント確認        │ Path("/Volumes/KIOXIA").is_mount()            │
  │     │                     │ で未マウント時 ABORT                          │
  ├─────┼─────────────────────┼───────────────────────────────────────────────┤
  │ R6  │ 出力先ガード        │ 既存の非trimデータセット宛なら ABORT          │
  └─────┴─────────────────────┴───────────────────────────────────────────────┘

  R1/R3/R4 は --trim-mid-idle 時のみ、R2 は既定経路にも、R5/R6 は常時です。

  確認結果

  ┌──────────────┬───────┬───────┬────────────────┐
  │     項目     │  元   │ trim  │     trim2      │
  ├──────────────┼───────┼───────┼────────────────┤
  │ 合計ステップ │ 3,949 │ 2,635 │ 2,717（68.8%） │
  ├──────────────┼───────┼───────┼────────────────┤
  │ 停止の割合   │ 40.4% │ 10.6% │ 9.6%           │
  └──────────────┴───────┴───────┴────────────────┘

  エピソードごとの数値は README の表に全19本あります（例: 208→144→144,
  245→155→165, 178→118→120）。

  - 継ぎ目の跳び: 161箇所で最大 2.275°。元データの通常1ステップの動きが最大
  3.263° なので、継ぎ目は通常の動きの範囲内に収まっており、特異点になっていません
  - action: 全ステップで actions[t,:6] == state[t+1,:6] 成立（最後は
  actions[-1,:6] == state[-1,:6]）
  - グリッパー: 38回すべてで i-1, i, i+1 が残存。切替回数は各エピソード2回のまま
  - 両端 state: 19本すべて元と完全一致
  - 画像: 2,717枚すべて元の対応フレームと MD5 一致
  - オプション未指定時: 19本を再生成して teach_v1 と
  t/state/actions/npzキー/frames MD5（3,949枚）すべて完全一致

  報告すべき2点

  1. R2 の保護は、この19本では0ステップしか効いていません。 trim2 が trim より
  +82ステップ多い内訳は、R1の区間分割が82・R2の保護が0でした。既定経路の出力が完
  全一致したのも同じ理由です。切替ステップの前後がもともと削られていなかったため
  で、R2 は「将来のデータへの安全網」として入った状態です。

  2. R1 で救われた区間は、本当に動いていました。
  該当34区間は端から端の変位が中央値0.78°、変位/経路長が全区間 1.00（＝完全に一方
  向）でした。1ステップあたりは中央値0.056°という小ささですが、ジッターではなく一
  方向にずるずる動いている低速移動です。指摘どおりの誤判定が実在していました。

  出力: datasets/mecharm_redblock_box_teach_v1_trim2/（README 同梱）。episode.npz
  は trim2 のみ t_orig
  キーが増えている点にご注意ください。元データは読むだけ（mtime は Oct 19
  のまま、3,949ステップ・19本）。作業ログは logs/20261021_0912.md です。

  openpi 側の学習設定には手を付けていません。
```

Claude 側でも、Claude Code とは別のやり方で確かめました。元のお手本の時刻（`t_orig`）から対応を取り直し、関節の角度・グリッパーの action・作り直した action・時刻・画像を見ています。グリッパーの切り替えは、「action が切り替わったステップ」と「state が切り替わったステップ」の両方で数えました。

```
# trim2 を元のお手本と突き合わせる: state・グリッパーの action・作り直した action・t・画像・継ぎ目・グリッパー切り替えの前後 (LOG358)
import numpy as np, os, hashlib
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/datasets")
A = "mecharm_redblock_box_teach_v1/raw_episodes"; B = "mecharm_redblock_box_teach_v1_trim2/raw_episodes"
def md5(p): return hashlib.md5(open(p, 'rb').read()).hexdigest()
tot = 0; issues = []; jumps = []; grip_ok = 0; grip_n = 0
for r in sorted(os.listdir(A)):
    if not os.path.exists(f"{A}/{r}/episode.npz"): continue
    o = np.load(f"{A}/{r}/episode.npz"); t = np.load(f"{B}/{r}/episode.npz")
    idx = np.array([int(np.argmin(np.abs(o["t"] - x))) for x in t["t_orig"]]); tot += len(idx)
    if not np.allclose(o["state"][idx], t["state"]): issues.append((r, "state"))
    if not np.allclose(o["actions"][idx, 6], t["actions"][:, 6]): issues.append((r, "grip action"))
    if not np.allclose(t["actions"][:-1, :6], t["state"][1:, :6]): issues.append((r, "action再計算"))
    if not np.allclose(t["t"], np.arange(len(idx)) / 10): issues.append((r, "t"))
    ft = sorted(os.listdir(f"{B}/{r}/frames")); fo = sorted(os.listdir(f"{A}/{r}/frames"))
    if len(ft) != len(idx) or any(md5(f"{B}/{r}/frames/{ft[k]}") != md5(f"{A}/{r}/frames/{fo[idx[k]]}") for k in range(len(idx))):
        issues.append((r, "frames"))
    for k in np.where(np.diff(idx) > 1)[0]:
        jumps.append(np.abs(t["state"][k + 1, :6] - t["state"][k, :6]).max())
    so = o["state"][:, 6]; ao = o["actions"][:, 6]
    rows = set(np.where(ao != so)[0]) | set(np.where(np.diff(so) != 0)[0] + 1)   # action の切り替え行と state の切り替え行
    keep = set(idx.tolist())
    for i in sorted(rows):
        grip_n += 1
        need = [j for j in (i - 1, i, i + 1) if 0 <= j < len(so)]
        if all(j in keep for j in need): grip_ok += 1
        else: issues.append((r[-15:], f"grip近傍 {i} 欠け {[j for j in need if j not in keep]}"))
print("total", tot, "seams", len(jumps), "seam max %.3f" % max(jumps), "seam>1deg", sum(j > 1 for j in jumps))
print("grip rows", grip_n, "ok", grip_ok)
print("issues", len(issues))
for x in issues: print(" ", x)
```

```
total 2717 seams 161 seam max 2.275 seam>1deg 11
grip rows 76 ok 38
issues 38
  ('20261019_183454', 'grip近傍 83 欠け [np.int64(82)]')
  ('20261019_183454', 'grip近傍 162 欠け [np.int64(161)]')
  ('20261019_191257', 'grip近傍 66 欠け [np.int64(65)]')
  ('20261019_191257', 'grip近傍 165 欠け [np.int64(164)]')
  ('20261019_191347', 'grip近傍 67 欠け [np.int64(66)]')
  ('20261019_191347', 'grip近傍 165 欠け [np.int64(164)]')
  ('20261019_191441', 'grip近傍 94 欠け [np.int64(93)]')
  ('20261019_191441', 'grip近傍 199 欠け [np.int64(198)]')
  ('20261019_191541', 'grip近傍 77 欠け [np.int64(76)]')
  ('20261019_191541', 'grip近傍 172 欠け [np.int64(171)]')
  ('20261019_191635', 'grip近傍 74 欠け [np.int64(73)]')
  ('20261019_191635', 'grip近傍 175 欠け [np.int64(174)]')
  ('20261019_192343', 'grip近傍 83 欠け [np.int64(82)]')
  ('20261019_192343', 'grip近傍 160 欠け [np.int64(159)]')
  ('20261019_192438', 'grip近傍 77 欠け [np.int64(76)]')
  ('20261019_192438', 'grip近傍 159 欠け [np.int64(158)]')
  ('20261019_192539', 'grip近傍 74 欠け [np.int64(73)]')
  ('20261019_192539', 'grip近傍 160 欠け [np.int64(159)]')
  ('20261019_192633', 'grip近傍 73 欠け [np.int64(72)]')
  ('20261019_192633', 'grip近傍 159 欠け [np.int64(158)]')
  ('20261019_193404', 'grip近傍 91 欠け [np.int64(90)]')
  ('20261019_193404', 'grip近傍 186 欠け [np.int64(185)]')
  ('20261019_193459', 'grip近傍 83 欠け [np.int64(82)]')
  ('20261019_193459', 'grip近傍 191 欠け [np.int64(190)]')
  ('20261019_193617', 'grip近傍 84 欠け [np.int64(83)]')
  ('20261019_193617', 'grip近傍 173 欠け [np.int64(172)]')
  ('20261019_193825', 'grip近傍 94 欠け [np.int64(93)]')
  ('20261019_193825', 'grip近傍 202 欠け [np.int64(201)]')
  ('20261019_193932', 'grip近傍 80 欠け [np.int64(79)]')
  ('20261019_193932', 'grip近傍 169 欠け [np.int64(168)]')
  ('20261019_194818', 'grip近傍 73 欠け [np.int64(72)]')
  ('20261019_194818', 'grip近傍 140 欠け [np.int64(139)]')
  ('20261019_194913', 'grip近傍 74 欠け [np.int64(73)]')
  ('20261019_194913', 'grip近傍 140 欠け [np.int64(139)]')
  ('20261019_195023', 'grip近傍 71 欠け [np.int64(70)]')
  ('20261019_195023', 'grip近傍 137 欠け [np.int64(136)]')
  ('20261019_195120', 'grip近傍 70 欠け [np.int64(69)]')
  ('20261019_195120', 'grip近傍 136 欠け [np.int64(135)]')
```

報告と1か所、食い違いがありました。Claude Code は「38回すべてで i−1, i, i+1 が残っている」と報告しています。これは、state のグリッパーが変わったステップを「切り替え」と数えた結果です。codex が指摘した「指令（action）が切り替わったステップ」で数えると、その直前の1ステップは、38回すべてで削られたままでした。183454 の閉じる場面で確かめました。

```
72 state_g 0.0 act_g 0.0 残る [-36.38  79.24   9.25   3.63 -87.39 -29.25]
73 state_g 0.0 act_g 0.0 残る [-36.38  80.65   8.43   3.56 -87.59 -29.25]
74 state_g 0.0 act_g 0.0 残る [-36.38  81.56   7.91   3.51 -87.71 -29.26]
75 state_g 0.0 act_g 0.0 残る [-36.38  81.56   7.91   3.51 -87.71 -29.26]
76 state_g 0.0 act_g 0.0 削除 [-36.38  81.56   7.91   3.51 -87.71 -29.26]
77 state_g 0.0 act_g 0.0 削除 [-36.38  81.56   7.91   3.51 -87.71 -29.26]
78 state_g 0.0 act_g 0.0 削除 [-36.38  81.56   7.91   3.51 -87.71 -29.26]
79 state_g 0.0 act_g 0.0 削除 [-36.38  81.56   7.91   3.51 -87.71 -29.26]
80 state_g 0.0 act_g 0.0 削除 [-36.38  81.56   7.91   3.51 -87.71 -29.26]
81 state_g 0.0 act_g 0.0 削除 [-36.38  81.56   7.91   3.51 -87.71 -29.28]
82 state_g 0.0 act_g 0.0 削除 [-36.38  81.56   7.91   3.51 -87.71 -29.31]
83 state_g 0.0 act_g 1.0 残る [-36.38  81.56   7.91   3.51 -87.71 -29.34]
84 state_g 1.0 act_g 1.0 残る [-36.38  81.56   7.91   3.51 -87.72 -29.36]
85 state_g 1.0 act_g 1.0 残る [-36.38  81.56   7.91   3.5  -87.74 -29.37]
86 state_g 1.0 act_g 1.0 削除 [-36.38  81.56   7.91   3.5  -87.77 -29.38]
87 state_g 1.0 act_g 1.0 削除 [-36.38  81.56   7.91   3.49 -87.79 -29.4 ]
trim2 で 83 の前後に残った元のステップ: [72, 73, 74, 75, 83, 84, 85, 104]
```

閉じる指令は元の 83 ステップ目で、直前の 82 は削られています。ただ、82 は 74〜81 と姿勢がまったく同じ（関節の角度の差は 0.1° 未満）で、trim2 には 74・75 が 83 の直前に残っています。「つかむ直前の、止まって落ち着いた姿勢」は学習データに入っているので、実害はないと判断して、このまま学習に進めました。

学習の前に、データをもう1回点検しました。この点検は、あとで作った点検スクリプト `check_dataset.py`（後述）でも同じ結果になっています。


## 学習用の Pod で、trim2 を変換して学習を始めた

学習には GPU のメモリが 22.5GB 以上要るので、[Runpod](https://www.runpod.io/) で A40（48GB）を借りました。

| 項目 | 値 |
|---|---|
| GPU | NVIDIA A40 ×1 |
| CPU・メモリ | 9 vCPU（Intel Xeon Gold 6342 @ 2.80GHz）・50GB |
| Container Disk | 200GB |
| 場所 | CA-MTL-1・Secure Cloud |
| テンプレート | runpod/pytorch:1.4.0-cu1281-torch280-ubuntu2404 |
| 料金 | 計算 $0.59/時 ＋ ディスク $0.028/時 ＝ $0.62/時 |

前の回は A40 の空きを待って起動まで約4時間半かかりましたが、この回は数分で起動しました。準備の手順は前の回と同じです。学習設定は、前の回の `add_teach_config.py` と同じ方式で、データ名だけ trim2 に変えた `add_trim_config.py` を作りました。

```
#!/usr/bin/env python3
"""openpi config.py に teach_v1_trim2 用の学習設定 pi05_mecharm_trim_lora を足す (lab Log11).

install_addon.py を実行した後に 1 回実行 (add_teach_config.py とは独立. 両方入れてもよい):
  python3 add_trim_config.py /workspace/openpi
pi05_mecharm_lora (v1) の設定をそのまま写し、次の 3 か所だけ変える (add_teach_config.py と同じ方式):
  name            pi05_mecharm_lora             -> pi05_mecharm_trim_lora
  repo_id         local/mecharm_redblock_box_v1 -> local/mecharm_redblock_box_teach_v1_trim2
  num_train_steps 5_000                         -> 4_000
学習率の予定 (decay_steps=5_000) は v1・teach_v1 と同じ. データ以外の条件を teach_v1 (Log10) と揃える.
"""
import sys
from pathlib import Path

cfg = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve() / "src" / "openpi" / "training" / "config.py"
s = cfg.read_text()
MARK = "    # >>> r2r2r mecharm teach_v1_trim2 (train config)\n"
if MARK in s:
    print("already installed (config.py は変更なし)")
    sys.exit(0)

A = "    # >>> r2r2r mecharm addon (train config)\n"
B = "    # <<< r2r2r mecharm addon (train config)\n"
assert s.count(A) == 1 and s.count(B) == 1, "先に install_addon.py を実行する"
i, j = s.index(A), s.index(B) + len(B)
block = s[i:j]
reps = [
    (A, MARK),
    (B, "    # <<< r2r2r mecharm teach_v1_trim2 (train config)\n"),
    ('name="pi05_mecharm_lora"', 'name="pi05_mecharm_trim_lora"'),
    ('repo_id="local/mecharm_redblock_box_v1"', 'repo_id="local/mecharm_redblock_box_teach_v1_trim2"'),
    ("num_train_steps=5_000,", "num_train_steps=4_000,"),
]
for a, b in reps:
    assert block.count(a) == 1, f"見つからない/重複: {a!r}"
    block = block.replace(a, b)
assert "decay_steps=5_000" in block
s = s[:j] + block + s[j:]
cfg.write_text(s)
print("installed: pi05_mecharm_trim_lora (repo_id=local/mecharm_redblock_box_teach_v1_trim2, 4,000 steps)")
```

openpi を模した仮のフォルダで、前の回の設定と並べて入れても二重に入らないことと、Python の文法として正しいことを確かめています。

```
installed: policies/mecharm_policy.py + config.py (pi05_mecharm_lora)
installed: pi05_mecharm_teach_lora (repo_id=local/mecharm_redblock_box_teach_v1, 4,000 steps)
installed: pi05_mecharm_trim_lora (repo_id=local/mecharm_redblock_box_teach_v1_trim2, 4,000 steps)
already installed (config.py は変更なし)
48:        name="pi05_mecharm_lora",
56:            repo_id="local/mecharm_redblock_box_v1",
74:        num_train_steps=5_000,  # 成功 20 本 (約 6,000 フレーム) で約 27 周
83:        name="pi05_mecharm_trim_lora",
91:            repo_id="local/mecharm_redblock_box_teach_v1_trim2",
109:        num_train_steps=4_000,  # 成功 20 本 (約 6,000 フレーム) で約 27 周
構文OK
```

最初の変換は、データが Pod に届き切る前に走っていました。正規化の値を計算する段で、Pod の中にデータが見つからず、[Hugging Face](https://huggingface.co/) のサイトに探しに行って失敗しています。

```
  File "/workspace/openpi/.venv/lib/python3.11/site-packages/huggingface_hub/utils/_validators.py", line 114, in _inner_fn
    return fn(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^
  File "/workspace/openpi/.venv/lib/python3.11/site-packages/huggingface_hub/hf_api.py", line 3200, in list_repo_refs
    hf_raise_for_status(response)
  File "/workspace/openpi/.venv/lib/python3.11/site-packages/huggingface_hub/utils/_http.py", line 459, in hf_raise_for_status
    raise _format(RepositoryNotFoundError, message, response) from e
huggingface_hub.errors.RepositoryNotFoundError: 401 Client Error. (Request ID: Root=1-6ad8002d-7b19f58317a1cdb761b4f5b4;5d5eea2f-95c8-4587-b2cc-4cbe8e90cc70)

Repository Not Found for url: https://huggingface.co/api/datasets/local/mecharm_redblock_box_teach_v1_trim2/refs.
Please make sure you specified the correct `repo_id` and `repo_type`.
If you are trying to access a private or gated repo, make sure you are authenticated. For more details, see https://huggingface.co/docs/huggingface_hub/authentication
Invalid username or password.
root@a890930c92f7:/workspace/openpi#
```

```
root@a890930c92f7:/workspace/openpi# ls ~/.cache/huggingface/lerobot/local/ 2>&1 
ls /workspace/data/raw_episodes | wc -l
ls: cannot access '/root/.cache/huggingface/lerobot/local/': No such file or directory
ls: cannot access '/workspace/data/raw_episodes': No such file or directory
0
root@a890930c92f7:/workspace/openpi# ls -la /workspace/data /workspace/r2r2r
/workspace/data:
total 71744
drwxr-xr-x 2 root root       35 Oct 20 23:58 .
drwxr-xr-x 1 root root       95 Oct 20 23:57 ..
-rw-r--r-- 1 root root 73463808 Oct 20 23:59 trim2_raw.tar

/workspace/r2r2r:
total 8
drwxr-xr-x 3 root root   56 Oct 20 23:58 .
drwxr-xr-x 1 root root   95 Oct 20 23:57 ..
-rwx------ 1 root root 1966 Oct 20 23:58 add_trim_config.py
drwxr-xr-x 4 root root 4096 Oct 20 23:58 pi05
root@a890930c92f7:/workspace/openpi#
```

Mac の tar と大きさを比べて、届き切っていることを確かめました。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro mecharm_redblock_box_teach_v1_trim2 % ls -l ~/trim2_raw.tar
-rw-r--r--  1 shimazueiichi  staff  73463808 10月 21 08:58 /Users/shimazueiichi/trim2_raw.tar
(base) shimazueiichi@shimadzueiichinoMacBook-Pro mecharm_redblock_box_teach_v1_trim2 %
```

展開してから、変換と正規化の値の計算をやり直しました。

```
cd /workspace/data && tar xf trim2_raw.tar && ls raw_episodes | wc -l
cd /workspace/openpi
uv run python /workspace/r2r2r/pi05/convert_to_lerobot.py --raw-dir /workspace/data/raw_episodes --repo-id local/mecharm_redblock_box_teach_v1_trim2
uv run scripts/compute_norm_stats.py --config-name pi05_mecharm_trim_lora
```

```
Map: 100%|███████████████████████████| 123/123 [00:00<00:00, 1274.38 examples/s]
Creating parquet from Arrow format: 100%|████████| 2/2 [00:00<00:00, 155.15ba/s]
  run_0001_20261019_194818: 123 steps
Map: 100%|████████████████████████████| 126/126 [00:00<00:00, 930.03 examples/s]
Creating parquet from Arrow format: 100%|████████| 2/2 [00:00<00:00, 154.24ba/s]
  run_0001_20261019_194913: 126 steps
Map: 100%|███████████████████████████| 123/123 [00:00<00:00, 1216.17 examples/s]
Creating parquet from Arrow format: 100%|████████| 2/2 [00:00<00:00, 129.94ba/s]
  run_0001_20261019_195023: 123 steps
Map: 100%|███████████████████████████| 120/120 [00:00<00:00, 1261.31 examples/s]
Creating parquet from Arrow format: 100%|████████| 2/2 [00:00<00:00, 118.76ba/s]
  run_0001_20261019_195120: 120 steps
done: 19 episodes / 2717 frames → /workspace/.cache/huggingface/lerobot/local/mecharm_redblock_box_teach_v1_trim2
Resolving data files: 100%|█████████████████| 19/19 [00:00<00:00, 194845.42it/s]
Downloading data: 100%|███████████████████| 19/19 [00:00<00:00, 94871.16files/s]
Generating train split: 2717 examples [00:00, 3731.74 examples/s]
Computing stats: 100%|██████████████████████████| 84/84 [00:22<00:00,  3.76it/s]
Writing stats to: /workspace/openpi/assets/pi05_mecharm_trim_lora/local/mecharm_redblock_box_teach_v1_trim2
root@a890930c92f7:/workspace/openpi#
```

学習を始めました。条件はデータ以外、前の回と同じです（4,000 ステップ、batch 32、学習率の予定も同じ）。学習の1ステップは、お手本から32コマ（batch 32）を取り出して予測と正解を比べ、モデルの重みを1回直す単位で、お手本の1ステップ（0.1 秒）とは別の数え方です。

```
XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_mecharm_trim_lora --exp-name=trim2_v1 --overwrite 2>&1 | tee /workspace/logs/train.log
```

tmux の別の画面で、GPU の様子を30秒おきに記録しました。最初の5分ほどは、π0.5 の元の重みのダウンロードとコンパイルで、使用率が 0% のままです。

```
2026/10/21 00:04:58.141, 43976 MiB, 0 %
2026/10/21 00:05:28.141, 43976 MiB, 0 %
2026/10/21 00:05:58.142, 43976 MiB, 0 %
2026/10/21 00:06:28.142, 44006 MiB, 100 %
2026/10/21 00:06:58.143, 44024 MiB, 0 %
2026/10/21 00:07:28.143, 44024 MiB, 0 %
2026/10/21 00:07:58.145, 44032 MiB, 100 %
2026/10/21 00:08:28.146, 44032 MiB, 100 %
2026/10/21 00:08:58.147, 44032 MiB, 100 %
2026/10/21 00:09:28.147, 44032 MiB, 100 %
2026/10/21 00:09:58.148, 44032 MiB, 100 %
2026/10/21 00:10:28.148, 44032 MiB, 100 %
2026/10/21 00:10:58.149, 44032 MiB, 100 %
2026/10/21 00:11:28.150, 44032 MiB, 100 %
```

時刻は Pod の時計（世界標準時）で、日本時間では 9 時台です。この画面を見ている間にも、Mac のターミナルがもう一度固まり、強制終了しています。学習は Pod の tmux の中で動いているので、止まっていません。Mac から1行で学習の記録をのぞきました。

```
Last login: Wed Oct 21 09:11:08 on ttys002
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % ssh -p <SSH_PORT> -i ~/.ssh/id_ed25519 root@<POD_IP> "grep -a 'Step' /workspace/logs/train.log | tail -5"
Step 0: grad_norm=0.9165, loss=0.1104, param_norm=1803.7705
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % ssh -p <SSH_PORT> -i ~/.ssh/id_ed25519 root@<POD_IP> "tail -c 1500 /workspace/logs/train.log"
s on: 24.0it/4.00kit rate:6.6s/it remaining:7:16:53 elapsed:06:53 postfix:- (3037:tqdm_logging.py:145)
00:10:40.476 [I] Progress on: 26.0it/4.00kit rate:6.6s/it remaining:7:16:08 elapsed:07:07 postfix:- (3037:tqdm_logging.py:145)
00:10:53.651 [I] Progress on: 28.0it/4.00kit rate:6.6s/it remaining:7:15:59 elapsed:07:20 postfix:- (3037:tqdm_logging.py:145)
00:11:06.817 [I] Progress on: 30.0it/4.00kit rate:6.6s/it remaining:7:15:38 elapsed:07:33 postfix:- (3037:tqdm_logging.py:145)
00:11:19.995 [I] Progress on: 32.0it/4.00kit rate:6.6s/it remaining:7:15:37 elapsed:07:46 postfix:- (3037:tqdm_logging.py:145)
00:11:33.155 [I] Progress on: 34.0it/4.00kit rate:6.6s/it remaining:7:15:12 elapsed:07:59 postfix:- (3037:tqdm_logging.py:145)
00:11:46.314 [I] Progress on: 36.0it/4.00kit rate:6.6s/it remaining:7:14:49 elapsed:08:12 postfix:- (3037:tqdm_logging.py:145)
00:11:59.483 [I] Progress on: 38.0it/4.00kit rate:6.6s/it remaining:7:14:40 elapsed:08:26 postfix:- (3037:tqdm_logging.py:145)
00:12:12.646 [I] Progress on: 40.0it/4.00kit rate:6.6s/it remaining:7:14:25 elapsed:08:39 postfix:- (3037:tqdm_logging.py:145)
00:12:25.830 [I] Progress on: 42.0it/4.00kit rate:6.6s/it remaining:7:14:33 elapsed:08:52 postfix:- (3037:tqdm_logging.py:145)
00:12:38.993 [I] Progress on: 44.0it/4.00kit rate:6.6s/it remaining:7:14:06 elapsed:09:05 postfix:- (3037:tqdm_logging.py:145)
00:12:52.185 [I] Progress on: 46.0it/4.00kit rate:6.6s/it remaining:7:14:18 elapsed:09:18 postfix:- (3037:tqdm_logging.py:145)
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ %
```

1ステップ 6.6 秒（A40）で、残り約7時間14分、16時半ごろに終わる見込みです。最初の loss は 0.1104 で、前の回（teach_v1・0.0858）と違うのは、データの中身が変わったためです。データ全体を回る回数は、前の回の約32周から約49周に増えます（4,000 ステップ × batch 32 ÷ 2,717 ステップ）。


## 上カメラの写り方が、実機を動かした回だけお手本と違っていた

記事にするために、AI に渡した画像とお手本の画像を並べたところで、写り方の違いに気づきました。

![左からお手本（10/19）、8:25 のドライラン、8:26 の実機の回の最初のコマ。黒い横線は同じ高さ。実機の回だけマットの上の端とアームの土台が写り、ブロックと箱が下にずれている](https://pixelstomotors.com/media/LOG358_02_camera_framing.jpg)

8:26 の実機の回だけ、マットの上の端とアームの土台が写り、ブロックと箱が下にずれています。1分前のドライランは、お手本と同じ写り方でした。マットの左端の列（x=70〜90）で、上から最初に暗くなる行を、データセットと実行の記録ごとに数えました。

```
# 上カメラの画像で、マットの上の端が何行目に写っているか (左端 x=70〜90 の列で、上から最初に暗くなる行) (LOG358)
import cv2, numpy as np, glob, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT)
def top(p):
    g = cv2.imread(p, 0).astype(float); col = g[:, 70:90].mean(1); d = np.where(col < 80)[0]
    return int(d.min()) if len(d) else -1
for r in sorted(glob.glob("datasets/mecharm_redblock_box_scripted_v1/raw_episodes/*"))[:20:3]:
    fs = sorted(glob.glob(r + "/frames/*.jpg")); print("scripted", r[-15:], [top(p) for p in fs[::40]])
for r in sorted(glob.glob("datasets/mecharm_redblock_box_teach_v1/raw_episodes/*")):
    fs = sorted(glob.glob(r + "/frames/*.jpg")); print("teach", r[-15:], [top(p) for p in fs[::40]])
for d in sorted(glob.glob("runs/pi05_policy/pi05_2026101[57]*")) + sorted(glob.glob("runs/pi05_policy/pi05_20261021*")):
    fs = sorted(glob.glob(d + "/frames/*.jpg"))
    if fs: print("run", d[-15:], [top(p) for p in fs[::5]])
```

```
scripted 20261015_173315 [21, 22, 22, 22, 22, 22, 22, 22]
scripted 20261015_182056 [20, 20, 20, 21, 21, 21, 21]
scripted 20261015_185536 [21, 20, 20, 20, 21, 21, 20]
scripted 20261015_194420 [18, 20, 20, 20, 20, 19, 20, 19]
scripted 20261016_180013 [18, 18, 18, 18, 18, 18, 18]
scripted 20261016_190925 [18, 18, 18, 18, 18, 18]
scripted 20261016_192229 [17, 18, 18, 18, 18, 18, 18, 18]
teach 20261019_183454 [0, 0, 0, 0, 0, 0]
teach 20261019_191257 [0, 1, 1, 1, 1, 0]
teach 20261019_191347 [0, 0, 1, 1, 1, 0]
teach 20261019_191441 [0, 0, 0, 1, 1, 1, 0]
teach 20261019_191541 [0, 0, 0, 0, 1, 1]
teach 20261019_191635 [0, 0, 1, 1, 1, 1]
teach 20261019_192343 [0, 1, 1, 1, 1]
teach 20261019_192438 [0, 1, 1, 1, 1, 0]
teach 20261019_192539 [0, 1, 1, 1, 1, 0]
teach 20261019_192633 [0, 1, 1, 1, 1]
teach 20261019_193404 [0, 1, 0, 0, 1, 1]
teach 20261019_193459 [0, 1, 0, 0, 1, 1]
teach 20261019_193617 [0, 0, 0, 0, 1, 1]
teach 20261019_193825 [0, 0, 0, 0, 0, 1, 1]
teach 20261019_193932 [0, 0, 0, 0, 1, 1]
teach 20261019_194818 [0, 1, 1, 1, 1]
teach 20261019_194913 [0, 1, 1, 1, 1]
teach 20261019_195023 [0, 1, 0, 1, 1]
teach 20261019_195120 [0, 1, 0, 1, 1]
run 20261015_193023 [19]
run 20261017_072035 [22]
run 20261017_072306 [21]
run 20261017_172323 [17]
run 20261017_172526 [17, 17, 17]
run 20261017_172828 [17, 17]
run 20261017_173054 [17, 17]
run 20261017_174533 [16]
run 20261017_174600 [16, 16]
run 20261017_175126 [15]
run 20261017_175143 [15]
run 20261017_175214 [15, 15]
run 20261017_175413 [13]
run 20261017_175438 [13, 13]
run 20261017_221600 [23]
run 20261017_221710 [22]
run 20261017_222053 [22, 23, 23]
run 20261017_222723 [22, 23, 23]
run 20261021_082212 [0]
run 20261021_082423 [0]
run 20261021_082512 [0]
run 20261021_082645 [18, 18, 18, 18]
```

写り方は大きく2通りあります。

| 記録 | マットの上端の行 |
|---|---|
| 前のお手本 scripted_v1（10/15〜16） | 17〜22 |
| 10/17 の実機（LOG345 の回） | 13〜23 |
| 今回のお手本 teach_v1（10/19） | 0〜1 |
| 8:22・8:24・8:25 のドライランと HOME 戻し | 0 |
| 8:26 の実機の回 | 18 |

画像全体のずれも、`cv2.phaseCorrelate`（2枚の画像を重ねて、どれだけずらせば合うかを測る）で測りました。基準は teach_v1 の 183454 の最初のコマです。

```
# 上カメラの画像全体のずれを cv2.phaseCorrelate で測る。基準は teach_v1 の 183454 の最初のコマ (LOG358)
import cv2, numpy as np, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT)
T = "datasets/mecharm_redblock_box_teach_v1/raw_episodes/"
def g(p): return cv2.imread(p, 0).astype(np.float32)
ref = g(T + "run_0001_20261019_183454/frames/000000.jpg")
win = cv2.createHanningWindow(ref.shape[::-1], cv2.CV_32F)
for name, p in [("teach 191257 t0", T + "run_0001_20261019_191257/frames/000000.jpg"),
                ("teach 195120 t0", T + "run_0001_20261019_195120/frames/000000.jpg"),
                ("today 082512 HOME dry", "runs/pi05_policy/pi05_20261021_082512/frames/0000.jpg"),
                ("today 082645 exec", "runs/pi05_policy/pi05_20261021_082645/frames/0000.jpg"),
                ("10/17 222723", "runs/pi05_policy/pi05_20261017_222723/frames/0000.jpg")]:
    (dx, dy), r = cv2.phaseCorrelate(ref, g(p), win)
    print(f"{name:24s} dx={dx:+6.1f} dy={dy:+6.1f} response={r:.2f}")
```

```
teach 191257 t0          dx=  +5.0 dy=  +9.1 response=0.46
teach 195120 t0          dx=  +5.8 dy=  -6.7 response=0.56
today 082512 HOME dry    dx=  +2.8 dy=  -7.8 response=0.58
today 082645 exec        dx=  -1.9 dy= +37.5 response=0.45
10/17 222723             dx=  -4.3 dy=  +8.0 response=0.05
```

お手本どうしでも、ブロックの位置の違いで上下に 7〜9 ピクセル揺れます。8:26 の実機の回は 37.5 ピクセルで、はっきり外れています。画像の高さは 216 ピクセルなので、2割近いずれです。

上のカメラは、普段使いの iPhone を毎回付け外しして取り付けています。付けるたびに写り方が変わるのは自然なことで、8:25 と 8:26 の間にも何かで位置が変わったと考えています。**この回のモデルは、学習で見たことのない写り方の画像を見ながら動いていました。** ブロックの近くで止まったことはお手本の停止で説明がつきますが、手を伸ばした先がずれていた可能性もあります。この2つは、この回の記録だけでは切り分けられません。


## 実機で通しで動かせていない理由を、これまでの3回で並べた

π0.5 を実機で動かした回を並べると、止まった原因は毎回お手本の側にあり、しかも8時間学習して実機で動かすまで分からない作りになっていました。

| 回 | 実機で起きたこと | 原因 | いつ分かったはずか |
|---|---|---|---|
| Log#6（[LOG345](https://pixelstomotors.com/record/pi05-mecharm-first-real-run)） | ブロックの真上まで来て、爪がブロックに乗って止まった | つかむ位置が爪1本分ずれていた | 実機で初めて分かった |
| Log#7（[LOG348](https://pixelstomotors.com/record/pi05-mecharm-4000-steps)） | 4,000 ステップ学習しても、爪が奥へずれた | お手本のブロックがほぼ同じ場所で、画像を見ずに「いつもの場所」へ手を伸ばしていた | お手本を集めた時点 |
| Log#11（この回・朝） | ブロックの近くで止まり、動かなくなった | お手本の 40% が停止で、真上で 1.5〜2 秒止まっていた。カメラの写り方もお手本と違っていた | 停止はお手本を集めた時点（数えれば1分）。写り方は実機を動かす前 |
| Log#11（この回・夕方） | つかんで箱の位置まで運んだが、持ち上げずに引きずり、箱の外で離した | 運ぶ間に手首 j4 が +18° 動き、肩で上げた分を打ち消した。1回に動ける上限が関節ごとにかかり、関節どうしの割合もずれた | 実機で初めて分かった |

1つの原因を見つけて直すたびに、「直す → 学習し直す（約8時間）→ 実機で試す」を1回まわすので、1つにほぼ1日かかっています。そのうえ、GPU の空き待ち（前の回は約4時間半）と、Mac と Pod の間のモデルの転送（この回は40分）が、毎回つきます。

そこで、次の4つを足しました。

| 足したもの | いつ使うか | 見つけるもの |
|---|---|---|
| `check_dataset.py`（お手本の点検） | 学習の前 | 停止の長さと割合、ブロックの位置のばらつき、グリッパーの切り替え、肩 j1 が 88° を超える姿勢、正解と次の角度の食い違い |
| `eval_policy_offline.py`（お手本との答え合わせ） | 学習のあと、実機の前 | お手本の画像と角度をサーバーに送り、予測が「お手本は動くのに止まる」場面がないか |
| `run_policy_client.py` の肩の上限と送る前の検査 | 実機で動かすとき | 88° を超える肩の指令（アームが黙って捨てる。[LOG352](https://pixelstomotors.com/record/teach-replay-19-demos)）と、安全範囲の外への指令を、送らずに止める |
| 上カメラの写り方の確認 | 実機で動かす前 | お手本と写り方が違えば、アームを動かさずに止める。iPhone を付けたあとに位置を合わせる画面も作る |

もう1つ、段取りを変えます。学習が終わったら、モデルを Mac に持ち帰る前に、学習に使った Pod でそのまま推論サーバーを起動して、実機で試します。モデルを送る往復（約1時間）がなくなります。


## 学習の前の点検 check_dataset.py は、teach_v1 で FAIL、trim2 で PASS になった

`check_dataset.py` は Claude Code が書きました。学習に出すお手本を読むだけで、FAIL が1つでもあれば終了コード 1 を返します。肩の上限 88° は、本線の `fk_lookup.py` の値をそのまま読み込んでいます。teach_v1 と trim2 で動かした結果です（Claude Code の報告から）。

```
A と D を入れて commit しました。codex レビューで必須 1 
  件が出ています（未反映）。

  A. pi05/check_dataset.py（新規・読むだけ）

  python3 pi05/check_dataset.py <raw_episodes> で 6 項目を PASS/WARN/FAIL
  表示、FAIL があれば終了コード 1。書き込み系の呼び出しは無し（grep
  済み）。J1_SAFE_MAX は本線 fk_lookup.py から import（二重定義しない）、停止の
  0.3° は build_demo_episodes.py の MID_IDLE_EPS_DEG と同値。

  teach_v1 の出力（全文）— 停止で FAIL・終了コード 1

  [DATA  ]
  /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1/raw_episodes
           19 本 / 3949 ステップ / 394.9 秒相当 / fps 10

  [PASS] 1. そろい方 (画像の枚数・画像サイズ・meta の task)
           task 'put the red block in the white box' (19 本すべて同じ)
           画像サイズ 384x216 (19 本すべて同じ)
           画像の枚数 = ステップ数 (19 本すべて一致)

  [FAIL] 2. 停止 (連続 1.0 秒超で FAIL / 割合 20% 超で WARN)
           全体 40.4% (1594/3949 ステップ) / いちばん長い連続 2.0 秒 (上限 1.0 秒
  = action_horizon 10 x 0.1 秒)
           [WARN] 全体の停止が 40.4% で 20% を超えている
  (停止を『動作』として覚える. build_demo_episodes.py --trim-mid-idle で詰める)
           [FAIL] run_0001_20261019_183454: 停止 37.0% ( 77/208)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_191257: 停止 37.1% ( 76/205)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_191347: 停止 40.4% ( 84/208)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_191441: 停止 44.0% (106/241)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_191541: 停止 43.6% ( 92/211)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_191635: 停止 44.4% ( 95/214)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_192343: 停止 38.0% ( 76/200)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_192438: 停止 41.6% ( 84/202)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_192539: 停止 40.9% ( 83/203)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_192633: 停止 39.4% ( 78/198)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_193404: 停止 36.4% ( 83/228)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_193459: 停止 41.5% ( 97/234)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_193617: 停止 37.0% ( 80/216)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_193825: 停止 43.7% (107/245)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_193932: 停止 36.8% ( 78/212)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_194818: 停止 41.5% ( 76/183)  最長 2.0 秒 (20
  ステップ)
           [FAIL] run_0001_20261019_194913: 停止 41.5% ( 76/183)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_195023: 停止 40.6% ( 73/180)  最長 1.9 秒 (19
  ステップ)
           [FAIL] run_0001_20261019_195120: 停止 41.0% ( 73/178)  最長 1.9 秒 (19
  ステップ)

  [PASS] 3. グリッパーの切り替え (各エピソードで「閉 → 開」の 2 回)
           19 本すべて 閉 → 開 の 2 回

  [PASS] 4. 肩 j1 <= 88° / j4 は J4_SAFE [-90, +60] の中
           j1 の最大 +87.89° (run_0001_20261019_191635 state t=64)
           j4 の範囲 -88.15° (run_0001_20261019_183454 actions t=103) .. +0.43°
  (run_0001_20261019_191257 state t=11)

  [PASS] 5. ブロックの位置のばらつき (つかんだ瞬間の j0 を 5° 刻み)
           j0    -60° 付近:  5 本  26.3%  #####
           j0    -35° 付近:  6 本  31.6%  ######
           j0    -30° 付近:  2 本  10.5%  ##
           j0    -25° 付近:  2 本  10.5%  ##
           j0    +15° 付近:  4 本  21.1%  ####

  [PASS] 6. |action[t] - state[t+1]| の最大 (関節 6 列. 3.5° 超で WARN)
           全体の最大 2.27° (run_0001_20261019_191441 t=77 j4)

  [RESULT] 1.PASS  2.FAIL  3.PASS  4.PASS  5.PASS  6.PASS
  [RESULT] FAIL 1 項目 / WARN 0 項目 — このまま学習に出さない
  ===== 終了コード: 1 =====

  teach_v1_trim2 の出力（全文）— 全項目 PASS・終了コード 0

  [DATA  ] /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim
  2/raw_episodes
           19 本 / 2717 ステップ / 271.7 秒相当 / fps 10

  [PASS] 1. そろい方 (画像の枚数・画像サイズ・meta の task)
           task 'put the red block in the white box' (19 本すべて同じ)
           画像サイズ 384x216 (19 本すべて同じ)
           画像の枚数 = ステップ数 (19 本すべて一致)

  [PASS] 2. 停止 (連続 1.0 秒超で FAIL / 割合 20% 超で WARN)
           全体 9.6% (261/2717 ステップ) / いちばん長い連続 0.4 秒 (上限 1.0 秒 =
  action_horizon 10 x 0.1 秒)
           run_0001_20261019_183454: 停止  6.9% ( 10/144)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_191257: 停止  7.5% ( 11/147)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_191347: 停止 11.1% ( 16/144)  最長 0.4 秒 (4
  ステップ)
           run_0001_20261019_191441: 停止 12.3% ( 20/163)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_191541: 停止 11.5% ( 16/139)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_191635: 停止 10.1% ( 14/138)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_192343: 停止  7.1% ( 10/140)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_192438: 停止 11.6% ( 16/138)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_192539: 停止 10.7% ( 15/140)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_192633: 停止 10.2% ( 14/137)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_193404: 停止  6.7% ( 11/164)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_193459: 停止 11.3% ( 18/159)  最長 0.4 秒 (4
  ステップ)
           run_0001_20261019_193617: 停止  9.6% ( 15/156)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_193825: 停止 10.9% ( 18/165)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_193932: 停止  7.3% ( 11/151)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_194818: 停止  8.9% ( 11/123)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_194913: 停止 11.1% ( 14/126)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_195023: 停止  8.9% ( 11/123)  最長 0.2 秒 (2
  ステップ)
           run_0001_20261019_195120: 停止  8.3% ( 10/120)  最長 0.2 秒 (2
  ステップ)

  [PASS] 3. グリッパーの切り替え (各エピソードで「閉 → 開」の 2 回)
           19 本すべて 閉 → 開 の 2 回

  [PASS] 4. 肩 j1 <= 88° / j4 は J4_SAFE [-90, +60] の中
           j1 の最大 +87.89° (run_0001_20261019_191635 state t=39)
           j4 の範囲 -88.15° (run_0001_20261019_183454 actions t=55) .. +0.43°
  (run_0001_20261019_191257 state t=11)

  [PASS] 5. ブロックの位置のばらつき (つかんだ瞬間の j0 を 5° 刻み)
           j0    -60° 付近:  5 本  26.3%  #####
           j0    -35° 付近:  6 本  31.6%  ######
           j0    -30° 付近:  2 本  10.5%  ##
           j0    -25° 付近:  2 本  10.5%  ##
           j0    +15° 付近:  4 本  21.1%  ####

  [PASS] 6. |action[t] - state[t+1]| の最大 (関節 6 列. 3.5° 超で WARN)
           全体の最大 0.00° (run_0001_20261019_195120 t=0 j0)

  [RESULT] 1.PASS  2.PASS  3.PASS  4.PASS  5.PASS  6.PASS
  [RESULT] 全項目 PASS
  ===== 終了コード: 0 =====

  読み取りとして補足: teach_v1 と trim2 で項目 4・5 の値が同じなのは、trim2
  が同じ 19 本から停止区間だけ詰めたデータだからです（つかんだ瞬間の j0
  も肩の最大も変わらない）。項目 6 が trim2 で 0.00° なのは、--trim-mid-idle が
  action を作り直しているため。teach_v1 の 2.27° は停止詰めのつなぎ目で、3.5°
  には届いていません。

  D. pi05/run_policy_client.py（指定の 3 点のみ）

  - load_envelope() の末尾に hi[1] = min(hi[1], J1_SAFE_MAX)（88.0 は
  fk_lookup.py から import）。実測で確認: teach_v1_trim2 の j1 上限が +97.9° → 
  +88.0°
  - --raw-dir を required=True にし
  DEFAULT_RAW（scripted_v1）を削除。指定なしで実行すると argparse が終了コード 2
  で止まる（確認済み）。scripted_v1 だと j0 下限 -52.5°、trim2 だと -71.7°
  で、ご指摘の通りズレていました
  - [SAFE  ] に 2 行目（88° で切った旨 + 安全範囲の元データのパス）
  - クランプ・移動量上限・J4_SAFE・グリッパーの待ち・Enter 確認・plan_chunk
  は未変更（diff で確認可能）

  あわせて

  - RUNPOD_TRAIN.md 手順 7 に 3 点＋コマンドへの --raw-dir 追加。手順 0 にも 
  check_dataset.py の実行を 1 ブロック足しました（指示は手順 7
  だけでしたが、学習前点検が手順書に無いと実行されないため。不要なら外します）
  - eval_policy_offline.py は中身を変えずに commit

  commit

  47d091c — 個別ファイル指定で 4
  ファイルのみ。pi05/build_demo_episodes.py（LOG352
  採否ゲート）は未コミットのまま残しています。作業サマリーは
  logs/20261021_0933.md（未コミット）。

  codex レビュー結果（未反映・R1 が必須）

  codex exec --sandbox read-only で回しました（ファイル変更なし）。

  R1（必須）: apply_limits() は「安全範囲でクランプ →
  移動量上限」の順なので、現在角が 88° より上にあると、送る目標が再び 88° 
  を超えます。実データで再現しました:

  現在 j1 = 110.0  予測 j1 = 100.0  →  送る目標 j1 = 90.0  (88° 超)
  notes: ['j1 安全範囲でクランプ +100.0→+88.0', 'j1 移動量 -22.0° を ±20°
  に制限']
  wr._is_valid_angles([0,110,0,0,0,-30]) = True   # JOINT_LIMITS の上限は 123°
  なので読み取りでも弾かれない

  発生条件は「アームを HOME に置き忘れて、肩が 88° より上でたたまれている」状態 —
  まさに手順 7 の注意 2 と同じ場面です。codex の修正案は「apply_limits()
  は変えず、送る直前に target[1] <= J1_SAFE_MAX を検査し、違反なら送信もグリッパ
  ー操作もせず停止」（再クランプは移動量上限を破るため不可）。

  R2（推奨）: グリッパー切替チャンクで元の予測が 88° 超だと、肩だけ 88°
  に置き換わった姿勢で開閉する。未到達でも手動モードはグリッパー処理に進む。
  R3（推奨）: データの j1 最小が 98° 超だと lo[1] > hi[1] になるが np.clip
  は例外を出さない。load_envelope() で lo <= hi を検査して中止。

  「問題なし」とされた点: 現在 j1 ≤ 88° なら通常経路の最終 j1 も 88° 以下 / HOME
  復帰（j1=0°）は違反しない / --raw-dir 必須化で壊れる他の呼び出しは無い /
  send_coords 追加・J4_SAFE 変更・待ち時間の削除短縮は無い。

  R1 は「送信前の停止ガードを足す」= 実機を動かす経路の変更なので、ご指示の「それ
  以外は変えない」の外に出ます。反映しますか（R3 も 2
  行で入ります）。実機テストの前に R1 は入れておく方が良いと考えています。
```

teach_v1 は、19本すべてで「いちばん長い停止が1秒を超える」で FAIL になりました。学習の前にこれを動かしていれば、この回の実機テストまでたどり着く前に止まれたことになります。

```
#!/usr/bin/env python3
"""check_dataset.py — 学習に出す前に、お手本データ (raw_episodes) を点検する (Mac 側・読むだけ).

2026-10-21 (lab Log11 / LOG358): teach_v1 で学習したモデルが、ブロックの真上で止まった.
原因はお手本の側で、停止しているステップが 40% あり、真上で 1.5〜2 秒止まっていた.
action_horizon は 10 (1 秒) なので、1 秒を超える停止は「止まる」という動作として丸ごと覚える.
学習の前に数えれば分かったことなので、毎回の学習前にこれを実行する.

点検する項目 (FAIL が 1 つでもあれば終了コード 1):
  1. そろい方   画像の枚数 = ステップ数 / 画像サイズが全エピソードで同じ / meta の task が同じ   違えば FAIL
  2. 停止       停止ステップの割合と、いちばん長い連続         1.0 秒超で FAIL / 割合 20% 超で WARN
  3. グリッパー 切り替えが「閉 → 開」の 2 回か                 違えば WARN
  4. 肩と j4    j1 が J1_SAFE_MAX 超 / j4 が J4_SAFE の外       どちらも FAIL
  5. ばらつき   つかんだ瞬間の j0 を 5° 刻みで数える           1 か所が半分を超えたら WARN
  6. action     |action[t] - state[t+1]| の最大                 3.5° 超で WARN

データには一切書き込まない (np.load と meta.json の読み取りだけ).

Usage:
  python3 pi05/check_dataset.py /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
"""
import argparse
import json
import sys
from collections import Counter
from pathlib import Path

import cv2
import numpy as np

# 肩の上限は本線 fk_lookup.py の値をそのまま使う (二重定義しない. record_teach_demo.py と同じ扱い)
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "dynamic_tracking_limits" / "place" / "place_modules"))
from fk_lookup import J1_SAFE_MAX  # noqa: E402  88.0. これを超える指令はアームが黙って捨てる (LOG352)

FPS_DEFAULT = 10                # meta.json の fps が無いときの既定 (build_demo_episodes.py の FPS)
ACTION_HORIZON = 10             # 学習設定の action_horizon (openpi_addon の config と同じ)
STOP_EPS_DEG = 0.3              # build_demo_episodes.py の MID_IDLE_EPS_DEG と同じ「停止」の定義
STOP_RUN_FAIL_SEC = ACTION_HORIZON / FPS_DEFAULT    # 1.0 秒. これを超える連続停止は丸ごと覚える
STOP_RATIO_WARN = 0.20          # 停止ステップの割合がこれを超えたら WARN
J4_SAFE = (-90.0, 60.0)         # run_pick_place.py の J4_SAFE_MIN/MAX
J0_BIN_DEG = 5.0                # つかんだ瞬間の j0 を分ける刻み (eval_policy_offline.py と同じ)
POS_SHARE_WARN = 0.5            # 1 か所がこれを超えたら WARN (LOG348: 同じ場所ばかりで画像を見ずに手を伸ばした)
ACT_STATE_WARN_DEG = 3.5        # |action[t] - state[t+1]| がこれを超えたら WARN
_LEVELS = {"PASS": 0, "WARN": 1, "FAIL": 2}


class Check:
    """1 項目の結果. fail/warn を呼ぶと status がその分だけ悪くなる."""

    def __init__(self, num, title):
        self.num, self.title, self.status, self.lines = num, title, "PASS", []

    def fail(self, msg):
        self._add("FAIL", msg)

    def warn(self, msg):
        self._add("WARN", msg)

    def note(self, msg):
        self.lines.append(("", msg))

    def _add(self, level, msg):
        if _LEVELS[level] > _LEVELS[self.status]:
            self.status = level
        self.lines.append((level, msg))

    def report(self):
        print(f"[{self.status:4s}] {self.num}. {self.title}")
        for level, msg in self.lines:
            print(f"         {('[' + level + '] ') if level else ''}{msg}")


def load_episodes(raw_dir: Path):
    eps = sorted(p.parent for p in raw_dir.glob("*/episode.npz"))
    if not eps:
        sys.exit(f"[ERROR] お手本が見つからない (*/episode.npz): {raw_dir}")
    out = []
    for ep in eps:
        z = np.load(ep / "episode.npz")
        meta_p = ep / "meta.json"
        out.append({
            "name": ep.name,
            "dir": ep,
            "state": np.asarray(z["state"], dtype=np.float64),
            "actions": np.asarray(z["actions"], dtype=np.float64),
            "frames": sorted((ep / "frames").glob("*.jpg")),
            "meta": json.loads(meta_p.read_text()) if meta_p.exists() else None,
        })
    return out


def fps_of(e):
    meta = e["meta"] or {}
    try:
        return float(meta.get("fps") or FPS_DEFAULT)
    except (TypeError, ValueError):
        return float(FPS_DEFAULT)


def stop_mask(e):
    """停止ステップ: 6 関節すべて |action - state| < 0.3° かつ グリッパーの action と state が同じ."""
    s, a = e["state"], e["actions"]
    n = min(len(s), len(a))
    if n == 0 or s.shape[1] < 7 or a.shape[1] < 7:
        return np.zeros(0, dtype=bool)
    moved = np.abs(a[:n, :6] - s[:n, :6]) < STOP_EPS_DEG
    return moved.all(axis=1) & (a[:n, 6] == s[:n, 6])


def longest_run(mask):
    best = cur = 0
    for v in mask:
        cur = cur + 1 if v else 0
        best = max(best, cur)
    return best


def grip_changes(e):
    """グリッパーの切り替え: [(ステップ, '閉' or '開'), ...]."""
    g = (e["state"][:, 6] > 0.5).astype(int)
    return [(int(i) + 1, "閉" if g[i + 1] == 1 else "開") for i in np.where(np.diff(g) != 0)[0]]


def check_shape(eps):
    c = Check(1, "そろい方 (画像の枚数・画像サイズ・meta の task)")
    tasks, metas, imgs = Counter(), Counter(), Counter()
    for e in eps:
        s, a, n_img = e["state"], e["actions"], len(e["frames"])
        if s.ndim != 2 or s.shape[1] != 7 or a.shape != s.shape:
            c.fail(f"{e['name']}: state{s.shape} / actions{a.shape} が (N,7) で揃っていない")
            continue
        if n_img != len(s):
            c.fail(f"{e['name']}: 画像 {n_img} 枚 ≠ ステップ {len(s)}")
        if e["meta"] is None:
            c.fail(f"{e['name']}: meta.json がない")
        else:
            tasks[str(e["meta"].get("task"))] += 1
            metas[tuple(e["meta"].get("image_size") or ())] += 1
        if n_img:
            bgr = cv2.imread(str(e["frames"][0]))
            if bgr is None:
                c.fail(f"{e['name']}: 画像を読めない: {e['frames'][0].name}")
            else:
                imgs[(bgr.shape[1], bgr.shape[0])] += 1

    if len(tasks) > 1:
        c.fail("meta の task が揃っていない: " + " / ".join(f"{t!r} x{n}" for t, n in tasks.most_common()))
    elif tasks:
        c.note(f"task {list(tasks)[0]!r} ({sum(tasks.values())} 本すべて同じ)")
    if len(imgs) > 1:
        c.fail("画像サイズが揃っていない: " + " / ".join(f"{w}x{h} x{n}" for (w, h), n in imgs.most_common()))
    elif imgs:
        (w, h), n = imgs.most_common(1)[0]
        c.note(f"画像サイズ {w}x{h} ({n} 本すべて同じ)")
    if len(metas) > 1:
        c.fail("meta の image_size が揃っていない: " + " / ".join(f"{list(k)} x{n}" for k, n in metas.most_common()))
    elif metas and imgs:
        (w, h) = imgs.most_common(1)[0][0]
        mw, mh = (list(metas)[0] + (None, None))[:2]
        if (mw, mh) != (w, h):
            c.fail(f"meta の image_size {[mw, mh]} が実際の画像 {w}x{h} と違う")
    if c.status == "PASS":
        c.note(f"画像の枚数 = ステップ数 ({len(eps)} 本すべて一致)")
    return c


def check_stop(eps):
    c = Check(2, f"停止 (連続 {STOP_RUN_FAIL_SEC:.1f} 秒超で FAIL / 割合 {STOP_RATIO_WARN:.0%} 超で WARN)")
    n_stop = n_all = 0
    rows = []
    for e in eps:
        m = stop_mask(e)
        fps = fps_of(e)
        run = longest_run(m)
        ratio = float(m.mean()) if len(m) else 0.0
        n_stop += int(m.sum())
        n_all += len(m)
        rows.append((e["name"], ratio, int(m.sum()), len(m), run, run / fps))
    overall = n_stop / n_all if n_all else 0.0
    c.note(f"全体 {overall:.1%} ({n_stop}/{n_all} ステップ) / "
           f"いちばん長い連続 {max((r[5] for r in rows), default=0.0):.1f} 秒 "
           f"(上限 {STOP_RUN_FAIL_SEC:.1f} 秒 = action_horizon {ACTION_HORIZON} x {1.0 / FPS_DEFAULT:.1f} 秒)")
    if overall > STOP_RATIO_WARN:
        c.warn(f"全体の停止が {overall:.1%} で {STOP_RATIO_WARN:.0%} を超えている "
               "(停止を『動作』として覚える. build_demo_episodes.py --trim-mid-idle で詰める)")
    for name, ratio, n_s, n_t, run, sec in rows:
        msg = f"{name}: 停止 {ratio:5.1%} ({n_s:3d}/{n_t:3d})  最長 {sec:.1f} 秒 ({run} ステップ)"
        if sec > STOP_RUN_FAIL_SEC + 1e-9:
            c.fail(msg)
        elif ratio > STOP_RATIO_WARN:
            c.warn(msg)
        else:
            c.note(msg)
    return c


def check_gripper(eps):
    c = Check(3, "グリッパーの切り替え (各エピソードで「閉 → 開」の 2 回)")
    for e in eps:
        ch = grip_changes(e)
        if [w for _, w in ch] != ["閉", "開"]:
            seq = " → ".join(f"{w}(t={t})" for t, w in ch) or "切り替えなし"
            c.warn(f"{e['name']}: {len(ch)} 回  {seq}")
    if c.status == "PASS":
        c.note(f"{len(eps)} 本すべて 閉 → 開 の 2 回")
    return c


def check_limits(eps):
    c = Check(4, f"肩 j1 <= {J1_SAFE_MAX:.0f}° / j4 は J4_SAFE [{J4_SAFE[0]:+.0f}, {J4_SAFE[1]:+.0f}] の中")
    j1_top, j4_lo, j4_hi = [], [], []
    for e in eps:
        for kind in ("state", "actions"):
            v = e[kind]
            if v.shape[1] < 7:
                continue
            j1 = v[:, 1]
            i = int(j1.argmax())
            j1_top.append((float(j1[i]), e["name"], kind, i))
            if j1[i] > J1_SAFE_MAX:
                c.fail(f"{e['name']}: {kind} の j1 最大 {j1[i]:+.2f}° > {J1_SAFE_MAX:.0f}° (t={i}. "
                       "この指令はアームが黙って捨てる / LOG352)")
            j4 = v[:, 4]
            lo, hi = int(j4.argmin()), int(j4.argmax())
            j4_lo.append((float(j4[lo]), e["name"], kind, lo))
            j4_hi.append((float(j4[hi]), e["name"], kind, hi))
            if j4[lo] < J4_SAFE[0]:
                c.fail(f"{e['name']}: {kind} の j4 最小 {j4[lo]:+.2f}° < {J4_SAFE[0]:+.0f}° (t={lo})")
            if j4[hi] > J4_SAFE[1]:
                c.fail(f"{e['name']}: {kind} の j4 最大 {j4[hi]:+.2f}° > {J4_SAFE[1]:+.0f}° (t={hi})")
    if j1_top:
        v, name, kind, i = max(j1_top)
        c.note(f"j1 の最大 {v:+.2f}° ({name} {kind} t={i})")
    if j4_lo and j4_hi:
        lo, lname, lkind, li = min(j4_lo)
        hi, hname, hkind, hi_t = max(j4_hi)
        c.note(f"j4 の範囲 {lo:+.2f}° ({lname} {lkind} t={li}) .. {hi:+.2f}° ({hname} {hkind} t={hi_t})")
    return c


def check_positions(eps):
    c = Check(5, f"ブロックの位置のばらつき (つかんだ瞬間の j0 を {J0_BIN_DEG:.0f}° 刻み)")
    bins = Counter()
    for e in eps:
        close = [t for t, w in grip_changes(e) if w == "閉"]
        if not close:
            bins["不明"] += 1
            continue
        bins[round(float(e["state"][close[0], 0]) / J0_BIN_DEG) * J0_BIN_DEG] += 1
    total = sum(bins.values())
    for key in sorted(bins, key=lambda k: (isinstance(k, str), k)):
        n = bins[key]
        label = "つかんだ瞬間が不明" if isinstance(key, str) else f"j0 {key:+6.0f}° 付近"
        c.note(f"{label}: {n:2d} 本  {n / total:5.1%}  {'#' * n}")
    top = [(n, k) for k, n in bins.items() if not isinstance(k, str)]
    if top:
        n, key = max(top)
        if n / total > POS_SHARE_WARN:
            c.warn(f"j0 {key:+.0f}° 付近が {n}/{total} ({n / total:.1%}) で半分を超えている "
                   "(同じ場所ばかりだと画像を見ずに手を伸ばす / LOG348)")
    if bins.get("不明"):
        c.warn(f"つかんだ瞬間が分からないエピソードが {bins['不明']} 本 (項目 3 も見る)")
    return c


def check_action_vs_next_state(eps):
    c = Check(6, f"|action[t] - state[t+1]| の最大 (関節 6 列. {ACT_STATE_WARN_DEG}° 超で WARN)")
    worst = []
    for e in eps:
        s, a = e["state"], e["actions"]
        n = min(len(s) - 1, len(a) - 1)
        if n <= 0 or s.shape[1] < 7 or a.shape[1] < 7:
            continue
        d = np.abs(a[:n, :6] - s[1:n + 1, :6])
        t, k = np.unravel_index(int(d.argmax()), d.shape)
        worst.append((float(d[t, k]), e["name"], int(t), int(k)))
        if d[t, k] > ACT_STATE_WARN_DEG:
            c.warn(f"{e['name']}: {d[t, k]:.2f}° (t={t}, j{k}) > {ACT_STATE_WARN_DEG}° "
                   "(action は 0.1 秒後の state のはず. 停止詰めのつなぎ目を確認)")
    if worst:
        v, name, t, k = max(worst)
        c.note(f"全体の最大 {v:.2f}° ({name} t={t} j{k})")
    return c


def main():
    ap = argparse.ArgumentParser(description="π0.5 の学習前に raw_episodes を点検する (読むだけ)")
    ap.add_argument("raw_dir", help="raw_episodes のフォルダ")
    args = ap.parse_args()

    raw_dir = Path(args.raw_dir)
    if not raw_dir.is_dir():
        sys.exit(f"[ERROR] フォルダがない (KIOXIA 未接続 / パスの打ち間違い): {raw_dir}")
    eps = load_episodes(raw_dir)
    steps = sum(len(e["state"]) for e in eps)
    fps_set = sorted({fps_of(e) for e in eps})
    print(f"[DATA  ] {raw_dir}")
    print(f"         {len(eps)} 本 / {steps} ステップ / "
          f"{steps / fps_set[0]:.1f} 秒相当 / fps {'・'.join(f'{f:g}' for f in fps_set)}")
    print()

    checks = [check_shape(eps), check_stop(eps), check_gripper(eps),
              check_limits(eps), check_positions(eps), check_action_vs_next_state(eps)]
    for c in checks:
        c.report()
        print()

    n_fail = sum(1 for c in checks if c.status == "FAIL")
    n_warn = sum(1 for c in checks if c.status == "WARN")
    print("[RESULT] " + "  ".join(f"{c.num}.{c.status}" for c in checks))
    if n_fail:
        print(f"[RESULT] FAIL {n_fail} 項目 / WARN {n_warn} 項目 — このまま学習に出さない")
    elif n_warn:
        print(f"[RESULT] FAIL なし / WARN {n_warn} 項目 — 中身を見て判断する")
    else:
        print("[RESULT] 全項目 PASS")
    return 1 if n_fail else 0


if __name__ == "__main__":
    sys.exit(main())
```


## お手本との答え合わせ eval_policy_offline.py は、偽のサーバーで判定を確かめた

学習のあと、実機の前に動かすスクリプトは Claude が書きました。お手本の各ステップの画像と角度を、そのままサーバーに送ります。返ってきた1秒分の予測とお手本のその後1秒の動きを比べ、「お手本は1秒で 2° 以上動くのに、予測は 0.5° 未満しか動かない」場面を「止まり」として数えます。アームは動かしません。

```
#!/usr/bin/env python3
"""eval_policy_offline.py — π0.5 サーバーの予測を、お手本と答え合わせする (アームは動かさない).

学習が終わったら、実機で動かす前にこれを実行する (lab Log11 / LOG358).
お手本の各ステップの「上カメラ画像 + 関節角 + グリッパー」をそのままサーバーへ送り,
返ってきた 1 秒分の予測 (10 x 7) と, お手本のその後 1 秒の動きを比べる.

見るもの:
  - 止まり (STUCK): お手本は 1 秒で 2° 以上動くのに, 予測は 0.5° 未満しか動かない
                    (LOG358: 学習データの停止を覚えて, ブロックの真上で止まった現象)
  - ずれ: 予測とお手本の関節角の差 (1 秒分の平均・最大)
  - グリッパー: 0.5 秒先までの開閉の予測が, お手本と食い違う回数

注意: 使うのは学習に使ったお手本なので, 「覚えたか」の確認であって, 初めて見る位置での確認ではない.
実機は, 着いた姿勢で止まったまま次の画像を撮る. その「止まった姿勢から動き出せるか」を見るのが一番の目的.

前提:
  - Runpod で serve_policy が起動し, Mac から SSH トンネル (localhost:8000) が張れている
  - pip install msgpack "websockets>=11"   (run_policy_client.py と同じ)

Usage:
  python3 pi05/eval_policy_offline.py                          # 位置ごとに 1 本ずつ, 3 ステップおき
  python3 pi05/eval_policy_offline.py --episodes all --stride 1
  python3 pi05/eval_policy_offline.py --raw-dir /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1/raw_episodes
記録: /Volumes/KIOXIA/r2r2r-data/lab/Log11/offline_eval/{stamp}/ (rows.csv / summary.json)
"""
import argparse
import csv
import json
import sys
import time
from datetime import datetime
from pathlib import Path

import cv2
import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
from policy_ws import PolicyClient  # noqa: E402

TASK = "put the red block in the white box"
KIOXIA = Path("/Volumes/KIOXIA")
DATA_ROOT = KIOXIA / "r2r2r-data"
DEFAULT_RAW = DATA_ROOT / "datasets" / "mecharm_redblock_box_teach_v1_trim2" / "raw_episodes"
DEFAULT_OUT = DATA_ROOT / "lab" / "Log11" / "offline_eval"
HORIZON = 10              # 学習設定の action_horizon (0.1 秒 x 10 = 1 秒)
CLIENT_STEPS = 5          # run_policy_client.py が 1 チャンクで進む既定のステップ数 (0.5 秒先)
STUCK_DEMO_DEG = 2.0      # お手本が 1 秒でこれ以上動く場面で
STUCK_PRED_DEG = 0.5      # 予測がこれ未満しか動かなければ「止まり」


def pick_episodes(raw_dir: Path, mode: str):
    eps = sorted(p.parent for p in raw_dir.glob("*/episode.npz"))
    if not eps:
        sys.exit(f"[ERROR] お手本が見つからない: {raw_dir}")
    if mode == "all":
        return eps
    # ブロックの位置ごとに 1 本: つかんだ瞬間 (グリッパーの状態が閉に変わった所) の j0 を 5° 刻みで分ける
    groups = {}
    for ep in eps:
        s = np.load(ep / "episode.npz")["state"]
        ch = np.where(np.diff(s[:, 6]) != 0)[0]
        key = round(float(s[ch[0] + 1, 0]) / 5.0) if len(ch) else None
        groups.setdefault(key, ep)
    return [groups[k] for k in sorted(groups, key=lambda k: (k is None, k))]


def load_rgb(path: Path):
    bgr = cv2.imread(str(path))
    if bgr is None:
        raise RuntimeError(f"画像を読めない: {path}")
    return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)   # run_policy_client.py と同じく RGB で送る


def future(arr, t, n):
    """t から n ステップ分. 終わりを越える分は最後の値で埋める."""
    out = arr[t:t + n]
    if len(out) < n:
        out = np.concatenate([out, np.repeat(arr[-1:], n - len(out), axis=0)])
    return out


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--host", default="localhost")
    ap.add_argument("--port", type=int, default=8000)
    ap.add_argument("--raw-dir", default=str(DEFAULT_RAW))
    ap.add_argument("--episodes", default="per-position", choices=["per-position", "all"])
    ap.add_argument("--stride", type=int, default=3, help="何ステップおきに問い合わせるか")
    ap.add_argument("--out", default=str(DEFAULT_OUT))
    args = ap.parse_args()

    out_root = Path(args.out)
    if str(out_root).startswith(str(KIOXIA)) and not KIOXIA.is_mount():
        sys.exit(f"[ERROR] KIOXIA がマウントされていない: {KIOXIA}")
    eps = pick_episodes(Path(args.raw_dir), args.episodes)
    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    out_dir = out_root / stamp
    out_dir.mkdir(parents=True, exist_ok=True)
    print(f"[EVAL  ] お手本 {len(eps)} 本 / {args.stride} ステップおき / 記録 {out_dir}")
    for ep in eps:
        print(f"         {ep.name}")

    policy = PolicyClient(args.host, args.port)
    print(f"[POLICY] 接続 {policy.uri}")

    fields = ["episode", "t", "j0", "j1", "j2", "j3", "j4", "j5", "grip", "latency_s",
              "demo_move_1s", "pred_move_1s", "demo_move_05s", "pred_move_05s",
              "err_mean", "err_max", "err_max_joint", "grip_demo_05s", "grip_pred_05s", "grip_mismatch", "stuck"]
    rows = []
    per_ep = {}
    t_start = time.time()
    with (out_dir / "rows.csv").open("w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=fields)
        w.writeheader()
        for ep in eps:
            z = np.load(ep / "episode.npz")
            state, actions = z["state"].astype(np.float32), z["actions"].astype(np.float32)
            frames = sorted((ep / "frames").glob("*.jpg"))
            if len(frames) != len(state):
                sys.exit(f"[ERROR] 画像とステップの数が違う: {ep.name} ({len(frames)} / {len(state)})")
            stats = {"queries": 0, "stuck": 0, "grip_mismatch": 0, "err_mean": [], "stuck_t": []}
            for t in range(0, len(state), args.stride):
                q = state[t]
                t0 = time.time()
                out = policy.infer({"observation/image": load_rgb(frames[t]), "observation/state": q, "prompt": TASK})
                lat = time.time() - t0
                pred = np.asarray(out["actions"], dtype=np.float32)[:HORIZON]
                demo = future(actions, t, HORIZON)
                d1 = float(np.abs(demo[-1, :6] - q[:6]).max())
                p1 = float(np.abs(pred[-1, :6] - q[:6]).max())
                d05 = float(np.abs(demo[CLIENT_STEPS - 1, :6] - q[:6]).max())
                p05 = float(np.abs(pred[CLIENT_STEPS - 1, :6] - q[:6]).max())
                diff = np.abs(pred[:, :6] - demo[:, :6])
                g_demo = "".join(str(int(v > 0.5)) for v in demo[:CLIENT_STEPS, 6])
                g_pred = "".join(str(int(v > 0.5)) for v in pred[:CLIENT_STEPS, 6])
                stuck = d1 >= STUCK_DEMO_DEG and p1 < STUCK_PRED_DEG
                row = {"episode": ep.name, "t": t, **{f"j{k}": round(float(q[k]), 2) for k in range(6)},
                       "grip": int(q[6] > 0.5), "latency_s": round(lat, 3),
                       "demo_move_1s": round(d1, 2), "pred_move_1s": round(p1, 2),
                       "demo_move_05s": round(d05, 2), "pred_move_05s": round(p05, 2),
                       "err_mean": round(float(diff.mean()), 2), "err_max": round(float(diff.max()), 2),
                       "err_max_joint": int(diff.max(axis=0).argmax()),
                       "grip_demo_05s": g_demo, "grip_pred_05s": g_pred,
                       "grip_mismatch": int(g_demo != g_pred), "stuck": int(stuck)}
                w.writerow(row)
                rows.append(row)
                stats["queries"] += 1
                stats["stuck"] += int(stuck)
                stats["grip_mismatch"] += int(g_demo != g_pred)
                stats["err_mean"].append(float(diff.mean()))
                if stuck:
                    stats["stuck_t"].append(t)
                mark = "  [STUCK]" if stuck else ""
                gm = f"  グリッパー お手本{g_demo} 予測{g_pred}" if g_demo != g_pred else ""
                print(f"[{ep.name[-15:]} t={t:3d}] 1秒の動き お手本{d1:5.1f}° 予測{p1:5.1f}°  "
                      f"ずれ 平均{diff.mean():4.1f}° 最大{diff.max():4.1f}°(j{row['err_max_joint']}){mark}{gm}")
            per_ep[ep.name] = {"queries": stats["queries"], "stuck": stats["stuck"], "stuck_t": stats["stuck_t"],
                               "grip_mismatch": stats["grip_mismatch"],
                               "err_mean_median": round(float(np.median(stats["err_mean"])), 2),
                               "err_mean_max": round(float(np.max(stats["err_mean"])), 2)}
    policy.close()

    n = len(rows)
    summary = {
        "stamp": stamp, "raw_dir": args.raw_dir, "episodes_mode": args.episodes, "stride": args.stride,
        "queries": n, "elapsed_sec": round(time.time() - t_start, 1),
        "stuck": sum(r["stuck"] for r in rows), "grip_mismatch": sum(r["grip_mismatch"] for r in rows),
        "err_mean_median": round(float(np.median([r["err_mean"] for r in rows])), 2),
        "thresholds": {"stuck_demo_deg": STUCK_DEMO_DEG, "stuck_pred_deg": STUCK_PRED_DEG,
                       "horizon": HORIZON, "client_steps": CLIENT_STEPS},
        "per_episode": per_ep,
    }
    (out_dir / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2))
    print()
    print(f"[SUMMARY] 問い合わせ {n} 回 / 止まり {summary['stuck']} 回 / グリッパーの食い違い {summary['grip_mismatch']} 回 / "
          f"ずれの中央値 {summary['err_mean_median']}°")
    for name, s in per_ep.items():
        print(f"  {name}: 止まり {s['stuck']}/{s['queries']} {s['stuck_t']}  グリッパー {s['grip_mismatch']}  "
              f"ずれ中央値 {s['err_mean_median']}°")
    print(f"[DONE  ] 記録: {out_dir}")


if __name__ == "__main__":
    main()
```

まだ本物のサーバーがないので、Claude のクラウドの作業環境に、決まった答えを返す偽のサーバーを立てて確かめました。`stuck` は「今の角度のまま動かない」答え、`move` は「肩を 0.1 秒ごとに 0.8° ずつ動かす」答えを返します。お手本は、trim2 の 183454 の角度に、画像を同じ1枚にしたものを3本（run_A・run_B は同じ位置、run_C は j0 を −20° ずらした位置）使っています。

```
import sys, numpy as np
sys.path.insert(0,"test/pi05")
from policy_ws import packb, unpackb
from websockets.sync.server import serve
mode=sys.argv[1]
def h(ws):
    ws.send(packb({}))
    for msg in ws:
        obs=unpackb(msg); s=np.asarray(obs["observation/state"],dtype=np.float32)
        assert obs["observation/image"].shape[2]==3 and obs["prompt"]
        a=np.repeat(s[None],10,0).copy()
        if mode=="move": a[:,1]+=np.arange(1,11)*0.8
        ws.send(packb({"actions":a}))
with serve(h,"localhost",8765,max_size=None) as srv: srv.serve_forever()
```

```
[EVAL  ] お手本 2 本 / 10 ステップおき / 記録 out/20261021_101224
         run_C
         run_A
[POLICY] 接続 ws://localhost:8765
[run_C t=  0] 1秒の動き お手本 20.9° 予測  0.0°  ずれ 平均 3.8° 最大20.9°(j4)  [STUCK]
[run_C t= 10] 1秒の動き お手本 29.0° 予測  0.0°  ずれ 平均 6.3° 最大29.0°(j4)  [STUCK]
[run_C t= 20] 1秒の動き お手本 28.8° 予測  0.0°  ずれ 平均 6.4° 最大28.8°(j4)  [STUCK]
[run_C t= 30] 1秒の動き お手本  6.7° 予測  0.0°  ずれ 平均 2.4° 最大 6.7°(j4)  [STUCK]
[run_C t= 40] 1秒の動き お手本 14.0° 予測  0.0°  ずれ 平均 2.2° 最大14.0°(j1)  [STUCK]
[run_C t= 50] 1秒の動き お手本  4.4° 予測  0.0°  ずれ 平均 0.5° 最大 4.4°(j1)  [STUCK]  グリッパー お手本00011 予測00000
[run_C t= 60] 1秒の動き お手本 12.5° 予測  0.0°  ずれ 平均 2.4° 最大12.5°(j1)  [STUCK]
[run_C t= 70] 1秒の動き お手本 28.7° 予測  0.0°  ずれ 平均 5.0° 最大28.7°(j0)  [STUCK]
[run_C t= 80] 1秒の動き お手本 29.4° 予測  0.0°  ずれ 平均 5.1° 最大29.4°(j0)  [STUCK]
[run_C t= 90] 1秒の動き お手本 13.4° 予測  0.0°  ずれ 平均 3.5° 最大13.4°(j1)  [STUCK]
[run_C t=100] 1秒の動き お手本  9.0° 予測  0.0°  ずれ 平均 3.2° 最大10.0°(j1)  [STUCK]
[run_C t=110] 1秒の動き お手本 25.7° 予測  0.0°  ずれ 平均 5.0° 最大25.7°(j1)  [STUCK]
[run_C t=120] 1秒の動き お手本 27.7° 予測  0.0°  ずれ 平均 6.5° 最大27.7°(j4)  [STUCK]
[run_C t=130] 1秒の動き お手本 28.0° 予測  0.0°  ずれ 平均 7.2° 最大28.0°(j4)  [STUCK]
[run_C t=140] 1秒の動き お手本  2.7° 予測  0.0°  ずれ 平均 0.9° 最大 2.7°(j0)  [STUCK]
[run_A t=  0] 1秒の動き お手本 20.9° 予測  0.0°  ずれ 平均 3.8° 最大20.9°(j4)  [STUCK]
[run_A t= 10] 1秒の動き お手本 29.0° 予測  0.0°  ずれ 平均 6.3° 最大29.0°(j4)  [STUCK]
[run_A t= 20] 1秒の動き お手本 28.8° 予測  0.0°  ずれ 平均 6.4° 最大28.8°(j4)  [STUCK]
[run_A t= 30] 1秒の動き お手本  6.7° 予測  0.0°  ずれ 平均 2.4° 最大 6.7°(j4)  [STUCK]
[run_A t= 40] 1秒の動き お手本 14.0° 予測  0.0°  ずれ 平均 2.2° 最大14.0°(j1)  [STUCK]
[run_A t= 50] 1秒の動き お手本  4.4° 予測  0.0°  ずれ 平均 0.5° 最大 4.4°(j1)  [STUCK]  グリッパー お手本00011 予測00000
[run_A t= 60] 1秒の動き お手本 12.5° 予測  0.0°  ずれ 平均 2.4° 最大12.5°(j1)  [STUCK]
[run_A t= 70] 1秒の動き お手本 28.7° 予測  0.0°  ずれ 平均 5.0° 最大28.7°(j0)  [STUCK]
[run_A t= 80] 1秒の動き お手本 29.4° 予測  0.0°  ずれ 平均 5.1° 最大29.4°(j0)  [STUCK]
[run_A t= 90] 1秒の動き お手本 13.4° 予測  0.0°  ずれ 平均 3.5° 最大13.4°(j1)  [STUCK]
[run_A t=100] 1秒の動き お手本  9.0° 予測  0.0°  ずれ 平均 3.2° 最大10.0°(j1)  [STUCK]
[run_A t=110] 1秒の動き お手本 25.7° 予測  0.0°  ずれ 平均 5.0° 最大25.7°(j1)  [STUCK]
[run_A t=120] 1秒の動き お手本 27.7° 予測  0.0°  ずれ 平均 6.5° 最大27.7°(j4)  [STUCK]
[run_A t=130] 1秒の動き お手本 28.0° 予測  0.0°  ずれ 平均 7.2° 最大28.0°(j4)  [STUCK]
[run_A t=140] 1秒の動き お手本  2.7° 予測  0.0°  ずれ 平均 0.9° 最大 2.7°(j0)  [STUCK]

[SUMMARY] 問い合わせ 30 回 / 止まり 30 回 / グリッパーの食い違い 2 回 / ずれの中央値 3.8°
  run_C: 止まり 15/15 [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140]  グリッパー 1  ずれ中央値 3.8°
  run_A: 止まり 15/15 [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140]  グリッパー 1  ずれ中央値 3.8°
[DONE  ] 記録: out/20261021_101224
```

```
[EVAL  ] お手本 3 本 / 20 ステップおき / 記録 out/20261021_101228
         run_A
         run_B
         run_C
[POLICY] 接続 ws://localhost:8765
[run_A t=  0] 1秒の動き お手本 20.9° 予測  8.0°  ずれ 平均 3.2° 最大20.9°(j4)
[run_A t= 20] 1秒の動き お手本 28.8° 予測  8.0°  ずれ 平均 5.6° 最大28.8°(j4)
[run_A t= 40] 1秒の動き お手本 14.0° 予測  8.0°  ずれ 平均 1.5° 最大 8.1°(j2)
[run_A t= 60] 1秒の動き お手本 12.5° 予測  8.0°  ずれ 平均 3.1° 最大20.5°(j1)
[run_A t= 80] 1秒の動き お手本 29.4° 予測  8.0°  ずれ 平均 5.8° 最大29.4°(j0)
[run_A t=100] 1秒の動き お手本  9.0° 予測  8.0°  ずれ 平均 2.5° 最大 7.7°(j4)
[run_A t=120] 1秒の動き お手本 27.7° 予測  8.0°  ずれ 平均 7.2° 最大27.7°(j4)
[run_A t=140] 1秒の動き お手本  2.7° 予測  8.0°  ずれ 平均 1.7° 最大 8.7°(j1)
[run_B t=  0] 1秒の動き お手本 20.9° 予測  8.0°  ずれ 平均 3.2° 最大20.9°(j4)
[run_B t= 20] 1秒の動き お手本 28.8° 予測  8.0°  ずれ 平均 5.6° 最大28.8°(j4)
[run_B t= 40] 1秒の動き お手本 14.0° 予測  8.0°  ずれ 平均 1.5° 最大 8.1°(j2)
[run_B t= 60] 1秒の動き お手本 12.5° 予測  8.0°  ずれ 平均 3.1° 最大20.5°(j1)
[run_B t= 80] 1秒の動き お手本 29.4° 予測  8.0°  ずれ 平均 5.8° 最大29.4°(j0)
[run_B t=100] 1秒の動き お手本  9.0° 予測  8.0°  ずれ 平均 2.5° 最大 7.7°(j4)
[run_B t=120] 1秒の動き お手本 27.7° 予測  8.0°  ずれ 平均 7.2° 最大27.7°(j4)
[run_B t=140] 1秒の動き お手本  2.7° 予測  8.0°  ずれ 平均 1.7° 最大 8.7°(j1)
[run_C t=  0] 1秒の動き お手本 20.9° 予測  8.0°  ずれ 平均 3.2° 最大20.9°(j4)
[run_C t= 20] 1秒の動き お手本 28.8° 予測  8.0°  ずれ 平均 5.6° 最大28.8°(j4)
[run_C t= 40] 1秒の動き お手本 14.0° 予測  8.0°  ずれ 平均 1.5° 最大 8.1°(j2)
[run_C t= 60] 1秒の動き お手本 12.5° 予測  8.0°  ずれ 平均 3.1° 最大20.5°(j1)
[run_C t= 80] 1秒の動き お手本 29.4° 予測  8.0°  ずれ 平均 5.8° 最大29.4°(j0)
[run_C t=100] 1秒の動き お手本  9.0° 予測  8.0°  ずれ 平均 2.5° 最大 7.7°(j4)
[run_C t=120] 1秒の動き お手本 27.7° 予測  8.0°  ずれ 平均 7.2° 最大27.7°(j4)
[run_C t=140] 1秒の動き お手本  2.7° 予測  8.0°  ずれ 平均 1.7° 最大 8.7°(j1)

[SUMMARY] 問い合わせ 24 回 / 止まり 0 回 / グリッパーの食い違い 0 回 / ずれの中央値 3.14°
  run_A: 止まり 0/8 []  グリッパー 0  ずれ中央値 3.14°
  run_B: 止まり 0/8 []  グリッパー 0  ずれ中央値 3.14°
  run_C: 止まり 0/8 []  グリッパー 0  ずれ中央値 3.14°
[DONE  ] 記録: out/20261021_101228
--- out を KIOXIA の既定にしたとき（クラウドの作業環境には KIOXIA がない） ---
[ERROR] KIOXIA がマウントされていない: /Volumes/KIOXIA
```

止まるモデルでは全部が「止まり」、動くモデルでは0件になりました。位置ごとに1本ずつ選ぶ指定では、同じ位置の2本から1本だけが選ばれています。KIOXIA がつながっていないときは、書き込まずに止まります。

ただし、このスクリプトはお手本の画像を使うので、カメラの写り方のずれは見つけられません。写り方は、実機で動かす前に別の確認で見ます。


## アームを動かすクライアントには、肩の上限と送る前の検査を入れた

`run_policy_client.py` の変更は、実機を動かすプログラムなので、Claude Code が実装し、codex がレビューしています。

1. 安全範囲の肩 j1 の上限を、`fk_lookup.py` と同じ `J1_SAFE_MAX = 88.0` で切る（これまでは +98° まで通っていた）
2. `--raw-dir` を必ず指定させる（前のお手本で安全範囲が作られるのを防ぐ）
3. 送る直前に、目標が全関節で安全範囲の中にあるかを確かめ、外れていれば送らずに止める。HOME に戻す `h` だけは、この検査を通さずに送れる（範囲の外にいるアームを戻す手段）

3つ目は、codex のレビューで2回指摘されて入りました。1回目は「肩が 108° を超えてたたまれていると、移動量の制限で 88° を超える目標ができる」（R1）、2回目は「同じことが手首 j4 などほかの関節でも起きる」（C2）です。どちらも、安全範囲でそろえた目標を、そのあと移動量の制限で現在の角度に近づける順番になっているために起きます。この回の最後の修正の報告です。

```
 C2 を入れて commit しました（901758d）。codex は「C2 
  は閉じています。必須指摘はありません」です。

  入れたもの

  check_send_safe(target, lo, hi) を全関節検査に変更しました。物理制約（J4_SAFE /
  wr.JOINT_LIMITS）を個別に並べるのではなく、load_envelope() が返す lo/hi 
  そのもので 6 関節を検査しています。lo/hi は 学習データ ±10° ∩ 
  JOINT_LIMITS(hard) ∩ J4_SAFE ∩ j1<=J1_SAFE_MAX なので、codex
  の修正案より狭い範囲を見ていることになります（この包含関係は codex も
  load_envelope を読んで確認済み）。

  - target[k] < lo[k] - 1e-6 または > hi[k] + 1e-6
  で違反。外れた関節ごとに「関節・値・範囲」を 1 行ずつ。再クランプなし
  - 非有限値は即 1 件返す
  - 停止時は [ABORT] を各行表示し、rec["unsafe"]（理由）と
  rec["envelope"]（lo/hi）を log.jsonl に残す
  - HOME 復帰はこの検査を通さない: --execute かつ --auto でないときだけ
  h=HOMEに戻して終了 / 他=そのまま終了 を出し、h なら
  _send_and_wait_arrival(HOME, ...) を送って終了。通常（安全な目標）の Enter
  確認の選択肢は 1 文字も変えていません

  確かめたこと（すべて送信なし・アーム未接続）

  1. codex の例（現在 j4=+100°・予測 +90°・上限 20°）→ 止まる

  apply_limits の目標: j4=+80.00
    [LIMIT] j4 安全範囲でクランプ +90.0→+10.4
    [LIMIT] j4 移動量 -89.6° を ±20° に制限
    [ABORT] j4 +80.00° が安全範囲 [-90.00, +10.43] の外 (j4 の範囲は 学習データ ∩
  J4_SAFE [-90, +60])
  参考: j1 と有限値だけの旧ガードでは「送れる」判定 ← C2 で塞いだ穴

  2. 今朝のたたんだ姿勢からの最初のチャンク → 送れる

  runs/pi05_policy/pi05_20261021_082212 の chunk0 の実測値を使いました（j0=-0.08
  j1=+92.54 j2=+1.14 j3=+1.75 j4=-95.97 j5=-29.26）。

  予測 (plan_chunk):   j1=+93.94  j4=-95.88
  apply_limits の目標: j1=+88.00  j4=-90.00   ←
  どちらもクランプされ、移動量の制限には当たらない
  判定: 送れる

  肩 -4.54°・j4 +5.97° の移動で、どちらも範囲内へ戻る目標なので通ります。codex
  も「判定対象は最終目標であって範囲外の現在角そのものではないので、これで正しい
  」と確認しています。

  3. 今朝の通常運転 20 チャンク → 0/20 で停止なし

  pi05_20261021_082645/log.jsonl の state と actions から plan_chunk →
  apply_limits → check_send_safe を再現し、20 チャンクすべて「送れる」。

  chunk  0: 送れる  目標   -2.16   +5.13   +1.74   +0.98   -5.03  -29.98
  chunk  5: 送れる  目標  -34.26  +61.83  +16.87   +4.25  -75.09  -29.71
  chunk 19: 送れる  目標  -33.89  +66.68  +16.79   +4.26  -76.09  -29.68
  止まったチャンク: 0/20

  （余談ですが、chunk 6 以降は目標がほぼ動いていません。j1≈66 / j4≈-76
  で張り付いていて、これが LOG358 の「真上で止まった」状態そのものです。）

  4. 1e-6 の余裕 — 上限ちょうど（88.0）→ 送れる / 上限 +1e-5 →
  止まる。複数関節が同時に外れた場合は 3 行すべて表示、非有限値は 1
  件で返ります。

  codex の C2 レビュー結果

  ▎ C2 は閉じています。通常チャンクの範囲外指令を止める修正は問題なしです。必須指
  ▎ 摘はありません。

  確認された点: lo/hi 検査は C2 の物理制約検査を包含し学習範囲でさらに絞っている
  / 検査位置はそのチャンクの送信・グリッパー操作より前 / finally
  にアーム操作は無い / HOME 例外の実装と
  --auto・ドライランで入力を求めない判断は復帰仕様に合っている / 1e-6
  は今回の演算誤差の許容として妥当 / 検証 2 の「送れる」は正しい。

  新規は推奨 1 件（C2-1・未反映）: ABORT レコードの書き込みが確認入力と HOME
  復帰の後にあるため、入力待ちや HOME 復帰中に Ctrl-C が入るとそのチャンクの
  unsafe / envelope が残らない。また _send_and_wait_arrival
  の戻り値を見ていないので、HOME が未到達でも home_return=True
  と記録される。修正案は「入力前にレコードを書いて flush し、HOME は
  home_requested と home_arrived=bool(ok) を別レコードに残す」。

  commit

  901758d — pi05/run_policy_client.py
  のみ個別指定。pi05/build_demo_episodes.py（LOG352）は未コミットのまま。作業ログ
  logs/20261021_0933.md に C2 の節を追記（未コミット）。

  未反映の指摘は、C2-1（推奨・ログの記録順）、3 回目の必須 1 件（framing の
  response 下限）、推奨の dx 上限・終了コード・開始時グリッパー・try/finally
  です。入れるものを指示ください。
```

朝の実機の 20 チャンクを同じ計算でたどり直すと、1回も止まりませんでした。検査が厳しすぎて、ふつうに動く場面まで止めていないことも確かめています。


## 上カメラの写り方は、開始時の1枚目をお手本の最初のコマと比べて確かめる

カメラの写り方の確認も、`run_policy_client.py` に入れました。HOME にいる状態の1枚目を、`--raw-dir` の最初のお手本の最初のコマ（同じく HOME）と `cv2.phaseCorrelate` で比べます。次の3つのどれかに当たれば、アームに何も送らずに終了します。

| 判定 | 条件 | 理由 |
|---|---|---|
| ずれ | 上下のずれ（dy）か左右のずれ（dx）が 20 ピクセルを超える | お手本どうしでも、ブロックの位置の違いで 9 ピクセルほど揺れるため、その外側に線を引いた |
| 測れない | 2枚の似ている度合い（response）が 0.20 未満 | 似ていない2枚では、ずれの値そのものが当てにならない |
| 測れない | 値が数でない（NaN など） | 同上 |

あわせて、開始時にグリッパーを開く操作を、写り方の確認と送る前の検査が通り、Enter で実行を選んだあとへ移しました。確認が通るまで、アームには何も送りません。そのかわり、始める前に爪が閉じていたら、手で開けておく必要があります（起動時に表示が出ます）。

iPhone を付けたあとに位置を合わせる画面 `camera_align.py` も作りました。上カメラのライブ映像に、お手本の最初のコマを半透明で重ね、ずれと判定を画面の隅に出します。表示だけで、ファイルには何も書きません。

最後の修正の報告です。カメラと Pi のデーモンを偽物に置き換えて `main()` を動かし、写り方が「ずれ」「測れない」のときは、アームへの呼び出しが1件もないことを確かめています。

```
 6 件すべて入れて commit しました（05e1b8b）。codex の最後のレビューは
  「必須の指摘なし」 です。コード変更はここで締め切りです。

  入れた 6 件

  1. response 下限 FRAMING_MIN_RESPONSE = 0.20。framing_verdict(dx, dy, response)
  が OK / ずれ / 測れない を返し、下限未満か非有限値なら「測れない」として dx/dy
  を信用しません
  2. dx の上限 FRAMING_MAX_DX = 20.0（お手本の dx は +0.00〜+7.23）
  3. 開始時のグリッパー開放を後ろへ — 写り方の確認を通り、目標が check_send_safe
  を通り、Enter で実行を選んだ後に 1 度だけ開きます。代わりに 1 チャンク目の
  grip=0 が仮定になるので、起動時に「爪が閉じていたら手で開けておく」と表示します
  4. 終了コード sys.exit(main())。1 = 安全停止 / 写り方の不一致 / 途中のエラー、0
  = 最後まで / q / h / Ctrl-C
  5. C2-1 — ABORT のレコードを入力より前に書いて flush。HOME は戻り値から
  home_requested / home_arrived を別レコードに残します
  6. try/finally — カメラ初期化と写り方の確認を try の中へ。finally は log_f /
  cap / policy / rec_sock を None
  判定付きで閉じるだけで、アームは動かしません（戻すのは h のときだけ）

  確かめたこと（すべて送信なし）

  写り方の判定（基準 = teach_v1 183454 の 1 枚目 / |dy|<=20 かつ |dx|<=20 かつ
  resp>=0.20）

  ┌──────────────────────────┬────────┬───────┬──────────┬──────────┬────────┐
  │           画像           │   dy   │  dx   │ response │   判定   │  期待  │
  ├──────────────────────────┼────────┼───────┼──────────┼──────────┼────────┤
  │ teach_v1                 │ +0.00  │ +0.00 │ 1.0000   │ OK       │ 通す ✓ │
  │ 183454（基準そのもの）   │        │       │          │          │        │
  ├──────────────────────────┼────────┼───────┼──────────┼──────────┼────────┤
  │ teach_v1 191257          │ +9.11  │ +4.96 │ 0.4575   │ OK       │ 通す ✓ │
  ├──────────────────────────┼────────┼───────┼──────────┼──────────┼────────┤
  │ teach_v1 195120          │ -6.66  │ +5.79 │ 0.5600   │ OK       │ 通す ✓ │
  ├──────────────────────────┼────────┼───────┼──────────┼──────────┼────────┤
  │ ドライラン 082512        │ -7.82  │ +2.87 │ 0.5960   │ OK       │ 通す ✓ │
  ├──────────────────────────┼────────┼───────┼──────────┼──────────┼────────┤
  │ 実機 082645              │ +37.50 │ -1.96 │ 0.4556   │ ずれ     │ 止める │
  │                          │        │       │          │          │  ✓     │
  ├──────────────────────────┼────────┼───────┼──────────┼──────────┼────────┤
  │ 10/17 222723             │ +8.18  │ -2.46 │ 0.0505   │ 測れない │ 止める │
  │                          │        │       │          │          │  ✓     │
  └──────────────────────────┴────────┴───────┴──────────┴──────────┴────────┘

  10/17 の 1 枚は dy=+8.2 / dx=-2.5
  なので、相関を見なければ「OK」で通っていました。お手本 19 本は 19/19 で
  OK（response 0.411〜1.000）。codex が挙げた合成ケースも、ランダム画像（resp
  0.0375）と真っ黒（0.0000）は「測れない」、横 70px
  ずらし（dx=+69.98）は「ずれ」になります。

  流れ（カメラと daemon をスタブにして main()
  を実行。実機には何も送っていません）

  ┌──────────────────────────────┬────────────┬──────────────────────────────┐
  │            ケース            │ 終了コード │    アームに触った呼び出し    │
  ├──────────────────────────────┼────────────┼──────────────────────────────┤
  │ A 写り方「ずれ」(082645)     │ 1          │ なし                         │
  ├──────────────────────────────┼────────────┼──────────────────────────────┤
  │ B 写り方「測れない」(10/17)  │ 1          │ なし                         │
  ├──────────────────────────────┼────────────┼──────────────────────────────┤
  │                              │            │ get_daemon_socket →          │
  │ C 写り方 OK + 安全な目標     │ 0          │ daemon_set_gripper(0) → SEND │
  │                              │            │  x2                          │
  ├──────────────────────────────┼────────────┼──────────────────────────────┤
  │ D 写り方 OK +                │ 1          │ get_daemon_socket だけ —     │
  │ 危険な目標（現在 j4=+100°）  │            │ グリッパーに触らない         │
  ├──────────────────────────────┼────────────┼──────────────────────────────┤
  │ E たたんだ姿勢（j1=+92.5 /   │ 0          │ …→ SEND j1=+88.0 j4=-90.0    │
  │ j4=-96.0）                   │            │                              │
  └──────────────────────────────┴────────────┴──────────────────────────────┘

  D の log.jsonl には unsafe（関節・値・範囲）と
  envelope（lo/hi）が残ります。A・B で「アームへの呼び出しが 1
  件もない」ことが、「確認が通るまで何も送らない」の実測です。

  codex 最終レビュー

  ▎ 必須の指摘なし

  - グリッパーの仮定: 爪が閉じたまま始めると画像と state
  が食い違い予測は変わりうるが、その予測にもクランプと check_send_safe
  がかかり、送角前に開放される。安全判定を迂回する経路ではない
  - 写り方確認前の送信は通常経路に無い / 安全停止を迂回する送角は明示的な h だけ
  / SystemExit でも finally を通り、finally にアーム操作は無い
  - しきい値 0.20・20px は提示の実測に対して正常例を通し異常例を止める。ただし未
  測定の画像全般で誤通過しないとまでは断定できない（この点はログに残しました）
  - 据え置き 1 件のみ: rec_sock.close() が無い（OS が回収。「今回の変更は不要」）

  今日の commit（すべて個別ファイル指定）

  47d091c π0.5 学習前のデータ点検を追加し, クライアントの肩上限と --raw-dir
  必須化 (LOG358)
  4d79df6 送信前の安全ガードと上カメラの写り方の検査を追加 (codex R1/R3 反映 +
  E/E2)
  901758d 送信前の検査を 6 関節すべてに広げる (codex C2)
  05e1b8b 写り方の判定を response と dx まで広げ, 残っていたレビュー指摘を反映

  対象は pi05/check_dataset.py pi05/camera_align.py pi05/eval_policy_offline.py
  pi05/run_policy_client.py pi05/RUNPOD_TRAIN.md の 5
  ファイルのみ。pi05/build_demo_episodes.py（LOG352
  の採否ゲート）は未コミットのままです。作業ログは
  logs/20261021_0933.md（未コミット）。

  16:30 の手順

  iPhone を付ける → アームを HOME（爪は開けておく）
  → python3 pi05/camera_align.py --raw-dir $RAW          # OK になるまで合わせる
  → python3 pi05/eval_policy_offline.py --raw-dir $RAW    # [STUCK] の出方を見る
  → python3 pi05/run_policy_client.py --raw-dir $RAW --max-chunks 5   #
  ドライラン
  → python3 pi05/run_policy_client.py --raw-dir $RAW --execute

  RAW は学習に使ったデータ（mecharm_redblock_box_teach_v1_trim2/raw_episodes）で
  す。学習前点検は python3 pi05/check_dataset.py $RAW で、trim2 なら全項目 PASS
  になります。
```

10/17 の画像は、ずれの値だけ見れば dy +8.2・dx −2.5 で「OK」になるところでした。似ている度合いが 0.05 と低いので、ずれの値そのものが当てにならないと判定されています。codex の最終レビューは「必須の指摘なし」でした。ただし codex は、しきい値は手元の実測の画像で正しく分かれることを確かめただけで、まだ測っていない画像すべてで誤って通さないとまでは言えない、と書いています。

最後に、trim2 を作った `build_demo_episodes.py` を commit しました。このとき Claude Code が、データの作られた時刻と中身から、元の teach_v1 は `--trim-mid-idle` を入れる前の版で作られていたことを確かめ、こちらの依頼文の前提（teach_v1 もこの版で作った）を訂正しています。

```
 commit しました（80932d1）。pi05/build_demo_episodes.py と
  logs/20261021_0933.md の 2 ファイル個別指定です。

  1 点、前提を訂正します

  commit メッセージを書く前に生成元を確認したところ、この版で作ったのは 
  teach_v1_trim2（と teach_v1_trim）だけで、teach_v1
  は別の（前の）版で作られています。

  ┌────────────────┬────────────────────┬─────────────────────┬─────────────┐
  │  データセット  │    index.json      │      meta の        │   npz の    │
  │                │     の生成時刻     │    trim_mid_idle    │   t_orig    │
  ├────────────────┼────────────────────┼─────────────────────┼─────────────┤
  │ teach_v1       │ 2026-10-19 19:53   │ キーなし            │ なし        │
  ├────────────────┼────────────────────┼─────────────────────┼─────────────┤
  │ teach_v1_trim  │ 2026-10-21 08:37   │ True                │ あり        │
  ├────────────────┼────────────────────┼─────────────────────┼─────────────┤
  │ teach_v1_trim2 │ 2026-10-21 08:47   │ True                │ あり        │
  └────────────────┴────────────────────┴─────────────────────┴─────────────┘

  trim_mid_idle / steps_before_mid_trim / mid_idle_trimmed_steps の 3 キーと
  t_orig はこの差分で追加されたものです。teach_v1 の meta
  にはどれも無いので、teach_v1 はこの版より前（--trim-mid-idle
  を入れる前）に作られています。LOG352 の採否ゲート部分が入っていたかは meta
  に痕跡が残らないので判定できません。

  スクリプトの mtime は 10-21 08:46 で、trim2
  の生成（08:47）直前・以降は未編集です。つまり作業ツリーの版 = trim2 
  を作った版で間違いありません（16:30 で使うモデルの学習データ）。

  commit メッセージにはこの事実関係どおりに書きました:

  **この版で mecharm_redblock_box_teach_v1_trim2 を作った** (2026-10-21 08:47.
  その前に同じ版で teach_v1_trim を 08:37 に作っている). 16:30 の実機テストで使う
  モデルは trim2 で学習したものなので, 再現できるようにこの版を記録する.
  teach_v1 (2026-10-19 19:53) は --trim-mid-idle を入れる前の版で作ったもので,
  meta.json に trim_mid_idle 系のキーが無い.

  「teach_v1 もこの版で作った」という認識がもし正しいのであれば（私が見落としてい
  る経緯があるなら）、git commit --amend で直せます。

  差分の中身（読んで確認した範囲）

  LOG352 の採否ゲート: recording_enabled=False →
  no_recording、gripper_state_uncertain → 不採用、gripper_check.verified=false
  を独立ゲートで弾く（codex R6 M3）、result が completed /
  completed_with_failures 以外は不採用（result
  が無い旧試行は人の判定のみ）、ensure_ssd を is_mount() 化（codex
  R5）。--include-failed でも迂回させない作りになっています。

  LOG358 の --trim-mid-idle: 停止ステップの定義は 6 関節すべて |action - state| <
  0.3° かつ グリッパーの action == state — 今日作った check_dataset.py の項目 2
  と同じ定義です。区間の先頭 2 ステップを残す / 0.5°
  のドリフトで区間を切る（R1）/ グリッパー切替前後を必ず残す（R2）/
  詰めた後に関節 6 列の action を作り直す（R3）/ t を等間隔に振り直して t_orig
  に原時刻を残す（R4）/ 非 trim データセットへの上書きを
  ABORT（R6）。既定（オプション未指定）では従来と同一出力です。

  py_compile は通り、send_coords の追加や time.sleep の削除・短縮はありません。

  残したもの

  - pi05/build_demo_episodes.py.bak_pre_LOG352_20261019
  は未追跡のまま（退避用のバックアップなので commit
  していません。必要なら追加します）
  - dynamic_tracking_limits/ observe/ visual_servo_pick.py
  などの未コミット分は今日触っておらず、そのままです

  今日の commit は 5 本（47d091c → 80932d1）、対象は pi05 配下の 5
  ファイルと作業ログ 1 ファイルです。
```

この回の commit は次の5本です（`~/r2r2r-scripts`）。どれも、変えたファイルを1つずつ指定して入れています。

| commit | 中身 |
|---|---|
| 47d091c | 学習前のデータ点検 `check_dataset.py`、クライアントの肩の上限と `--raw-dir` の必須化、答え合わせ `eval_policy_offline.py` |
| 4d79df6 | 送る前の検査（肩）と上カメラの写り方の確認、`camera_align.py`（codex R1・R3） |
| 901758d | 送る前の検査を6関節すべてに広げた（codex C2） |
| 05e1b8b | 写り方の判定に response の下限と dx の上限を足し、残りの指摘を入れた |
| 80932d1 | `build_demo_episodes.py`（LOG352 の採否ゲートと、この回の `--trim-mid-idle`。この版で teach_v1_trim2 を作った） |


## 16時26分に学習が終わり、同じ Pod で推論サーバーを起動した

trim2 の学習は、4,000 ステップを 7時間22分38秒で終えました（A40・1ステップ平均 6.6 秒）。Pod から持ち帰った `train.log` の、500 ステップごとの loss です。

| Step | loss |
|---|---|
| 0 | 0.1104 |
| 500 | 0.0091 |
| 1000 | 0.0057 |
| 1500 | 0.0046 |
| 2000 | 0.0040 |
| 2500 | 0.0036 |
| 3000 | 0.0028 |
| 3500 | 0.0026 |
| 3950 | 0.0021 |

学習の最後の行と、保存の終わりの行です。

```
07:26:11.448 [I] Progress on: 4.00kit/4.00kit rate:10.0s/it remaining:00:00 elapsed:7:22:38 postfix:- (3037:tqdm_logging.py:145)
07:26:14.748 [I] [process=0][thread=save_finalize][step=3999] CheckpointManager Save Finalize is syncing with other hosts... (3037:checkpoint_manager.py:2095)
07:26:14.748 [I] [process=0][thread=save_finalize][step=3999] CheckpointManager Save Finalize is done on all hosts. (3037:checkpoint_manager.py:2110)
07:26:14.748 [I] [process=0][thread=MainThread][step=3999][wait_until_finished] Done waiting for Save Finalize thread (save_finalize) running at step=3999. (3037:checkpoint_manager.py:2010)
1000  2000  3000  3999
```

学習に使った Pod で、そのまま推論サーバーを起動しました。朝のように、モデルを Mac から送り直す必要はありません。

```
cd /workspace/openpi
uv run scripts/serve_policy.py policy:checkpoint --policy.config=pi05_mecharm_trim_lora --policy.dir=checkpoints/pi05_mecharm_trim_lora/trim2_v1/3999 2>&1 | tee /workspace/logs/serve.log
```

```
INFO:root:Loading model...
INFO:2026-10-21 08:59:21,903:jax._src.xla_bridge:925: Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'
INFO:jax._src.xla_bridge:Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'
INFO:2026-10-21 08:59:21,905:jax._src.xla_bridge:925: Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory
INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory
INFO:absl:orbax-checkpoint version: 0.11.13
INFO:absl:Created BasePyTreeCheckpointHandler: use_ocdbt=True, use_zarr3=False, pytree_metadata_options=PyTreeMetadataOptions(support_rich_types=False), array_metadata_store=<orbax.checkpoint._src.metadata.array_metadata_store.Store object at 0x7cf4d44a7950>
INFO:absl:Restoring checkpoint from /workspace/openpi/checkpoints/pi05_mecharm_trim_lora/trim2_v1/3999/params.
INFO:absl:[thread=MainThread] Failed to get flag value for EXPERIMENTAL_ORBAX_USE_DISTRIBUTED_PROCESS_ID.
INFO:absl:[process=0] /jax/checkpoint/read/bytes_per_sec: 1.2 GiB/s (total bytes: 6.3 GiB) (time elapsed: 5 seconds) (per-host)
INFO:absl:Finished restoring checkpoint in 5.36 seconds from /workspace/openpi/checkpoints/pi05_mecharm_trim_lora/trim2_v1/3999/params.
INFO:root:Loaded norm stats from /workspace/openpi/assets/pi05_mecharm_trim_lora/local/mecharm_redblock_box_teach_v1_trim2
INFO:root:Loaded norm stats from /workspace/openpi/checkpoints/pi05_mecharm_trim_lora/trim2_v1/3999/assets/local/mecharm_redblock_box_teach_v1_trim2
INFO:root:Creating server (host: a890930c92f7, ip: 172.24.0.2)
INFO:websockets.server:server listening on 0.0.0.0:8000
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 60634) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 60634) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 57618) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 57618) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 44858) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 44858) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 35920) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 35920) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 37116) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 37116) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 46382) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 46382) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 32948) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 32948) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 35152) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 35152) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 36496) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 36496) closed
INFO:websockets.server:connection open
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 57728) opened
INFO:openpi.serving.websocket_policy_server:Connection from ('127.0.0.1', 57728) closed
```

正規化の値は trim2 のもの（`mecharm_redblock_box_teach_v1_trim2`）を読み込んでいます。


## 写り方の確認は、アームがたたんだ姿勢のままだと「測れない」になった

ここから下は、Mac のターミナルの記録をそのまま載せています。最初に `camera_align.py` を開くと、似ている度合い（response）が 0.02〜0.04 しかなく、「測れない」が続きました。

```
Last login: Wed Oct 21 09:12:28 on ttys003
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 'ss -ltn | grep 5555' || { ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 "setsid nohup python3 /home/ubuntu/mecharm_daemon.py </dev/null >>/home/ubuntu/daemon.log 2>&1 &"; sleep 5; ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 'tail -3 ~/daemon.log; ss -ltn | grep 5555'; }
[DAEMON 14:35:27] ✓ MyCobot 初期化完了
[DAEMON 14:35:27] startup_warmup angles=[-0.26, 92.54, 1.66, -1.49, -96.32, -29.7]
[DAEMON 14:35:27] ポート 5555 で待ち受け中...
LISTEN0      1                                 0.0.0.0:5555        0.0.0.0:*    
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % cd ~/r2r2r-scripts
RAW=/Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
python3 pi05/camera_align.py --raw-dir $RAW
[REF   ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない)
[ALIGN ] dy= -26.8  dx=  +5.0  response=0.040  → 測れない (相関が弱く dx/dy が当てにならない (response=0.040 < 0.20))
[ALIGN ] dy= -27.9  dx=  +5.1  response=0.032  → 測れない (相関が弱く dx/dy が当てにならない (response=0.032 < 0.20))
[ALIGN ] dy= -29.0  dx=  +4.9  response=0.029  → 測れない (相関が弱く dx/dy が当てにならない (response=0.029 < 0.20))
[ALIGN ] dy= -27.8  dx=  +4.8  response=0.034  → 測れない (相関が弱く dx/dy が当てにならない (response=0.034 < 0.20))
[ALIGN ] dy= -28.9  dx=  +4.9  response=0.030  → 測れない (相関が弱く dx/dy が当てにならない (response=0.030 < 0.20))
[ALIGN ] dy= -27.8  dx=  +5.0  response=0.035  → 測れない (相関が弱く dx/dy が当てにならない (response=0.035 < 0.20))
[ALIGN ] dy= -28.8  dx=  +4.9  response=0.029  → 測れない (相関が弱く dx/dy が当てにならない (response=0.029 < 0.20))
[ALIGN ] dy= -31.6  dx=  +4.5  response=0.022  → 測れない (相関が弱く dx/dy が当てにならない (response=0.022 < 0.20))
[ALIGN ] dy= -28.5  dx=  +5.2  response=0.033  → 測れない (相関が弱く dx/dy が当てにならない (response=0.033 < 0.20))
[ALIGN ] dy= -29.6  dx=  +4.6  response=0.026  → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20))
[ALIGN ] dy= -28.6  dx=  +5.1  response=0.033  → 測れない (相関が弱く dx/dy が当てにならない (response=0.033 < 0.20))
[ALIGN ] dy= -30.1  dx=  +4.9  response=0.025  → 測れない (相関が弱く dx/dy が当てにならない (response=0.025 < 0.20))
[ALIGN ] dy= -28.2  dx=  +4.9  response=0.033  → 測れない (相関が弱く dx/dy が当てにならない (response=0.033 < 0.20))
[ALIGN ] dy= -29.7  dx=  +4.9  response=0.027  → 測れない (相関が弱く dx/dy が当てにならない (response=0.027 < 0.20))
[ALIGN ] dy= -28.5  dx=  +5.0  response=0.031  → 測れない (相関が弱く dx/dy が当てにならない (response=0.031 < 0.20))
[ALIGN ] dy= -29.7  dx=  +5.0  response=0.026  → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20))
[ALIGN ] dy= -28.5  dx=  +5.0  response=0.032  → 測れない (相関が弱く dx/dy が当てにならない (response=0.032 < 0.20))
[ALIGN ] dy= -29.7  dx=  +4.7  response=0.026  → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20))
[ALIGN ] dy= -28.4  dx=  +5.2  response=0.032  → 測れない (相関が弱く dx/dy が当てにならない (response=0.032 < 0.20))
[ALIGN ] dy= -29.8  dx=  +5.0  response=0.026  → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20))
[ALIGN ] dy= -28.6  dx=  +5.0  response=0.031  → 測れない (相関が弱く dx/dy が当てにならない (response=0.031 < 0.20))
[ALIGN ] dy= -30.1  dx=  +5.0  response=0.025  → 測れない (相関が弱く dx/dy が当てにならない (response=0.025 < 0.20))
[ALIGN ] dy= -29.1  dx=  +5.1  response=0.030  → 測れない (相関が弱く dx/dy が当てにならない (response=0.030 < 0.20))
[ALIGN ] dy= -30.7  dx=  +4.5  response=0.022  → 測れない (相関が弱く dx/dy が当てにならない (response=0.022 < 0.20))
[ALIGN ] dy= -28.8  dx=  +5.1  response=0.031  → 測れない (相関が弱く dx/dy が当てにならない (response=0.031 < 0.20))
[ALIGN ] dy= -29.9  dx=  +4.9  response=0.026  → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20))
[ALIGN ] dy= -28.6  dx=  +5.2  response=0.031  → 測れない (相関が弱く dx/dy が当てにならない (response=0.031 < 0.20))
[ALIGN ] dy= -30.0  dx=  +4.9  response=0.024  → 測れない (相関が弱く dx/dy が当てにならない (response=0.024 < 0.20))
[ALIGN ] dy= -28.4  dx=  +5.0  response=0.031  → 測れない (相関が弱く dx/dy が当てにならない (response=0.031 < 0.20))
[ALIGN ] dy= -30.1  dx=  +5.1  response=0.025  → 測れない (相関が弱く dx/dy が当てにならない (response=0.025 < 0.20))
[ALIGN ] dy= -28.6  dx=  +5.2  response=0.033  → 測れない (相関が弱く dx/dy が当てにならない (response=0.033 < 0.20))
[ALIGN ] dy= -29.8  dx=  +5.1  response=0.026  → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20))
[ALIGN ] dy= -28.6  dx=  +5.4  response=0.032  → 測れない (相関が弱く dx/dy が当てにならない (response=0.032 < 0.20))
[ALIGN ] dy= -30.8  dx=  +4.9  response=0.024  → 測れない (相関が弱く dx/dy が当てにならない (response=0.024 < 0.20))
[ALIGN ] dy= -29.4  dx=  +5.0  response=0.028  → 測れない (相関が弱く dx/dy が当てにならない (response=0.028 < 0.20))
[ALIGN ] dy= -28.2  dx=  +5.2  response=0.034  → 測れない (相関が弱く dx/dy が当てにならない (response=0.034 < 0.20))
[ALIGN ] dy= -29.3  dx=  +5.1  response=0.028  → 測れない (相関が弱く dx/dy が当てにならない (response=0.028 < 0.20))
[ALIGN ] dy= -30.3  dx=  +5.0  response=0.026  → 測れない (相関が弱く dx/dy が当てにならない (response=0.026 < 0.20))
[ALIGN ] dy= -29.3  dx=  +5.1  response=0.028  → 測れない (相関が弱く dx/dy が当てにならない (response=0.028 < 0.20))
[ALIGN ] dy= -30.4  dx=  +4.8  response=0.024  → 測れない (相関が弱く dx/dy が当てにならない (response=0.024 < 0.20))
[ALIGN ] dy= -29.2  dx=  +5.2  response=0.029  → 測れない (相関が弱く dx/dy が当てにならない (response=0.029 < 0.20))
^C
[STOP  ] Ctrl-C
[DONE  ] 終了 (何も書いていません)
```

原因は iPhone の位置ではなく、アームがたたんだ姿勢（j1 +92.5°・j4 −96.3°）のままだったことです。基準の画像は HOME の姿勢なので、腕の写り方が大きく違い、2枚が似ていないと判定されました。HOME に戻すスクリプト `08_home_from_anywhere.py`（Pi のデーモンに HOME を送るだけのもの）で戻してから開き直すと、すぐに「OK」になりました。途中の「測れない」は、iPhone の位置を手で直している最中のコマです。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % cd ~/r2r2r-scripts
python3 dynamic_tracking_limits/place/place_modules/08_home_from_anywhere.py
[INIT] daemon 接続中...
  [WARN] fresh_mode切替不可: daemon error: set_fresh_mode is not available in this pymycobot environment
[INIT] fresh_mode=1
[PRE]  現在姿勢: [-0.26, 92.54, 1.66, -1.49, -96.32, -29.70]
[SEND] HOME へ移動指令
[WAIT] t=2.1s  max_err=11.25°
[WAIT] t=2.7s  max_err=2.02°
[DONE] HOME 到達 max_err=2.02°
[POST] 最終姿勢: [-0.26, 1.31, 2.02, -0.61, 1.31, -29.70]
  [WARN] fresh_mode切替不可: daemon error: set_fresh_mode is not available in this pymycobot environment
[EXIT] fresh_mode=0, socket close
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % cd ~/r2r2r-scripts
RAW=/Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
python3 pi05/camera_align.py --raw-dir $RAW
[REF   ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない)
[ALIGN ] dy=  +3.4  dx= +11.2  response=0.648  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  +0.9  dx= +10.3  response=0.648  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -0.9  dx=  +6.7  response=0.695  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -2.0  dx=  -0.4  response=0.642  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -3.2  dx=  -2.2  response=0.652  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -2.1  dx=  -5.1  response=0.536  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -3.6  dx=  -4.1  response=0.650  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -5.4  dx=  -5.6  response=0.650  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -7.5  dx=  -8.0  response=0.561  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -9.6  dx= -10.8  response=0.496  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=+196.9  dx= -16.2  response=-0.001  → 測れない (相関が弱く dx/dy が当てにならない (response=-0.001 < 0.20))
[ALIGN ] dy= -10.6  dx=  -8.2  response=0.554  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -9.4  dx=  -8.5  response=0.505  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -6.2  dx=  -8.3  response=0.507  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy= -21.3  dx=  -4.8  response=0.022  → 測れない (相関が弱く dx/dy が当てにならない (response=0.022 < 0.20))
[ALIGN ] dy=  -2.4  dx=  -8.2  response=0.512  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  +0.5  dx=  -9.6  response=0.482  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  +1.5  dx= -10.1  response=0.477  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  +3.4  dx= -11.0  response=0.455  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  +5.9  dx= -13.2  response=0.366  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -5.7  dx= -12.2  response=0.037  → 測れない (相関が弱く dx/dy が当てにならない (response=0.037 < 0.20))
[ALIGN ] dy=  +8.2  dx= -14.0  response=0.324  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy= -11.2  dx= -13.6  response=0.025  → 測れない (相関が弱く dx/dy が当てにならない (response=0.025 < 0.20))
[ALIGN ] dy=  +5.7  dx= -18.0  response=0.278  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy= -14.9  dx= -19.4  response=0.016  → 測れない (相関が弱く dx/dy が当てにならない (response=0.016 < 0.20))
[ALIGN ] dy= -13.5  dx= -16.5  response=0.022  → 測れない (相関が弱く dx/dy が当てにならない (response=0.022 < 0.20))
[ALIGN ] dy=  +3.3  dx= -13.7  response=0.459  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  +0.7  dx=  -3.8  response=0.616  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -0.7  dx=  -2.2  response=0.662  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -1.7  dx=  -1.1  response=0.700  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -3.5  dx=  -3.1  response=0.623  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -4.6  dx=  -5.3  response=0.589  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -3.0  dx=  -0.3  response=0.674  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -1.9  dx=  +1.0  response=0.700  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[ALIGN ] dy=  -0.8  dx=  +2.8  response=0.710  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
^C
[STOP  ] Ctrl-C
[DONE  ] 終了 (何も書いていません)
```

![camera_align.py の画面。上カメラのライブ映像にお手本の最初のコマを半透明で重ね、左上に OK と dy −0.9・dx +1.8 が出ている](https://pixelstomotors.com/media/LOG358_09_camera_align_ok.jpg)


## お手本との答え合わせは、166回の問い合わせで「止まり」が0回だった

`eval_policy_offline.py` で、お手本の画像と角度をサーバーに送りました。位置ごとに1本ずつ、5本を3ステップおきに問い合わせる設定です。全部で6分ほどかかる見込みのところ、4本目の途中まで流したところで実機に進むことにして、Ctrl-C で止めています。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/eval_policy_offline.py --raw-dir $RAW
[EVAL  ] お手本 5 本 / 3 ステップおき / 記録 /Volumes/KIOXIA/r2r2r-data/lab/Log11/offline_eval/20261021_180539
         run_0001_20261019_193404
         run_0001_20261019_183454
         run_0001_20261019_192343
         run_0001_20261019_192539
         run_0001_20261019_194818
[POLICY] 接続 ws://localhost:8000
[20261019_193404 t=  0] 1秒の動き お手本  7.4° 予測  5.7°  ずれ 平均 0.3° 最大 1.7°(j1)
[20261019_193404 t=  3] 1秒の動き お手本  5.6° 予測  4.6°  ずれ 平均 0.3° 最大 2.0°(j4)
[20261019_193404 t=  6] 1秒の動き お手本  4.6° 予測  3.5°  ずれ 平均 0.3° 最大 2.0°(j0)
[20261019_193404 t=  9] 1秒の動き お手本 12.5° 予測 11.5°  ずれ 平均 0.4° 最大 1.8°(j4)
[20261019_193404 t= 12] 1秒の動き お手本 20.9° 予測 22.0°  ずれ 平均 0.5° 最大 1.4°(j4)
[20261019_193404 t= 15] 1秒の動き お手本 26.1° 予測 28.1°  ずれ 平均 0.7° 最大 2.0°(j4)
[20261019_193404 t= 18] 1秒の動き お手本 27.5° 予測 28.5°  ずれ 平均 0.3° 最大 1.2°(j2)
[20261019_193404 t= 21] 1秒の動き お手本 28.8° 予測 29.2°  ずれ 平均 0.3° 最大 1.1°(j1)
[20261019_193404 t= 24] 1秒の動き お手本 30.1° 予測 29.9°  ずれ 平均 0.2° 最大 1.1°(j0)
[20261019_193404 t= 27] 1秒の動き お手本 29.8° 予測 28.8°  ずれ 平均 0.2° 最大 1.0°(j4)
[20261019_193404 t= 30] 1秒の動き お手本 29.3° 予測 27.8°  ずれ 平均 0.2° 最大 1.5°(j4)
[20261019_193404 t= 33] 1秒の動き お手本 21.7° 予測 22.2°  ずれ 平均 0.2° 最大 1.0°(j0)
[20261019_193404 t= 36] 1秒の動き お手本 13.4° 予測 13.9°  ずれ 平均 0.3° 最大 1.6°(j4)
[20261019_193404 t= 39] 1秒の動き お手本  7.0° 予測  6.7°  ずれ 平均 0.3° 最大 2.4°(j4)
[20261019_193404 t= 42] 1秒の動き お手本  8.0° 予測  8.9°  ずれ 平均 0.3° 最大 1.4°(j4)
[20261019_193404 t= 45] 1秒の動き お手本 12.5° 予測 12.2°  ずれ 平均 0.2° 最大 1.1°(j4)
[20261019_193404 t= 48] 1秒の動き お手本 12.7° 予測 11.9°  ずれ 平均 0.2° 最大 1.5°(j4)
[20261019_193404 t= 51] 1秒の動き お手本  8.4° 予測  8.1°  ずれ 平均 0.2° 最大 0.8°(j1)
[20261019_193404 t= 54] 1秒の動き お手本  3.3° 予測  3.0°  ずれ 平均 0.2° 最大 1.0°(j4)
[20261019_193404 t= 57] 1秒の動き お手本  1.6° 予測  2.9°  ずれ 平均 0.3° 最大 1.7°(j4)
[20261019_193404 t= 60] 1秒の動き お手本  5.1° 予測  6.1°  ずれ 平均 0.3° 最大 1.1°(j4)
[20261019_193404 t= 63] 1秒の動き お手本  8.5° 予測  8.7°  ずれ 平均 0.1° 最大 0.7°(j4)
[20261019_193404 t= 66] 1秒の動き お手本 11.7° 予測 11.6°  ずれ 平均 0.3° 最大 0.9°(j4)
[20261019_193404 t= 69] 1秒の動き お手本 10.4° 予測 10.9°  ずれ 平均 0.3° 最大 1.6°(j0)
[20261019_193404 t= 72] 1秒の動き お手本  6.9° 予測  6.8°  ずれ 平均 0.3° 最大 2.0°(j0)
[20261019_193404 t= 75] 1秒の動き お手本 11.7° 予測  8.4°  ずれ 平均 0.4° 最大 3.3°(j0)
[20261019_193404 t= 78] 1秒の動き お手本 19.7° 予測 21.7°  ずれ 平均 0.4° 最大 2.1°(j0)
[20261019_193404 t= 81] 1秒の動き お手本 27.4° 予測 24.4°  ずれ 平均 0.9° 最大 3.7°(j0)
[20261019_193404 t= 84] 1秒の動き お手本 28.7° 予測 28.7°  ずれ 平均 0.1° 最大 0.4°(j0)
[20261019_193404 t= 87] 1秒の動き お手本 29.8° 予測 28.9°  ずれ 平均 0.2° 最大 0.9°(j0)
[20261019_193404 t= 90] 1秒の動き お手本 30.2° 予測 30.0°  ずれ 平均 0.1° 最大 0.7°(j1)
[20261019_193404 t= 93] 1秒の動き お手本 29.8° 予測 29.9°  ずれ 平均 0.1° 最大 0.5°(j0)
[20261019_193404 t= 96] 1秒の動き お手本 29.6° 予測 29.4°  ずれ 平均 0.1° 最大 0.5°(j4)
[20261019_193404 t= 99] 1秒の動き お手本 30.2° 予測 29.7°  ずれ 平均 0.2° 最大 1.1°(j4)
[20261019_193404 t=102] 1秒の動き お手本 30.8° 予測 29.8°  ずれ 平均 0.1° 最大 1.0°(j0)
[20261019_193404 t=105] 1秒の動き お手本 29.5° 予測 28.6°  ずれ 平均 0.2° 最大 0.9°(j0)
[20261019_193404 t=108] 1秒の動き お手本 24.0° 予測 23.3°  ずれ 平均 0.3° 最大 1.0°(j0)
[20261019_193404 t=111] 1秒の動き お手本 14.8° 予測 15.6°  ずれ 平均 0.2° 最大 0.8°(j0)
[20261019_193404 t=114] 1秒の動き お手本 11.0° 予測 12.1°  ずれ 平均 0.4° 最大 1.3°(j1)
[20261019_193404 t=117] 1秒の動き お手本 16.0° 予測 15.2°  ずれ 平均 0.2° 最大 0.8°(j1)
[20261019_193404 t=120] 1秒の動き お手本 13.2° 予測 13.9°  ずれ 平均 0.1° 最大 0.8°(j1)
[20261019_193404 t=123] 1秒の動き お手本  8.1° 予測  7.1°  ずれ 平均 0.2° 最大 1.0°(j1)
[20261019_193404 t=126] 1秒の動き お手本  1.7° 予測  1.5°  ずれ 平均 0.3° 最大 2.7°(j1)  グリッパー お手本11110 予測11111
[20261019_193404 t=129] 1秒の動き お手本  9.9° 予測  6.9°  ずれ 平均 0.6° 最大 3.2°(j1)  グリッパー お手本10000 予測11000
[20261019_193404 t=132] 1秒の動き お手本 15.1° 予測 12.2°  ずれ 平均 0.7° 最大 2.8°(j1)
[20261019_193404 t=135] 1秒の動き お手本 17.4° 予測 17.2°  ずれ 平均 0.2° 最大 0.6°(j2)
[20261019_193404 t=138] 1秒の動き お手本 19.0° 予測 17.6°  ずれ 平均 0.3° 最大 1.4°(j1)
[20261019_193404 t=141] 1秒の動き お手本 21.9° 予測 22.8°  ずれ 平均 0.1° 最大 0.9°(j4)
[20261019_193404 t=144] 1秒の動き お手本 28.5° 予測 29.3°  ずれ 平均 0.3° 最大 0.9°(j4)
[20261019_193404 t=147] 1秒の動き お手本 29.0° 予測 29.5°  ずれ 平均 0.2° 最大 0.8°(j2)
[20261019_193404 t=150] 1秒の動き お手本 29.3° 予測 30.9°  ずれ 平均 0.2° 最大 1.5°(j4)
[20261019_193404 t=153] 1秒の動き お手本 26.9° 予測 26.4°  ずれ 平均 0.2° 最大 1.6°(j0)
[20261019_193404 t=156] 1秒の動き お手本 18.1° 予測 19.4°  ずれ 平均 0.2° 最大 1.5°(j0)
[20261019_193404 t=159] 1秒の動き お手本  9.1° 予測  9.5°  ずれ 平均 0.2° 最大 0.7°(j1)
[20261019_193404 t=162] 1秒の動き お手本  2.5° 予測  3.9°  ずれ 平均 0.4° 最大 1.5°(j0)
[20261019_183454 t=  0] 1秒の動き お手本 20.9° 予測 23.6°  ずれ 平均 1.0° 最大 3.7°(j1)
[20261019_183454 t=  3] 1秒の動き お手本 26.5° 予測 26.2°  ずれ 平均 0.2° 最大 0.6°(j1)
[20261019_183454 t=  6] 1秒の動き お手本 27.4° 予測 26.7°  ずれ 平均 0.2° 最大 1.3°(j0)
[20261019_183454 t=  9] 1秒の動き お手本 28.6° 予測 28.8°  ずれ 平均 0.3° 最大 0.7°(j4)
[20261019_183454 t= 12] 1秒の動き お手本 29.8° 予測 30.3°  ずれ 平均 0.2° 最大 0.8°(j4)
[20261019_183454 t= 15] 1秒の動き お手本 30.2° 予測 30.4°  ずれ 平均 0.3° 最大 0.9°(j4)
[20261019_183454 t= 18] 1秒の動き お手本 29.9° 予測 29.6°  ずれ 平均 0.2° 最大 0.9°(j1)
[20261019_183454 t= 21] 1秒の動き お手本 28.0° 予測 26.0°  ずれ 平均 0.4° 最大 2.0°(j4)
[20261019_183454 t= 24] 1秒の動き お手本 21.8° 予測 21.2°  ずれ 平均 0.2° 最大 1.3°(j4)
[20261019_183454 t= 27] 1秒の動き お手本 13.2° 予測 12.1°  ずれ 平均 0.2° 最大 1.1°(j4)
[20261019_183454 t= 30] 1秒の動き お手本  6.7° 予測  5.5°  ずれ 平均 0.2° 最大 1.3°(j4)
[20261019_183454 t= 33] 1秒の動き お手本  4.6° 予測  5.8°  ずれ 平均 0.4° 最大 2.1°(j1)
[20261019_183454 t= 36] 1秒の動き お手本  8.3° 予測  7.1°  ずれ 平均 0.5° 最大 1.7°(j1)
[20261019_183454 t= 39] 1秒の動き お手本 12.5° 予測 13.2°  ずれ 平均 0.3° 最大 1.8°(j4)
[20261019_183454 t= 42] 1秒の動き お手本 12.2° 予測 13.5°  ずれ 平均 0.2° 最大 1.3°(j1)
[20261019_183454 t= 45] 1秒の動き お手本  8.0° 予測  9.7°  ずれ 平均 0.3° 最大 1.8°(j1)
[20261019_183454 t= 48] 1秒の動き お手本  1.0° 予測  3.5°  ずれ 平均 0.3° 最大 2.4°(j1)
[20261019_183454 t= 51] 1秒の動き お手本  6.5° 予測  7.6°  ずれ 平均 0.2° 最大 1.3°(j1)  グリッパー お手本00111 予測01111
[20261019_183454 t= 54] 1秒の動き お手本 10.4° 予測 12.2°  ずれ 平均 0.4° 最大 1.9°(j1)
[20261019_183454 t= 57] 1秒の動き お手本 12.5° 予測 12.2°  ずれ 平均 0.1° 最大 0.6°(j0)
[20261019_183454 t= 60] 1秒の動き お手本 12.5° 予測 11.2°  ずれ 平均 0.5° 最大 4.9°(j0)
[20261019_183454 t= 63] 1秒の動き お手本 17.7° 予測 16.2°  ずれ 平均 0.3° 最大 1.5°(j0)
[20261019_183454 t= 66] 1秒の動き お手本 26.0° 予測 25.0°  ずれ 平均 0.4° 最大 1.7°(j0)
[20261019_183454 t= 69] 1秒の動き お手本 28.3° 予測 28.5°  ずれ 平均 0.2° 最大 0.5°(j0)
[20261019_183454 t= 72] 1秒の動き お手本 28.9° 予測 29.4°  ずれ 平均 0.2° 最大 0.7°(j4)
[20261019_183454 t= 75] 1秒の動き お手本 29.3° 予測 28.7°  ずれ 平均 0.2° 最大 1.1°(j0)
[20261019_183454 t= 78] 1秒の動き お手本 29.6° 予測 28.9°  ずれ 平均 0.3° 最大 0.9°(j0)
[20261019_183454 t= 81] 1秒の動き お手本 29.6° 予測 29.2°  ずれ 平均 0.2° 最大 0.9°(j1)
[20261019_183454 t= 84] 1秒の動き お手本 28.7° 予測 28.8°  ずれ 平均 0.3° 最大 1.5°(j1)
[20261019_183454 t= 87] 1秒の動き お手本 20.7° 予測 20.1°  ずれ 平均 0.3° 最大 1.7°(j0)
[20261019_183454 t= 90] 1秒の動き お手本 13.4° 予測 14.0°  ずれ 平均 0.3° 最大 1.6°(j0)
[20261019_183454 t= 93] 1秒の動き お手本 24.2° 予測 24.0°  ずれ 平均 0.2° 最大 1.1°(j4)
[20261019_183454 t= 96] 1秒の動き お手本 20.2° 予測 21.3°  ずれ 平均 0.3° 最大 1.5°(j1)
[20261019_183454 t= 99] 1秒の動き お手本 12.6° 予測 11.0°  ずれ 平均 0.4° 最大 1.6°(j1)
[20261019_183454 t=102] 1秒の動き お手本  1.3° 予測  2.3°  ずれ 平均 0.2° 最大 1.0°(j1)
[20261019_183454 t=105] 1秒の動き お手本 13.9° 予測 12.6°  ずれ 平均 0.4° 最大 2.3°(j4)  グリッパー お手本10000 予測11000
[20261019_183454 t=108] 1秒の動き お手本 21.7° 予測 21.8°  ずれ 平均 0.2° 最大 1.1°(j4)
[20261019_183454 t=111] 1秒の動き お手本 24.5° 予測 23.9°  ずれ 平均 0.4° 最大 1.5°(j4)
[20261019_183454 t=114] 1秒の動き お手本 21.7° 予測 21.1°  ずれ 平均 0.2° 最大 0.8°(j0)
[20261019_183454 t=117] 1秒の動き お手本 24.1° 予測 24.4°  ずれ 平均 0.3° 最大 1.6°(j0)
[20261019_183454 t=120] 1秒の動き お手本 27.7° 予測 28.4°  ずれ 平均 0.3° 最大 1.2°(j0)
[20261019_183454 t=123] 1秒の動き お手本 28.9° 予測 29.5°  ずれ 平均 0.2° 最大 1.2°(j4)
[20261019_183454 t=126] 1秒の動き お手本 29.4° 予測 29.7°  ずれ 平均 0.3° 最大 1.5°(j0)
[20261019_183454 t=129] 1秒の動き お手本 28.6° 予測 27.1°  ずれ 平均 0.2° 最大 1.5°(j4)
[20261019_183454 t=132] 1秒の動き お手本 23.4° 予測 23.6°  ずれ 平均 0.3° 最大 1.0°(j0)
[20261019_183454 t=135] 1秒の動き お手本 14.4° 予測 12.8°  ずれ 平均 0.4° 最大 1.6°(j4)
[20261019_183454 t=138] 1秒の動き お手本  6.8° 予測  5.8°  ずれ 平均 0.4° 最大 1.2°(j4)
[20261019_183454 t=141] 1秒の動き お手本  1.2° 予測  0.3°  ずれ 平均 0.2° 最大 1.1°(j0)
[20261019_192343 t=  0] 1秒の動き お手本  5.4° 予測  5.1°  ずれ 平均 0.2° 最大 0.6°(j0)
[20261019_192343 t=  3] 1秒の動き お手本  4.3° 予測  4.7°  ずれ 平均 0.2° 最大 1.1°(j1)
[20261019_192343 t=  6] 1秒の動き お手本  8.7° 予測 10.0°  ずれ 平均 0.4° 最大 1.7°(j1)
[20261019_192343 t=  9] 1秒の動き お手本 18.0° 予測 19.6°  ずれ 平均 0.3° 最大 1.9°(j1)
[20261019_192343 t= 12] 1秒の動き お手本 26.6° 予測 27.1°  ずれ 平均 0.4° 最大 1.4°(j4)
[20261019_192343 t= 15] 1秒の動き お手本 27.6° 予測 27.2°  ずれ 平均 0.3° 最大 0.8°(j4)
[20261019_192343 t= 18] 1秒の動き お手本 28.7° 予測 28.6°  ずれ 平均 0.2° 最大 1.3°(j0)
[20261019_192343 t= 21] 1秒の動き お手本 29.7° 予測 30.9°  ずれ 平均 0.5° 最大 1.6°(j1)
[20261019_192343 t= 24] 1秒の動き お手本 30.1° 予測 29.8°  ずれ 平均 0.2° 最大 0.6°(j0)
[20261019_192343 t= 27] 1秒の動き お手本 26.5° 予測 27.4°  ずれ 平均 0.4° 最大 1.1°(j4)
[20261019_192343 t= 30] 1秒の動き お手本 18.8° 予測 19.1°  ずれ 平均 0.2° 最大 0.8°(j4)
[20261019_192343 t= 33] 1秒の動き お手本 10.3° 予測 10.6°  ずれ 平均 0.2° 最大 0.8°(j1)
[20261019_192343 t= 36] 1秒の動き お手本  5.6° 予測  5.2°  ずれ 平均 0.2° 最大 1.0°(j4)
[20261019_192343 t= 39] 1秒の動き お手本  4.7° 予測  4.5°  ずれ 平均 0.3° 最大 1.1°(j1)
[20261019_192343 t= 42] 1秒の動き お手本  8.3° 予測  7.6°  ずれ 平均 0.2° 最大 0.8°(j3)
[20261019_192343 t= 45] 1秒の動き お手本  6.9° 予測  7.4°  ずれ 平均 0.3° 最大 1.1°(j2)
[20261019_192343 t= 48] 1秒の動き お手本  3.8° 予測  3.7°  ずれ 平均 0.2° 最大 0.5°(j0)
[20261019_192343 t= 51] 1秒の動き お手本  0.7° 予測  0.8°  ずれ 平均 0.2° 最大 0.9°(j4)
[20261019_192343 t= 54] 1秒の動き お手本  3.3° 予測  2.4°  ずれ 平均 0.2° 最大 0.9°(j2)  グリッパー お手本01111 予測00111
[20261019_192343 t= 57] 1秒の動き お手本  5.4° 予測  5.7°  ずれ 平均 0.2° 最大 0.5°(j4)
[20261019_192343 t= 60] 1秒の動き お手本  6.4° 予測  5.3°  ずれ 平均 0.6° 最大 1.1°(j2)
[20261019_192343 t= 63] 1秒の動き お手本  6.4° 予測  5.6°  ずれ 平均 0.2° 最大 0.9°(j1)
[20261019_192343 t= 66] 1秒の動き お手本 14.6° 予測 14.0°  ずれ 平均 0.3° 最大 1.2°(j0)
[20261019_192343 t= 69] 1秒の動き お手本 22.8° 予測 13.1°  ずれ 平均 2.3° 最大 9.9°(j0)
[20261019_192343 t= 72] 1秒の動き お手本 27.5° 予測 28.4°  ずれ 平均 0.3° 最大 1.5°(j0)
[20261019_192343 t= 75] 1秒の動き お手本 28.6° 予測 28.2°  ずれ 平均 0.1° 最大 0.6°(j1)
[20261019_192343 t= 78] 1秒の動き お手本 29.5° 予測 28.5°  ずれ 平均 0.3° 最大 1.0°(j0)
[20261019_192343 t= 81] 1秒の動き お手本 30.1° 予測 28.9°  ずれ 平均 0.3° 最大 1.2°(j0)
[20261019_192343 t= 84] 1秒の動き お手本 29.9° 予測 29.2°  ずれ 平均 0.2° 最大 0.6°(j0)
[20261019_192343 t= 87] 1秒の動き お手本 22.3° 予測 23.1°  ずれ 平均 0.2° 最大 0.8°(j0)
[20261019_192343 t= 90] 1秒の動き お手本 13.4° 予測 12.1°  ずれ 平均 0.4° 最大 1.5°(j4)
[20261019_192343 t= 93] 1秒の動き お手本 14.3° 予測 15.5°  ずれ 平均 0.8° 最大 2.0°(j0)
[20261019_192343 t= 96] 1秒の動き お手本 15.7° 予測 14.9°  ずれ 平均 0.1° 最大 0.9°(j1)
[20261019_192343 t= 99] 1秒の動き お手本 10.6° 予測 10.2°  ずれ 平均 0.1° 最大 0.7°(j4)
[20261019_192343 t=102] 1秒の動き お手本  5.6° 予測  5.8°  ずれ 平均 0.1° 最大 0.9°(j4)
[20261019_192343 t=105] 1秒の動き お手本  5.9° 予測  7.2°  ずれ 平均 0.3° 最大 1.5°(j4)
[20261019_192343 t=108] 1秒の動き お手本 11.5° 予測  9.6°  ずれ 平均 0.5° 最大 2.7°(j4)  グリッパー お手本00000 予測10000
[20261019_192343 t=111] 1秒の動き お手本 16.8° 予測 17.4°  ずれ 平均 0.2° 最大 1.0°(j4)
[20261019_192343 t=114] 1秒の動き お手本 18.7° 予測 19.4°  ずれ 平均 0.2° 最大 1.0°(j1)
[20261019_192343 t=117] 1秒の動き お手本 22.1° 予測 22.7°  ずれ 平均 0.3° 最大 1.6°(j0)
[20261019_192343 t=120] 1秒の動き お手本 25.5° 予測 26.3°  ずれ 平均 0.2° 最大 1.1°(j0)
[20261019_192343 t=123] 1秒の動き お手本 28.2° 予測 29.1°  ずれ 平均 0.2° 最大 0.9°(j4)
[20261019_192343 t=126] 1秒の動き お手本 29.0° 予測 28.9°  ずれ 平均 0.2° 最大 0.6°(j0)
[20261019_192343 t=129] 1秒の動き お手本 29.2° 予測 27.5°  ずれ 平均 0.3° 最大 2.3°(j1)
[20261019_192343 t=132] 1秒の動き お手本 20.8° 予測 19.3°  ずれ 平均 0.3° 最大 1.7°(j4)
[20261019_192343 t=135] 1秒の動き お手本 11.7° 予測 11.8°  ずれ 平均 0.4° 最大 1.7°(j0)
[20261019_192343 t=138] 1秒の動き お手本  2.9° 予測  5.0°  ずれ 平均 0.5° 最大 2.4°(j0)
[20261019_192539 t=  0] 1秒の動き お手本 19.6° 予測 23.9°  ずれ 平均 1.6° 最大 4.3°(j4)
[20261019_192539 t=  3] 1秒の動き お手本 26.2° 予測 25.6°  ずれ 平均 0.2° 最大 0.6°(j4)
[20261019_192539 t=  6] 1秒の動き お手本 27.4° 予測 27.5°  ずれ 平均 0.2° 最大 1.0°(j1)
[20261019_192539 t=  9] 1秒の動き お手本 28.5° 予測 28.7°  ずれ 平均 0.3° 最大 1.2°(j1)
[20261019_192539 t= 12] 1秒の動き お手本 29.6° 予測 30.6°  ずれ 平均 0.2° 最大 1.0°(j4)
[20261019_192539 t= 15] 1秒の動き お手本 30.0° 予測 29.7°  ずれ 平均 0.2° 最大 0.8°(j4)
[20261019_192539 t= 18] 1秒の動き お手本 25.7° 予測 26.0°  ずれ 平均 0.2° 最大 0.9°(j1)
[20261019_192539 t= 21] 1秒の動き お手本 17.8° 予測 18.1°  ずれ 平均 0.2° 最大 0.5°(j1)
[20261019_192539 t= 24] 1秒の動き お手本  9.5° 予測  8.8°  ずれ 平均 0.2° 最大 1.3°(j4)
[20261019_192539 t= 27] 1秒の動き お手本  4.4° 予測  4.0°  ずれ 平均 0.3° 最大 1.7°(j4)
[20261019_192539 t= 30] 1秒の動き お手本  3.8° 予測  3.4°  ずれ 平均 0.3° 最大 0.8°(j4)
[20261019_192539 t= 33] 1秒の動き お手本  6.8° 予測  7.9°  ずれ 平均 0.4° 最大 1.3°(j4)
[20261019_192539 t= 36] 1秒の動き お手本  7.6° 予測  8.6°  ずれ 平均 0.3° 最大 1.1°(j1)
[20261019_192539 t= 39] 1秒の動き お手本  5.1° 予測  5.0°  ずれ 平均 0.1° 最大 0.5°(j4)
[20261019_192539 t= 42] 1秒の動き お手本  2.0° 予測  1.9°  ずれ 平均 0.2° 最大 0.9°(j4)
[20261019_192539 t= 45] 1秒の動き お手本  2.1° 予測  3.6°  ずれ 平均 0.3° 最大 1.6°(j4)  グリッパー お手本00111 予測01111
^CTraceback (most recent call last):
  File "/Users/shimazueiichi/r2r2r-scripts/pi05/eval_policy_offline.py", line 185, in <module>
    main()
  File "/Users/shimazueiichi/r2r2r-scripts/pi05/eval_policy_offline.py", line 126, in main
    out = policy.infer({"observation/image": load_rgb(frames[t]), "observation/state": q, "prompt": TASK})
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/Users/shimazueiichi/r2r2r-scripts/pi05/policy_ws.py", line 58, in infer
    resp = self.ws.recv()
           ^^^^^^^^^^^^^^
  File "/opt/homebrew/Caskroom/miniforge/base/lib/python3.12/site-packages/websockets/sync/connection.py", line 319, in recv
    return self.recv_messages.get(timeout, decode)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/opt/homebrew/Caskroom/miniforge/base/lib/python3.12/site-packages/websockets/sync/messages.py", line 169, in get
    frame = self.get_next_frame(deadline.timeout(raise_if_elapsed=False))
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/opt/homebrew/Caskroom/miniforge/base/lib/python3.12/site-packages/websockets/sync/messages.py", line 87, in get_next_frame
    frame = self.frames.get(block=True, timeout=timeout)
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
KeyboardInterrupt
```

途中で止めたため最後の集計は出ていないので、それまでに書き出された `rows.csv` を集計しました。

```
# 答え合わせ (途中で止めた回) の rows.csv を集計する (LOG358)
import csv, os, statistics
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
rows = list(csv.DictReader(open(ROOT + "/lab/Log11/offline_eval/20261021_180539/rows.csv")))
print("問い合わせ", len(rows), "止まり", sum(int(r["stuck"]) for r in rows), "グリッパーの食い違い", sum(int(r["grip_mismatch"]) for r in rows))
print("ずれの平均の中央値 %.2f°  最大 %.2f°" % (statistics.median(float(r["err_mean"]) for r in rows), max(float(r["err_max"]) for r in rows)))
for ep in sorted(set(r["episode"] for r in rows)):
    rs = [r for r in rows if r["episode"] == ep]
    print(" ", ep, "問い合わせ", len(rs), "止まり", sum(int(r["stuck"]) for r in rs), "ずれ中央値 %.2f°" % statistics.median(float(r["err_mean"]) for r in rs))
```

```
問い合わせ 166 止まり 0 グリッパーの食い違い 7
ずれの平均の中央値 0.25°  最大 9.91°
  run_0001_20261019_183454 問い合わせ 48 止まり 0 ずれ中央値 0.26°
  run_0001_20261019_192343 問い合わせ 47 止まり 0 ずれ中央値 0.24°
  run_0001_20261019_192539 問い合わせ 16 止まり 0 ずれ中央値 0.24°
  run_0001_20261019_193404 問い合わせ 55 止まり 0 ずれ中央値 0.25°
```

166回の問い合わせで、「お手本は1秒で 2° 以上動くのに、予測は 0.5° 未満」という止まりは0回でした。朝に止まった「真上で待つ」場面（183454 の t=45〜57）でも、予測はお手本と同じように下ろし始めています。予測とお手本のずれの平均は、中央値で 0.25° です。大きく外れたのは 192343 の t=69 の1回（最大 9.9°）だけで、グリッパーの開け閉めは7回、1ステップ（0.1 秒）早いか遅いかの違いがありました。


## 実機の1回目（18:09）は、止まらずに下ろして閉じたが、ブロックの手前で空を握った

ドライランで、写り方が OK のまま、ブロックへ腕を伸ばす向きの予測が出ることを確かめてから、実機で動かしました。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --max-chunks 5
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] DRY-RUN (アームには送らない)  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_180851
[CAMERA] 写り方 dy=-0.9 dx=+1.7 response=0.691 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[000] 推論 547ms  5ステップ先  Δ= -5.8 +11.5  -1.1  +1.7 -12.2  -1.0
[001] 推論 546ms  5ステップ先  Δ= -5.3 +10.6  -1.0  +1.7 -11.3  -0.8
[002] 推論 549ms  5ステップ先  Δ= -4.9 +10.0  -0.7  +1.2 -11.0  -0.8
[003] 推論 551ms  5ステップ先  Δ= -5.5 +10.7  -1.4  +1.8 -10.8  -0.9
[004] 推論 367ms  5ステップ先  Δ= -4.9 +10.0  -1.2  +1.7 -10.2  -0.8
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_180851
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_180924
[CAMERA] 写り方 dy=-1.1 dx=+1.7 response=0.693 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 674ms  5ステップ先  Δ= -5.7 +11.2  -1.4  +1.8 -12.3  -1.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [  -5.98,  +12.53,   +0.58,   +1.49,  -12.56,  -30.83]  speed=20 wait=1.0s  (pre max|Δ|=12.30°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.44° (tol 3.0°)
[001] 推論 1499ms  5ステップ先  Δ= -6.9 +12.1  +0.1  +1.7 -13.6  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk001: send_angles (single) [ -12.78,  +25.54,   +2.14,   +3.47,  -24.95,  -30.41]  speed=20 wait=1.0s  (pre max|Δ|=12.74°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.00° (tol 3.0°)
[002] 推論 548ms  5ステップ先  Δ= -8.2 +11.6  +1.0  +1.4 -14.7  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -21.20,  +38.14,   +3.89,   +5.31,  -39.09,  -30.53]  speed=20 wait=1.0s  (pre max|Δ|=14.66°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.05° (tol 3.0°)
[003] 推論 632ms  5ステップ先  Δ= -7.2 +12.0  +1.3  +0.7 -14.6  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk003: send_angles (single) [ -28.60,  +51.17,   +5.74,   +6.61,  -53.36,  -30.41]  speed=20 wait=1.0s  (pre max|Δ|=14.61°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.03° (tol 3.0°)
[004] 推論 1536ms  5ステップ先  Δ= -6.0  +9.6  +0.6  +0.0 -11.8  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk004: send_angles (single) [ -34.94,  +61.76,   +6.72,   +6.89,  -65.19,  -30.38]  speed=20 wait=1.0s  (pre max|Δ|=11.85°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.08° (tol 3.0°)
[005] 推論 683ms  5ステップ先  Δ= -0.9  +5.3  -1.6  -0.3  -1.5  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk005: send_angles (single) [ -35.65,  +68.12,   +5.44,   +7.25,  -66.33,  -30.48]  speed=20 wait=1.0s  (pre max|Δ|=5.28°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.15° (tol 3.0°)
[006] 推論 1489ms  5ステップ先  Δ= -0.2  +4.0  -1.7  -0.1  +0.3  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk006: send_angles (single) [ -36.04,  +73.21,   +4.94,   +7.40,  -66.24,  -30.60]  speed=20 wait=1.0s  (pre max|Δ|=4.05°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.66° (tol 3.0°)
[007] 推論 592ms  5ステップ先  Δ= +0.1  +2.4  -1.2  -0.2  +0.8  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk007: send_angles (single) [ -35.76,  +76.16,   +4.34,   +6.81,  -68.14,  -30.84]  speed=20 wait=1.0s  (pre max|Δ|=2.42°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.64° (tol 3.0°)
[008] 推論 681ms  5ステップ先  Δ= -0.0  +1.3  -0.5  -0.1  +0.7  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk008: send_angles (single) [ -35.85,  +77.12,   +3.70,   +6.77,  -69.08,  -30.92]  speed=20 wait=1.0s  (pre max|Δ|=1.28°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.79° (tol 3.0°)
[009] 推論 1521ms  5ステップ先  Δ= -0.0  +0.8  +0.0  -0.0  +0.3  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk009: send_angles (single) [ -35.89,  +77.44,   +3.63,   +6.75,  -69.60,  -30.88]  speed=20 wait=1.0s  (pre max|Δ|=0.80°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.72° (tol 3.0°)
[010] 推論 554ms  5ステップ先  Δ= +0.1  +1.4  -0.4  +0.0  +0.6  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk010: send_angles (single) [ -35.73,  +78.26,   +3.20,   +6.70,  -69.30,  -30.91]  speed=20 wait=1.0s  (pre max|Δ|=1.45°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.75° (tol 3.0°)
[011] 推論 557ms  5ステップ先  Δ= -0.0  +0.7  -0.2  +0.0  +0.3  -0.1  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk011: send_angles (single) [ -35.89,  +78.17,   +2.49,   +6.72,  -69.58,  -30.87]  speed=20 wait=1.0s  (pre max|Δ|=0.66°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.66° (tol 3.0°)
  [Pi] GRIPPER: VALUE=20 speed=100 result= -1
[012] 推論 652ms  5ステップ先  Δ= +1.5  -3.8  +2.2  +0.1  -0.3  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk012: send_angles (single) [ -34.28,  +73.73,   +4.25,   +6.26,  -70.22,  -30.70]  speed=20 wait=1.0s  (pre max|Δ|=3.78°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.41° (tol 3.0°)
[013] 推論 1522ms  5ステップ先  Δ= +2.3  -5.1  +3.5  -0.0  -0.8  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk013: send_angles (single) [ -32.27,  +70.05,   +7.24,   +7.63,  -69.93,  -30.70]  speed=20 wait=1.0s  (pre max|Δ|=5.09°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.84° (tol 3.0°)
[014] 推論 548ms  5ステップ先  Δ= +3.7  -3.2  +1.6  +0.3  -0.4  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk014: send_angles (single) [ -28.61,  +68.69,   +8.58,   +7.29,  -68.65,  -30.91]  speed=20 wait=1.0s  (pre max|Δ|=3.73°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.97° (tol 3.0°)
[015] 推論 643ms  5ステップ先  Δ= +5.1  -3.4  +1.7  +0.5  -0.2  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk015: send_angles (single) [ -23.27,  +67.30,  +10.03,   +7.90,  -68.37,  -31.04]  speed=20 wait=1.0s  (pre max|Δ|=5.11°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.04° (tol 3.0°)
[016] 推論 1533ms  5ステップ先  Δ= +6.3  -3.3  +1.8  +0.4  -0.0  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk016: send_angles (single) [ -16.69,  +66.02,  +11.56,   +8.21,  -67.70,  -31.06]  speed=20 wait=1.0s  (pre max|Δ|=6.33°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.18° (tol 3.0°)
[017] 推論 613ms  5ステップ先  Δ= +5.2  -2.4  +1.0  +0.2  -0.4  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk017: send_angles (single) [ -11.25,  +65.84,  +12.25,   +8.45,  -68.03,  -31.21]  speed=20 wait=1.0s  (pre max|Δ|=5.18°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.92° (tol 3.0°)

[018] 推論 683ms  5ステップ先  Δ= +8.0  -3.9  +0.4  -0.0  +1.2  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > [SEND] pi05_chunk018: send_angles (single) [  -3.08,  +63.85,  +12.73,   +8.69,  -66.66,  -31.21]  speed=20 wait=1.0s  (pre max|Δ|=7.99°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.24° (tol 3.0°)
[019] 推論 1455ms  5ステップ先  Δ= +6.6  -3.7  +0.5  -0.1  +1.1  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk019: send_angles (single) [  +3.35,  +62.35,  +12.95,   +7.84,  -65.37,  -31.31]  speed=20 wait=1.0s  (pre max|Δ|=6.51°, post-send timeout 8.0s)

[SEND] arrival OK: max|Δ|=2.24° (tol 3.0°)
[020] 推論 722ms  5ステップ先  Δ= +2.2  -3.2  +1.9  +0.1  -0.5  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > [SEND] pi05_chunk020: send_angles (single) [  +5.72,  +61.43,  +14.41,   +8.06,  -65.48,  -31.13]  speed=20 wait=1.0s  (pre max|Δ|=3.16°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.02° (tol 3.0°)
[021] 推論 595ms  5ステップ先  Δ= +2.7  -3.5  +2.1  +0.1  -0.4  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk021: send_angles (single) [  +8.71,  +59.92,  +16.87,   +8.10,  -65.34,  -31.17]  speed=20 wait=1.0s  (pre max|Δ|=3.53°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.04° (tol 3.0°)
[022] 推論 1578ms  5ステップ先  Δ= +2.4  -2.0  +1.0  +0.3  -0.8  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk022: send_angles (single) [ +11.48,  +59.98,  +18.18,   +8.10,  -65.73,  -31.08]  speed=20 wait=1.0s  (pre max|Δ|=2.43°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.98° (tol 3.0°)
[023] 推論 548ms  5ステップ先  Δ= +1.4  -2.7  +1.7  +0.2  -0.8  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk023: send_angles (single) [ +13.24,  +59.23,  +19.90,   +8.64,  -66.46,  -31.10]  speed=20 wait=1.0s  (pre max|Δ|=2.73°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.02° (tol 3.0°)
[024] 推論 553ms  5ステップ先  Δ= +0.2  -1.1  +0.9  +0.1  -1.0  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk024: send_angles (single) [ +13.56,  +60.17,  +20.82,   +9.11,  -67.29,  -31.02]  speed=20 wait=1.0s  (pre max|Δ|=1.08°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.08° (tol 3.0°)
[025] 推論 680ms  5ステップ先  Δ= +0.1  -2.5  +2.0  +0.0  -0.8  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk025: send_angles (single) [ +13.45,  +58.76,  +22.76,   +8.97,  -67.93,  -31.02]  speed=20 wait=1.0s  (pre max|Δ|=2.49°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.88° (tol 3.0°)
[026] 推論 1532ms  5ステップ先  Δ= -0.1  -1.1  +1.2  +0.1  -1.1  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk026: send_angles (single) [ +13.27,  +59.50,  +24.06,   +9.03,  -69.27,  -31.02]  speed=20 wait=1.0s  (pre max|Δ|=1.21°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.14° (tol 3.0°)
[027] 推論 548ms  5ステップ先  Δ= -0.1  -2.3  +1.9  -0.0  -0.7  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk027: send_angles (single) [ +13.24,  +58.34,  +25.77,   +8.82,  -70.04,  -30.98]  speed=20 wait=1.0s  (pre max|Δ|=2.30°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.77° (tol 3.0°)
[028] 推論 598ms  5ステップ先  Δ= -0.1  -0.4  +0.7  -0.2  -0.9  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk028: send_angles (single) [ +13.22,  +59.74,  +26.27,   +8.64,  -71.17,  -30.99]  speed=20 wait=1.0s  (pre max|Δ|=0.86°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.70° (tol 3.0°)
[029] 推論 1484ms  5ステップ先  Δ= -0.7  -0.6  +0.6  -0.6  -0.5  +0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk029: send_angles (single) [ +12.63,  +59.83,  +26.14,   +8.23,  -71.29,  -30.95]  speed=20 wait=1.0s  (pre max|Δ|=0.72°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.63° (tol 3.0°)
[030] 推論 618ms  5ステップ先  Δ= -0.2  -1.5  +1.6  -0.6  -0.8  +0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk030: send_angles (single) [ +12.81,  +59.00,  +27.13,   +7.71,  -71.60,  -30.95]  speed=20 wait=1.0s  (pre max|Δ|=1.56°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.46° (tol 3.0°)
[031] 推論 612ms  5ステップ先  Δ= -0.2  -1.9  +2.0  -0.4  -1.0  +0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk031: send_angles (single) [ +12.77,  +58.59,  +28.98,   +7.99,  -73.21,  -30.97]  speed=20 wait=1.0s  (pre max|Δ|=2.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.70° (tol 3.0°)
[032] 推論 599ms  5ステップ先  Δ= +0.5  -0.9  +1.1  -0.3  -0.9  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk032: send_angles (single) [ +13.49,  +59.39,  +29.79,   +7.88,  -74.63,  -31.02]  speed=20 wait=1.0s  (pre max|Δ|=1.05°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.90° (tol 3.0°)
[033] 推論 1712ms  5ステップ先  Δ= +0.5  -1.3  +1.5  -0.3  -1.1  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > s
[034] 推論 548ms  5ステップ先  Δ= +0.4  -1.2  +1.6  -0.3  -1.2  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > s
[035] 推論 623ms  5ステップ先  Δ= +0.2  -1.6  +2.2  -0.5  -1.3  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > s
[036] 推論 598ms  5ステップ先  Δ= +0.4  -1.6  +1.9  -0.3  -1.3  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > s
[037] 推論 796ms  5ステップ先  Δ= +0.2  -1.9  +2.6  -0.3  -1.4  +0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk037: send_angles (single) [ +13.19,  +58.42,  +31.76,   +7.79,  -75.93,  -30.91]  speed=20 wait=1.0s  (pre max|Δ|=2.59°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.87° (tol 3.0°)

[038] 推論 1568ms  5ステップ先  Δ= +0.3  -0.6  +0.6  -0.2  -1.4  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > [SEND] pi05_chunk038: send_angles (single) [ +13.35,  +59.68,  +32.09,   +7.87,  -78.08,  -30.98]  speed=20 wait=1.0s  (pre max|Δ|=1.36°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.92° (tol 3.0°)
[039] 推論 547ms  5ステップ先  Δ= +0.3  -0.1  -0.2  -0.4  -1.3  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=77.60°, post-send timeout 13.6s)
[SEND] arrival OK: max|Δ|=2.46° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_180924
```

朝は チャンク 06 で止まりましたが、この回は止まらずに下ろし続け（肩 j1 61.8° → 78.3°）、チャンク 11 でグリッパーを閉じています。ただ、閉じたのはブロックの手前で、何もつかんでいません。横から撮った動画です（6秒おきのコマ）。

![18:09 の回を横から撮った動画のコマ。0:30 前後で爪がブロックの横で閉じ、そのあと腕がマットの中央へ回っている](https://pixelstomotors.com/media/LOG358_03_side_run_180924.jpg)

[動画: 18:09 の回を横から撮った動画（約3分）](https://pixelstomotors.com/media/LOG358_v1_side_180924.mp4)


## つかみ損ねたあと、土台を +13° まで回し、別の位置でつかむときの姿勢で下げ続けた

閉じたあと、アームは土台 j0 を −36° から +13° まで回し、そこで1回 1〜2° ずつ下げ続けました。箱に入れるときの姿勢とは違います。お手本19本の「閉じた姿勢」と「開いた姿勢」を並べました。

```
# お手本 19 本で、グリッパーを閉じた姿勢と開いた姿勢 (j0..j4) を並べる (LOG358)
import numpy as np, glob, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes")
for p in sorted(glob.glob("*/episode.npz")):
    s = np.load(p)["state"]; ch = np.where(np.diff(s[:, 6]) != 0)[0] + 1
    c, o = ch[0], ch[1]
    print(os.path.dirname(p)[-15:], "close j", np.round(s[c, :5], 1), " open j", np.round(s[o, :5], 1))
```

```
20261019_183454 close j [-36.4  81.6   7.9   3.5 -87.7]  open j [ 44.4  60.8   7.6   9.9 -74.6]
20261019_191257 close j [-34.8  87.9 -34.    7.1 -45.9]  open j [ 44.6  70.3  -8.3  11.7 -65.7]
20261019_191347 close j [-34.7  87.9 -34.    6.5 -46.3]  open j [ 44.6  70.3  -8.3  11.6 -65.8]
20261019_191441 close j [-35.7  87.5 -35.5   6.8 -40.5]  open j [ 44.6  70.3  -8.4  11.6 -65.8]
20261019_191541 close j [-35.7  87.9 -34.    6.4 -46.1]  open j [ 44.5  70.3  -8.3  11.6 -65.7]
20261019_191635 close j [-35.5  87.9 -34.    6.4 -46.1]  open j [ 44.6  70.3  -8.3  11.6 -65.8]
20261019_192343 close j [-27.7  63.7  14.1  -7.6 -61.2]  open j [ 41.1  62.9   2.8   3.5 -68.5]
20261019_192438 close j [-27.8  63.7  14.1  -7.7 -61.4]  open j [ 40.9  62.9   2.7   3.5 -68.8]
20261019_192539 close j [-27.2  63.7  14.1  -7.7 -61.4]  open j [ 41.   62.9   2.9   3.6 -69. ]
20261019_192633 close j [-27.4  63.7  14.1  -7.6 -61.4]  open j [ 41.   62.9   2.9   3.6 -69.1]
20261019_193404 close j [-61.6  62.5  14.8   1.5 -60.7]  open j [ 43.8  63.4  -3.3   7.4 -61.7]
20261019_193459 close j [-61.6  62.4  14.8   1.1 -60.8]  open j [ 43.7  63.4  -3.3   7.4 -62. ]
20261019_193617 close j [-61.7  62.4  14.8   1.1 -60.8]  open j [ 43.8  63.4  -3.3   7.5 -61.7]
20261019_193825 close j [-61.5  62.3  13.9   1.3 -58. ]  open j [ 43.8  63.4  -3.3   7.5 -61.7]
20261019_193932 close j [-61.6  62.5  14.8   1.2 -60.7]  open j [ 43.8  63.4  -3.3   7.4 -61.7]
20261019_194818 close j [ 13.2  60.   19.5  -2.5 -61.5]  open j [ 42.9  66.9  -4.7   6.2 -60.8]
20261019_194913 close j [ 12.8  60.   19.4  -3.6 -61.6]  open j [ 42.8  66.9  -4.6   6.7 -60.9]
20261019_195023 close j [ 12.8  60.   19.4  -3.4 -61.5]  open j [ 43.1  66.9  -4.7   6.3 -60.9]
20261019_195120 close j [ 12.9  60.   19.4  -3.1 -61.5]  open j [ 42.9  67.   -4.4   6.4 -60.7]
```

箱の上で開く姿勢は、どの位置のお手本でも j0 +41〜+45° です。一方、j0 +13° で下げていた姿勢（j1 59〜60°・j2 20〜32°・j4 −67〜−76°）は、位置E（194818〜195120）でブロックをつかむときの姿勢（j0 +13°・j1 60.0°・j2 19.4°・j4 −61.5°）に近いものでした。お手本では、グリッパーを閉じたあとは必ずブロックを持っています。「閉じているのに何も持っていない」状態はお手本にないので、別の位置のつかむ動きが出てきたのだと考えています。止まったのではなく、少しずつ動き続けていました。

18:09 の回のブロックの位置と、お手本のブロックの位置を、上カメラの最初のコマで比べました。

![18:09 の回の最初のコマと、お手本の位置A・B・C の最初のコマ、18:09 の回の閉じる直前と j0 +13° のコマ](https://pixelstomotors.com/media/LOG358_06_grasp_position_A.jpg)

```
# 上カメラの最初のコマで、赤いブロックの位置 (いちばん大きい赤い塊の中心, 384x216 の画像の座標) を出す (LOG358)
import cv2, numpy as np, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT)
def red(p):
    im = cv2.imread(p); hsv = cv2.cvtColor(im, cv2.COLOR_BGR2HSV)
    m = ((hsv[..., 0] < 8) | (hsv[..., 0] > 170)) & (hsv[..., 1] > 120) & (hsv[..., 2] > 80)
    n, lab, st, cen = cv2.connectedComponentsWithStats(m.astype(np.uint8))
    k = 1 + np.argmax(st[1:, 4]); return tuple(np.round(cen[k], 1)), int(st[k, 4])
D = "datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/"
items = [("demo A 183454", D + "run_0001_20261019_183454/frames/000000.jpg"), ("demo B 191257", D + "run_0001_20261019_191257/frames/000000.jpg"),
         ("demo C 192343", D + "run_0001_20261019_192343/frames/000000.jpg"), ("demo D 193404", D + "run_0001_20261019_193404/frames/000000.jpg"),
         ("demo E 194818", D + "run_0001_20261019_194818/frames/000000.jpg")]
items += [(d, f"runs/pi05_policy/pi05_20261021_{d}/frames/0000.jpg") for d in ["180924", "182013", "182130", "182945", "183033", "183114", "183151", "183245"]]
for n, p in items:
    (x, y), area = red(p)
    print(f"{n:16s} x={x:6.1f} y={y:6.1f} 画素数={area}")
```

```
demo A 183454    x= 121.7 y= 115.7 画素数=15
demo B 191257    x= 113.9 y= 131.4 画素数=17
demo C 192343    x= 148.8 y= 127.9 画素数=27
demo D 193404    x=  92.2 y=  76.5 画素数=200
demo E 194818    x= 233.5 y= 139.7 画素数=18
180924           x= 109.0 y= 126.3 画素数=60
182013           x= 136.7 y= 131.1 画素数=23
182130           x= 135.9 y= 123.4 画素数=40
182945           x= 141.4 y= 129.6 画素数=30
183033           x= 135.1 y= 130.5 画素数=34
183114           x= 178.0 y=  34.5 画素数=14
183151           x= 176.2 y=  17.8 画素数=13
183245           x= 109.0 y= 121.7 画素数=51
```

赤い塊の中心で見ると、18:09 の回のブロック（x=109・y=126）は、位置A（1本）と位置B（5本）の間です（183114 と 183151 の行は、ブロックではなくアームの赤い配線を拾っているので使いません）。位置AとBは同じ向き（j0 −35° 前後）ですが、つかむ姿勢がまったく違います。位置Aは j2 +7.9°・j4 −87.7°、位置Bは j2 −34°・j4 −46° で、Bのほうが腕を遠くまで伸ばしています。18:09 の回の閉じた姿勢（j2 +2.5°・j4 −69.6°）は、その間でした。

学習前の点検 `check_dataset.py` は、位置を「つかむ瞬間の j0 を 5° 刻み」で分けているため、AとBを同じ1か所（6本）として数えていました。同じ向きで距離だけが違う位置を、この点検では見分けられません。

ただし、つかみ損ねた原因はこれだと決められていません。このあと 18:32 の回では、ほぼ同じ場所のブロックをつかめているからです（後述）。


## 2回目と3回目（18:20・18:21）は、つかんだが持ち上げずに引きずり、箱の手前で離した

HOME に戻し、前の回で閉じたままだったグリッパーを開け、写り方を確かめ直してから、ブロックを置き直して2回動かしました。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % 08_home_from_anywhere.py
zsh: command not found: 08_home_from_anywhere.py
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 dynamic_tracking_limits/place/place_modules/08_home_from_anywhere.py
[INIT] daemon 接続中...
  [WARN] fresh_mode切替不可: daemon error: set_fresh_mode is not available in this pymycobot environment
[INIT] fresh_mode=1
[PRE]  現在姿勢: [0.08, 1.31, 1.58, 0.26, -0.26, -30.23]
[SEND] HOME へ移動指令
[WAIT] t=2.0s  max_err=1.58°
[DONE] HOME 到達 max_err=1.58°
[POST] 最終姿勢: [0.08, 1.31, 1.58, 0.26, -0.26, -30.23]
  [WARN] fresh_mode切替不可: daemon error: set_fresh_mode is not available in this pymycobot environment
[EXIT] fresh_mode=0, socket close
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 -c "from visual_servo_pick import get_daemon_socket, daemon_set_gripper, close_daemon_socket; get_daemon_socket(); daemon_set_gripper(0); close_daemon_socket()"
  [Pi] GRIPPER: OPEN result= -1
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/camera_align.py --raw-dir $RAW
[REF   ] 基準画像: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[ALIGN ] |dy| <= 20 なら OK. アームは HOME に置いた状態で合わせる. q または Esc で終了 (ファイルには何も書かない)
[ALIGN ] dy=  -0.8  dx=  +2.5  response=0.605  → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
^C
[STOP  ] Ctrl-C
[DONE  ] 終了 (何も書いていません)
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_182013
[CAMERA] 写り方 dy=-0.9 dx=+2.5 response=0.607 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 663ms  5ステップ先  Δ= -4.9  +8.9  +0.8  +0.2 -10.0  +0.5
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [  -4.85,  +10.19,   +2.37,   +0.46,  -10.25,  -29.73]  speed=20 wait=1.0s  (pre max|Δ|=9.99°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.29° (tol 3.0°)
[001] 推論 1632ms  5ステップ先  Δ= -5.8 +11.5  +2.5  +0.0 -13.5  +0.7
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk001: send_angles (single) [ -10.59,  +22.59,   +5.62,   +0.28,  -22.42,  -29.28]  speed=20 wait=1.0s  (pre max|Δ|=12.41°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.05° (tol 3.0°)
[002] 推論 554ms  5ステップ先  Δ= -6.9 +11.3  +3.3  -0.2 -14.3  +0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -17.52,  +34.89,   +9.70,   -0.22,  -36.19,  -29.30]  speed=20 wait=1.0s  (pre max|Δ|=14.31°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.05° (tol 3.0°)
[003] 推論 546ms  5ステップ先  Δ= -7.3 +11.7  +3.3  -0.2 -16.9  +0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk003: send_angles (single) [ -25.15,  +47.60,  +13.79,   -0.32,  -52.71,  -29.40]  speed=20 wait=1.0s  (pre max|Δ|=16.86°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.91° (tol 3.0°)
[004] 推論 593ms  5ステップ先  Δ= -7.1  +9.7  +2.8  +0.1 -13.1  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk004: send_angles (single) [ -32.09,  +58.20,  +16.98,   -0.10,  -65.53,  -29.47]  speed=20 wait=1.0s  (pre max|Δ|=13.15°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.95° (tol 3.0°)

[005] 推論 1470ms  5ステップ先  Δ= -1.6  +3.0  +0.7  +0.0  -1.7  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > [SEND] pi05_chunk005: send_angles (single) [ -33.38,  +62.17,  +17.68,   +0.17,  -66.99,  -29.38]  speed=20 wait=1.0s  (pre max|Δ|=3.02°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.11° (tol 3.0°)
[006] 推論 737ms  5ステップ先  Δ= -0.0  +1.7  -1.5  -0.5  +1.3  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk006: send_angles (single) [ -33.58,  +64.99,  +16.46,   -0.19,  -65.47,  -29.40]  speed=20 wait=1.0s  (pre max|Δ|=1.71°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.38° (tol 3.0°)
[007] 推論 1623ms  5ステップ先  Δ= +0.2  +1.9  -2.2  -0.5  +2.1  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk007: send_angles (single) [ -33.41,  +67.50,  +15.03,   -0.38,  -65.73,  -29.59]  speed=20 wait=1.0s  (pre max|Δ|=2.19°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.85° (tol 3.0°)
[008] 推論 786ms  5ステップ先  Δ= +0.2  +1.5  -2.4  -1.0  +3.4  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk008: send_angles (single) [ -33.39,  +68.88,  +12.72,   -1.06,  -64.18,  -29.74]  speed=20 wait=1.0s  (pre max|Δ|=3.40°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.00° (tol 3.0°)
[009] 推論 814ms  5ステップ先  Δ= +0.2  +1.5  -1.9  -0.8  +2.0  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=68.64°, post-send timeout 12.3s)
[SEND] arrival OK: max|Δ|=1.75° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_182013
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=5  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_182130
[CAMERA] 写り方 dy=-1.5 dx=+1.0 response=0.702 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 711ms  5ステップ先  Δ= -4.3  +8.9  +2.1  -0.8 -11.2  +0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [  -4.83,  +10.21,   +3.89,   -1.05,  -10.74,  -29.33]  speed=20 wait=1.0s  (pre max|Δ|=11.09°, post-send timeout 8.0s)

[SEND] arrival OK: max|Δ|=0.95° (tol 3.0°)
[001] 推論 545ms  5ステップ先  Δ= -5.3 +10.9  +2.6  -0.9 -12.5  +0.9
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > [SEND] pi05_chunk001: send_angles (single) [ -10.35,  +22.09,   +7.48,   -1.17,  -24.13,  -28.81]  speed=20 wait=1.0s  (pre max|Δ|=12.53°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.93° (tol 3.0°)
[002] 推論 687ms  5ステップ先  Δ= -7.8 +11.7  +3.7  -0.2 -15.3  +0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -17.95,  +34.77,  +11.98,   -0.92,  -39.06,  -29.27]  speed=20 wait=1.0s  (pre max|Δ|=15.25°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.08° (tol 3.0°)
[003] 推論 1502ms  5ステップ先  Δ= -6.7 +11.6  +3.5  -0.1 -16.1  +0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk003: send_angles (single) [ -24.36,  +47.42,  +16.18,   -0.84,  -55.06,  -29.43]  speed=20 wait=1.0s  (pre max|Δ|=16.13°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.91° (tol 3.0°)
[004] 推論 551ms  5ステップ先  Δ= -6.9  +9.0  +3.0  +0.2 -12.2  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk004: send_angles (single) [ -31.03,  +57.33,  +19.74,   -0.36,  -66.91,  -29.57]  speed=20 wait=1.0s  (pre max|Δ|=12.16°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.94° (tol 3.0°)
[005] 推論 549ms  5ステップ先  Δ= -0.4  +0.7  +0.7  -0.1  -0.3  -0.0
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk005: send_angles (single) [ -31.15,  +58.99,  +20.10,   -0.23,  -67.66,  -29.65]  speed=20 wait=1.0s  (pre max|Δ|=0.72°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.03° (tol 3.0°)
[006] 推論 755ms  5ステップ先  Δ= -0.2  +1.4  -1.2  -0.4  +1.4  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk006: send_angles (single) [ -30.99,  +61.40,  +19.06,   -0.62,  -65.98,  -29.71]  speed=20 wait=1.0s  (pre max|Δ|=1.43°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.43° (tol 3.0°)
[007] 推論 1500ms  5ステップ先  Δ= +0.1  +2.0  -2.2  -0.9  +2.3  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk007: send_angles (single) [ -30.67,  +64.31,  +17.92,   -1.05,  -65.09,  -29.69]  speed=20 wait=1.0s  (pre max|Δ|=2.20°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.14° (tol 3.0°)
[008] 推論 577ms  5ステップ先  Δ= -0.0  +1.9  -1.9  -0.7  +2.0  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk008: send_angles (single) [ -30.79,  +66.74,  +16.37,   -1.25,  -65.23,  -29.92]  speed=20 wait=1.0s  (pre max|Δ|=1.91°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.91° (tol 3.0°)
[009] 推論 676ms  5ステップ先  Δ= -0.0  +2.1  -2.6  -0.9  +3.2  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk009: send_angles (single) [ -30.77,  +68.61,  +13.88,   -1.74,  -63.99,  -30.11]  speed=20 wait=1.0s  (pre max|Δ|=3.07°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.01° (tol 3.0°)
[010] 推論 1541ms  5ステップ先  Δ= -0.2  +1.5  -1.4  -0.6  +2.0  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk010: send_angles (single) [ -30.93,  +69.65,  +12.12,   -1.88,  -64.03,  -30.27]  speed=20 wait=1.0s  (pre max|Δ|=1.54°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.74° (tol 3.0°)
[011] 推論 555ms  5ステップ先  Δ= -0.0  +0.8  -0.9  -0.3  +1.5  -0.1  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk011: send_angles (single) [ -30.79,  +69.83,  +10.77,   -1.84,  -63.30,  -30.18]  speed=20 wait=1.0s  (pre max|Δ|=1.47°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.75° (tol 3.0°)
  [Pi] GRIPPER: VALUE=20 speed=100 result= -1
[012] 推論 649ms  5ステップ先  Δ= +1.5  -1.3  +0.4  +1.5  -1.1  -0.8
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk012: send_angles (single) [ -29.28,  +67.83,  +10.62,   -1.20,  -64.42,  -30.59]  speed=20 wait=1.0s  (pre max|Δ|=1.48°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.06° (tol 3.0°)
[013] 推論 628ms  5ステップ先  Δ= +1.1  -1.4  +1.1  +1.0  -1.4  -0.6
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk013: send_angles (single) [ -28.51,  +66.98,  +11.32,   +0.29,  -64.78,  -30.74]  speed=20 wait=1.0s  (pre max|Δ|=1.42°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.50° (tol 3.0°)
[014] 推論 1495ms  5ステップ先  Δ= +2.2  -1.0  +0.5  +0.7  -1.3  -0.6
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk014: send_angles (single) [ -26.74,  +66.90,  +10.73,   +1.34,  -64.58,  -30.79]  speed=20 wait=1.0s  (pre max|Δ|=2.17°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.30° (tol 3.0°)
[015] 推論 590ms  5ステップ先  Δ= +5.1  -2.0  +0.7  +0.6  -0.6  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk015: send_angles (single) [ -22.11,  +65.90,  +10.88,   +3.24,  -63.90,  -30.99]  speed=20 wait=1.0s  (pre max|Δ|=5.13°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.51° (tol 3.0°)
[016] 推論 548ms  5ステップ先  Δ= +7.8  -2.7  +0.1  +0.8  +0.5  -0.5
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk016: send_angles (single) [ -14.31,  +64.74,  +10.41,   +3.56,  -62.79,  -31.22]  speed=20 wait=1.0s  (pre max|Δ|=7.83°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.70° (tol 3.0°)
[017] 推論 552ms  5ステップ先  Δ= +7.9  -2.4  -0.4  +0.9  +0.7  -0.6
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk017: send_angles (single) [  -6.46,  +64.03,  +10.02,   +4.18,  -61.75,  -31.42]  speed=20 wait=1.0s  (pre max|Δ|=7.86°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.80° (tol 3.0°)
[018] 推論 648ms  5ステップ先  Δ= +4.7  -1.6  -0.1  +0.4  -0.4  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk018: send_angles (single) [  -1.76,  +64.23,  +10.31,   +4.90,  -62.04,  -31.41]  speed=20 wait=1.0s  (pre max|Δ|=4.74°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.60° (tol 3.0°)
[019] 推論 1624ms  5ステップ先  Δ= +7.6  -2.8  +0.4  +0.5  +0.2  -0.6
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk019: send_angles (single) [  +5.77,  +63.07,  +10.79,   +5.43,  -61.36,  -31.76]  speed=20 wait=1.0s  (pre max|Δ|=7.61°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.96° (tol 3.0°)
[020] 推論 548ms  5ステップ先  Δ= +6.0  -3.7  +1.2  +0.6  +0.2  -0.7
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk020: send_angles (single) [ +11.83,  +61.33,  +11.52,   +6.13,  -60.28,  -32.02]  speed=20 wait=1.0s  (pre max|Δ|=6.03°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.39° (tol 3.0°)
[021] 推論 619ms  5ステップ先  Δ= +3.4  -2.8  +0.8  +0.6  -0.5  -0.7
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk021: send_angles (single) [ +15.64,  +60.97,  +11.85,   +5.99,  -60.20,  -32.33]  speed=20 wait=1.0s  (pre max|Δ|=3.43°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.13° (tol 3.0°)
[022] 推論 586ms  5ステップ先  Δ= +2.4  -2.4  +1.2  +0.1  -0.6  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk022: send_angles (single) [ +18.39,  +60.74,  +12.94,   +5.93,  -60.29,  -32.15]  speed=20 wait=1.0s  (pre max|Δ|=2.40°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.01° (tol 3.0°)
[023] 推論 614ms  5ステップ先  Δ= +2.8  -2.0  +1.2  +0.2  -0.8  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk023: send_angles (single) [ +21.58,  +60.73,  +14.30,   +6.59,  -61.17,  -32.29]  speed=20 wait=1.0s  (pre max|Δ|=2.78°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.93° (tol 3.0°)
[024] 推論 1508ms  5ステップ先  Δ= +3.4  -2.0  +0.8  +0.4  -0.2  -0.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk024: send_angles (single) [ +25.31,  +60.64,  +15.21,   +7.05,  -61.85,  -32.33]  speed=20 wait=1.0s  (pre max|Δ|=3.43°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.02° (tol 3.0°)
[025] 推論 683ms  4ステップ先  Δ= +0.2  +0.3  -0.1  +0.1  -0.6  -0.0  グリッパー→開
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk025: send_angles (single) [ +25.87,  +62.99,  +14.59,   +7.35,  -62.31,  -32.00]  speed=20 wait=1.0s  (pre max|Δ|=0.62°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.64° (tol 3.0°)
  [Pi] GRIPPER: OPEN result= -1
[026] 推論 676ms  5ステップ先  Δ= -0.0  +1.6  -0.2  +0.2  -2.0  -0.1  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk026: send_angles (single) [ +25.65,  +65.26,  +14.47,   +7.26,  -64.80,  -32.05]  speed=20 wait=1.0s  (pre max|Δ|=1.96°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.85° (tol 3.0°)
  [Pi] GRIPPER: VALUE=20 speed=100 result= -1
[027] 推論 1489ms  5ステップ先  Δ= +1.8  -0.7  +0.2  +0.6  -0.9  -0.2
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk027: send_angles (single) [ +27.44,  +65.11,  +14.89,   +7.36,  -66.51,  -32.23]  speed=20 wait=1.0s  (pre max|Δ|=1.78°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.34° (tol 3.0°)
[028] 推論 549ms  5ステップ先  Δ= +0.1  -0.1  +0.0  +0.0  -0.3  -0.1  グリッパー→開
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
  [Pi] GRIPPER: OPEN result= -1
[029] 推論 551ms  5ステップ先  Δ= +0.2  +2.1  -0.3  +0.4  -2.1  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=65.83°, post-send timeout 11.9s)
[SEND] arrival OK: max|Δ|=1.75° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_182130
```

18:20 の回は、つかむ前のチャンク 09 で `h` を押して止めています（止めた理由は記録していません）。18:21 の回は、チャンク 11 でブロックをつかみ、土台を −31° から +27° まで回して、チャンク 25 で開いています。そのあと「閉じる」「開く」を繰り返しました。

![18:20 と 18:21 の回を横から撮った動画のコマ。後半でブロックをつかんだまま、マットに付けて引きずっている](https://pixelstomotors.com/media/LOG358_04_side_runs_182013_182130.jpg)

[動画: 18:20 と 18:21 の回を横から撮った動画（約3分）](https://pixelstomotors.com/media/LOG358_v2_side_182013_182130.mp4)

動画では、ブロックをつかんだまま、マットに付けて引きずっています。位置C（192343）のお手本で、閉じてから開くまでの角度を 0.4 秒おきに並べ、18:21 の回と比べました。

```
# 位置 C のお手本 (192343) の、閉じてから開くまでの j0 j1 j2 j4 を 0.4 秒おきに並べる (LOG358)
import numpy as np, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes")
s = np.load("run_0001_20261019_192343/episode.npz")["state"]
ch = np.where(np.diff(s[:, 6]) != 0)[0] + 1; c, o = ch
print("demo C 192343 close", c, "open", o, "len", len(s))
for t in range(c, o + 3, 4):
    print(" t", t, np.round(s[t, [0, 1, 2, 4]], 1), "g", int(s[t, 6]))
```

```
demo C 192343 close 56 open 109 len 140
 t 56 [-27.7  63.7  14.1 -61.2] g 1
 t 60 [-27.8  63.7  13.9 -62.1] g 1
 t 64 [-27.8  62.1  16.2 -64.7] g 1
 t 68 [-27.8  60.5  18.5 -67.3] g 1
 t 72 [-24.1  58.6  19.  -68.1] g 1
 t 76 [-13.1  55.9  16.6 -66.1] g 1
 t 80 [ -2.2  53.2  14.2 -64.1] g 1
 t 84 [  9.6  50.3  11.3 -61.2] g 1
 t 88 [ 21.8  47.3   8.1 -57.8] g 1
 t 92 [ 33.5  44.9   5.1 -54.4] g 1
 t 96 [ 41.1  47.2   3.3 -54.2] g 1
 t 100 [ 41.1  54.    3.1 -60.1] g 1
 t 104 [ 41.1  60.9   2.9 -66.1] g 1
 t 108 [ 41.1  62.9   2.8 -68.5] g 1
```

| 場面 | お手本（位置C・192343） | 18:21 の回 |
|---|---|---|
| 閉じた姿勢 | j1 63.7° | j1 69.0°（お手本より5°深い） |
| 持ち上げ | j1 63.7° → 44.9°（19° 上げる）、そのあと回す | j1 69.0° → 62.7°（6° しか上げない）、上げきる前に回し始めた |
| 離した場所 | j0 +41.1°（箱の上）、j1 62.9° | j0 +25.7°、j1 62.7° |

お手本の持ち上げは、閉じた直後の 0.8 秒ほどがとてもゆっくりで（j1 が 1.6° しか変わらない）、そのあと速くなります。クライアントは、1秒分の予測のうち最初の 0.5 秒（5ステップ）だけを動かして、また予測し直します。そのため、毎回「持ち上げ始めのゆっくりした部分」だけを繰り返して、低いまま回し始めたのだと考えました。

早く離したのも、ここから説明がつきます。低いまま運んだので、関節の角度（j1 約 63°）が、お手本の「箱の上で下ろし終えて、離す直前」（j1 62.9°）とほぼ同じになりました。そのため、箱に着く前に「離す」の予測が出ています。


## 1秒分を全部動かすと、箱の位置まで運び、箱の前で離した

1回の予測で1秒分（10ステップ）を全部動かす設定 `--steps-per-chunk 10` に変えて、5回動かしました。もともとある設定で、コードは変えていません。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute --steps-per-chunk 10
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=10  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_182945
[CAMERA] 写り方 dy=-1.0 dx=+1.3 response=0.673 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 1091ms  10ステップ先  Δ=-10.6 +19.9  +6.0  -2.9 -20.0  +2.5
       [LIMIT] j4 移動量 -24.9° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [ -10.84,  +21.21,   +7.68,   -2.64,  -20.26,  -27.74]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.11° (tol 3.0°)
[001] 推論 725ms  10ステップ先  Δ=-13.3 +20.0  +7.1  -0.4 -20.0  +0.7
       [LIMIT] j1 移動量 +23.3° を ±20° に制限
       [LIMIT] j4 移動量 -30.8° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk001: send_angles (single) [ -24.11,  +42.32,  +15.68,   -3.10,  -39.42,  -27.29]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.01° (tol 3.0°)
[002] 推論 1511ms  10ステップ先  Δ= -9.7 +15.9  +5.5  +0.0 -20.0  +0.0
       [LIMIT] j4 移動量 -20.3° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -33.79,  +59.22,  +21.70,   -3.32,  -59.19,  -27.48]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.42° (tol 3.0°)
[003] 推論 664ms  9ステップ先  Δ= +0.5  +3.5  -2.9  -2.0  +2.0  +0.1  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk003: send_angles (single) [ -32.99,  +63.24,  +18.24,   -6.11,  -59.64,  -27.72]  speed=20 wait=1.0s  (pre max|Δ|=3.48°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.79° (tol 3.0°)
  [Pi] GRIPPER: VALUE=20 speed=100 result= -1
[004] 推論 553ms  10ステップ先  Δ= +0.8  -2.4  +3.9  +1.5  -4.5  -0.1
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=62.75°, post-send timeout 11.4s)
[SEND] arrival OK: max|Δ|=1.66° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_182945
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute --steps-per-chunk 10
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=10  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183033
[CAMERA] 写り方 dy=-1.3 dx=+0.8 response=0.436 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 551ms  10ステップ先  Δ=-10.9 +20.0  +2.5  +1.4 -20.0  +0.3
       [LIMIT] j1 移動量 +21.2° を ±20° に制限
       [LIMIT] j4 移動量 -26.6° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [ -11.32,  +21.31,   +4.17,   +1.09,  -19.65,  -29.27]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.10° (tol 3.0°)
[001] 推論 627ms  10ステップ先  Δ=-14.2 +20.0  +4.6  +0.5 -20.0  +0.4
       [LIMIT] j1 移動量 +23.9° を ±20° に制限
       [LIMIT] j4 移動量 -29.6° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk001: send_angles (single) [ -25.73,  +42.41,   +9.40,   +2.05,  -39.42,  -29.26]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.09° (tol 3.0°)
[002] 推論 368ms  10ステップ先  Δ=-13.1 +20.0  +4.8  +0.5 -20.0  -0.0
       [LIMIT] j1 移動量 +20.1° を ±20° に制限
       [LIMIT] j4 移動量 -28.1° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -39.11,  +63.50,  +14.69,   +3.30,  -59.37,  -29.73]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.76° (tol 3.0°)
[003] 推論 402ms  7ステップ先  Δ= +0.2  +1.6  -1.1  -0.3  +2.5  -0.2  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=64.51°, post-send timeout 11.7s)
[SEND] arrival OK: max|Δ|=1.75° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183033
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute --steps-per-chunk 10
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=10  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183114
[CAMERA] 写り方 dy=-1.3 dx=+1.5 response=0.612 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 603ms  10ステップ先  Δ= -9.7 +19.7  +4.6  -2.4 -20.0  +1.1
       [LIMIT] j4 移動量 -24.0° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [ -10.00,  +20.96,   +6.31,   -2.17,  -19.83,  -28.47]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.01° (tol 3.0°)
[001] 推論 1643ms  10ステップ先  Δ=-14.1 +20.0  +6.5  +0.3 -20.0  +0.3
       [LIMIT] j1 移動量 +24.4° を ±20° に制限
       [LIMIT] j4 移動量 -30.8° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk001: send_angles (single) [ -24.06,  +41.97,  +13.59,   -2.30,  -39.24,  -29.05]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.00° (tol 3.0°)
[002] 推論 573ms  10ステップ先  Δ=-10.7 +16.4  +5.4  +0.1 -20.0  -0.1
       [LIMIT] j4 移動量 -22.1° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -34.82,  +59.36,  +19.54,   -2.22,  -59.46,  -29.38]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.36° (tol 3.0°)
[003] 推論 368ms  8ステップ先  Δ= +0.1  +2.6  -1.1  -0.9  -0.6  -0.1  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=60.55°, post-send timeout 11.1s)
[SEND] arrival OK: max|Δ|=1.66° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183114
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute --steps-per-chunk 10
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=10  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183151
[CAMERA] 写り方 dy=-1.5 dx=+0.9 response=0.674 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 595ms  10ステップ先  Δ=-10.8 +20.0  +1.8  +2.0 -20.0  -0.4
       [LIMIT] j1 移動量 +21.4° を ±20° に制限
       [LIMIT] j4 移動量 -25.5° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [ -11.23,  +21.23,   +3.47,   +1.65,  -18.69,  -29.96]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.00° (tol 3.0°)

[001] 推論 1512ms  10ステップ先  Δ=-13.0 +20.0  +3.4  +1.2 -20.0  +0.6
       [LIMIT] j1 移動量 +22.8° を ±20° に制限
       [LIMIT] j4 移動量 -27.6° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > [SEND] pi05_chunk001: send_angles (single) [ -24.13,  +42.23,   +7.52,   +3.44,  -39.59,  -29.00]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.10° (tol 3.0°)
[002] 推論 573ms  10ステップ先  Δ=-13.2 +19.5  +4.1  +1.0 -20.0  -0.1
       [LIMIT] j4 移動量 -26.8° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -37.74,  +62.86,  +12.22,   +5.12,  -59.37,  -29.80]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.86° (tol 3.0°)
[003] 推論 655ms  7ステップ先  Δ= +0.1  +3.1  -0.9  -0.1  -0.6  -0.1  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk003: send_angles (single) [ -37.37,  +66.79,  +11.14,   +5.32,  -60.11,  -29.95]  speed=20 wait=1.0s  (pre max|Δ|=3.07°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.55° (tol 3.0°)
  [Pi] GRIPPER: VALUE=20 speed=100 result= -1
[004] 推論 1467ms  10ステップ先  Δ=+18.9  -6.5  +0.1  +2.1  +1.3  -1.3
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=67.23°, post-send timeout 12.1s)
[SEND] arrival OK: max|Δ|=2.37° (tol 2.5°)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183151
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/run_policy_client.py --raw-dir $RAW --execute --steps-per-chunk 10
[SAFE  ] 安全範囲 (学習 19 本 ±10°): j0[-72,+55]  j1[-9,+88]  j2[-46,+41]  j3[-18,+27]  j4[-90,+10]  j5[-51,-14]
[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX=88° で切った (これを超える指令はアームが黙って捨てる / LOG352)  元データ: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
[MODE  ] EXECUTE  steps/chunk=10  max_move=20.0°  log=/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183245
[CAMERA] 写り方 dy=-1.5 dx=+1.4 response=0.394 → OK (|dy|<=20 / |dx|<=20 / response>=0.20)
[CAMERA] 基準: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes/run_0001_20261019_183454/frames/000000.jpg
[POLICY] 接続 ws://localhost:8000  metadata={}
[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います (爪が閉じていたら手で開けておく)
[000] 推論 564ms  10ステップ先  Δ=-10.9 +20.0  -1.7  +3.5 -20.0  -1.2
       [LIMIT] j1 移動量 +22.4° を ±20° に制限
       [LIMIT] j4 移動量 -22.3° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[GRIP  ] 開始時にグリッパーを開く
  [Pi] GRIPPER: OPEN result= -1
[SEND] pi05_chunk000: send_angles (single) [ -11.07,  +21.05,   -0.80,   +3.75,  -19.04,  -30.86]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.67° (tol 3.0°)
[001] 推論 549ms  10ステップ先  Δ=-16.0 +20.0  -0.3  +2.7 -20.0  +0.0
       [LIMIT] j1 移動量 +23.7° を ±20° に制限
       [LIMIT] j4 移動量 -27.1° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk001: send_angles (single) [ -27.29,  +42.06,   +0.58,   +5.60,  -37.92,  -30.56]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.00° (tol 3.0°)
[002] 推論 653ms  10ステップ先  Δ=-12.6 +20.0  +0.5  +0.7 -20.0  -0.0
       [LIMIT] j1 移動量 +21.5° を ±20° に制限
       [LIMIT] j4 移動量 -22.7° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk002: send_angles (single) [ -39.87,  +63.06,   +1.40,   +6.94,  -57.70,  -30.69]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.10° (tol 3.0°)
[003] 推論 1505ms  7ステップ先  Δ= -0.2  +1.2  +0.4  +0.4  +0.6  -0.2  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk003: send_angles (single) [ -39.84,  +65.39,   +2.28,   +7.84,  -56.76,  -30.95]  speed=20 wait=1.0s  (pre max|Δ|=1.23°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.05° (tol 3.0°)
  [Pi] GRIPPER: VALUE=20 speed=100 result= -1
[004] 推論 763ms  10ステップ先  Δ=+10.1  -5.8  +1.3  +0.4  +2.5  -0.6
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk004: send_angles (single) [ -29.60,  +60.61,   +3.90,   +7.72,  -55.04,  -31.40]  speed=20 wait=1.0s  (pre max|Δ|=10.12°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.58° (tol 3.0°)
[005] 推論 1691ms  10ステップ先  Δ=+20.0  -9.6  +1.3  +1.6  +6.1  -1.0
       [LIMIT] j0 移動量 +23.1° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk005: send_angles (single) [  -9.88,  +53.55,   +5.72,   +9.72,  -49.65,  -32.11]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.52° (tol 3.0°)
[006] 推論 909ms  10ステップ先  Δ=+20.0  -9.8  -0.3  +0.6  +7.0  -0.4
       [LIMIT] j0 移動量 +26.2° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk006: send_angles (single) [  +9.72,  +46.22,   +5.84,   +9.90,  -42.87,  -32.25]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.47° (tol 3.0°)
[007] 推論 730ms  10ステップ先  Δ=+20.0  -4.6  -1.8  -0.1  +4.5  -0.1
       [LIMIT] j0 移動量 +24.7° を ±20° に制限
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk007: send_angles (single) [ +29.40,  +44.11,   +4.31,  +10.04,  -38.65,  -31.97]  speed=20 wait=1.0s  (pre max|Δ|=20.00°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.64° (tol 3.0°)
[008] 推論 604ms  10ステップ先  Δ=+11.6 +10.1  -5.9  +0.5  -3.9  -0.7
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk008: send_angles (single) [ +40.86,  +56.88,   +0.16,  +11.01,  -42.77,  -32.74]  speed=20 wait=1.0s  (pre max|Δ|=11.60°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.21° (tol 3.0°)
[009] 推論 564ms  8ステップ先  Δ= -0.2  +7.3  -1.8  -0.0  -5.3  -0.2  グリッパー→開
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk009: send_angles (single) [ +40.73,  +65.38,   -0.63,  +11.76,  -47.53,  -33.21]  speed=20 wait=1.0s  (pre max|Δ|=7.29°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=2.56° (tol 3.0°)
  [Pi] GRIPPER: OPEN result= -1
[010] 推論 550ms  6ステップ先  Δ= +0.1  +4.4  -1.4  +0.1  -3.0  -0.1  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk010: send_angles (single) [ +41.37,  +70.28,   -1.95,  +11.81,  -49.62,  -33.88]  speed=20 wait=1.0s  (pre max|Δ|=4.37°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=1.00° (tol 3.0°)
  [Pi] GRIPPER: VALUE=20 speed=100 result= -1
[011] 推論 594ms  5ステップ先  Δ= -0.2  +1.0  +0.0  -0.0  -2.4  -0.0  グリッパー→開
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > 
[SEND] pi05_chunk011: send_angles (single) [ +40.98,  +70.89,   -2.36,  +12.00,  -53.07,  -33.52]  speed=20 wait=1.0s  (pre max|Δ|=2.36°, post-send timeout 8.0s)
[SEND] arrival OK: max|Δ|=0.78° (tol 3.0°)
  [Pi] GRIPPER: OPEN result= -1
[012] 推論 1468ms  6ステップ先  Δ= +0.2  +1.8  -0.5  +0.3  -2.2  -0.4  グリッパー→閉
       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > h
[SEND] pi05_home: send_angles (single) [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]  speed=20 wait=1.0s  (pre max|Δ|=71.19°, post-send timeout 12.7s)
  [WARN] _daemon_request timeout (timeout=4.0s, cmd=send_angles). socket closed.
[SEND] [ERROR] daemon_send_angles 例外: daemon timeout after 4.0s (cmd=send_angles)
[DONE  ] 記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/pi05_20261021_183245
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % 
```

最初の4回（18:29・18:30・18:31・18:31）は、つかむ前後で爪とブロックの位置がずれていて、つかめそうになかったので `h` で止めました。5回目（18:32）は、チャンク 03 でブロックをつかみ、チャンク 04〜08 で土台を −40° から +41° まで回して、チャンク 09 で開いています。開いた位置の j0 +40.7° は、お手本で箱の上で開く位置（+41〜+45°）と同じです。

![18:32 の回で π0.5 に渡した上カメラの画像。チャンク03でつかみ、05・07 で運び、09 で箱の前で開いている](https://pixelstomotors.com/media/LOG358_07_top_run_183245.jpg)

![18:32 の回を横から撮った動画のコマ。ブロックをマットに付けたまま箱へ運び、箱の壁に当てて、箱の外で離している](https://pixelstomotors.com/media/LOG358_05_side_run_183245.jpg)

[動画: 18:32 の回を横から撮った動画（約1分20秒）](https://pixelstomotors.com/media/LOG358_v3_side_183245.mp4)

ただし、運ぶ間もブロックはマットに付いたままで、箱の壁に当たり、箱の外に落ちました。**ブロックをつかんで箱の位置まで運ぶところまではできたが、持ち上げる高さが足りなかった**、というのがこの日の夕方の結果です。


## 運ぶ間に手首 j4 が +18° 動き、肩で上げた分を打ち消していた

18:32 の回では、肩はお手本と同じだけ上げています。違ったのは手首です。夕方の各回の、チャンクごとの角度を出しました。

```
# 夕方の実機の各回: 1 チャンクごとの state (j0 j1 j2 j4・グリッパー) とグリッパーの指令 (LOG358)
import numpy as np, json, glob, os
ROOT = os.environ.get("R2R2R_DATA", "/Volumes/KIOXIA/r2r2r-data")
os.chdir(ROOT + "/runs/pi05_policy")
for d in sorted(glob.glob("pi05_20261021_18*")):
    rows = [json.loads(l) for l in open(d + "/log.jsonl")]
    rows = [r for r in rows if "chunk" in r and "state" in r]
    if not rows: continue
    print(d, "chunks", len(rows))
    for r in rows:
        st = np.array(r["state"])
        print("  c%02d" % r["chunk"], np.round(st[[0, 1, 2, 4]], 1), "g", int(st[6] > 0.5),
              "grip_cmd", r.get("grip_cmd"), "executed", r.get("executed"))
```

```
pi05_20261021_180851 chunks 5
  c00 [-0.3  1.3  2.  -0.3] g 0 grip_cmd None executed False
  c01 [-0.3  1.3  2.  -0.3] g 0 grip_cmd None executed False
  c02 [-0.3  1.3  2.  -0.3] g 0 grip_cmd None executed False
  c03 [-0.3  1.3  2.  -0.3] g 0 grip_cmd None executed False
  c04 [-0.3  1.3  2.  -0.3] g 0 grip_cmd None executed False
pi05_20261021_180924 chunks 40
  c00 [-0.3  1.3  2.  -0.3] g 0 grip_cmd None executed True
  c01 [ -5.9  13.4   2.  -11.3] g 0 grip_cmd None executed True
  c02 [-13.   26.5   2.9 -24.4] g 0 grip_cmd None executed True
  c03 [-21.4  39.2   4.5 -38.8] g 0 grip_cmd None executed True
  c04 [-28.9  52.2   6.2 -53.3] g 0 grip_cmd None executed True
  c05 [-34.8  62.8   7.  -64.9] g 0 grip_cmd None executed True
  c06 [-35.8  69.2   6.6 -66.5] g 0 grip_cmd None executed True
  c07 [-35.8  73.7   5.5 -68.9] g 0 grip_cmd None executed True
  c08 [-35.8  75.8   4.2 -69.8] g 0 grip_cmd None executed True
  c09 [-35.8  76.6   3.6 -69.9] g 0 grip_cmd None executed True
  c10 [-35.8  76.8   3.6 -69.9] g 0 grip_cmd None executed True
  c11 [-35.8  77.5   2.7 -69.9] g 0 grip_cmd 1 executed True
  c12 [-35.8  77.5   2.  -70. ] g 1 grip_cmd None executed True
  c13 [-34.5  75.1   3.7 -69.2] g 1 grip_cmd None executed True
  c14 [-32.3  71.9   6.9 -68.2] g 1 grip_cmd None executed True
  c15 [-28.4  70.7   8.3 -68.2] g 1 grip_cmd None executed True
  c16 [-23.   69.3   9.8 -67.7] g 1 grip_cmd None executed True
  c17 [-16.4  68.2  11.2 -67.7] g 1 grip_cmd None executed True
  c18 [-11.1  67.8  12.3 -67.8] g 1 grip_cmd None executed True
  c19 [ -3.2  66.1  12.5 -66.4] g 1 grip_cmd None executed True
  c20 [  3.5  64.6  12.5 -64.9] g 1 grip_cmd None executed True
  c21 [  6.1  63.5  14.8 -64.9] g 1 grip_cmd None executed True
  c22 [  9.1  62.   17.1 -64.9] g 1 grip_cmd None executed True
  c23 [ 11.9  62.   18.2 -65.7] g 1 grip_cmd None executed True
  c24 [ 13.4  61.2  20.  -66.3] g 1 grip_cmd None executed True
  c25 [ 13.4  61.2  20.7 -67.1] g 1 grip_cmd None executed True
  c26 [ 13.4  60.6  22.9 -68.2] g 1 grip_cmd None executed True
  c27 [ 13.4  60.6  23.9 -69.3] g 1 grip_cmd None executed True
  c28 [ 13.4  60.1  25.6 -70.3] g 1 grip_cmd None executed True
  c29 [ 13.4  60.4  25.6 -70.8] g 1 grip_cmd None executed True
  c30 [ 13.   60.5  25.6 -70.8] g 1 grip_cmd None executed True
  c31 [ 13.   60.5  27.  -72.2] g 1 grip_cmd None executed True
  c32 [ 13.   60.3  28.7 -73.7] g 1 grip_cmd None executed True
  c33 [ 13.   60.3  29.2 -74.2] g 1 grip_cmd None executed False
  c34 [ 13.   60.3  29.2 -74.3] g 1 grip_cmd None executed False
  c35 [ 13.   60.3  29.2 -74.5] g 1 grip_cmd None executed False
  c36 [ 13.   60.3  29.2 -74.5] g 1 grip_cmd None executed False
  c37 [ 13.   60.3  29.2 -74.5] g 1 grip_cmd None executed True
  c38 [ 13.   60.3  31.5 -76.7] g 1 grip_cmd None executed True
  c39 [ 13.   60.4  31.5 -77.2] g 1 grip_cmd None executed False
pi05_20261021_182013 chunks 10
  c00 [ 0.1  1.3  1.6 -0.3] g 0 grip_cmd None executed True
  c01 [-4.8 11.1  3.2 -9. ] g 0 grip_cmd None executed True
  c02 [-10.6  23.6   6.4 -21.9] g 0 grip_cmd None executed True
  c03 [-17.8  35.9  10.4 -35.8] g 0 grip_cmd None executed True
  c04 [-25.   48.5  14.2 -52.4] g 0 grip_cmd None executed True
  c05 [-31.8  59.2  17.  -65.3] g 0 grip_cmd None executed True
  c06 [-33.6  63.3  17.9 -66.8] g 0 grip_cmd None executed True
  c07 [-33.6  65.7  17.2 -67.8] g 0 grip_cmd None executed True
  c08 [-33.6  67.4  15.1 -67.6] g 0 grip_cmd None executed True
  c09 [-33.7  68.6  12.6 -66.2] g 0 grip_cmd None executed False
pi05_20261021_182130 chunks 30
  c00 [-0.5  1.3  1.8  0.4] g 0 grip_cmd None executed True
  c01 [ -5.1  11.2   4.8 -11.6] g 0 grip_cmd None executed True
  c02 [-10.2  23.    8.3 -23.8] g 0 grip_cmd None executed True
  c03 [-17.7  35.8  12.6 -38.9] g 0 grip_cmd None executed True
  c04 [-24.1  48.3  16.7 -54.8] g 0 grip_cmd None executed True
  c05 [-30.8  58.3  19.4 -67.4] g 0 grip_cmd None executed True
  c06 [-30.8  60.   20.2 -67.4] g 0 grip_cmd None executed True
  c07 [-30.8  62.3  20.1 -67.4] g 0 grip_cmd None executed True
  c08 [-30.8  64.9  18.3 -67.2] g 0 grip_cmd None executed True
  c09 [-30.8  66.5  16.4 -67.1] g 0 grip_cmd None executed True
  c10 [-30.8  68.1  13.5 -66. ] g 0 grip_cmd None executed True
  c11 [-30.8  69.   11.7 -64.8] g 0 grip_cmd 1 executed True
  c12 [-30.8  69.1  10.2 -63.4] g 1 grip_cmd None executed True
  c13 [-29.6  68.4  10.2 -63.4] g 1 grip_cmd None executed True
  c14 [-28.9  67.9  10.2 -63.3] g 1 grip_cmd None executed True
  c15 [-27.2  67.9  10.2 -63.3] g 1 grip_cmd None executed True
  c16 [-22.1  67.4  10.3 -63.3] g 1 grip_cmd None executed True
  c17 [-14.3  66.4  10.4 -62.5] g 1 grip_cmd None executed True
  c18 [ -6.5  65.8  10.4 -61.6] g 1 grip_cmd None executed True
  c19 [ -1.8  65.8  10.4 -61.5] g 1 grip_cmd None executed True
  c20 [  5.8  65.   10.4 -60.5] g 1 grip_cmd None executed True
  c21 [ 12.2  63.7  11.1 -59.7] g 1 grip_cmd None executed True
  c22 [ 16.   63.1  11.8 -59.7] g 1 grip_cmd None executed True
  c23 [ 18.8  62.8  13.1 -60.4] g 1 grip_cmd None executed True
  c24 [ 21.9  62.7  14.4 -61.6] g 1 grip_cmd None executed True
  c25 [ 25.7  62.7  14.7 -61.7] g 1 grip_cmd 0 executed True
  c26 [ 25.7  63.6  14.7 -62.8] g 0 grip_cmd 1 executed True
  c27 [ 25.7  65.8  14.7 -65.7] g 1 grip_cmd None executed True
  c28 [ 27.1  65.8  14.7 -65.9] g 1 grip_cmd 0 executed True
  c29 [ 27.1  65.8  14.7 -65. ] g 0 grip_cmd None executed False
pi05_20261021_182945 chunks 5
  c00 [-0.3  1.3  1.7 -0.3] g 0 grip_cmd None executed True
  c01 [-10.8  22.3   8.6 -19.4] g 0 grip_cmd None executed True
  c02 [-24.1  43.3  16.2 -39.2] g 0 grip_cmd None executed True
  c03 [-33.5  59.8  21.1 -61.6] g 0 grip_cmd 1 executed True
  c04 [-33.5  62.8  17.6 -61.5] g 1 grip_cmd None executed False
pi05_20261021_183033 chunks 4
  c00 [-0.4  1.3  1.7  0.3] g 0 grip_cmd None executed True
  c01 [-11.5  22.4   4.8 -19.4] g 0 grip_cmd None executed True
  c02 [-26.   43.5   9.9 -39.4] g 0 grip_cmd None executed True
  c03 [-38.6  64.5  15.  -62.1] g 0 grip_cmd 1 executed False
pi05_20261021_183114 chunks 4
  c00 [-0.3  1.3  1.8  0.2] g 0 grip_cmd None executed True
  c01 [ -9.9  22.    7.1 -19.2] g 0 grip_cmd None executed True
  c02 [-24.1  43.   14.1 -39.5] g 0 grip_cmd None executed True
  c03 [-34.6  60.1  19.4 -60.8] g 0 grip_cmd 1 executed False
pi05_20261021_183151 chunks 5
  c00 [-0.4  1.2  1.7  1.3] g 0 grip_cmd None executed True
  c01 [-11.2  22.2   4.1 -19.6] g 0 grip_cmd None executed True
  c02 [-24.5  43.3   8.1 -39.4] g 0 grip_cmd None executed True
  c03 [-37.4  63.7  12.  -59.5] g 0 grip_cmd 1 executed True
  c04 [-37.4  67.2  10.8 -62.7] g 1 grip_cmd None executed False
pi05_20261021_183245 chunks 13
  c00 [-0.2  1.   0.9  1. ] g 0 grip_cmd None executed True
  c01 [-11.3  22.1   0.9 -17.9] g 0 grip_cmd None executed True
  c02 [-27.2  43.1   0.9 -37.7] g 0 grip_cmd None executed True
  c03 [-39.6  64.2   1.8 -57.4] g 0 grip_cmd 1 executed True
  c04 [-39.7  66.4   2.6 -57.6] g 1 grip_cmd None executed True
  c05 [-29.9  63.2   4.4 -55.7] g 1 grip_cmd None executed True
  c06 [-10.3  56.1   6.2 -49.8] g 1 grip_cmd None executed True
  c07 [  9.4  48.7   6.2 -43.2] g 1 grip_cmd None executed True
  c08 [ 29.3  46.8   6.1 -38.8] g 1 grip_cmd None executed True
  c09 [ 41.   58.1   1.1 -42.3] g 1 grip_cmd 0 executed True
  c10 [ 41.2  65.9  -0.5 -46.6] g 0 grip_cmd 1 executed True
  c11 [ 41.2  69.9  -2.4 -50.7] g 1 grip_cmd 0 executed True
  c12 [ 41.2  71.1  -2.4 -52.5] g 0 grip_cmd 1 executed False
```

| | お手本（位置C・運んでいる途中・t=92） | 18:32 の回（チャンク 07） |
|---|---|---|
| 肩 j1 | 44.9° | 44.1° |
| 肘 j2 | 5.1° | 4.3° |
| 手首 j4 | −54.4° | −38.7° |

持ち上げの間に、手首 j4 は −56.8° から −38.7° へ +18° 動いています。mechArm 270 は、j4 を + に動かすと爪先が下がります（DAY200 で実測）。肩で上げた分を手首で下げて打ち消し、爪先はマットの高さのままでした。

もう1つ、1秒分を全部動かす設定にしたことで、1回の移動の上限（20°）に当たる関節が増えました（ログの `[LIMIT]` の行）。この上限は関節ごとに別々にかかるので、土台だけ 20° で止められ、手首は予測どおり動く、ということが起きます。関節どうしの動きの割合が、お手本からずれます。手首が先に進みすぎたのは、これも効いている可能性があります。


## 夕方の8回を並べると、止まった回は0回だった

| 時刻 | 1回に動かす長さ | 結果 |
|---|---|---|
| 18:09 | 0.5秒 | 止まらずに下ろして閉じたが、ブロックの手前で空を握った。そのあと j0 +13° で下げ続けた |
| 18:20 | 0.5秒 | つかむ前のチャンク 09 で止めた（理由は記録していない） |
| 18:21 | 0.5秒 | つかんで回したが、持ち上げずに引きずり、j0 +25.7° で離した |
| 18:29 | 1秒 | 爪とブロックの位置がずれていて、つかめそうになかったので、閉じた直後に止めた |
| 18:30 | 1秒 | 同じ理由で、閉じる前に止めた |
| 18:31 | 1秒 | 同じ理由で、閉じる前に止めた |
| 18:31 | 1秒 | 同じ理由で、閉じた直後に止めた |
| 18:32 | 1秒 | つかんで箱の位置（j0 +40.7°）まで運び、箱の前で離した。持ち上げが足りず、箱の外に落ちた |

朝との違いをまとめると、次のとおりです。

| | 朝（teach_v1） | 夕方（trim2） |
|---|---|---|
| 真上で止まる | 止まった | 8回とも止まらなかった |
| つかむ | ― | 8回中2回つかんだ |
| 運ぶ | ― | 1回は箱の位置まで運んだ（低いまま） |
| 離す | ― | 箱の前で離した（箱には入らなかった） |


## Pod を削除する前に、モデル 6GB とログを KIOXIA に持ち帰った

Pod の中のモデル（`params`・`assets`・`_CHECKPOINT_METADATA`）を、大きいファイルから順に4本同時で持ち帰りました。朝は8本同時で Mac のターミナルが固まったので、本数を減らしています。学習を続けるための `train_state` は持ち帰っていません。

```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % P=<SSH_PORT>; IP=<POD_IP>; K=~/.ssh/id_ed25519
R=/workspace/openpi/checkpoints/pi05_mecharm_trim_lora/trim2_v1/3999
D=/Volumes/KIOXIA/r2r2r-data/checkpoints/pi05_mecharm_trim_lora_v1/3999
mkdir -p $D && cd $D
ssh -p $P -i $K root@$IP "cd $R && find params assets -type d" | xargs mkdir -p
ssh -p $P -i $K root@$IP "cd $R && find params assets _CHECKPOINT_METADATA -type f -printf '%s %p\n'" > /tmp/remote_trim2.txt
sort -rn /tmp/remote_trim2.txt | cut -d' ' -f2- | xargs -P 4 -I{} scp -q -P $P -i $K root@$IP:$R/{} {}
while read s f; do [ "$(stat -f %z "$f" 2>/dev/null)" = "$s" ] || echo "不一致: $f"; done < /tmp/remote_trim2.txt; echo "確認おわり"
scp -P $P -i $K -r root@$IP:/workspace/logs /Volumes/KIOXIA/r2r2r-data/lab/Log11/pod_trim2_logs
確認おわり
train.log                                     100%  305KB 241.4KB/s   00:01    
gpu_train.csv                                 100%   43KB  92.0KB/s   00:00    
serve.log                                     100% 4002    10.8KB/s   00:00    
(base) shimazueiichi@shimadzueiichinoMacBook-Pro 3999 %
```

18:41 に始めて、19:01 に終わりました。そのあと Runpod の画面で Stop → Terminate して、Pod を削除しています。

| 項目 | 値 |
|---|---|
| モデル | KIOXIA `checkpoints/pi05_mecharm_trim_lora_v1/3999/` |
| 学習とサーバーのログ | KIOXIA `lab/Log11/pod_trim2_logs/`（`train.log`・`gpu_train.csv`・`serve.log`） |
| 答え合わせの記録 | KIOXIA `lab/Log11/offline_eval/20261021_180539/rows.csv` |
| 実機の記録 | KIOXIA `runs/pi05_policy/pi05_20261021_18*/`（各チャンクの入力画像と予測） |
| 学習用 Pod の時間と費用 | 8:45ごろ〜19:03、約10時間20分 × $0.62/時 ＝ 約6.4ドル（約1,011円） |


## この回で変えた3つのファイルの全文（run_policy_client.py・camera_align.py・build_demo_episodes.py）

実機を動かすクライアント `run_policy_client.py` の、この回の最後の版（commit 05e1b8b）です。

```
#!/usr/bin/env python3
"""run_policy_client.py — π0.5 (Runpod の serve_policy) の出力で mechArm 270 を動かす Mac 側クライアント.

流れ (1 チャンクごと):
  上カメラ画像 + 実測 6 軸 + グリッパー状態 → π0.5 → 行動チャンク (10 x 7, 0.1 秒刻みの絶対角)
  → 先頭 N ステップ先 (既定 5 = 0.5 秒先) の姿勢へ単発 send_angles (学習データと同じ速度 20)
  → グリッパーの開閉がチャンク内で切り替わるなら, その直前の姿勢まで動いてから開閉
  → 撮り直して次のチャンクへ

安全策:
  - 既定はドライラン (アームに送らない). 送るには --execute
  - --execute でも既定は 1 チャンクごとに Enter で確認 (--auto で連続)
  - 学習データで通った関節範囲 ±ENVELOPE_MARGIN_DEG の外へは出さない (クランプ)
  - 肩 j1 の上限は J1_SAFE_MAX (88°) で更に切る. これを超える指令はアームが黙って捨てる (LOG352)
  - 送る直前に最終検査. 6 関節のどれかが安全範囲の外か非有限値なら, 送信もグリッパー操作もせず
    停止 (codex R1 / C2). HOME 復帰 (h) はこの検査を通さずに送れる
  - 1 回の移動量を --max-move-deg で制限 (クランプ), j4 は J4_SAFE 範囲内
  - グリッパー操作後は 2 秒待つ (DAY175 対策・本線と同じ)
  - --raw-dir は必須. 安全範囲は **学習に使ったデータ** から作る (別のデータだと範囲が合わない)
  - 開始時に上カメラの写り方をお手本と比べ, OK 以外ならアームに何も送らずに終了
    (ずれ / 測れない. --ignore-framing で続行). この確認が通るまで daemon にも触らない
  - 開始時のグリッパー開放も, 最初に送る目標が検査を通ってから (codex R2)
  - 止まったときに finally でアームを動かさない. 戻すときは Enter 確認の h で明示的に送る

終了コード: 0 = 最後まで / q / h / Ctrl-C,  1 = 安全停止・写り方の不一致・途中のエラー

前提:
  - Pi の daemon が待ち受け中 / 上カメラ (iPhone 連係) が見えている
  - Runpod で serve_policy が起動し, Mac から SSH トンネル (localhost:8000) が張れている
  - pip install msgpack "websockets>=11"

Usage:
  RAW=/Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
  python3 pi05/camera_align.py --raw-dir $RAW                   # 先に上カメラの写り方を合わせる
  python3 pi05/run_policy_client.py --raw-dir $RAW              # ドライラン (予測を表示・記録するだけ)
  python3 pi05/run_policy_client.py --raw-dir $RAW --execute    # 1 チャンクごとに Enter で実行
  python3 pi05/run_policy_client.py --raw-dir $RAW --execute --auto --max-chunks 40
記録: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/{stamp}/ (log.jsonl + 各チャンクの入力画像)
--record を付けると recorder.py --top にも trial_start/trial_end を送り, 上カメラ動画を残す.
"""
import argparse
import json
import socket
import sys
import time
import types
from datetime import datetime
from pathlib import Path

import cv2
import numpy as np

# ---- パス (run_pick_place.py と同じ構成) ----------------------------------------
_HERE = Path(__file__).resolve().parent
_ROOT = _HERE.parent
_PLACE = _ROOT / "dynamic_tracking_limits" / "place" / "place_modules"
_DRAG = _ROOT / "dynamic_tracking_limits" / "drag_teaching"
for p in (_HERE, _ROOT, _PLACE, _DRAG):
    sys.path.insert(0, str(p))

# pymycobot スタブ (waypoint_replay 経由の import を Mac 上で通すため. アーム制御は daemon 経由のみ)
if "pymycobot" not in sys.modules:
    _pkg = types.ModuleType("pymycobot"); _mod = types.ModuleType("pymycobot.mycobot")

    class _MyCobotStub:
        def __init__(self, *a, **k):
            raise RuntimeError("MyCobot は直接使わない (daemon 経由のみ)")
    _mod.MyCobot = _MyCobotStub
    sys.modules["pymycobot"] = _pkg; sys.modules["pymycobot.mycobot"] = _mod

import camera_resolver  # noqa: E402
import waypoint_replay as wr  # noqa: E402
from camera_align import (  # noqa: E402
    FRAMING_MAX_DX, FRAMING_MAX_DY, FRAMING_MIN_RESPONSE, framing_verdict, load_reference, measure_framing,
)
from fk_lookup import J1_SAFE_MAX  # noqa: E402  88.0. 本線と二重定義しない
from j0_sweep_scan import _send_and_wait_arrival  # noqa: E402
from policy_ws import PolicyClient  # noqa: E402
from visual_servo_pick import (  # noqa: E402
    close_daemon_socket, daemon_get_angles, daemon_set_gripper, daemon_set_gripper_value, get_daemon_socket,
)

TASK = "put the red block in the white box"
IMG_LONG = 384                  # build_demo_episodes.py と同じ (学習画像の長辺)
HOME = [0.0, 0.0, 0.0, 0.0, 0.0, -30.0]
GRIP_VALUE = 20                 # run_pick_place.py の close 値
GRIPPER_SLEEP = 2.0
J4_SAFE = (-90.0, 60.0)         # run_pick_place.py の J4_SAFE_MIN/MAX
ENVELOPE_MARGIN_DEG = 10.0
SEND_EPS_DEG = 1e-6             # 送信前の検査の余裕 (小数の誤差で止まらないように)
DATA_ROOT = Path("/Volumes/KIOXIA/r2r2r-data")
LOG_ROOT = DATA_ROOT / "runs" / "pi05_policy"
RECORDER = ("127.0.0.1", 5556)


def load_envelope(raw_dir: Path):
    """学習データで通った各関節の範囲 ± マージン. 物理可動域 (wr.JOINT_LIMITS)・J4_SAFE・J1_SAFE_MAX で更に絞る."""
    qs = [np.load(p)["state"][:, :6] for p in raw_dir.glob("*/episode.npz")]
    if not qs:
        sys.exit(f"[ERROR] 学習エピソードが見つからない (安全範囲を作れない): {raw_dir}")
    q = np.concatenate(qs)
    lo = q.min(axis=0) - ENVELOPE_MARGIN_DEG
    hi = q.max(axis=0) + ENVELOPE_MARGIN_DEG
    for k, (plo, phi) in enumerate(wr.JOINT_LIMITS):
        lo[k], hi[k] = max(lo[k], plo), min(hi[k], phi)
    lo[4], hi[4] = max(lo[4], J4_SAFE[0]), min(hi[4], J4_SAFE[1])
    # 肩 j1: wr.JOINT_LIMITS[1] の上限は +123° なので, マージンを足すと +98° まで通ってしまう.
    # 88° を超える指令はアームが黙って捨てる (LOG352) ので, ここで切る.
    hi[1] = min(hi[1], J1_SAFE_MAX)
    # codex R3: lo > hi や非有限値のまま運転しない (np.clip は例外を出さないので黙って通る).
    # lo を書き換えて辻褄を合わせるのではなく, 起動を中止する.
    bad = [k for k in range(6)
           if not (np.isfinite(lo[k]) and np.isfinite(hi[k])) or lo[k] > hi[k]]
    if bad:
        sys.exit("[ERROR] 安全範囲が不整合 (lo > hi か非有限値): "
                 + "  ".join(f"j{k}[{lo[k]:+.1f},{hi[k]:+.1f}]" for k in bad)
                 + f"\n        学習データが安全制約 (J1_SAFE_MAX={J1_SAFE_MAX:.0f}° / J4_SAFE / "
                 f"JOINT_LIMITS) と合っていない: {raw_dir}")
    return lo, hi, len(qs)


def read_angles():
    for _ in range(5):
        try:
            a = daemon_get_angles()
        except Exception:
            a = None
        if wr._is_valid_angles(a):
            return np.array([float(x) for x in a])
        time.sleep(0.1)
    return None


def grab_rgb(cap):
    for _ in range(3):            # バッファに溜まった古いフレームを捨てる
        cap.grab()
    ok, frame = cap.read()
    if not ok or frame is None:
        return None, None
    h, w = frame.shape[:2]
    s = IMG_LONG / max(h, w)
    small = cv2.resize(frame, (round(w * s), round(h * s)), interpolation=cv2.INTER_AREA)
    return cv2.cvtColor(small, cv2.COLOR_BGR2RGB), small   # モデルへは RGB, 保存は BGR


def plan_chunk(actions, q, grip, n_steps):
    """チャンクから今回動かす目標を決める. 戻り値: (目標6軸, グリッパー指令 None/0/1, 使ったステップ)."""
    want = (actions[:, 6] > 0.5).astype(int)
    for f in range(min(n_steps, len(actions))):
        if want[f] != grip:
            target = q.copy() if f == 0 else actions[f - 1, :6]
            return np.asarray(target, dtype=float), int(want[f]), f
    k = min(n_steps, len(actions)) - 1
    return np.asarray(actions[k, :6], dtype=float), None, k


def apply_limits(target, q, lo, hi, max_move):
    notes = []
    t = target.copy()
    clipped = np.clip(t, lo, hi)
    for k in np.where(np.abs(clipped - t) > 1e-6)[0]:
        notes.append(f"j{k} 安全範囲でクランプ {t[k]:+.1f}→{clipped[k]:+.1f}")
    t = clipped
    d = t - q
    big = np.abs(d) > max_move
    for k in np.where(big)[0]:
        notes.append(f"j{k} 移動量 {d[k]:+.1f}° を ±{max_move:.0f}° に制限")
    t = q + np.clip(d, -max_move, max_move)
    return t, notes


def check_send_safe(target, lo, hi):
    """送る直前の最終検査 (codex R1 / C2). 違反の理由を返す (空なら送って良い).

    apply_limits は「安全範囲でクランプ → 移動量の上限」の順なので, 現在角が安全範囲の
    外にあると, クランプで範囲内に入れた目標が移動量の制限でまた範囲の外に戻る.
      j1 (codex R1): 現在 110° / 予測 100° / 上限 20° → 88° にクランプ後, 110-20 = 90° を送る
      j4 (codex C2): 現在 100° / 予測  90° / 上限 20° → 60° にクランプ後, 100-20 = 80° を送る
    j1 だけでなく 6 関節すべてを見る. ここで再クランプすると移動量の上限を破るので, 送らずに止める.
    HOME 復帰 (Enter 確認の h) はこの検査を通さない: 範囲の外にいるアームを戻す手段として残す.
    """
    if not np.all(np.isfinite(target)):
        return ["目標に非有限値が入っている: " + " ".join(f"j{k}={v}" for k, v in enumerate(target))]
    bad = []
    for k in range(6):
        if target[k] < lo[k] - SEND_EPS_DEG or target[k] > hi[k] + SEND_EPS_DEG:
            msg = f"j{k} {target[k]:+.2f}° が安全範囲 [{lo[k]:+.2f}, {hi[k]:+.2f}] の外"
            if k == 1 and target[k] > hi[k] and abs(hi[k] - J1_SAFE_MAX) < 1e-9:
                msg += (f" (上限は J1_SAFE_MAX={J1_SAFE_MAX:.0f}°. "
                        "これを超える指令はアームが黙って捨てる / LOG352)")
            elif k == 4:
                msg += f" (j4 の範囲は 学習データ ∩ J4_SAFE [{J4_SAFE[0]:+.0f}, {J4_SAFE[1]:+.0f}])"
            bad.append(msg)
    return bad


def notify_recorder(sock, payload):
    try:
        payload = dict(payload, ts=time.time())
        sock.sendto((json.dumps(payload) + "\n").encode(), RECORDER)
    except Exception:
        pass


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--host", default="localhost")
    ap.add_argument("--port", type=int, default=8000)
    ap.add_argument("--execute", action="store_true", help="アームに送る (未指定はドライラン)")
    ap.add_argument("--auto", action="store_true", help="Enter 確認なしで連続実行")
    ap.add_argument("--steps-per-chunk", type=int, default=5, help="1 チャンクで何ステップ先まで進むか (0.1 秒単位)")
    ap.add_argument("--max-chunks", type=int, default=60)
    ap.add_argument("--max-move-deg", type=float, default=20.0, help="1 回の移動で各関節が動ける上限")
    ap.add_argument("--raw-dir", required=True,
                    help="安全範囲の算出に使う学習エピソード (必須. 学習に使った raw_episodes を指定する)")
    ap.add_argument("--prompt", default=TASK)
    ap.add_argument("--record", action="store_true", help="recorder.py --top に上カメラ動画を記録させる")
    ap.add_argument("--ignore-framing", action="store_true",
                    help="上カメラの写り方がお手本と違っても続ける (既定は何も送らずに終了)")
    args = ap.parse_args()

    if not DATA_ROOT.exists():
        sys.exit(f"[ERROR] SSD 未マウント: {DATA_ROOT}")
    lo, hi, n_eps = load_envelope(Path(args.raw_dir))
    print(f"[SAFE  ] 安全範囲 (学習 {n_eps} 本 ±{ENVELOPE_MARGIN_DEG:.0f}°): "
          + "  ".join(f"j{k}[{lo[k]:+.0f},{hi[k]:+.0f}]" for k in range(6)))
    print(f"[SAFE  ] 肩 j1 の上限は J1_SAFE_MAX={J1_SAFE_MAX:.0f}° で切った "
          f"(これを超える指令はアームが黙って捨てる / LOG352)  元データ: {args.raw_dir}")

    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    log_dir = LOG_ROOT / f"pi05_{stamp}"
    (log_dir / "frames").mkdir(parents=True, exist_ok=True)
    log_f = (log_dir / "log.jsonl").open("w")
    run_stem = f"pi05_{stamp}"
    mode = "EXECUTE" if args.execute else "DRY-RUN (アームには送らない)"
    print(f"[MODE  ] {mode}  steps/chunk={args.steps_per_chunk}  max_move={args.max_move_deg}°  log={log_dir}")

    # 以降は try/finally の中だけで資源を触る (codex R3: 途中で終了しても cap / log_f を必ず閉じる).
    # sys.exit は SystemExit を投げるので, この finally を通って後始末される.
    cap = policy = rec_sock = None
    exit_code = 0
    grip = 0
    grip_opened = False          # 開始時のグリッパー開放を済ませたか (codex R2)
    try:
        cams = camera_resolver.resolve_cameras(require_top=True, require_side=False, verbose=False)
        cap = cv2.VideoCapture(cams["top"])
        if not cap.isOpened():
            sys.exit("[ERROR] 上カメラを開けない")
        t_cam = time.time()
        while time.time() - t_cam < 8.0:       # 連係カメラは映像が来るまで数秒かかることがある
            ok, _f = cap.read()
            if ok and _f is not None:
                break
            time.sleep(0.2)
        else:
            sys.exit("[ERROR] 上カメラから映像が来ない. iPhone のロック解除・連係カメラの接続を確認 "
                     "(Photo Booth の『カメラ』メニューに iPhone が出るか)")

        # E (2026-10-21): 上カメラの写り方は 2 通りあり, カメラを開くたびに切り替わることがある.
        # お手本と違う写り方のまま動かすと, 学習と別の画像を見せることになる
        # (082645 は dy=+37.5 のまま実機を動かした. その 1 分前のドライラン 082512 は dy=-7.8).
        # アームは HOME に置いた状態で, 1 枚目を お手本の 1 枚目 (同じく HOME) と比べる.
        # **この確認が通るまで daemon にも触らない** (アームには何も送らない).
        ref_bgr, ref_path = load_reference(Path(args.raw_dir))
        bgr0 = None
        for _ in range(10):
            _rgb0, bgr0 = grab_rgb(cap)
            if bgr0 is not None:
                break
            time.sleep(0.2)
        if bgr0 is None:
            sys.exit("[ERROR] 上カメラの 1 枚目を撮れない")
        dx, dy, resp = measure_framing(ref_bgr, bgr0)
        verdict, why = framing_verdict(dx, dy, resp)
        print(f"[CAMERA] 写り方 dy={dy:+.1f} dx={dx:+.1f} response={resp:.3f} → {verdict} ({why})")
        print(f"[CAMERA] 基準: {ref_path}")
        log_f.write(json.dumps({"type": "framing", "dy": round(dy, 2), "dx": round(dx, 2),
                                "response": round(resp, 3), "verdict": verdict, "why": why,
                                "max_dy": FRAMING_MAX_DY, "max_dx": FRAMING_MAX_DX,
                                "min_response": FRAMING_MIN_RESPONSE,
                                "ok": verdict == "OK", "ignored": bool(args.ignore_framing),
                                "reference": str(ref_path)}) + "\n")
        log_f.flush()
        if verdict != "OK":
            if not args.ignore_framing:
                sys.exit(f"[ABORT ] 上カメラの写り方が『{verdict}』. アームには何も送らずに終了しました.\n"
                         f"         {why}\n"
                         "         pi05/camera_align.py で合わせ直す "
                         "(iPhone を付け直す / 連係カメラを開き直す).\n"
                         "         この写り方のまま続けるなら --ignore-framing")
            print(f"[WARN  ] 写り方が『{verdict}』だが --ignore-framing が指定されたので続けます")

        # ---- ここから先でアームに触る (写り方の確認を通ったあと) ----
        get_daemon_socket()
        policy = PolicyClient(args.host, args.port)
        print(f"[POLICY] 接続 {policy.uri}  metadata={policy.metadata}")
        rec_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        if args.record:
            notify_recorder(rec_sock, {"type": "trial_start", "run_stem": run_stem})

        q = read_angles()
        if q is None:
            sys.exit("[ERROR] 関節角を読めない (daemon を確認)")
        if np.max(np.abs(q - np.array(HOME))) > 5.0:
            print(f"[WARN  ] HOME から離れています (max|Δ|={np.max(np.abs(q - np.array(HOME))):.1f}°). "
                  "学習データは HOME から始まっています")
            print("         現在角: " + " ".join(f"j{k}={v:+.1f}" for k, v in enumerate(q)))
        if args.execute:
            # 開始時の開放は, 最初に送る目標が検査を通ってからにする (codex R2).
            # 以前はここで開いていたので, 1 チャンク目が安全ガードで止まる場合でも
            # 爪だけ先に開いてしまっていた (物を持っていれば落とす).
            print("[GRIP  ] 開始時のグリッパー開放は, 最初の目標が検査を通ってから行います "
                  "(爪が閉じていたら手で開けておく)")

        for i in range(args.max_chunks):
            q = read_angles()
            if q is None:
                print("[ERROR] 関節角を読めない (daemon を確認). 停止"); exit_code = 1; break
            rgb = bgr_small = None
            for _ in range(10):
                rgb, bgr_small = grab_rgb(cap)
                if rgb is not None:
                    break
                time.sleep(0.2)
            if rgb is None:
                print("[ERROR] 上カメラの映像が途切れた (iPhone のスリープ等). 停止")
                exit_code = 1; break
            state = np.concatenate([q, [float(grip)]]).astype(np.float32)
            t0 = time.time()
            out = policy.infer({"observation/image": rgb, "observation/state": state, "prompt": args.prompt})
            latency = time.time() - t0
            acts = np.asarray(out["actions"], dtype=float)
            target, grip_cmd, used = plan_chunk(acts, q, grip, args.steps_per_chunk)
            target, notes = apply_limits(target, q, lo, hi, args.max_move_deg)
            delta = target - q

            cv2.imwrite(str(log_dir / "frames" / f"{i:04d}.jpg"), bgr_small)
            rec = {"chunk": i, "t": time.time(), "latency_s": round(latency, 3), "state": state.tolist(),
                   "actions": acts.tolist(), "used_step": used, "target": target.tolist(),
                   "grip_cmd": grip_cmd, "notes": notes, "executed": False}
            gtxt = "" if grip_cmd is None else ("  グリッパー→閉" if grip_cmd == 1 else "  グリッパー→開")
            print(f"[{i:03d}] 推論 {latency*1000:.0f}ms  {used + 1}ステップ先  Δ="
                  + " ".join(f"{d:+5.1f}" for d in delta) + gtxt)
            for n in notes:
                print(f"       [LIMIT] {n}")

            # 送る直前の最終検査 (codex R1 / C2). 送信にもグリッパー操作にも入らず止める.
            # HOME 復帰 (h) だけはこの検査を通さずに送れる (範囲の外にいるアームを戻す手段).
            unsafe = check_send_safe(target, lo, hi)
            if unsafe:
                rec["unsafe"] = unsafe
                rec["envelope"] = {"lo": [round(float(v), 2) for v in lo],
                                   "hi": [round(float(v), 2) for v in hi]}
                for u in unsafe:
                    print(f"       [ABORT] {u}")
                print("[STOP  ] 安全でない目標のため, 送らずに停止します "
                      "(現在角が安全範囲の外にあると, 移動量の制限で範囲の外に戻る)")
                # 記録は入力より前に書いて flush する (codex C2-1: 入力待ちや HOME 復帰中の
                # Ctrl-C でこのチャンクの unsafe / envelope が消えないように).
                log_f.write(json.dumps(rec) + "\n"); log_f.flush()
                exit_code = 1
                if args.execute and not args.auto:
                    ans = input("       h=HOMEに戻して終了 / 他=そのまま終了 > ").strip().lower()
                    if ans == "h":
                        ok_home, _ = _send_and_wait_arrival(HOME, "pi05_home", 2.5)
                        log_f.write(json.dumps({"chunk": i, "type": "home_return", "t": time.time(),
                                                "home_requested": True,
                                                "home_arrived": bool(ok_home)}) + "\n")
                        log_f.flush()
                else:
                    print("         アームを HOME に置き直してからやり直してください")
                break

            if args.execute:
                if not args.auto:
                    ans = input("       Enter=実行 / s=送らず次へ / h=HOMEに戻して終了 / q=終了 > ").strip().lower()
                    if ans == "q":
                        log_f.write(json.dumps(rec) + "\n"); break
                    if ans == "h":
                        ok_home, _ = _send_and_wait_arrival(HOME, "pi05_home", 2.5)
                        rec["home_requested"] = True
                        rec["home_arrived"] = bool(ok_home)
                        log_f.write(json.dumps(rec) + "\n"); break
                    if ans == "s":
                        log_f.write(json.dumps(rec) + "\n"); continue
                if not grip_opened:
                    # 開始時の開放はここで 1 度だけ (写り方の確認と目標の検査を通り, 送ると決めてから)
                    print("[GRIP  ] 開始時にグリッパーを開く")
                    daemon_set_gripper(0)
                    time.sleep(GRIPPER_SLEEP)
                    grip_opened = True
                    rec["initial_gripper_open"] = True
                if np.max(np.abs(delta)) > 0.5:
                    ok, _ = _send_and_wait_arrival(target.tolist(), f"pi05_chunk{i:03d}", 3.0)
                    rec["arrived"] = bool(ok)
                    if not ok:
                        print("       [WARN] 未到達. j4 の発熱などを確認してください")
                        if args.auto:
                            exit_code = 1
                            log_f.write(json.dumps(rec) + "\n"); break
                if grip_cmd is not None:
                    if grip_cmd == 1:
                        daemon_set_gripper_value(GRIP_VALUE)
                    else:
                        daemon_set_gripper(0)
                    time.sleep(GRIPPER_SLEEP)
                    grip = grip_cmd
                rec["executed"] = True
            log_f.write(json.dumps(rec) + "\n"); log_f.flush()
    except KeyboardInterrupt:
        print("\n[STOP  ] Ctrl-C")
    finally:
        # finally ではアームを動かさない (HOME 復帰もサーボ解放もしない). 止まった姿勢は
        # そのまま保つ: 未知の姿勢から勝手に動かす方が危ない. 戻すときは h で明示的に送る.
        if args.record and rec_sock is not None:
            notify_recorder(rec_sock, {"type": "trial_end", "run_stem": run_stem})
        if not log_f.closed:
            log_f.close()
        if cap is not None:
            cap.release()
        if policy is not None:
            policy.close()
        try:
            close_daemon_socket()
        except Exception:
            pass
        print(f"[DONE  ] 記録: {log_dir}")
    # 終了コードは正常に抜けた経路でだけ表示する (sys.exit で抜ける場合は, その [ABORT] /
    # [ERROR] の文言が出て終了コード 1 になるので, ここで 0 と書くと食い違う).
    if exit_code:
        print(f"[DONE  ] 終了コード {exit_code} (安全停止 / 途中のエラー)")
    return exit_code


if __name__ == "__main__":
    sys.exit(main())
```

上カメラの位置合わせの画面 `camera_align.py`（commit 05e1b8b）です。

```
#!/usr/bin/env python3
"""camera_align.py — 上カメラの写り方をお手本に合わせる画面 (Mac 側・アームは動かさない).

上カメラの iPhone は普段使いのもので, 毎回付け外しする. 付けるたびに写り方が変わり,
2026-10-21 の実機では お手本より下に大きくずれたまま動かしてしまった
(runs/pi05_policy/pi05_20261021_082645 は dy=+37.5. 1 分前のドライランは dy=-7.8 で正常).
iPhone を付けたあと, この画面で写り方を合わせてから実機に進む.

画面:
  ライブ映像に 基準画像 (--raw-dir の最初のエピソードの 1 枚目・HOME の姿勢) を半透明で重ねる.
  隅に写り方のずれ (dx, dy) と相関の強さ (response) を出し, 判定を大きく表示する:
    OK       しきい値以内
    ZURE     dx か dy がしきい値の外 (= ずれ)
    NO MATCH 相関が弱く dx/dy が当てにならない (= 測れない)
  q または Esc で終了. **表示だけで, ファイルには何も書かない.**

run_policy_client.py は開始時に この measure_framing / framing_verdict で同じ検査をして,
OK 以外ならアームに何も送らずに終了する (--ignore-framing で続行).

前提:
  - 上カメラ (iPhone 連係) が見えている. アームは HOME に置いておく (基準画像が HOME の姿勢)

Usage:
  RAW=/Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_teach_v1_trim2/raw_episodes
  python3 pi05/camera_align.py --raw-dir $RAW
  python3 pi05/camera_align.py --raw-dir $RAW --alpha 0.7 --scale 2   # 基準を濃く / 画面を小さく
"""
import argparse
import sys
import time
from pathlib import Path

import cv2
import numpy as np

_HERE = Path(__file__).resolve().parent
_ROOT = _HERE.parent
_PLACE = _ROOT / "dynamic_tracking_limits" / "place" / "place_modules"   # camera_resolver はここ
for p in (_HERE, _ROOT, _PLACE):
    sys.path.insert(0, str(p))

import camera_resolver  # noqa: E402

IMG_LONG = 384            # build_demo_episodes.py / run_policy_client.py と同じ (学習画像の長辺)
FRAMING_MAX_DY = 20.0     # |dy| がこれを超えたら「ずれ」. 下の実測値の間を取った
FRAMING_MAX_DX = 20.0     # |dx| の上限 (codex R2). お手本の dx は +0.00..+7.23 (2026-10-21 実測)
# response (相関の強さ) がこれ未満なら, dx/dy を信用できないので「測れない」として止める (codex R1).
# 2026-10-21 実測: 正しく対応している比較は 0.411..1.000.
# 無関係な画像は ランダム 0.0375 / 真っ黒 0.0000, 10/17 の 222723 の 1 枚目は 0.0505
# (dy=+8.2 / dx=-2.5 なので, 相関を見ないと「OK」で通ってしまう).
FRAMING_MIN_RESPONSE = 0.20
WINDOW = "camera_align (q で終了)"


def to_small_bgr(frame):
    """学習画像と同じ大きさに縮める (run_policy_client.grab_rgb と同じ処理)."""
    h, w = frame.shape[:2]
    s = IMG_LONG / max(h, w)
    return cv2.resize(frame, (round(w * s), round(h * s)), interpolation=cv2.INTER_AREA)


def load_reference(raw_dir: Path):
    """基準画像 = --raw-dir の最初のエピソードの 1 枚目 (HOME の姿勢). 戻り値: (BGR 画像, パス)."""
    eps = sorted(p.parent for p in raw_dir.glob("*/episode.npz"))
    if not eps:
        sys.exit(f"[ERROR] お手本が見つからない (基準画像を決められない): {raw_dir}")
    frames = sorted((eps[0] / "frames").glob("*.jpg"))
    if not frames:
        sys.exit(f"[ERROR] お手本の画像が無い: {eps[0]}")
    bgr = cv2.imread(str(frames[0]))
    if bgr is None:
        sys.exit(f"[ERROR] 基準画像を読めない: {frames[0]}")
    return bgr, frames[0]


def measure_framing(ref_bgr, cur_bgr):
    """写り方のずれを測る. 戻り値: (dx, dy, response). cv2.phaseCorrelate + ハニング窓.

    2026-10-21 実測 (基準 = teach_v1 の run_0001_20261019_183454 の 1 枚目):
      お手本 191257   dy= +9.1  / お手本 195120 dy= -6.7   ← ブロックの位置で揺れる範囲
      ドライラン 082512 dy= -7.8                            ← お手本と同じ写り方. 通す
      実機 082645       dy=+37.5                            ← 下にずれた写り方. 止める
    dx はブロックの位置で ±6 ほど動く (お手本どうしで +5.0 / +5.8) ので判定には使わず, 表示だけ.
    """
    a = cv2.cvtColor(ref_bgr, cv2.COLOR_BGR2GRAY).astype(np.float32)
    b = cv2.cvtColor(cur_bgr, cv2.COLOR_BGR2GRAY).astype(np.float32)
    if a.shape != b.shape:
        b = cv2.resize(b, (a.shape[1], a.shape[0]), interpolation=cv2.INTER_AREA)
    win = cv2.createHanningWindow((a.shape[1], a.shape[0]), cv2.CV_32F)
    (dx, dy), response = cv2.phaseCorrelate(a, b, win)
    return float(dx), float(dy), float(response)


def framing_verdict(dx, dy, response):
    """写り方の判定. 戻り値: (verdict, 理由). verdict は "OK" / "ずれ" / "測れない".

    相関が弱い (response が低い) ときは dx/dy 自体が当てにならないので,
    「ずれ」ではなく「測れない」として扱う (既定ではどちらも止める).
    """
    if not all(np.isfinite(v) for v in (dx, dy, response)):
        return "測れない", "dx / dy / response に非有限値"
    if response < FRAMING_MIN_RESPONSE:
        return "測れない", (f"相関が弱く dx/dy が当てにならない "
                            f"(response={response:.3f} < {FRAMING_MIN_RESPONSE:.2f})")
    bad = []
    if abs(dy) > FRAMING_MAX_DY:
        bad.append(f"|dy|={abs(dy):.1f} > {FRAMING_MAX_DY:.0f}")
    if abs(dx) > FRAMING_MAX_DX:
        bad.append(f"|dx|={abs(dx):.1f} > {FRAMING_MAX_DX:.0f}")
    if bad:
        return "ずれ", " / ".join(bad)
    return "OK", (f"|dy|<={FRAMING_MAX_DY:.0f} / |dx|<={FRAMING_MAX_DX:.0f} / "
                  f"response>={FRAMING_MIN_RESPONSE:.2f}")


def open_top_camera():
    cams = camera_resolver.resolve_cameras(require_top=True, require_side=False, verbose=False)
    cap = cv2.VideoCapture(cams["top"])
    if not cap.isOpened():
        sys.exit("[ERROR] 上カメラを開けない")
    t0 = time.time()
    while time.time() - t0 < 8.0:           # 連係カメラは映像が来るまで数秒かかることがある
        ok, f = cap.read()
        if ok and f is not None:
            return cap
        time.sleep(0.2)
    cap.release()
    sys.exit("[ERROR] 上カメラから映像が来ない. iPhone のロック解除・連係カメラの接続を確認 "
             "(Photo Booth の『カメラ』メニューに iPhone が出るか)")


def draw_overlay(small_bgr, ref_bgr, dx, dy, resp, alpha, scale):
    ref = ref_bgr
    if ref.shape[:2] != small_bgr.shape[:2]:
        ref = cv2.resize(ref, (small_bgr.shape[1], small_bgr.shape[0]), interpolation=cv2.INTER_AREA)
    view = cv2.addWeighted(small_bgr, 1.0 - alpha, ref, alpha, 0)
    big = cv2.resize(view, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST)
    verdict, _why = framing_verdict(dx, dy, resp)
    # cv2.putText は日本語を出せないので画面はローマ字. 端末には日本語で出す.
    label = {"OK": "OK", "ずれ": "ZURE", "測れない": "NO MATCH"}[verdict]
    color = (0, 200, 0) if verdict == "OK" else (0, 0, 255)
    cv2.putText(big, label, (16, 56), cv2.FONT_HERSHEY_SIMPLEX, 1.8, color, 4, cv2.LINE_AA)
    cv2.putText(big, f"dy={dy:+6.1f}  dx={dx:+6.1f}  (OK: both <= {FRAMING_MAX_DY:.0f})", (16, 92),
                cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2, cv2.LINE_AA)
    cv2.putText(big, f"resp={resp:.3f}  (OK: >= {FRAMING_MIN_RESPONSE:.2f})   q: quit", (16, 116),
                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (220, 220, 220), 1, cv2.LINE_AA)
    return big


def main():
    ap = argparse.ArgumentParser(description="上カメラの写り方をお手本に合わせる (アームは動かさない・表示だけ)")
    ap.add_argument("--raw-dir", required=True,
                    help="基準画像に使う学習エピソード (必須. 最初の 1 本の 1 枚目を基準にする)")
    ap.add_argument("--alpha", type=float, default=0.5, help="基準画像の重ね具合 (0=ライブのみ / 1=基準のみ)")
    ap.add_argument("--scale", type=float, default=3.0, help="画面の拡大倍率")
    args = ap.parse_args()

    ref_bgr, ref_path = load_reference(Path(args.raw_dir))
    print(f"[REF   ] 基準画像: {ref_path}")
    print(f"[ALIGN ] |dy| <= {FRAMING_MAX_DY:.0f} なら OK. アームは HOME に置いた状態で合わせる. "
          "q または Esc で終了 (ファイルには何も書かない)")
    cap = open_top_camera()
    last = None
    try:
        while True:
            for _ in range(2):            # バッファに溜まった古いフレームを捨てる
                cap.grab()
            ok, frame = cap.read()
            if not ok or frame is None:
                if cv2.waitKey(100) & 0xFF in (ord("q"), 27):
                    break
                continue
            small = to_small_bgr(frame)
            dx, dy, resp = measure_framing(ref_bgr, small)
            cv2.imshow(WINDOW, draw_overlay(small, ref_bgr, dx, dy, resp, args.alpha, args.scale))
            if last is None or abs(dy - last) > 1.0:      # 端末は値が動いたときだけ出す
                verdict, why = framing_verdict(dx, dy, resp)
                print(f"[ALIGN ] dy={dy:+6.1f}  dx={dx:+6.1f}  response={resp:.3f}  "
                      f"→ {verdict} ({why})")
                last = dy
            if cv2.waitKey(30) & 0xFF in (ord("q"), 27):
                break
    except KeyboardInterrupt:
        print("\n[STOP  ] Ctrl-C")
    finally:
        cap.release()
        cv2.destroyAllWindows()
        print("[DONE  ] 終了 (何も書いていません)")


if __name__ == "__main__":
    main()
```

お手本を作る `build_demo_episodes.py` の、teach_v1_trim2 を作った版（commit 80932d1）です。

```
#!/usr/bin/env python3
"""build_demo_episodes.py — run_pick_place の記録から π0.5 学習用エピソードを作る (Mac 側・段階1).

入力 (1 試行 = 1 run_stem):
  runs/run_pick_place/{run_stem}/{run_stem}.json      判定 (judgments.pick/place.human_verdict)
  runs/run_pick_place/{run_stem}/recording/states.csv  actual (実測6軸) / gripper_cmd / stage 行
  runs/run_pick_place/{run_stem}/recording/top.mp4 + top_frame_log.csv  上カメラ
  (recorder.py --top と run_pick_place.py --record-demo で記録したもの)

出力 (1 エピソード = 1 フォルダ):
  datasets/{DATASET}/raw_episodes/{run_stem}/
    frames/000000.jpg ...   上カメラ (長辺 IMG_LONG px, 縦横比維持)
    episode.npz             t[N], state[N,7], actions[N,7]   (7 = j0..j5 [deg] + gripper 0/1)
    meta.json
  datasets/{DATASET}/index.json   採用/不採用とその理由

設計:
  - 時間軸は FPS (10Hz) で並べ直す.
  - state: 実測角 (約3Hz) を線形補間. gripper は指令した瞬間で 0→1 / 1→0 に切替.
  - action: 0.1 秒後の state (絶対角). π0.5 は action chunk でこれを予測する.
  - 停止区間 (動き < IDLE_EPS_DEG が IDLE_MAX_SEC 超) は先頭 IDLE_KEEP_SEC だけ残して詰める.
    検出・VLM・人の入力待ちを「待つ動作」として学習させないため.
  - --trim-mid-idle を付けると、上の処理で残った停止区間もさらに先頭
    MID_IDLE_KEEP_STEPS だけ残して詰める (DAY288. mid_idle_keep_mask を参照).
    このとき 関節 6 列の action を残ったステップで作り直し、t を等間隔に振り直して
    元の時刻を t_orig に残す. オプション未指定時の出力は従来と同一.
  - グリッパー切替ステップの前後 (i-1, i, i+1) は どちらの停止詰めでも必ず残す.
  - 採用条件: pick と place の人の判定がどちらも yes (既定). VLM 判定は使わない.

Usage:
  python3 pi05/build_demo_episodes.py                # 2026-10-15 以降の全試行
  python3 pi05/build_demo_episodes.py --since 20261020 --dataset mecharm_redblock_box_scripted_v1
  python3 pi05/build_demo_episodes.py --run run_0001_20261015_180000 --force
  python3 pi05/build_demo_episodes.py --dataset mecharm_redblock_box_teach_v1_trim \
      --trim-mid-idle --since 20261019   # 途中の停止を先頭2ステップまで詰める
"""
import argparse
import csv
import json
import shutil
import sys
from pathlib import Path

import cv2
import numpy as np

DATA_ROOT = Path("/Volumes/KIOXIA/r2r2r-data")
RUNS_ROOT = DATA_ROOT / "runs" / "run_pick_place"
DEFAULT_DATASET = "mecharm_redblock_box_scripted_v1"
TASK = "put the red block in the white box"
FPS = 10
IMG_LONG = 384            # 保存画像の長辺 px. openpi 側で 224x224 に resize_with_pad される
JPEG_QUALITY = 95
IDLE_EPS_DEG = 0.3        # 1 ステップでの最大関節変化がこれ未満なら「停止」
IDLE_MAX_SEC = 2.0        # これより長い停止区間は詰める
IDLE_KEEP_SEC = 1.0       # 詰めるときに残す長さ
# --trim-mid-idle (DAY288) 用. 既定 (オプション未指定) では一切使わない。
MID_IDLE_EPS_DEG = 0.3    # 6 関節すべての |action - state| がこれ未満 かつ
                          # グリッパーの action == state なら「停止ステップ」
MID_IDLE_KEEP_STEPS = 2   # 連続する停止区間で残す先頭ステップ数
# codex レビュー R1: 1 ステップの変化だけで見ると「0.2°ずつ動き続ける区間」も
# 停止として削れてしまう。区間の先頭 state からのずれがこれを超えたら区間を切る。
MID_IDLE_DRIFT_DEG = 0.5
GRIPPER_GUARD_STEPS = 1   # グリッパー切替ステップ i の前後 i-1, i, i+1 を必ず残す
ANGLE_ABS_MAX = 200.0     # 実測値のサニティ (これを超えたら読み取り異常として捨てる)
MIN_ACTUAL_SAMPLES = 20

# LOG352 (2026-10-19): 試行の状態で採否を決める。
# 人の yes/yes だけでは「爪が開いたか不明な試行」を弾けない
# (codex R3 A9)。record_teach_demo.py は
#   result: completed / aborted / interrupted / error
#   gripper_state_uncertain: True (gripper の指令失敗 or 開いたか確認できなかった)
# を試行 JSON に残すので、それを見て除外する。
#
# OK_RESULTS に "completed_with_failures" を入れているのは **既存データを
# 落とさないため**。run_pick_place.py はステージ単位の失敗があっても完走すると
# この値を入れる。2026-10-19 実測で、mecharm_redblock_box_scripted_v1 の
# 採用 20 本のうち **15 本が completed_with_failures** だった
# (残り 5 本が completed)。人の判定は 20 本すべて yes/yes。
# "completed" だけに絞ると既存データセットが 20 本 -> 5 本に減ってしまう。
# run_pick_place.py 側の失敗は stage_failures に残り、最終的な採否は
# 人の判定が正である、という既存の運用をそのまま維持する。
OK_RESULTS = ("completed", "completed_with_failures")
# 古い試行 JSON には result が無いことがある。その場合は従来どおり
# 人の yes/yes だけで決める (後から基準を変えて過去を落とさない)。


def ensure_ssd():
    """KIOXIA のマウントを確認する (codex レビュー R5).

    DATA_ROOT.exists() だけでは、SSD 未マウントのまま /Volumes/KIOXIA/... が
    ローカルのディレクトリとして存在する場合を見抜けず、SSD だと思って
    内蔵ディスクへ書いてしまう。マウントポイント自体を is_mount() で見る。
    """
    mount = Path("/Volumes/KIOXIA")
    if not mount.is_mount():
        sys.exit(f"[ABORT] KIOXIA not mounted: {mount}")
    if not DATA_ROOT.exists():
        sys.exit(f"[ABORT] data root not found: {DATA_ROOT}")


def load_states(path):
    actual_t, actual_q, grip_t, grip_s = [], [], [], []
    with path.open(newline="") as f:
        for row in csv.DictReader(f):
            ev = row.get("event_type")
            try:
                ts = float(row["ts"])
            except Exception:
                continue
            if ev == "actual":
                try:
                    q = [float(row[f"j{i}"]) for i in range(6)]
                except Exception:
                    continue
                if any(abs(v) > ANGLE_ABS_MAX for v in q):
                    continue
                actual_t.append(ts); actual_q.append(q)
            elif ev == "gripper_cmd":
                try:
                    grip_t.append(ts); grip_s.append(1.0 if int(float(row["gripper_state"])) == 1 else 0.0)
                except Exception:
                    pass
    return (np.array(actual_t), np.array(actual_q, dtype=np.float64).reshape(-1, 6),
            np.array(grip_t), np.array(grip_s))


def drop_spikes(t, q, max_jump_deg=40.0):
    """前後どちらとも max_jump_deg 以上離れた孤立点 (読み取り異常) を捨てる."""
    if len(t) < 3:
        return t, q
    keep = np.ones(len(t), dtype=bool)
    for i in range(1, len(t) - 1):
        a = np.max(np.abs(q[i] - q[i - 1])); b = np.max(np.abs(q[i] - q[i + 1]))
        c = np.max(np.abs(q[i + 1] - q[i - 1]))
        if a > max_jump_deg and b > max_jump_deg and c < max_jump_deg:
            keep[i] = False
    return t[keep], q[keep]


def load_frame_log(path):
    idx, ts = [], []
    with path.open(newline="") as f:
        for row in csv.DictReader(f):
            idx.append(int(row["frame_idx"])); ts.append(float(row["capture_ts"]))
    return np.array(idx), np.array(ts)


def judge(run_json):
    j = json.loads(run_json.read_text())
    jd = j.get("judgments") or {}
    pick_h = (jd.get("pick") or {}).get("human_verdict")
    place_h = (jd.get("place") or {}).get("human_verdict")
    return pick_h, place_h, j


def trial_state_reject_reason(j):
    """試行の状態から「学習に使えない理由」を返す. 使えるなら None (LOG352).

    - gripper_state_uncertain が真 -> 爪が開いた/閉じたかが不明。
      state[:, 6] のラベルが正しいと言えないので使わない。
    - result がある かつ OK_RESULTS に無い -> 中断した試行。
    - result が無い (古い試行 JSON) -> 従来どおり人の判定だけで決める。
    """
    if j.get("gripper_state_uncertain"):
        return "gripper_state_uncertain"
    res = j.get("result")
    if res is not None and res not in OK_RESULTS:
        return f"result={res}"
    return None


def _recording_disabled(run_dir):
    """試行 JSON が recording_enabled=False を明示しているか（LOG352）.

    読めない・キーが無い場合は False（従来どおり扱う）。
    """
    p = run_dir / f"{run_dir.name}.json"
    try:
        return json.loads(p.read_text()).get("recording_enabled") is False
    except Exception:
        return False


def gripper_switch_indices(state):
    """グリッパーが切り替わるステップの添字 (新しい値が最初に現れる添字) を返す."""
    if len(state) < 2:
        return np.empty(0, dtype=int)
    return np.flatnonzero(state[1:, 6] != state[:-1, 6]) + 1


def gripper_guard_mask(state):
    """グリッパー切替ステップ i の前後 (i-1, i, i+1) を True にしたマスク (codex R2).

    切替ステップそのものは `action[6] != state[6]` なので停止判定には入らないが、
    **切替の次のステップ (i, i+1)** は「関節が止まっていてグリッパーも変わらない」
    ステップなので停止として削除され得る。爪が閉じた/開いた直後の画像と state が
    消えると、グリッパーを動かす手がかりが学習データから落ちる。
    """
    n = len(state)
    guard = np.zeros(n, dtype=bool)
    for i in gripper_switch_indices(state):
        lo = max(0, i - GRIPPER_GUARD_STEPS)
        hi = min(n, i + GRIPPER_GUARD_STEPS + 1)
        guard[lo:hi] = True
    return guard


def mid_idle_keep_mask(state, actions):
    """停止区間を先頭 MID_IDLE_KEEP_STEPS だけ残す keep マスクを返す (DAY288).

    既存の「停止区間を詰める」処理 (IDLE_MAX_SEC=2.0 超) では、お手本の
    1.5〜2 秒の停止 (19〜20 ステップ) が閾値のすぐ下に収まって残っていた。
    π0.5 の action_horizon は 10 (1 秒) で停止より短いため、停止中は入力が
    変わらず「止まる」しか出せない → 実機でブロック真上から動かなくなる
    (記録: runs/pi05_policy/pi05_20261021_082645)。

    停止ステップの定義:
      - 6 関節すべてで |action - state| < MID_IDLE_EPS_DEG
      - かつ グリッパーの action と state が同じ

    codex レビュー R1: 上の条件は「1 ステップの変化」しか見ないので、
    0.2°ずつ動き続ける区間 (ゆっくりした動き) も停止と判定されてしまう。
    そこで停止区間の中でも、**区間の先頭 state からのずれ**が 6 関節のどれかで
    MID_IDLE_DRIFT_DEG を超えたら、そこで区間を切って新しい区間として数え直す。
    こうするとゆっくり動く区間は短い区間の連続になり、ほぼ削られない。

    グリッパー切替ステップの前後は gripper_guard_mask で必ず残す (codex R2)。
    先頭・末尾のステップも明示的に残す (エピソード両端の state を変えない)。
    """
    n = len(state)
    joint_still = np.max(np.abs(actions[:, :6] - state[:, :6]), axis=1) < MID_IDLE_EPS_DEG
    grip_same = actions[:, 6] == state[:, 6]
    idle = joint_still & grip_same

    keep = np.ones(n, dtype=bool)
    i = 0
    while i < n:
        if not idle[i]:
            i += 1
            continue
        # i から始まる停止区間を、先頭 state からのずれで切りながら進む
        anchor = i
        kept_in_region = 0
        while i < n and idle[i]:
            if np.max(np.abs(state[i, :6] - state[anchor, :6])) > MID_IDLE_DRIFT_DEG:
                anchor = i              # ここから新しい区間として数え直す
                kept_in_region = 0
            if kept_in_region < MID_IDLE_KEEP_STEPS:
                kept_in_region += 1     # 区間の先頭 MID_IDLE_KEEP_STEPS は残す
            else:
                keep[i] = False
            i += 1

    keep |= gripper_guard_mask(state)
    if n:
        keep[0] = True
        keep[-1] = True
    return keep


def build_one(run_dir, out_dir, args):
    stem = run_dir.name
    rec = run_dir / "recording"
    run_json = run_dir / f"{stem}.json"
    # LOG352: まず試行 JSON を読み、記録なしで走らせた試行をはっきり弾く。
    # record_teach_demo.py は --no-record で走らせると recording_enabled=False を残す
    # (段階C の検証はこれで走らせる)。映像が無いのでそもそもエピソードを作れない。
    # --include-failed でも迂回させない (分析用でも映像なしでは作れない)。
    if not run_json.exists():
        return {"run": stem, "used": False, "reason": f"missing:{run_json.name}"}
    try:
        trial = json.loads(run_json.read_text())
    except Exception as e:
        return {"run": stem, "used": False,
                "reason": f"run_json 読めない:{type(e).__name__}"}
    if trial.get("recording_enabled") is False:
        return {"run": stem, "used": False, "reason": "no_recording"}
    # LOG352 (codex R6 M3): グリッパーの開放確認ができない状態で取った試行を
    # **独立のゲート**で弾く。`gripper_state_uncertain` は「走行中に不明だった」
    # 試行しか捕まえられず、起動時に daemon が gv を読めなかった試行
    # (gripper_check.verified=false) は取りこぼす。
    # ABORT_IF_FIRST_OPEN_UNKNOWN を True へ戻し忘れたまま記録した場合の保険。
    # --include-failed でも迂回させない。キーが無い旧試行は従来どおり扱う。
    gc = trial.get("gripper_check")
    if isinstance(gc, dict) and gc.get("verified") is False:
        return {"run": stem, "used": False, "reason": "gripper_not_verified"}

    need = [rec / "states.csv", rec / "top.mp4", rec / "top_frame_log.csv"]
    missing = [p.name for p in need if not p.exists()]
    if missing:
        return {"run": stem, "used": False, "reason": "missing:" + ",".join(missing)}

    pick_h, place_h, trial = judge(run_json)
    if not args.include_failed and not (pick_h == "yes" and place_h == "yes"):
        return {"run": stem, "used": False, "reason": f"human_verdict pick={pick_h} place={place_h}"}
    # LOG352: 人の判定が yes/yes でも、試行の状態が不明/中断なら使わない
    if not args.include_failed:
        bad = trial_state_reject_reason(trial)
        if bad:
            return {"run": stem, "used": False, "reason": f"trial_state {bad}"}

    at, aq, gt, gs = load_states(rec / "states.csv")
    if len(at) < MIN_ACTUAL_SAMPLES:
        return {"run": stem, "used": False, "reason": f"actual 実測が少ない ({len(at)})"}
    order = np.argsort(at); at, aq = at[order], aq[order]
    at, aq = drop_spikes(at, aq)
    fidx, fts = load_frame_log(rec / "top_frame_log.csv")
    if len(fts) < FPS:
        return {"run": stem, "used": False, "reason": f"top フレームが少ない ({len(fts)})"}

    t0, t1 = max(fts[0], at[0]), min(fts[-1], at[-1])
    if t1 - t0 < 3.0:
        return {"run": stem, "used": False, "reason": "記録の重なりが短い"}
    t = np.arange(t0, t1, 1.0 / FPS)

    q = np.stack([np.interp(t, at, aq[:, k]) for k in range(6)], axis=1)
    g = np.zeros(len(t))
    if len(gt):
        go = np.argsort(gt); gt, gs = gt[go], gs[go]
        for i, ti in enumerate(t):
            k = np.searchsorted(gt, ti, side="right") - 1
            g[i] = gs[k] if k >= 0 else 0.0
    state = np.concatenate([q, g[:, None]], axis=1).astype(np.float32)
    actions = np.concatenate([state[1:], state[-1:]], axis=0)

    # 停止区間を詰める
    motion = np.max(np.abs(actions - state), axis=1)
    keep = np.ones(len(t), dtype=bool)
    i, idle_trim_steps = 0, 0
    while i < len(t):
        if motion[i] < IDLE_EPS_DEG:
            j = i
            while j < len(t) and motion[j] < IDLE_EPS_DEG:
                j += 1
            if (j - i) / FPS > IDLE_MAX_SEC:
                cut_from = i + int(IDLE_KEEP_SEC * FPS)
                keep[cut_from:j] = False
                idle_trim_steps += j - cut_from
            i = j
        else:
            i += 1
    # codex レビュー R2: グリッパー切替の前後 (i-1, i, i+1) はこの既存処理でも残す。
    guard = gripper_guard_mask(state)
    idle_trim_steps -= int((~keep & guard).sum())
    keep |= guard
    t, state, actions = t[keep], state[keep], actions[keep]

    # 途中の停止を縮める (--trim-mid-idle のときだけ). 既定では何もしない。
    steps_before_mid_trim = int(len(t))
    mid_idle_trimmed_steps = 0
    if args.trim_mid_idle:
        mkeep = mid_idle_keep_mask(state, actions)
        mid_idle_trimmed_steps = int((~mkeep).sum())
        t, state, actions = t[mkeep], state[mkeep], actions[mkeep]
        # codex レビュー R3: 削ったあとは「0.1 秒後の state」が隣のステップに
        # なっていないので、関節 6 列の action を残ったステップで作り直す。
        # グリッパー列 (actions[:, 6]) は元の指令のまま触らない。
        actions = actions.copy()
        actions[:-1, :6] = state[1:, :6]
        actions[-1, :6] = state[-1, :6]

    # 各ステップに最も近い上カメラのフレーム (frames は残したステップ分だけ書き出す)
    nearest = np.clip(np.searchsorted(fts, t), 1, len(fts) - 1)
    left = fts[nearest - 1]; right = fts[nearest]
    nearest = np.where(np.abs(t - left) <= np.abs(right - t), nearest - 1, nearest)
    want = {int(fidx[n]): [] for n in nearest}
    for step, n in enumerate(nearest):
        want[int(fidx[n])].append(step)

    if out_dir.exists():
        if not args.force:
            return {"run": stem, "used": True, "reason": "既存 (スキップ・--force で再生成)",
                    "steps": int(len(t))}
        shutil.rmtree(out_dir)
    (out_dir / "frames").mkdir(parents=True)

    cap = cv2.VideoCapture(str(rec / "top.mp4"))
    fi, written, max_need = 0, 0, max(want)
    size = None
    while fi <= max_need:
        ok, frame = cap.read()
        if not ok:
            break
        if fi in want:
            h, w = frame.shape[:2]
            s = IMG_LONG / max(h, w)
            small = cv2.resize(frame, (round(w * s), round(h * s)), interpolation=cv2.INTER_AREA)
            size = small.shape[1], small.shape[0]
            for step in want[fi]:
                cv2.imwrite(str(out_dir / "frames" / f"{step:06d}.jpg"), small,
                            [cv2.IMWRITE_JPEG_QUALITY, JPEG_QUALITY])
                written += 1
        fi += 1
    cap.release()
    if written != len(t):
        shutil.rmtree(out_dir)
        return {"run": stem, "used": False,
                "reason": f"フレーム抽出不足 written={written} steps={len(t)} (mp4 と frame_log の不一致)"}

    if args.trim_mid_idle:
        # codex レビュー R4: 詰めたあとの t は実時刻のままだと飛びがあり、
        # 「FPS 10 の等間隔」という前提と食い違う。等間隔に振り直し、
        # 元の時刻は t_orig に残す (どの瞬間を取ったか後から追えるように)。
        np.savez_compressed(out_dir / "episode.npz",
                            t=(np.arange(len(t)) / FPS).astype(np.float64),
                            t_orig=t - t[0], state=state, actions=actions)
    else:
        np.savez_compressed(out_dir / "episode.npz", t=t - t[0], state=state, actions=actions)
    meta = {
        "run_stem": stem, "task": TASK, "fps": FPS, "steps": int(len(t)),
        "duration_sec": round(len(t) / FPS, 1),
        "idle_trimmed_sec": round(idle_trim_steps / FPS, 1),
        "trim_mid_idle": bool(args.trim_mid_idle),
        "steps_before_mid_trim": steps_before_mid_trim,
        "mid_idle_trimmed_steps": mid_idle_trimmed_steps,
        "image_size": size, "state_dim": 7,
        "state_names": ["j0", "j1", "j2", "j3", "j4", "j5", "gripper"],
        "action": "absolute target = state 0.1s later",
        "actual_samples": int(len(at)), "gripper_cmds": int(len(gt)),
        "human_verdict": {"pick": pick_h, "place": place_h},
    }
    (out_dir / "meta.json").write_text(json.dumps(meta, indent=2, ensure_ascii=False))
    return {"run": stem, "used": True, "reason": "ok", "steps": int(len(t)),
            "idle_trimmed_sec": meta["idle_trimmed_sec"],
            "steps_before_mid_trim": steps_before_mid_trim,
            "mid_idle_trimmed_steps": mid_idle_trimmed_steps}


def assert_trim_target_is_new(ds):
    """--trim-mid-idle の出力先が「既存の非 trim データセット」なら ABORT (codex R6).

    `--dataset mecharm_redblock_box_teach_v1 --trim-mid-idle` のように入力と同じ名前を
    渡すと、お手本データそのものを詰めた版で上書きしてしまう (frames も作り直され、
    元の 10Hz の記録が復元できなくなる)。
    既に全エピソードが trim_mid_idle=true で作られているデータセットは、
    作り直し (--force) を通すため許可する。
    """
    metas = sorted((ds / "raw_episodes").glob("*/meta.json"))
    if not metas:
        return
    not_trimmed = [p.parent.name for p in metas
                   if json.loads(p.read_text()).get("trim_mid_idle") is not True]
    if not_trimmed:
        sys.exit(
            f"[ABORT] --trim-mid-idle の出力先が既存の非 trim データセットです: {ds}\n"
            f"        trim_mid_idle でないエピソード {len(not_trimmed)} 本 "
            f"(例: {', '.join(not_trimmed[:3])})\n"
            f"        元データを上書きしないよう、--dataset に新しい名前を指定してください。")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dataset", default=DEFAULT_DATASET)
    ap.add_argument("--since", default="20261015", help="run_stem の日付 (YYYYMMDD) 以降")
    ap.add_argument("--run", action="append", help="特定の run_stem だけ (複数可)")
    ap.add_argument("--include-failed", action="store_true", help="人の判定 no も含める (分析用)")
    ap.add_argument("--force", action="store_true", help="既存エピソードを作り直す")
    ap.add_argument("--trim-mid-idle", action="store_true",
                    help="途中の停止区間を先頭 %d ステップだけ残して詰める (既定: しない)"
                         % MID_IDLE_KEEP_STEPS)
    args = ap.parse_args()
    ensure_ssd()

    ds = DATA_ROOT / "datasets" / args.dataset
    if args.trim_mid_idle:
        assert_trim_target_is_new(ds)   # codex R6: 元データの上書きを防ぐ
    out_root = ds / "raw_episodes"
    out_root.mkdir(parents=True, exist_ok=True)
    runs = sorted(p for p in RUNS_ROOT.glob("run_*") if p.is_dir())
    if args.run:
        runs = [p for p in runs if p.name in set(args.run)]
    else:
        runs = [p for p in runs if p.name.split("_")[2] >= args.since]
        # LOG352 (codex R5 K3-a): top.mp4 が無い試行は対象から外すのが既定だが、
        # **recording_enabled=False を明示している試行だけは残す**。
        # こうしないと --no-record で走らせた試行が build_one に届かず、
        # index.json に no_recording の理由が残らない。
        runs = [p for p in runs
                if (p / "recording" / "top.mp4").exists()
                or _recording_disabled(p)]

    results = []
    for r in runs:
        try:
            res = build_one(r, out_root / r.name, args)
        except Exception as e:
            res = {"run": r.name, "used": False, "reason": f"exception:{type(e).__name__}:{e}"}
        results.append(res)
        flag = "OK " if res["used"] else "-- "
        print(f"[{flag}] {res['run']}  {res.get('steps', '')}  {res['reason']}")

    index_path = ds / "index.json"
    old = json.loads(index_path.read_text()) if index_path.exists() else {}
    for res in results:
        old[res["run"]] = res
    index_path.write_text(json.dumps(old, indent=2, ensure_ascii=False))
    used = [v for v in old.values() if v.get("used")]
    print(f"\n採用エピソード合計: {len(used)}  総ステップ: {sum(v.get('steps', 0) for v in used)}"
          f"  → {out_root}")


if __name__ == "__main__":
    main()
```


## 次は、移動量の上限を全関節同じ割合で縮め、持ち上げのところをお手本と比べる

次にやることは3つです。

1. 移動量の上限を、関節ごとに切るのではなく、全関節を同じ割合で縮めるように直す。関節どうしの動きの割合を、お手本のまま保つため（実機を動かすコードなので、Claude Code が実装し、codex がレビューする）
2. 持ち上げの場面で、予測の手首 j4 がお手本からずれていないかを、答え合わせのスクリプトで場面ごとに見る
3. 学習前の点検で、位置を土台の角度だけでなく、上カメラで見たブロックの位置でも分ける。同じ向きで距離が違う位置（AとB）を、別々に数えるため

まだ確かめていないことも残っています。つかみ損ねた原因が、位置AとBの間にブロックを置いたことなのか、0.5 秒ずつ動かしたことなのかは、切り分けられていません。写り方の判定のしきい値も、手元の数枚で決めたものです。
