# 小さな会社のロボットはなぜ確実に動くのか ― MicroFactory の LLM と π0.5 の使い分け

- 記録: LOG545（考察記事）
- 公開: 2026/11/21
- 記事のページ: https://pixelstomotors.com/record/why-microfactory-robots-are-reliable-llm-and-pi05
- サイト: Pixels to Motors（ADAPT DESIGN / 島津 栄一） https://pixelstomotors.com/
- 要約: MicroFactory の組み立てロボットが確実に動くのは、作業ごとに手段を選ぶから。位置が決まる作業は LLM がコードと治具を書き、柔らかい物は π0.5 を人が直して約20分で学び直す。mechArm の記録のずれも測った。

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

---

**サンフランシスコの MicroFactory が、電子部品の組み立てロボットで高い確実さを出せているのは、1つの賢い AI に任せず、作業ごとに一番確実な手段を選んでいるからだった。** 位置が決まる作業は Anthropic の Claude Opus などの LLM（文章や言葉を扱う大きな AI）が画像認識と制御のコードと治具（物を決まった位置に固定する道具）を書き、配線のような柔らかい物は Physical Intelligence の π0.5（ロボット用の AI モデル）を人が直して約20分で学習し直す。

創業者 Igor Kulakov さんのポッドキャスト・研究ブログ・LinkedIn の動画を読み解いて、次のことが手に入った。

- 小さなチームがロボットの確実さを上げるときの、見る順番。モデルの賢さより先に、作業の切り分け・治具・データのそろい方を見る
- 自分の mechArm 270 の記録に同じ見方を当てた結果。学習に使ったお手本1309ステップのうち633ステップが、関節の値を読めなかった0.25秒を超える抜けを直線でつないだ値だった。カメラの映像は、関節より約70〜80ミリ秒遅れていた
- 測るまでの手間の小ささ。今ある記録を読むだけの依頼を Claude Code に渡し、測り終えるまで12分だった。アームは一度も動かしていない

きっかけは、ロボティクスの起業家に話を聞くポッドキャスト [22Astronauts の Ep 104「How to Train 99.9% Reliable Robots for $5」](https://www.youtube.com/watch?v=aoBAdHjOhLM)の文字起こしだった。Igor さんは、ゲーム作りと写真用の照明の会社を経て、2024年に MicroFactory を立ち上げた人だ。話の中で、強化学習（ロボットに試行錯誤させて覚えさせる学び方）は組み立てでは部品もロボットも壊すから使わない、人が直した動きで学習し直す、学習し直しは1回約5ドル、と語っていた。

MicroFactory の名前は前から知っていて、半年ほど前から注目していた。このプロジェクトでも、失敗した区間を巻き戻して人が直す方式を、10月に MicroFactory を参考に取り入れている。今回は、その中身をもう一段深く知りたくて、Claude（Anthropic の AI）と一緒に、ポッドキャスト、[研究ブログ「Steps towards continual learning」](https://research.microfactory.com/)、[Founders, Inc. の紹介動画](https://www.youtube.com/watch?v=DhcWVqxF_wo)、[Igor さんの LinkedIn の投稿](https://www.linkedin.com/in/igor-kulakov-364a1553/recent-activity/all/)を順に読んだ。

読み進めるうちに、見立てが2回変わった。1回目は、モデルを小さくして安くしていると思っていたのが、中身は π0.5 そのものを手直しして使っていると分かったとき。2回目は、1か月前に「最先端の LLM に全面的に切り替えた」という投稿を見つけ、人が直して学習し直す方式をやめたのかと思ったら、柔らかい物の担当として残っていたと字幕で分かったとき。

| 何を | なぜ | 分かったこと |
|---|---|---|
| ポッドキャストの文字起こしを読む | MicroFactory が何をしている会社かをつかむ | 人が直して学習し直すループを、安く何度も回すことが強み |
| 直しのデータの雑さを考える | 学習し直すたびに誤差がたまる話が気になった | カメラの時刻合わせ・遠隔操作の機材の精度・制御の間隔が土台 |
| 自分の記録で時刻のずれを測る（依頼249） | 同じ土台が mechArm にあるか | お手本の約半分が、長い抜けを直線でつないだ関節の値だった |
| 研究ブログを読む | 細かい手順と数字を確かめる | 巻き戻し・差分で直す・1:4に縮める。モデルは小さくなかった |
| 紹介動画と LinkedIn の動画を見る | 今の製品の形を知る | 1か月前から LLM がコードと治具を書く形へ。π0.5 は柔らかい物の担当 |
| 字幕を読む | 映像だけでは話の中身が分からない | π0.5 の学習は12時間が20分、推論の機械は4,000ドルが500ドル |


## 作業ログ ― Claude との対話を、そのまま残す

ここから下は、対話の全量です。私の発言を引用で、Claude の答えを本文で載せています。各節の頭の太字の一文は、その節で Claude が答えようとした問いです。記事化の段取りのやり取りと、本題と関係ない話は外しました。指すものが前後を読まないと分からない私の短い発言は、引用にせず、何を聞いたかを地の文で書いています。Claude の答えの中の太字と出典の書き込みは、記事の決まりに合わせて外しました。Claude の答えの中で私の名前を呼んでいた所は、言い換えています。

ポッドキャスト・研究ブログ・動画の中身は、Claude が日本語でまとめたもので、元の英語の文をそのまま訳したものではありません。数字は元の資料のとおりです。MicroFactory の数字は MicroFactory 自身が出したもので、同じ条件で他社と比べたかは確かめられていません。

### この記事に出てくる言葉

| 言葉 | ふだんの言葉で言うと |
|---|---|
| [MicroFactory](https://microfactory.com/) | サンフランシスコの会社。2本のアームが入った箱型の組み立てセルを作っている |
| LLM | 文章や言葉を扱う大きな AI。ここでは Claude Opus など、コードも書ける AI を指す |
| [π0.5](https://www.physicalintelligence.company/blog/pi05) | Physical Intelligence が公開した、画像と言葉の指示からロボットの動きを出す AI モデル。このプロジェクトでは mechArm 270 に学習させている |
| VLA | 画像と言葉を見てロボットの動きを出す AI モデルの種類。π0.5 もこれ |
| DAgger | ロボットを動かし、間違えたら人が操作を取って直し、直した動きで学習し直す方法 |
| 強化学習 | ロボットに試行錯誤させ、うまくいった動きを覚えさせる学び方 |
| 遠隔操作（テレオペ） | ロボットと同じ形の小さな腕などを人が動かし、ロボットにまねさせること |
| 治具 | 物を決まった位置に固定する道具。位置が決まれば、ロボットの仕事が簡単になる |
| [Jetson](https://developer.nvidia.com/embedded/jetson-orin-nano-developer-kit) | NVIDIA の小さな AI 用コンピューター。Jetson Orin Nano は数万円台 |
| 推論 | 学習を終えた AI を、実際に動かすこと |
| 補間 | 抜けた所の値を、前後の値をつないで埋めること |

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


## ポッドキャストの文字起こしから、MicroFactory の話の全体をつかむ

（このとき、22Astronauts の Ep 104 の文字起こしのファイルを渡し、何を話しているのかを聞いた。文字起こしでは名前が「Seagar」と聞き取られていたので、ゲストが Igor Kulakov さんだと伝えて直してもらった）

**— このポッドキャストでは、何が話されているか。**

ポッドキャスト「22 Astronauts」の約1時間のインタビューです。ゲストは MicroFactory の創業者で、電子部品を組み立てる双腕ロボットのセルを作り、最終的には「自律工場」を目指しています。

前半：経歴

- ウクライナ出身。子どもの頃から望遠鏡やピンボール台を自作していた。
- 学生時代に SNS 向けアプリを作り、1日100万人以上が使った。その後インディーゲームを約15本作ったが、ヒットは続かなかった。
- ウェディング写真向けの照明機材の会社を約9年経営し、黒字にした。ただ、市場が東欧の好みに偏っていて、伸びが頭打ちになった。
- ChatGPT や自動運転を見て、サンフランシスコへ移住。

後半：技術の話（中心）

- 出発点：照明の事業で組み立て作業に苦労した自分の経験。ほかの会社でも組み立てが必要なのは明らかなので、「需要があるか」より「技術ができるか」が本当のリスクだと考えた。
- 最初の作例：アクセラレーター Founders Inc. の知人が設計したフォトフレームの組み立てを自動化した。まだ失敗も多かったが、その動画が拡散して資金調達につながった。
- 大手の AGI ラボとの違い：大手は「確実さや精度は10年後に解ければいい」という姿勢。自分たちは今の現場で使える確実さ（99.9%）を優先している。
- 強化学習を使わない理由：組み立て作業で強化学習をやると、部品もロボットも壊れてしまう。
- 代わりのやり方（DAgger の改良版）：ロボットを動かし、間違えたら人が操作を取って直し、それで学習し直す。これを繰り返して、ほぼ100%の確実さに近づけた。
- 支える仕組み：
  - 制御のプログラムは Rust で書いている
  - カメラ同士のタイミングを合わせている
  - 遠隔操作の機材の精度を高めている
  - モデルを小さくして Jetson Nano で動かし、学習し直しは1回約5ドル
- SO-100 から出発：最初は SO-100 を使った。安いモーターは2個1組で使ってガタ（バックラッシュ）を消すなど、かなり手を入れている。
- 現状：お客さんへの出荷が始まっていて、順番待ちの人もいる。研究の詳細を microfactory.com のリサーチブログで公開予定。
- 大事にしていること：デモで終わらず、費用に見合う効果（投資対効果のプラス）が最初から出ること。遠隔操作に頼らず、手元の小さな GPU で推論するので、10〜100倍安くできると話している。

締めの言葉は、「うまくいかないのは自分のせいではなく、環境のせいかもしれない。成長できる場所へ移ろう」でした。

このプロジェクトの研究に近い点が2つあります。

- 「失敗したら人が直して学習し直す」流れは、ゲームパッドで mechArm を手で直す道具（LOG419）と同じ考え方です。
- SO-100 を改造して出発した点も、SO-101 の系列と重なります。

記事や X で取り上げる材料になりそうです。

補足。「モデルを小さくして」は、この時点の Claude の読み方で、あとで研究ブログと動画を読んで直すことになる。ポッドキャストでは「squeeze（絞った）」と言っていただけで、何を絞ったのかまでは話していなかった。


## 人が直して学習し直すループの、どこが大事か

（ここで、上の答えのうち「代わりのやり方」と「支える仕組み」の2つ、それと「遠隔操作に頼らず、手元の小さな GPU で推論する」所が大事な情報だと伝えた）

**— 人が直して学習し直すループの中で、本当に大事なのはどこか。**

大事なのは、ここが本当のポイントだからです。この会社の強みはモデルの性能ではなく、「人が直す → 学習し直す」をとにかく安く、何度も回せることにあります。

つながりで読むと

- 1回5ドルで学習し直せるから、人が直すたびにすぐ学習し直せる。直す回数が多いほど確実さが上がる。
- 学習し直しを安くするために、モデルを小さくして Jetson Nano に載せている。
- 何度も学習し直すと誤差がたまるので、それを防ぐためにカメラのタイミング合わせ、遠隔操作の機材の精度、Rust で書いた制御がある。直すときのデータが雑だと、学習し直すたびに悪くなるからです。
- 「遠隔操作に頼らない」というのは、運用中は人が操作しないという意味です。人が出てくるのは、間違いを直すときだけ。

このプロジェクトの研究との違い

- 今の研究室は、π0.5 という大きなモデルをクラウド GPU（Runpod）で回すやり方です。こちらは、小さなモデルを手元で何度も学習し直すやり方。目指すものが「できることの広さ」か「1つの作業の確実さ」かで、そもそも逆の設計です。
- ゲームパッドで直す道具（LOG419）と、成功/失敗の判定の表がそろっています。あとは「直したデータで学習し直す」をつなげれば、同じ形の仕組みが小さく試せそうです。

具体的な中身（モデルの大きさ、直すデータの集め方など）は、研究ブログ（microfactory.com）に書かれているそうです。

補足。「そもそも逆の設計」という見立ては、このあと研究ブログと字幕を読んで外れる。MicroFactory も π0.5 を使っていて、違いはモデルの大きさではなく、学習し直す単位の小ささと、機械に合わせた軽くし方だった。


## 学習し直しを安くするために、推論を手元の機械で済ませる

（ここで、学習し直しを安くするためにモデルを小さくして Jetson Nano に載せている所も大事だと伝えた）

**— 推論と学習し直しを小さな機械で済ませると、何が変わるか。**

小さいモデルにすると、良いことが一度にいくつも起きます。

- 学習し直しが安い：1回5ドルなら、毎日でも学習し直せます。
- 推論が手元で済む：クラウドの料金がかからず、通信の遅れもありません。現場のネットが切れても止まりません。
- 機械1台あたりが安い：GPU は Jetson Nano 程度で足ります。何台も入れても採算が合います。

つまり、確実さと費用に見合う効果（投資対効果のプラス）の両方を、「モデルを小さくする」という1つの決断で取っています。「1つの作業に絞るなら、大きなモデルはいらない」という割り切りです。

今の時点で運用に耐える落とし所の、まさに実例だと思います。大手が汎用の大きなモデルで攻めるなかで、小さな会社が勝てる場所を示しています。記事や動画にするときの切り口になります。

補足。ここでも「モデルを小さくする」と書いているが、あとで分かった実際は、π0.5 並みの大きさのモデルを量子化などで軽くして Jetson Orin Nano で動かす形だった。「1つの作業に絞るなら、大きなモデルはいらない」という割り切りは、半分だけ当たっていた。絞っているのはモデルの大きさではなく、1回に学習し直す範囲（作業の1区間と、数本の直し）だった。


## 直しのデータが雑だと、学習し直すたびに悪くなる

（ここで、何度も学習し直すと誤差がたまるので、カメラの時刻合わせや遠隔操作の機材の精度や Rust の制御で防いでいる、という所は、本気で参考にしたいと伝えた）

**— MicroFactory がデータのノイズを防いでいる所を、mechArm の環境に置き換えると、何を測ればいいか。**

ここは、この環境に置き換えると「まず測るべきこと」が3つになります。

1. カメラの映像と関節の角度、時刻がずれていないか
   - iPhone の映像は Iriun でネット越しに来るので、遅れも揺らぎもあるはずです。
   - 1コマごとの映像の時刻と、同じ瞬間の関節の角度の時刻がどれだけずれているかを測ります。
   - ずれていると、モデルは「この絵のときにこの動き」を1テンポずれて覚えます。
2. 直したときの指令と、実際に動いた角度が合っているか
   - ゲームパッドで直したとき、送った角度と実際に届いた角度の差を見ます。mechArm はガタも遅れもあるので、差は出るはずです。
   - 学習に使うのは「送った指令」か「届いた角度」か、どちらかに決めておきます。混ざっているとデータが雑になります。
   - MicroFactory も、安いモーターを2個1組で使ってガタを消すところから始めています。
3. 制御の1回の間隔がそろっているか
   - 今は Python から SSH 越しに動かしています。1回ごとの間隔のばらつきを測ります。
   - Rust を使う狙いは、この間隔を毎回そろえることです。測ってばらつきが小さければ、書き直す必要はありません。

それと、もう1つ。直したデータには「人が直した区間」の印を付けておくこと。DAgger のやり方では、ロボットが間違えた場面と、人が直した動きを組にすることが大事だからです。

どれも、新しく何かを作る前に今の記録で測れるものです。最初の一手としては、Claude Code に「1と3を今の録画と記録で測る」ことを頼むのが早いと思います。

補足。2つ目の「送った指令か届いた角度か」は、このあとの依頼249で、学習データを作るコードを読んで答えが出た。関節の値は届いた角度（実測）を時刻でつないだもの、爪だけは送った指令だった。


## Claude Code に、今ある記録だけで時刻のずれと制御の間隔を測ってもらう（依頼249）

1と3を測る依頼文を作ってもらい、Claude Code に作業を渡す「依頼箱」（iCloud のフォルダに依頼の Markdown を置くと、Mac の見張り係が Claude Code に渡して、報告を書き戻す仕組み）に置いた。依頼文を作る前に、Claude は直近の実機推論の記録（`states.csv`・`top_frame_log.csv`・`top_meta.json`）を開き、記録の形を確かめている。そのとき、直近の1本では、映像が狙いの10fps に対して実際は8.7fps、関節を読む間隔が約7.9回/秒で、読み取りの失敗が11回あった。

この節を作っている間に、制御の1回の間隔をそろえるのは、データを組にするときに問題が出ないようにするための考えだね、と伝えた。Claude は、研究ブログでも Rust を使う理由をガベージコレクション（プログラムが使い終わったメモリを片付けるために、ときどき処理が止まること）による止まりがないことと書いていて、まさにその話だと答えた。

**— 今ある録画と記録だけで、映像と関節の時刻のずれと、制御の間隔はどのくらいか。**

### 依頼249 の依頼文（依頼箱に置いたもの）

```markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 90
---
# 録画と記録から「映像と関節の時刻のずれ」と「制御の1回の間隔」を測る（依頼249・読むだけ）

人が直したデータで何度も学習し直すとき、データの雑さ（時刻のずれ・間隔のばらつき）は学習し直すたびに積み重なる（MicroFactory の研究ブログより）。補正データで学習し直す前に、今の mechArm の記録がどのくらいそろっているかを、すでにある記録だけで測ってほしい。**アームは動かさない。新しく撮らない。**

## 使う記録（読むだけ）
- 学習に使ったお手本：`/Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_split10_v2/raw_episodes/`（全エピソード）
- 実機推論の記録：`/Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/` の直近20本（`recording/` の `states.csv`・`top_frame_log.csv`・`top_meta.json`・`currents.csv` と、`log.jsonl`）
- 補正（ゲームパッド）で作ったお手本があれば、それも同じように測る（どのフォルダかはコードと記録から探し、見つけた場所を報告に書く）

## 測ること
1. 映像と関節の時刻のずれ
   - 1コマごとに、映像の時刻（capture_ts）といちばん近い関節の読み値（actual）の時刻の差。中央値・95%点・最大
   - 映像のコマ間隔と、関節を読む間隔。それぞれ狙いの値（target_fps など）と実際の値、ばらつき（中央値・95%点・最大）、読み取りの失敗の数
   - 学習データを作るとき、コードが1コマにどの関節の値を組にしているか（いちばん近い・直前・補間など）をコードを読んで確かめ、そのやり方で実際に何秒ずれた組になっているかを出す
   - カメラ自体の遅れの見積もり：動き出しの場面で、映像のコマ間の差（動きの量）と関節の速さの時刻を突き合わせ、映像が何秒遅れているかを推定する。推定のやり方と確からしさも書く
2. 制御の1回の間隔
   - 指令を送った間隔（ts_send）、送ってから届くまで（ts_send→ts_arrival）、サーボを読むのにかかった時間、推論1回の待ち（log.jsonl の latency_s）。それぞれ中央値・95%点・最大
   - 間隔が大きく空いた所（中央値の2倍を超える所）の数と、どの段階（つかむ前・つかんだ後など）で起きているか
3. お手本と実機推論で、上の数字に違いがあるか

## 置き場所
- 測るスクリプト：`/Users/shimazueiichi/r2r2r-scripts/diag/` に1本（例 `measure_timing_alignment.py`）。git に個別に add して commit する
- 出力（CSV・図・まとめの md）：`/Volumes/KIOXIA/r2r2r-data/diag/timing_249/`（ensure_ssd_mounted() で確かめてから書く。未マウントなら止めて報告）

## 絶対にしないこと
- 実機・サーボへの接続と指令は一切しない
- `runs/`・`datasets/` の既存ファイルの書き換え・移動・削除はしない（読むだけ）
- `git add .`・`git clean` は使わない

## 報告に書くこと
- 上の 1〜3 の表（お手本と実機推論を分けて）
- 学習データでの組み方と、そのずれの大きさ
- 見つかった問題を「学習データが雑になるもの」から順に3つまで。直し方の案は書いてよいが、直すのはしない
- 最後の1行に「判定：合格／止めた（決めてほしいことあり）／失敗」
```

依頼箱に置いてから12分で、Claude Code が測り終えた。アーム・サーボには一度もつないでいない。

### 依頼249 の報告（Claude Code）

```markdown
# 結果：20261121_249_録画と記録で時刻のずれと制御の間隔を測る

- 状態：完了
- 始めた時刻：2026-11-21 20:47
- 終わった時刻：2026-11-21 20:59（12分）
- 作業フォルダ：/Users/shimazueiichi/r2r2r-scripts
- この続きを Claude Code で話すとき：作業フォルダで `claude --resume 4af09f9d-4a21-41cb-8b61-f9630684c415`
- 止められた操作：1件（いちばん下に一覧）

## Claude Code の報告

## やったこと

依頼249の内容を、すでにある記録を読むだけで測りました。アーム・サーボ・daemon には一度もつないでいません。`runs/` と `datasets/` の既存ファイルも書き換えていません。

測った記録は次の3組です。
- **お手本**：split10_v2 の10本。元の記録は `runs/run_pick_place/<run>/recording`。
- **実機推論**：`runs/pi05_policy` の直近20本（pi05_20261114_182327 〜 pi05_20261119_200424）。
- **補正お手本**：ゲームパッドで補正した run は全部で25本ありました。このうち学習データ `datasets/mecharm_redblock_box_corr_v5` に入っている4本（pi05_20261106_183926・184452・184650・184906）を測りました。元の記録は `runs/pi05_policy/<run>`。

学習データでの組み方は、`build_demo_episodes.py` と `build_correction_episodes.py` を読んで確かめました。そのとおりに組を作り直すと、14本すべてでエピソードの関節の値と差0.0°で一致しました。

## 結果

値は「中央値 / 95%点 / 最大」です。

**1. 映像と関節の時刻のずれ（記録そのもの）**

| 項目 | お手本 | 実機推論 | 補正お手本 |
|---|---|---|---|
| 1コマと、いちばん近い関節の読み値の時刻差 | 99 / 2565 / 3020 ms | 28 / 1036 / 3172 ms | 25 / 62 / 1060 ms |
| コマ間隔（狙い） | 指定なし（約30fps） | 10fps | 10fps |
| コマ間隔（実際） | 33 / 37 / 196 ms | 102 / 134 / 252 ms | 102 / 134 / 3326 ms |
| 関節を読む間隔（狙い） | 3Hz ＋記録用 最大10Hz | 10Hz | 10Hz |
| 関節を読む間隔（実際） | 120 / 304 / 6052 ms | 93 / 204 / 6422 ms | 98 / 109 / 3429 ms |
| 読み取りの失敗 | 0 | 461 | 0 |
| カメラ自体の遅れ（映像と関節の速さの突き合わせ） | 70 / 86 / 90 ms | 80 / 100 / 100 ms | 60 / 69 / 70 ms |

- カメラの遅れは34本すべてで 40〜100ms に入り、相関係数は 0.65〜0.89 でした。
- 別のやり方（動き出しの瞬間を1件ずつ比べる）では中央値が 52〜90ms でした。ただし1件ごとの誤差が ±100〜170ms あるので、目安にとどまります。

**学習データでの組み方とずれ**
- 組み方は、10Hz の時刻の並びを置き、そこに次を組にするものです。
  - 関節：実測の線形補間（補正お手本は、0.25秒を超える抜けを「速度20の直線」で埋める）
  - 爪：その時刻までの最後の指令
  - 画像：撮った時刻がいちばん近いコマ
- 画像と関節の時刻の差：お手本 13 / 17 / 21 ms、補正お手本 30 / 63 / 3135 ms。
- 補間に使った2つの実測の間隔：お手本 244ms / 2.0s / 6.1s、補正お手本 96 / 228 / 3350 ms。
- お手本では、1309ステップのうち633ステップが0.25秒を超える抜けをまたいで補間されていました。このうち586ステップは、その間に0.5°を超えて動いています。補正お手本は691ステップ中26ステップでした。
- 補間でどれだけ角度がずれるかを、密に読めている実機推論の記録で模擬しました。送るたびに1.04秒読めなかったことにすると、誤差は 1.3 / 5.4 / 9.4° でした。

**2. 制御の1回の間隔**

| 項目 | お手本 | 実機推論 | 補正お手本 |
|---|---|---|---|
| 指令を送った間隔 | 4.08 / 11.5 / 11.7 s | 0.84 / 4.53 / 50.8 s | 0.54 / 7.61 / 43.9 s |
| 送る命令の往復 | 1.043 / 1.058 / 1.064 s | 0.126 / 0.139 / 0.222 s | 0.034 / 0.138 / 0.142 s |
| 送ってから届くまで | 1.74 / 4.62 / 4.68 s | 1.57 / 7.18 / 10.3 s | 1.76 / 4.59 / 4.88 s |
| サーボを読む時間 | 117 / 124 / 221 ms | 79 / 200 / 2195 ms | 記録なし |
| 推論1回の待ち（latency_s） | — | 0.94 / 2.45 / 3.11 s | 0.63 / 1.73 / 53.0 s |

- 実機推論には「届いた時刻」（ts_arrival）が記録されていません。そこで「送ってから届くまで」は、チャンク1つの実行時間（中継点を含む）で代わりに出しています。
- 補正お手本の4本は11月6日の記録で、電流の記録（サーボを読む時間）を始めた11月7日より前のため空です。

**中央値の2倍を超えて空いた所**（つかむ前 / つかんだ後 / 放した後）

| 種類 | お手本 | 実機推論 | 補正お手本 |
|---|---|---|---|
| 関節の読み | 270 / 124 / 47 | 225 / 251 / 391 | 19 / 22 / 5 |
| 指令 | 10 / 4 / 0 | 42 / 48 / 46 | 18 / 20 / 9 |
| 映像 | 12 / 1 / 0 | 1 / 0 / 0 | 8 / 4 / 0 |

**3. お手本と実機推論の違い**
- お手本は、映像は30fpsで細かい一方、関節を読めるのは平均で約4Hzです。しかも動いている最中に1〜6秒抜けています（送る命令の往復1.04秒と、爪の命令の最中）。
- 実機推論は約10Hzで読めていますが、読み取りの失敗が461回あり、送った直後に最大6.4秒の抜けがあります。
- カメラの遅れ（約70〜80ms）は、どの組でもほぼ同じでした。

**見つかった問題（学習データが雑になるものから順に）**
1. **お手本の関節が、動いている最中の長い抜けを直線で補間した値になっている。** お手本のステップの約半分が該当し、誤差は数度（模擬で95%点5.4°）の見込みです。直し方の案：送る命令の往復の間も別の経路で関節を読む、または速度20の動き方で埋める（補正お手本の speed20 と同じ）。
2. **画像は約70〜80ms 古い瞬間を写しているのに、その補正をしていない。** どの組でも同じで、動いている間は関節の値と画像が食い違います。直し方の案：組を作るとき、画像の時刻から約75msを引いて組にする。
3. **実機推論と補正の記録に抜けがある。** 実機推論では送った直後に最大6.4秒関節の読みが抜け、読み取りの失敗も461回ありました。補正では、補正を始めるときに映像が約3秒止まり、画像が1.8〜3.1秒ずれたステップが3つありました。この3ステップはその間ほぼ動いていない（0.09〜0.26°）ので、影響は小さいです。今後の補正データを作るときに効いてきます。

## 変えたファイル
- `diag/measure_timing_alignment.py`（新規。commit 944d083）
- `logs/20261121_2058.md`（作業サマリー。commit していません）
- 出力：`/Volumes/KIOXIA/r2r2r-data/diag/timing_249/20261121_205633/`（summary.md・CSV・図）
- 途中の試しの出力 `20261121_205323` と `20261121_205354` も同じ場所に残っています。消そうとしましたが削除を止められたので、そのままです。

## 決めてほしいこと
- 上の問題1〜3を直すかどうか、直すならどの案にするか（データの作り方と記録の仕方を変えることになるので、エイイチの判断です）。
- 学習データを作るとき、カメラの遅れ（約75ms）を引いて組にするかどうか。
- 途中の試しの出力2つを消すかどうか。

判定：止めた（決めてほしいことあり）

## 止められた操作

- {"tool_name": "Bash", "tool_use_id": "toolu_01AffHaAfZBb3qAfnuFob21G", "tool_input": {"command": "rm -rf /Volumes/KIOXIA/r2r2r-data/diag/timing_249/20261121_2053* && time python3 diag/measure_timing_alignment.py 2>&1 | grep -E \"WARN|INFO|DONE\"", "timeout": 1200000}}
```

### 依頼249 のまとめ summary.md

```markdown
# 依頼249 映像と関節の時刻のずれ・制御の間隔

作成 2026-11-21T20:58:19 / `diag/measure_timing_alignment.py`

読んだ記録:

- お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_split10_v2/raw_episodes (10 本) ← 元 /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/<run>/recording
- 実機推論: /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy の pi05_20261114_182327 〜 pi05_20261119_200424 (20 本)
- 補正お手本: /Volumes/KIOXIA/r2r2r-data/datasets/mecharm_redblock_box_corr_v5/raw_episodes のうちゲームパッド補正の 4 本 (pi05_20261106_183926, pi05_20261106_184452, pi05_20261106_184650, pi05_20261106_184906) ← 元 /Volumes/KIOXIA/r2r2r-data/runs/pi05_policy/<run>. ゲームパッド補正の run は全部で 25 本

表の値は 中央値 / 95%点 / 最大 (n=数).

## 1. 映像と関節の時刻のずれ (記録そのもの)

| 項目 | お手本 (split10_v2) | 実機推論 (直近20本) | 補正お手本 (corr_v5 のゲームパッド分) |
|---|---|---|---|
| 1コマと最寄りの actual の差 (ms) | 99 / 2565 / 3020 (n=10913) | 28 / 1036 / 3172 (n=12070) | 25 / 62 / 1060 (n=4003) |
| 映像のコマ間隔 狙い | 指定なし (カメラ任せ. 約30fps) | 10.0fps | 10.0fps |
| 映像のコマ間隔 実際 (ms) | 33 / 37 / 196 (n=10903) | 102 / 134 / 252 (n=12050) | 102 / 134 / 3326 (n=3999) |
| 関節を読む間隔 狙い | 本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ) | 記録スレッド 10Hz + 本体の読み (note=main) | 記録スレッド 10Hz + 本体の読み (note=main) |
| 関節を読む間隔 実際 (ms) | 120 / 304 / 6052 (n=1529) | 93 / 204 / 6422 (n=13984) | 98 / 109 / 3429 (n=5414) |
| 読み取りの失敗 (数) / 弾いた値 | 0 / 0 | 461 / 0 | 0 / 0 |
| コマ数 / actual 数 | 10913 / 1539 | 12070 / 14004 | 4003 / 5418 |

## 1b. 学習データでの組のずれ (作り直した格子で)

組み方 (コードで確認): 10Hz の格子 t を置き, state の関節 6 列 = actual の **線形補間** (np.interp) (補正は actual の間が 0.25 秒を超える所を speed20 の直線で埋める), 爪 = その時刻までの最後の指令, 画像 = capture_ts が t に **いちばん近い** コマ (補正は除いた区間のコマを候補から外す).

| 項目 | お手本 (split10_v2) | 補正お手本 (corr_v5 のゲームパッド分) |
|---|---|---|
| ステップ数 | 1309 | 691 |
| 画像の時刻 − state の時刻 の絶対値 (ms) | 13 / 17 / 21 (n=1309) | 30 / 63 / 3135 (n=691) |
| state の時刻と最寄りの実測の差 (ms) | 44 / 153 / 2924 (n=1309) | 17 / 69 / 192 (n=691) |
| 補間に使った 2 つの実測の間 (ms) | 244 / 2031 / 6052 (n=1309) | 96 / 228 / 3350 (n=691) |
| 0.25 秒を超える間をまたいで補間したステップ (うち 0.5° 超動いた) | 633 (586) | 26 (17) |

補間の誤差の見積もり (実機推論 20 本の密な actual で, 送るたびに 1.04 秒 読めなかったことにして線形補間し, 消した実測と比べた. 6 関節の最大誤差): 全体 1.30 / 5.37 / 9.38 (n=8857)°, 前後で 0.5° 超動いた所 1.91 / 5.68 / 9.38 (n=6835)°. 実機推論の 1 回の動きはお手本の区間の動きより小さいので, お手本の誤差はこれより大きくなりうる.

格子の見つけ方の確かめ: エピソードの state と作り直した state の差の最大 = 0.0° (14/14 本で一致を確認. state_match.csv)

## 1c. カメラ自体の遅れの見積もり

やり方 A (動き出し): 関節の速さが 0.8 秒以上 1.0°/秒未満のあと 5.0°/秒を超えた区間 (前後の読みの間 ≤ 0.35 秒) を関節の動き出し (区間の中点) とし, 映像のコマ間差分 (96x54 灰色・1 秒あたり) が直前の止まりの 中央値 + 6.0×MAD を初めて超えたコマ間 (中点) を映像の動き出しとする. 差 = 映像 − 関節 (正 = 映像が遅れる). 1 件ごとの確からしさ = 関節の読みの間の半分 + コマ間隔の半分.

やり方 B (相互相関): 関節の速さと映像の動きの量を 10ms の格子にのせ, −0.3〜+0.6 秒ずらして相関がいちばん高いずれ.

| 項目 | お手本 (split10_v2) | 実機推論 (直近20本) | 補正お手本 (corr_v5 のゲームパッド分) |
|---|---|---|---|
| A: 映像の遅れ (ms) | 52 / 251 / 413 (n=33) | 90 / 738 / 1414 (n=182) | 65 / 134 / 462 (n=51) |
| A: 1件の確からしさ ± (ms) | 144 / 160 / 169 (n=33) | 117 / 182 / 237 (n=182) | 96 / 149 / 155 (n=51) |
| B: 相関の山のずれ (ms) run ごと | 70 / 86 / 90 (n=10) | 80 / 100 / 100 (n=20) | 60 / 69 / 70 (n=4) |
| B: 山の相関係数 | 0.77 / 0.80 / 0.81 (n=10) | 0.80 / 0.88 / 0.89 (n=20) | 0.77 / 0.82 / 0.82 (n=4) |

## 2. 制御の1回の間隔

| 項目 | お手本 (split10_v2) | 実機推論 (直近20本) | 補正お手本 (corr_v5 のゲームパッド分) |
|---|---|---|---|
| 指令を送った間隔 (s) | 4.08 / 11.51 / 11.68 (n=70) | 0.84 / 4.53 / 50.78 (n=767) | 0.54 / 7.61 / 43.92 (n=174) |
| 送る命令の往復 (s) | 1.043 / 1.058 / 1.064 (n=80) | 0.126 / 0.139 / 0.222 (n=787) | 0.034 / 0.138 / 0.142 (n=178) |
| 送ってから届くまで (s) | 1.74 / 4.62 / 4.68 (n=80) | 1.57 / 7.18 / 10.29 (n=336) | 1.76 / 4.59 / 4.88 (n=46) |
| パッドの 1 刻み 送って着くまで (s) | — | 0.40 / 0.63 / 0.73 (n=7) | 0.18 / 1.09 / 1.09 (n=18) |
| サーボを読む時間 (ms) | 117 / 124 / 221 (n=971) | 79 / 200 / 2195 (n=10771) | — |
| 推論 1 回の待ち latency_s (s) | — | 0.94 / 2.45 / 3.11 (n=357) | 0.63 / 1.73 / 52.97 (n=58) |
| 推論の間隔 (s) | — | 2.93 / 8.44 / 39.57 (n=337) | 4.28 / 23.99 / 40.70 (n=54) |

送る・届くの意味: お手本 (split10_v2): stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec) / 実機推論 (直近20本): send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空 / 補正お手本 (corr_v5 のゲームパッド分): send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空

### 中央値の 2 倍を超えて空いた所 (数)

| 組 | 種類 | つかむ前 | つかんだ後 | 放した後 | その他 |
|---|---|---|---|---|---|
| お手本 (split10_v2) | send | 10 | 4 | 0 | 0 |
| お手本 (split10_v2) | actual | 270 | 124 | 47 | 0 |
| お手本 (split10_v2) | frame | 12 | 1 | 0 | 0 |
| 実機推論 (直近20本) | send | 42 | 48 | 46 | 0 |
| 実機推論 (直近20本) | actual | 225 | 251 | 391 | 0 |
| 実機推論 (直近20本) | frame | 1 | 0 | 0 | 0 |
| 補正お手本 (corr_v5 のゲームパッド分) | send | 18 | 20 | 9 | 0 |
| 補正お手本 (corr_v5 のゲームパッド分) | actual | 19 | 22 | 5 | 0 |
| 補正お手本 (corr_v5 のゲームパッド分) | frame | 8 | 4 | 0 | 0 |

(stage 別の内訳は gaps.csv)
```

### 依頼249 の記録ごとの値 per_run.csv

```csv
group,run,frame_dt_n,frame_dt_median,frame_dt_p95,frame_dt_max,actual_dt_n,actual_dt_median,actual_dt_p95,actual_dt_max,n_frames,n_actual,actual_invalid,frame_target,actual_target,read_fail,top_status,frame_actual_abs_n,frame_actual_abs_median,frame_actual_abs_p95,frame_actual_abs_max,servo_read_ms_n,servo_read_ms_median,servo_read_ms_p95,servo_read_ms_max,send_dt_n,send_dt_median,send_dt_p95,send_dt_max,send_rpc_n,send_rpc_median,send_rpc_p95,send_rpc_max,send_to_arrival_n,send_to_arrival_median,send_to_arrival_p95,send_to_arrival_max,latency_n,latency_median,latency_p95,latency_max,infer_dt_n,infer_dt_median,infer_dt_p95,infer_dt_max,send_note,video_frames_read,xcorr_lag_s,xcorr_r,pad_send_to_reach_n,pad_send_to_reach_median,pad_send_to_reach_p95,pad_send_to_reach_max,ts_arrival_recorded
demo,run_0001_20261116_180222,1122,0.03342,0.03719,0.06573,162,0.11963,0.30429,6.04457,1123,163,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1123,0.09504,2.54972,3.01793,103,118.4,123.47,127.9,7,4.09034,10.82786,11.44543,8,1.04255,1.04621,1.0467,8,2.2175,4.40485,4.45,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1123,0.09000000000000036,0.7880607923016535,,,,,
demo,run_0001_20261116_180445,1104,0.03332,0.03728,0.06009,155,0.11992,0.30405,6.04355,1105,156,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1105,0.09845,2.55525,3.01952,98,118.2,125.325,130.3,7,4.08986,10.57814,11.51193,8,1.04525,1.05788,1.0603,8,1.725,4.5808,4.627,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1105,0.07000000000000034,0.7802649002528331,,,,,
demo,run_0001_20261116_180649,1122,0.03342,0.03757,0.1279,161,0.11851,0.30707,6.04544,1123,162,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1123,0.09677,2.544,3.01139,102,116.4,123.15,140.3,7,4.09218,10.50245,11.52796,8,1.03675,1.05401,1.0586,8,2.2,4.4374,4.513,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1123,0.07000000000000034,0.7751209512608864,,,,,
demo,run_0001_20261116_180850,1143,0.03332,0.03779,0.19222,169,0.11996,0.30651,6.03369,1144,170,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1144,0.09272,2.53694,3.01635,107,117.5,125.62,176.5,7,4.06425,10.60146,11.67613,8,1.03945,1.04504,1.0457,8,2.3785,4.6566,4.679,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1144,0.08000000000000035,0.7700236423093899,,,,,
demo,run_0001_20261116_181120,1065,0.03341,0.03748,0.05794,144,0.11992,0.31026,6.04265,1066,145,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1066,0.10176,2.57081,3.00657,92,119.2,127.285,220.8,7,4.06225,10.47256,11.4965,8,1.04365,1.0458,1.0458,8,1.4225,4.5775,4.63,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1066,0.07000000000000034,0.7515135736717025,,,,,
demo,run_0001_20261116_181313,1055,0.03349,0.03744,0.18812,145,0.11969,0.30717,6.03851,1056,146,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1056,0.10503,2.56577,3.01505,92,115.6,122.535,130.0,7,4.08266,10.49207,11.53185,8,1.0392,1.0576,1.064,8,1.4125,4.6279,4.679,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1056,0.08000000000000035,0.7204701978094449,,,,,
demo,run_0001_20261116_181848,1090,0.03334,0.03673,0.19615,154,0.11908,0.30295,6.04189,1091,155,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1091,0.09629,2.55474,3.01925,98,114.3,123.315,132.8,7,3.96878,10.47026,11.49742,8,1.04365,1.05375,1.0582,8,1.574,4.3057,4.487,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1091,0.06000000000000033,0.7796692120299423,,,,,
demo,run_0001_20261116_182124,1035,0.03343,0.03708,0.04321,138,0.11988,0.30408,6.03025,1036,139,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1036,0.10545,2.57752,3.00803,88,117.45,126.295,127.5,7,4.0692,10.45106,11.46109,8,1.0431,1.04507,1.0456,8,1.242,4.41135,4.474,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1036,0.04000000000000031,0.762386136582991,,,,,
demo,run_0001_20261116_182309,1066,0.03342,0.03692,0.04546,146,0.11985,0.30044,6.05155,1067,147,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1067,0.10098,2.57032,3.0105,93,114.5,122.46,127.7,7,3.97088,10.47322,11.49146,8,1.03785,1.0476,1.0483,8,1.7225,4.30965,4.492,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1067,0.07000000000000034,0.8070792252920239,,,,,
demo,run_0001_20261116_182848,1101,0.03349,0.03693,0.13589,155,0.11942,0.3044,6.04205,1102,156,0,指定なし (カメラ任せ. 約30fps),本体 3.0Hz + 記録スレッド 最大 10.0Hz (本体が眠る間だけ),0,ok,1102,0.09843,2.55944,3.00562,98,117.65,122.58,129.3,7,4.08211,10.45472,11.47919,8,1.0371,1.05873,1.0609,8,1.584,4.4053,4.469,0,,,,0,,,,stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec),1102,0.07000000000000034,0.7740536330316095,,,,,
policy,pi05_20261114_182327,1767,0.10202,0.13412,0.14103,2462,0.08005,0.20396,2.28544,1768,2463,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),28,ok,1768,0.02534,0.09631,1.10489,1652,93.7,198.29,2174.0,229,0.60256,2.10256,4.10448,230,0.125,0.201,0.222,60,2.19043,2.67371,5.32101,60,0.684,1.6585,1.773,59,3.06214,4.19232,6.11924,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,1768,0.08000000000000035,0.8505885284027158,0,,,,0
policy,pi05_20261119_192601,452,0.10226,0.13349,0.16961,560,0.08829,0.19727,2.28985,453,561,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),16,ok,453,0.02831,0.46273,1.11391,429,84.5,197.58,2195.2,30,1.15911,3.10563,5.69881,31,0.118,0.139,0.139,15,1.43747,4.07431,4.37075,16,0.8985,2.3345,2.426,15,2.6156,6.92352,8.23928,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,453,0.08000000000000035,0.869182241979374,0,,,,0
policy,pi05_20261119_192826,633,0.10244,0.13421,0.1604,792,0.09266,0.2179,2.26801,634,793,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),30,ok,634,0.0285,0.19389,1.08212,610,78.7,198.765,2174.4,42,1.33697,3.24344,6.48087,43,0.125,0.139,0.139,22,1.47896,3.33928,4.34177,23,0.941,2.4684,2.559,22,2.57371,5.15405,6.00717,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,634,0.08000000000000035,0.785844857333708,0,,,,0
policy,pi05_20261119_192957,568,0.10242,0.13407,0.1409,624,0.09378,0.21407,6.11986,569,625,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),27,ok,569,0.03224,1.34948,3.02297,484,79.3,215.055,2177.6,32,1.26772,4.91167,7.55999,33,0.13,0.139,0.14,16,1.60301,5.62822,7.17041,17,0.858,2.39,2.482,16,3.13931,7.42701,8.3325,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,569,0.09000000000000036,0.8514094520404635,0,,,,0
policy,pi05_20261119_193141,512,0.10181,0.13419,0.16297,546,0.09365,0.20406,6.29236,513,547,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),26,ok,513,0.02962,1.62825,3.13842,425,87.7,214.54,2173.9,30,1.16047,3.983,7.60119,31,0.126,0.139,0.139,15,1.31803,5.43472,7.57713,16,1.02,2.45975,2.861,15,3.1341,6.38145,8.50846,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,513,0.08000000000000035,0.8578728731637751,0,,,,0
policy,pi05_20261119_193318,894,0.10237,0.13439,0.13971,1104,0.09619,0.10994,2.28769,895,1105,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),15,ok,895,0.0224,0.30466,1.13012,909,77.5,116.12,2175.8,29,1.32,6.9695,50.77811,30,0.12,0.139,0.142,15,1.51187,7.42504,7.64686,17,0.963,2.2656,2.344,16,2.76869,18.72254,39.57101,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,895,0.08000000000000035,0.8268385891447364,6,0.4,0.65,0.73,0
policy,pi05_20261119_193525,493,0.10193,0.13392,0.13955,517,0.09594,0.19838,6.26189,494,518,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),23,ok,494,0.03173,1.6721,3.11604,406,78.8,206.8,2171.7,25,1.39981,5.4239,7.68064,26,0.124,0.139,0.139,13,1.57251,6.01626,7.37395,14,1.0505,2.40275,2.432,13,3.54597,7.24191,8.42816,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,494,0.10000000000000037,0.652803420939721,0,,,,0
policy,pi05_20261119_193737,538,0.10262,0.13429,0.14,517,0.08946,0.21807,6.39357,539,518,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),29,ok,539,0.03356,2.33692,3.14126,404,80.75,215.555,2173.8,29,1.43806,6.52511,8.7797,30,0.138,0.13955,0.14,15,1.52684,7.25527,7.45589,16,0.8855,2.34775,2.476,15,3.12514,8.73093,9.44212,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,539,0.09000000000000036,0.7799718349280266,0,,,,0
policy,pi05_20261119_193903,606,0.10308,0.13434,0.1395,603,0.09598,0.20365,6.28166,607,604,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),37,ok,607,0.03646,2.25574,3.10503,475,78.0,231.99,2193.5,31,1.61847,5.35959,6.61982,32,0.1255,0.139,0.141,16,1.55085,7.1017,7.3184,17,1.122,2.5978,2.701,16,3.67153,8.04832,8.25586,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,607,0.07000000000000034,0.8712350331092845,0,,,,0
policy,pi05_20261119_194048,449,0.1025,0.13395,0.14052,453,0.09454,0.21804,6.42187,450,454,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),28,ok,450,0.03521,1.92955,3.1696,343,80.0,232.94,2173.7,28,1.1296,4.93198,7.65889,29,0.133,0.139,0.139,15,1.551,5.47341,10.2949,16,0.8395,2.37625,2.416,15,2.33674,7.52734,11.25767,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,450,0.09000000000000036,0.8147346935811743,0,,,,0
policy,pi05_20261119_194206,445,0.10232,0.13385,0.13792,529,0.09538,0.2155,2.27147,446,530,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),20,ok,446,0.02383,0.4889,1.11918,414,79.95,197.475,2174.1,28,1.24925,3.36977,5.88013,29,0.125,0.139,0.139,14,1.48479,4.19531,4.52614,15,1.079,2.5085,2.519,14,2.73356,6.54456,6.56117,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,446,0.08000000000000035,0.8775065968252967,0,,,,0
policy,pi05_20261119_194324,553,0.10232,0.13445,0.1517,694,0.09587,0.19474,2.26016,554,695,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),0,top_meta.json なし,554,0.02501,0.3027,1.11929,542,78.1,211.63,2174.6,34,0.99844,3.72739,9.12415,35,0.138,0.139,0.14,17,1.40779,4.01608,4.4432,18,0.8835,2.4327,2.482,17,2.51009,5.00661,5.42185,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,554,0.09000000000000036,0.7862408802267262,0,,,,0
policy,pi05_20261119_195403,560,0.10274,0.13408,0.1393,630,0.09683,0.11195,6.38185,561,631,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),19,ok,561,0.02545,1.60746,3.14109,531,77.6,172.05,2165.7,16,1.15027,8.96017,9.6206,17,0.12,0.1402,0.145,8,2.89547,8.16516,8.55631,9,0.896,2.1608,2.204,8,6.0551,16.63677,20.49532,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,561,0.07000000000000034,0.7497044362021462,0,,,,0
policy,pi05_20261119_195531,510,0.10285,0.13404,0.14042,538,0.09377,0.22112,6.38439,511,539,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),25,ok,511,0.03008,1.67632,3.1716,420,78.4,216.705,2173.3,30,1.47904,4.62843,6.62091,31,0.138,0.139,0.14,16,1.42149,5.21349,7.40198,17,0.921,2.4594,2.521,16,2.58514,6.87093,9.96772,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,511,0.08000000000000035,0.7361399868705103,0,,,,0
policy,pi05_20261119_195712,492,0.10299,0.13469,0.25159,604,0.09152,0.19812,2.29254,493,605,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),20,ok,493,0.02623,0.44232,1.11342,475,78.9,194.69,2174.1,30,1.17165,4.55774,5.52317,31,0.121,0.139,0.139,15,1.51505,4.17274,4.51553,16,1.009,2.351,2.453,15,2.66331,6.43864,6.78403,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,493,0.09000000000000036,0.7062188010211425,0,,,,0
policy,pi05_20261119_195830,270,0.104,0.13416,0.14262,343,0.09344,0.10953,2.25605,271,344,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),5,ok,271,0.02475,0.33811,1.0924,272,78.45,173.87,2159.4,12,1.14021,5.24396,6.51997,13,0.138,0.139,0.139,6,2.78935,4.40771,4.4187,7,0.931,2.1454,2.173,6,4.41672,6.27598,6.57773,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,271,0.08000000000000035,0.8884294259201565,0,,,,0
policy,pi05_20261119_195919,568,0.1035,0.1343,0.13942,555,0.0943,0.2182,6.24168,569,556,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),33,ok,569,0.0333,2.28241,3.08821,435,79.8,219.41,2173.7,31,1.6584,5.59287,7.6623,32,0.124,0.14035,0.145,16,1.50549,7.3018,7.60445,17,1.093,2.256,2.468,16,2.91249,8.49232,9.10415,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,569,0.07000000000000034,0.8021137333924397,0,,,,0
policy,pi05_20261119_200105,473,0.10256,0.13403,0.13942,495,0.09485,0.21222,6.062,474,496,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),29,ok,474,0.03252,1.5904,3.03095,384,78.5,217.665,2178.8,28,1.43971,4.82593,6.68302,29,0.126,0.1402,0.141,14,1.43777,5.63382,7.98929,15,1.09,2.3336,2.356,14,2.59312,7.50805,9.06991,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,474,0.09000000000000036,0.7902747535378862,0,,,,0
policy,pi05_20261119_200220,901,0.10245,0.13442,0.13813,979,0.09752,0.11034,6.34623,902,980,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),33,ok,902,0.02551,1.88013,3.12856,817,76.1,180.44,2174.5,30,1.66816,8.7935,31.02013,31,0.137,0.139,0.14,16,1.49614,8.03378,9.20801,18,1.2515,2.5918,3.112,17,3.90743,12.32254,19.94325,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,902,0.07000000000000034,0.7700115304517208,1,0.1,0.1,0.1,0
policy,pi05_20261119_200424,366,0.10478,0.13442,0.13892,439,0.09553,0.20282,2.25948,367,440,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),18,ok,367,0.03012,0.59066,1.12911,344,78.8,214.27,2173.8,23,1.3189,3.13722,4.68612,24,0.1325,0.13985,0.14,12,1.4402,4.01302,4.5651,13,1.097,2.4118,2.59,12,3.06446,5.11027,5.56048,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,367,0.10000000000000037,0.7966815411045007,0,,,,0
pad_corr,pi05_20261106_183926,1642,0.10226,0.13415,3.32586,2137,0.09964,0.10806,3.42928,1643,2138,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),0,ok,1643,0.02615,0.0489,1.03775,0,,,,52,0.53928,4.19743,43.92175,53,0.034,0.139,0.142,14,1.67081,3.71677,4.63938,17,0.627,11.8292,52.97,16,4.08983,28.27225,40.7031,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,1643,0.06000000000000033,0.7450337547998334,5,0.46,1.084,1.09,0
pad_corr,pi05_20261106_184452,756,0.10226,0.13458,3.15851,1070,0.09592,0.11114,3.26198,757,1071,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),0,ok,757,0.02539,0.08394,1.05297,0,,,,38,0.55598,10.50023,25.49607,39,0.035,0.137,0.137,10,1.86445,4.40584,4.75415,13,0.612,1.5962,1.73,12,5.23663,18.84773,23.92142,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,757,0.07000000000000034,0.8196169972160905,9,0.18,0.738,1.07,0
pad_corr,pi05_20261106_184650,893,0.10277,0.13436,3.22087,1215,0.09762,0.10926,3.32057,894,1216,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),0,ok,894,0.0251,0.07798,1.04825,0,,,,45,0.55223,5.98514,37.15205,46,0.0325,0.137,0.138,12,1.72866,4.17827,4.88175,15,0.774,1.5284,1.541,14,3.94873,20.08006,29.46988,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,894,0.05000000000000032,0.6649647931298412,1,0.16,0.16,0.16,0
pad_corr,pi05_20261106_184906,708,0.1022,0.13432,3.19232,992,0.09612,0.10875,3.35028,709,993,0,10.0fps,記録スレッド 10Hz + 本体の読み (note=main),0,ok,709,0.02271,0.1001,1.05975,0,,,,39,0.48441,7.97084,25.19978,40,0.034,0.1363,0.142,10,1.60572,4.03549,4.43468,13,0.781,1.7814,1.824,12,4.52656,18.15551,19.57102,send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空,709,0.06000000000000033,0.7905153292176227,3,0.17,0.998,1.09,0
```

### 依頼249 のカメラの遅れ（相互相関）camera_lag_xcorr.csv

```csv
group,run,lag_s,r
demo,run_0001_20261116_180222,0.09000000000000036,0.7880607923016535
demo,run_0001_20261116_180445,0.07000000000000034,0.7802649002528331
demo,run_0001_20261116_180649,0.07000000000000034,0.7751209512608864
demo,run_0001_20261116_180850,0.08000000000000035,0.7700236423093899
demo,run_0001_20261116_181120,0.07000000000000034,0.7515135736717025
demo,run_0001_20261116_181313,0.08000000000000035,0.7204701978094449
demo,run_0001_20261116_181848,0.06000000000000033,0.7796692120299423
demo,run_0001_20261116_182124,0.04000000000000031,0.762386136582991
demo,run_0001_20261116_182309,0.07000000000000034,0.8070792252920239
demo,run_0001_20261116_182848,0.07000000000000034,0.7740536330316095
policy,pi05_20261114_182327,0.08000000000000035,0.8505885284027158
policy,pi05_20261119_192601,0.08000000000000035,0.869182241979374
policy,pi05_20261119_192826,0.08000000000000035,0.785844857333708
policy,pi05_20261119_192957,0.09000000000000036,0.8514094520404635
policy,pi05_20261119_193141,0.08000000000000035,0.8578728731637751
policy,pi05_20261119_193318,0.08000000000000035,0.8268385891447364
policy,pi05_20261119_193525,0.10000000000000037,0.652803420939721
policy,pi05_20261119_193737,0.09000000000000036,0.7799718349280266
policy,pi05_20261119_193903,0.07000000000000034,0.8712350331092845
policy,pi05_20261119_194048,0.09000000000000036,0.8147346935811743
policy,pi05_20261119_194206,0.08000000000000035,0.8775065968252967
policy,pi05_20261119_194324,0.09000000000000036,0.7862408802267262
policy,pi05_20261119_195403,0.07000000000000034,0.7497044362021462
policy,pi05_20261119_195531,0.08000000000000035,0.7361399868705103
policy,pi05_20261119_195712,0.09000000000000036,0.7062188010211425
policy,pi05_20261119_195830,0.08000000000000035,0.8884294259201565
policy,pi05_20261119_195919,0.07000000000000034,0.8021137333924397
policy,pi05_20261119_200105,0.09000000000000036,0.7902747535378862
policy,pi05_20261119_200220,0.07000000000000034,0.7700115304517208
policy,pi05_20261119_200424,0.10000000000000037,0.7966815411045007
pad_corr,pi05_20261106_183926,0.06000000000000033,0.7450337547998334
pad_corr,pi05_20261106_184452,0.07000000000000034,0.8196169972160905
pad_corr,pi05_20261106_184650,0.05000000000000032,0.6649647931298412
pad_corr,pi05_20261106_184906,0.06000000000000033,0.7905153292176227
```

### 依頼249 の組み方の確かめ state_match.csv

```csv
group,run,state_match_max_err_deg
demo,run_0001_20261116_180222,0.0
demo,run_0001_20261116_180445,0.0
demo,run_0001_20261116_180649,0.0
demo,run_0001_20261116_180850,0.0
demo,run_0001_20261116_181120,0.0
demo,run_0001_20261116_181313,0.0
demo,run_0001_20261116_181848,0.0
demo,run_0001_20261116_182124,0.0
demo,run_0001_20261116_182309,0.0
demo,run_0001_20261116_182848,0.0
pad_corr,pi05_20261106_183926,0.0
pad_corr,pi05_20261106_184452,0.0
pad_corr,pi05_20261106_184650,0.0
pad_corr,pi05_20261106_184906,0.0
```

ほかに、1コマごとのずれ（`frame_actual_offset.csv`・約1.6MB）、空いた所の一覧（`gaps.csv`）、学習データの組（`pairs_dataset.csv`）、動き出しの比べ（`camera_lag_onsets.csv`）、図（`fig_offsets.png`）が、`/Volumes/KIOXIA/r2r2r-data/diag/timing_249/20261121_205633/` にある。

### 測ったスクリプト diag/measure_timing_alignment.py

r2r2r-scripts の commit 944d083。

```python
#!/usr/bin/env python3
"""measure_timing_alignment.py — 録画と記録から「映像と関節の時刻のずれ」と「制御の1回の間隔」を測る (依頼 249).

読むだけ. アーム・サーボ・daemon には一切つながない. runs/ と datasets/ の既存ファイルは書き換えない.

対象 (3 組):
  demo     : datasets/mecharm_redblock_box_split10_v2 の全エピソード
             元の記録 = runs/run_pick_place/{run}/ (record_teach_demo.py. build_demo_episodes.py で作った)
  policy   : runs/pi05_policy/ の直近 N 本 (recording/ がある run. 既定 20)
  pad_corr : ゲームパッド補正 (log.jsonl に type=pad) の run のうち, datasets/mecharm_redblock_box_corr_v5
             に入っている本 (build_correction_episodes.py --gap-fill speed20 --trim-hold で作った)

測ること:
  1. 映像と関節の時刻のずれ
     - 1 コマごとに capture_ts といちばん近い actual の時刻の差
     - コマ間隔・関節を読む間隔 (狙いの値と実際. 読み取りの失敗の数)
     - 学習データでの組み方 (state = 10Hz の格子 t に actual を線形補間. 画像 = t にいちばん近いコマ)
       を作り直し, エピソードの state と突き合わせて同じ格子を見つけたうえで, 組のずれを出す
     - カメラ自体の遅れ: 動き出しの場面で, 映像のコマ間差分 (動きの量) と関節の速さの立ち上がりの時刻を比べる.
       あわせて全体の相互相関の山の位置も出す
  2. 制御の1回の間隔
     - 指令を送った間隔・送ってから届くまで・サーボの読み取り時間・推論 1 回の待ち (latency_s)
     - 中央値の 2 倍を超えて空いた所の数と, つかむ前/つかんだ後/放した後 のどこか
  3. demo / policy / pad_corr の比べ

出力: /Volumes/KIOXIA/r2r2r-data/diag/timing_249/{YYYYmmdd_HHMMSS}/
  per_run.csv  pairs_dataset.csv  frame_actual_offset.csv  gaps.csv  camera_lag_onsets.csv
  camera_lag_xcorr.csv  summary.md  fig_*.png

Usage:
  python3 diag/measure_timing_alignment.py
  python3 diag/measure_timing_alignment.py --policy-n 20 --no-video   # カメラの遅れを測らない (速い)
"""
import argparse
import csv
import json
import os
import sys
from datetime import datetime
from pathlib import Path

import cv2
import numpy as np

REPO = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(REPO / "pi05"))

import build_demo_episodes as bde  # noqa: E402  (読むための関数だけ使う)
import build_correction_episodes as bce  # noqa: E402
from rewind_correct import excluded_windows, step_keep_mask  # noqa: E402

DATA_ROOT = Path("/Volumes/KIOXIA/r2r2r-data")
OUT_ROOT = DATA_ROOT / "diag" / "timing_249"
DEMO_DS = DATA_ROOT / "datasets" / "mecharm_redblock_box_split10_v2"
CORR_DS = DATA_ROOT / "datasets" / "mecharm_redblock_box_corr_v5"
RUNS_PP = DATA_ROOT / "runs" / "run_pick_place"
RUNS_POL = DATA_ROOT / "runs" / "pi05_policy"
FPS = bde.FPS

# カメラの遅れの見積もり
VID_SMALL = (96, 54)            # 差分を取る大きさ
STILL_DEG_S = 1.0               # これ未満は止まり
MOVE_DEG_S = 5.0                # これを超えたら動き
STILL_BEFORE_SEC = 0.8          # 動き出しの前に止まっている長さ
MAX_JOINT_GAP_SEC = 0.35        # 動き出しをはさむ 2 つの読みの間がこれ以下のときだけ使う
VID_K_MAD = 6.0                 # 映像の動き出し = 止まりの中央値 + この倍の MAD を超えた最初のコマ
XCORR_LAGS = np.arange(-0.30, 0.6001, 0.01)
XCORR_GRID = 0.01


def abort(msg):
    sys.exit("[ABORT] " + msg)


def ensure_ssd_mounted():
    if not os.path.ismount("/Volumes/KIOXIA"):
        abort("KIOXIA が未マウント。ローカルには書きません。")
    if not DATA_ROOT.exists():
        abort(f"データの場所がない: {DATA_ROOT}")


def st(x):
    """中央値・95%点・最大 (と数)."""
    x = np.asarray([v for v in x if v is not None and np.isfinite(v)], dtype=float)
    if len(x) == 0:
        return {"n": 0, "median": None, "p95": None, "max": None}
    return {"n": int(len(x)), "median": float(np.median(x)), "p95": float(np.percentile(x, 95)),
            "max": float(np.max(x))}


def fmt(s, scale=1.0, nd=1):
    if not s or s["n"] == 0:
        return "—"
    return f"{s['median'] * scale:.{nd}f} / {s['p95'] * scale:.{nd}f} / {s['max'] * scale:.{nd}f} (n={s['n']})"


def visible(names):
    return sorted(n for n in names if not n.startswith("._"))


# ---------------------------------------------------------------- 記録を読む
def read_states(path):
    """states.csv を全部読む (actual は build_demo_episodes と同じ決まりで弾いた数も数える)."""
    rows = []
    with path.open(newline="") as f:
        for r in csv.DictReader(f):
            try:
                r["_ts"] = float(r["ts"])
            except Exception:
                continue
            rows.append(r)
    act_t, act_note, invalid = [], [], 0
    for r in rows:
        if r.get("event_type") != "actual":
            continue
        try:
            q = [float(r[f"j{i}"]) for i in range(6)]
        except Exception:
            invalid += 1
            continue
        if any(abs(v) > bde.ANGLE_ABS_MAX for v in q):
            invalid += 1
            continue
        act_t.append(r["_ts"]); act_note.append(r.get("note") or "")
    return rows, np.array(act_t), act_note, invalid


def gripper_events(rows):
    ev = sorted((r["_ts"], int(float(r["gripper_state"]))) for r in rows
                if r.get("event_type") == "gripper_cmd" and r.get("gripper_state") not in (None, ""))
    return ev


def phase_of(ts, gev):
    """つかむ前 / つかんだ後 / 放した後. 最初の閉じる指令とその後の最初の開く指令で分ける."""
    t_close = next((t for t, s in gev if s == 1), None)
    if t_close is None:
        return "つかむ前(閉じる指令なし)"
    t_open = next((t for t, s in gev if s == 0 and t > t_close), None)
    if ts < t_close:
        return "つかむ前"
    if t_open is None or ts < t_open:
        return "つかんだ後"
    return "放した後"


def stage_at(rows, ts):
    """その時刻の stage 列 (demo は区間名, policy は model/correct/wait など)."""
    s = ""
    for r in rows:
        if r["_ts"] > ts:
            break
        if r.get("stage"):
            s = r["stage"]
    return s


def read_currents_ms(path):
    out = []
    if not path.exists():
        return out
    with path.open(newline="") as f:
        for r in csv.DictReader(f):
            try:
                out.append(float(r["rpc_ms"]))
            except Exception:
                pass
    return out


def read_log(path):
    out = []
    if not path.exists():
        return out
    for line in path.open(errors="ignore"):
        try:
            out.append(json.loads(line))
        except Exception:
            pass
    return out


def note_val(note, key):
    for tok in (note or "").split():
        if tok.startswith(key + "="):
            try:
                return float(tok.split("=", 1)[1])
            except ValueError:
                return None
    return None


# ---------------------------------------------------------------- カメラの遅れ
def video_motion(mp4, fts):
    """コマ間差分の大きさ (1 秒あたり). 時刻は 2 コマの capture_ts の中点."""
    cap = cv2.VideoCapture(str(mp4))
    prev, vals, mids, dts, i = None, [], [], [], 0
    while i < len(fts):
        ok, fr = cap.read()
        if not ok:
            break
        g = cv2.cvtColor(cv2.resize(fr, VID_SMALL, interpolation=cv2.INTER_AREA), cv2.COLOR_BGR2GRAY)
        g = cv2.GaussianBlur(g, (3, 3), 0).astype(np.float32)
        if prev is not None:
            dt = fts[i] - fts[i - 1]
            if dt > 0:
                vals.append(float(np.mean(np.abs(g - prev))) / dt)
                mids.append((fts[i] + fts[i - 1]) / 2); dts.append(dt)
        prev = g; i += 1
    cap.release()
    return np.array(mids), np.array(vals), np.array(dts), i


def joint_speed(at, aq):
    dt = np.diff(at)
    ok = dt > 1e-3
    v = np.full(len(dt), np.nan)
    v[ok] = np.max(np.abs(np.diff(aq, axis=0))[ok], axis=1) / dt[ok]
    return v, dt


def onset_lags(at, aq, vm_t, vm_v, vm_dt):
    """動き出しごとに 映像の立ち上がり − 関節の立ち上がり."""
    v, dt = joint_speed(at, aq)
    res = []
    if len(vm_v) < 10:
        return res
    for k in range(1, len(v)):
        if not (np.isfinite(v[k]) and v[k] > MOVE_DEG_S and dt[k] <= MAX_JOINT_GAP_SEC):
            continue
        # 区間 k (at[k]→at[k+1]) で動き出した. その前 STILL_BEFORE_SEC は止まり
        j = k - 1; still_ok = True
        while j >= 0 and at[k] - at[j] < STILL_BEFORE_SEC:
            if not np.isfinite(v[j]) or v[j] >= STILL_DEG_S or dt[j] > MAX_JOINT_GAP_SEC:
                still_ok = False; break
            j -= 1
        if not still_ok or j < 0:
            continue
        t_joint = (at[k] + at[k + 1]) / 2
        unc_joint = (at[k + 1] - at[k]) / 2
        base = (vm_t >= at[k] - STILL_BEFORE_SEC) & (vm_t <= at[k])
        if base.sum() < 2:
            continue
        b = vm_v[base]; med = np.median(b); mad = np.median(np.abs(b - med)) + 1e-6
        thr = med + VID_K_MAD * 1.4826 * mad
        win = np.where((vm_t > at[k] - 0.2) & (vm_t <= at[k] + 1.5) & (vm_v > thr))[0]
        if len(win) == 0:
            continue
        n = win[0]
        res.append({"t_joint_onset": t_joint, "joint_unc_s": unc_joint, "t_video_onset": vm_t[n],
                    "video_unc_s": vm_dt[n] / 2, "lag_s": vm_t[n] - t_joint,
                    "unc_s": unc_joint + vm_dt[n] / 2, "joint_speed": float(v[k]),
                    "video_thr": float(thr), "video_val": float(vm_v[n])})
    return res


def xcorr_lag(at, aq, vm_t, vm_v):
    """関節の速さと映像の動きの量の相互相関. 正 = 映像が遅れている."""
    v, dt = joint_speed(at, aq)
    mid = (at[1:] + at[:-1]) / 2
    ok = np.isfinite(v) & (dt <= MAX_JOINT_GAP_SEC)
    if ok.sum() < 20 or len(vm_v) < 20:
        return None, None
    jt, jv = mid[ok], v[ok]
    t0 = max(jt[0], vm_t[0]) + 0.7; t1 = min(jt[-1], vm_t[-1]) - 0.7
    if t1 - t0 < 5:
        return None, None
    grid = np.arange(t0, t1, XCORR_GRID)
    # 関節の速さが分かっている所 (読みの間が短い所) だけを使う
    near = np.min(np.abs(grid[:, None] - jt[None, :]), axis=1) if len(grid) * len(jt) < 4e7 else None
    jg = np.interp(grid, jt, jv)
    best, best_r = None, -2
    for L in XCORR_LAGS:
        vg = np.interp(grid + L, vm_t, vm_v)
        m = np.ones(len(grid), bool) if near is None else near <= MAX_JOINT_GAP_SEC
        if m.sum() < 50:
            continue
        a = jg[m] - jg[m].mean(); b = vg[m] - vg[m].mean()
        den = np.sqrt((a * a).sum() * (b * b).sum())
        r = float((a * b).sum() / den) if den > 0 else -2
        if r > best_r:
            best_r, best = r, float(L)
    return best, best_r


# ---------------------------------------------------------------- 学習データの組を作り直す
def rebuild_pairs(group, run_dir, ep_dir):
    """エピソードの state と同じ 10Hz 格子を見つけ, 各ステップの画像と関節の組のずれを出す."""
    rec = run_dir / "recording"
    at, aq, _gt, _gs = bde.load_states(rec / "states.csv")
    order = np.argsort(at); at, aq = at[order], aq[order]
    at, aq = bde.drop_spikes(at, aq)
    fidx, fts = bde.load_frame_log(rec / "top_frame_log.csv")
    t0, t1 = max(fts[0], at[0]), min(fts[-1], at[-1])
    t = np.arange(t0, t1, 1.0 / FPS)
    meta = json.loads((ep_dir / "meta.json").read_text())
    if group == "demo":
        q = np.stack([np.interp(t, at, aq[:, k]) for k in range(6)], axis=1)
        cand = np.ones(len(fts), bool)
    else:
        mode = (meta.get("gap_fill") or {}).get("mode", "linear")
        q, _ = bce.fill_motion_gaps(t, at, aq, mode=mode)
        log = bce.load_log(run_dir / "log.jsonl")
        mode_ts, modes = bce.load_stage_times(rec / "states.csv")
        cand, _ = step_keep_mask(fts, mode_ts, modes, excluded_windows(log))
    ep = np.load(ep_dir / "episode.npz")
    trel = ep["t_orig"] if "t_orig" in ep.files else ep["t"]
    offs = np.round(trel * FPS).astype(int)
    S = ep["state"][:, :6].astype(np.float64)
    best_n0, best_err = None, np.inf
    for n0 in range(0, len(t) - offs[-1]):
        e = float(np.max(np.abs(q[n0 + offs] - S)))
        if e < best_err:
            best_err, best_n0 = e, n0
            if e < 1e-3:
                break
    tt = t[best_n0 + offs]
    cf = fts[cand]
    nn = np.clip(np.searchsorted(cf, tt), 1, len(cf) - 1)
    left, right = cf[nn - 1], cf[nn]
    nn = np.where(np.abs(tt - left) <= np.abs(right - tt), nn - 1, nn)
    frame_off = cf[nn] - tt
    k = np.clip(np.searchsorted(at, tt), 1, len(at) - 1)
    near_actual = np.minimum(np.abs(at[k - 1] - tt), np.abs(at[k] - tt))
    bracket = at[k] - at[k - 1]
    moved = np.max(np.abs(aq[k] - aq[k - 1]), axis=1)
    rows = []
    for i in range(len(tt)):
        rows.append({"group": group, "run": run_dir.name, "step": i, "t_abs": f"{tt[i]:.6f}",
                     "frame_minus_state_s": round(float(frame_off[i]), 4),
                     "nearest_actual_s": round(float(near_actual[i]), 4),
                     "actual_bracket_s": round(float(bracket[i]), 4),
                     "bracket_move_deg": round(float(moved[i]), 3),
                     "interp_over_gap": int(bracket[i] > bce.GAP_SEC)})
    return rows, best_err


# ---------------------------------------------------------------- 補間の誤差の見積もり
DEMO_BLOCK_SEC = 1.04           # お手本の送る命令の往復 (send_rtt 中央値). この間 actual が読めない


def interp_error_sim(run_dir, block=DEMO_BLOCK_SEC):
    """実機推論の密な actual で, 送るたびに block 秒読めなかったことにして線形補間し, 消した実測との差を出す.
    戻り値は 消した実測 1 点ごとの 6 関節の最大誤差 (度) と, その 2 点の間に動いた量 (度)."""
    rows, _t, _n, _i = read_states(run_dir / "recording" / "states.csv")
    at, aq, _gt, _gs = bde.load_states(run_dir / "recording" / "states.csv")
    o = np.argsort(at); at, aq = bde.drop_spikes(at[o], aq[o])
    sends = [r["_ts"] for r in rows if r.get("event_type") == "send_angles"]
    errs, moves = [], []
    for ts in sends:
        drop = (at > ts) & (at < ts + block)
        keep_l = np.where(at <= ts)[0]; keep_r = np.where(at >= ts + block)[0]
        if drop.sum() == 0 or len(keep_l) == 0 or len(keep_r) == 0:
            continue
        a, b = keep_l[-1], keep_r[0]
        if at[b] - at[a] > block + 0.3:      # もともと抜けていた所は使わない
            continue
        idx = np.where(drop)[0]
        w = (at[idx] - at[a]) / (at[b] - at[a])
        est = aq[a][None, :] + w[:, None] * (aq[b] - aq[a])[None, :]
        e = np.max(np.abs(est - aq[idx]), axis=1)
        errs += list(e); moves += [float(np.max(np.abs(aq[b] - aq[a])))] * len(e)
    return errs, moves


# ---------------------------------------------------------------- 1 run を測る
def measure_run(group, run_dir, do_video):
    rec = run_dir / "recording"
    rows, at_all, notes, invalid = read_states(rec / "states.csv")
    at_all = np.sort(at_all)
    fidx, fts = bde.load_frame_log(rec / "top_frame_log.csv")
    gev = gripper_events(rows)
    res = {"group": group, "run": run_dir.name}
    out_off, out_gaps, out_on = [], [], []

    # コマ間隔・読み間隔
    fdt = np.diff(fts); adt = np.diff(at_all)
    res["frame_dt"] = st(fdt); res["actual_dt"] = st(adt)
    res["n_frames"] = int(len(fts)); res["n_actual"] = int(len(at_all)); res["actual_invalid"] = invalid
    if group == "demo":
        trial = json.loads((run_dir / f"{run_dir.name}.json").read_text())
        rm = json.loads((rec / "currents_meta.json").read_text()) if (rec / "currents_meta.json").exists() else {}
        asmp = trial.get("actual_sampling") or {}
        res["frame_target"] = "指定なし (カメラ任せ. 約30fps)"
        res["actual_target"] = f"本体 {asmp.get('target_hz')}Hz + 記録スレッド 最大 {rm.get('target_hz_max')}Hz (本体が眠る間だけ)"
        res["read_fail"] = int((asmp.get("reads_attempted", 0) - asmp.get("reads_ok", 0))
                               + (asmp.get("reads_once_attempted", 0) - asmp.get("reads_once_ok", 0))
                               + rm.get("currents_rows_incomplete", 0) + rm.get("loop_errors", 0))
        tm_p = rec / "top_meta.json"
        res["top_status"] = json.loads(tm_p.read_text()).get("status") if tm_p.exists() else "top_meta.json なし"
    else:
        tm_p = rec / "top_meta.json"
        tm = json.loads(tm_p.read_text()) if tm_p.exists() else {"status": "top_meta.json なし"}
        res["frame_target"] = "10.0fps"     # policy_recorder.RECORD_FPS
        res["actual_target"] = "記録スレッド 10Hz + 本体の読み (note=main)"
        res["read_fail"] = int(tm.get("actual_read_failures", 0)) + int(tm.get("currents_rows_incomplete", 0))
        res["top_status"] = tm.get("status")

    # 1 コマごとの いちばん近い actual との差 (actual − capture)
    k = np.clip(np.searchsorted(at_all, fts), 1, len(at_all) - 1)
    dl, dr = at_all[k - 1] - fts, at_all[k] - fts
    near = np.where(np.abs(dl) <= np.abs(dr), dl, dr)
    res["frame_actual_abs"] = st(np.abs(near))
    for i in range(len(fts)):
        out_off.append({"group": group, "run": run_dir.name, "frame_idx": int(fidx[i]),
                        "capture_ts": f"{fts[i]:.6f}", "nearest_actual_minus_capture_s": round(float(near[i]), 4)})

    # サーボの読み取り時間
    res["servo_read_ms"] = st(read_currents_ms(rec / "currents.csv"))

    # 指令・到着・推論
    if group == "demo":
        trial = json.loads((run_dir / f"{run_dir.name}.json").read_text())
        segs = trial.get("segments") or []
        send_ts = [r["_ts"] for r in rows if r.get("event_type") == "stage"]
        res["send_dt"] = st(np.diff(send_ts))
        res["send_rpc"] = st([s.get("send_rtt_sec") for s in segs if s.get("kind") == "move"])
        res["send_to_arrival"] = st([s.get("segment_elapsed_sec") for s in segs if s.get("kind") == "move"])
        res["latency"] = st([])
        res["infer_dt"] = st([])
        res["send_note"] = "stage 行 = 区間 1 つにつき 1 回送る (single_send_per_segment). 届く = 到着確認まで (segment_elapsed_sec)"
    else:
        sends = [r for r in rows if r.get("event_type") == "send_angles"]
        send_ts = [r["_ts"] for r in sends]
        res["send_dt"] = st(np.diff(send_ts))
        res["send_rpc"] = st([note_val(r.get("note"), "rpc_sec") for r in sends])
        log = read_log(run_dir / "log.jsonl")
        chunks = [j for j in log if "chunk" in j and "type" not in j]
        res["latency"] = st([c.get("latency_s") for c in chunks])
        res["infer_dt"] = st(np.diff([c["t"] for c in chunks if "t" in c]))
        ex = [c["t_exec_end"] - c["t_exec_start"] for c in chunks
              if c.get("t_exec_end") and c.get("t_exec_start")]
        pads = [p.get("elapsed_sec") for p in log if p.get("type") == "pad" and p.get("elapsed_sec") is not None]
        res["send_to_arrival"] = st(ex)
        res["pad_send_to_reach"] = st(pads)
        res["ts_arrival_recorded"] = sum(1 for r in sends if r.get("ts_arrival"))
        res["send_note"] = "send_angles 行. 届く = チャンク 1 つの実行 (t_exec_start→t_exec_end. 中継点こみ). ts_arrival は空"

    # 間隔が大きく空いた所
    for kind, ts in (("send", np.array(send_ts)), ("actual", at_all), ("frame", fts)):
        if len(ts) < 3:
            continue
        d = np.diff(ts); med = float(np.median(d))
        for i in np.where(d > 2 * med)[0]:
            out_gaps.append({"group": group, "run": run_dir.name, "kind": kind,
                             "t_start": f"{ts[i]:.6f}", "gap_s": round(float(d[i]), 4),
                             "median_s": round(med, 4), "phase": phase_of(ts[i], gev),
                             "stage": stage_at(rows, ts[i])})

    # カメラの遅れ
    if do_video:
        at, aq, _gt, _gs = bde.load_states(rec / "states.csv")
        o = np.argsort(at); at, aq = bde.drop_spikes(at[o], aq[o])
        vm_t, vm_v, vm_dt, nread = video_motion(rec / "top.mp4", fts)
        res["video_frames_read"] = nread
        for r in onset_lags(at, aq, vm_t, vm_v, vm_dt):
            r.update({"group": group, "run": run_dir.name, "phase": phase_of(r["t_joint_onset"], gev)})
            out_on.append(r)
        res["xcorr_lag_s"], res["xcorr_r"] = xcorr_lag(at, aq, vm_t, vm_v)
    return res, out_off, out_gaps, out_on


# ---------------------------------------------------------------- まとめ
def pick_runs(policy_n):
    demo_eps = visible(os.listdir(DEMO_DS / "raw_episodes"))
    demo = [(RUNS_PP / e, DEMO_DS / "raw_episodes" / e) for e in demo_eps]
    pol_all = [d for d in visible(os.listdir(RUNS_POL))
               if d.startswith("pi05_") and (RUNS_POL / d / "recording" / "states.csv").exists()
               and (RUNS_POL / d / "recording" / "top_frame_log.csv").exists()]
    policy = [(RUNS_POL / d, None) for d in pol_all[-policy_n:]]
    pad_all = [d for d in pol_all if any('"type": "pad"' in ln for ln in
                                          (RUNS_POL / d / "log.jsonl").open(errors="ignore"))]
    corr_eps = set(visible(os.listdir(CORR_DS / "raw_episodes")))
    pad = [(RUNS_POL / d, CORR_DS / "raw_episodes" / d) for d in pad_all if d in corr_eps]
    return demo, policy, pad, pad_all


def write_csv(path, rows):
    if not rows:
        path.write_text("")
        return
    keys = list(rows[0].keys())
    for r in rows:
        for kk in r:
            if kk not in keys:
                keys.append(kk)
    with path.open("w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=keys)
        w.writeheader(); w.writerows(rows)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--policy-n", type=int, default=20)
    ap.add_argument("--no-video", action="store_true", help="カメラの遅れを測らない")
    args = ap.parse_args()

    ensure_ssd_mounted()
    out = OUT_ROOT / datetime.now().strftime("%Y%m%d_%H%M%S")
    if out.exists():
        abort(f"同じ名前の出力先がある: {out}")
    out.mkdir(parents=True)

    demo, policy, pad, pad_all = pick_runs(args.policy_n)
    print(f"[INFO] demo {len(demo)} / policy {len(policy)} / pad_corr {len(pad)} (pad の run 全体 {len(pad_all)})")

    results, offs, gaps, onsets, pairs, match = [], [], [], [], [], []
    for group, items in (("demo", demo), ("policy", policy), ("pad_corr", pad)):
        for run_dir, ep_dir in items:
            print(f"[RUN] {group} {run_dir.name}")
            try:
                r, o, g, on = measure_run(group, run_dir, not args.no_video)
            except Exception as e:
                print(f"[WARN] {run_dir.name}: {type(e).__name__}: {e}")
                results.append({"group": group, "run": run_dir.name, "error": f"{type(e).__name__}: {e}"})
                continue
            results.append(r); offs += o; gaps += g; onsets += on
            if ep_dir is not None:
                try:
                    pr, err = rebuild_pairs(group, run_dir, ep_dir)
                    pairs += pr
                    match.append({"group": group, "run": run_dir.name, "state_match_max_err_deg": round(err, 5)})
                except Exception as e:
                    print(f"[WARN] 組の作り直し {run_dir.name}: {type(e).__name__}: {e}")
                    match.append({"group": group, "run": run_dir.name, "state_match_max_err_deg": None,
                                  "error": f"{type(e).__name__}: {e}"})

    def vals(rows, group, key, fn=float):
        return [fn(r[key]) for r in rows if r["group"] == group and r.get(key) not in (None, "")]

    groups = ["demo", "policy", "pad_corr"]
    G = {}
    for g in groups:
        rr = [r for r in results if r["group"] == g and "error" not in r]
        G[g] = {"runs": len(rr)}
        G[g]["frame_actual_abs"] = st([abs(v) for v in vals(offs, g, "nearest_actual_minus_capture_s")])
        G[g]["frame_actual_signed_med"] = st(vals(offs, g, "nearest_actual_minus_capture_s"))["median"]
        G[g]["n_frames"] = sum(r["n_frames"] for r in rr)
        G[g]["n_actual"] = sum(r["n_actual"] for r in rr)
        G[g]["read_fail"] = sum(r.get("read_fail", 0) for r in rr)
        G[g]["actual_invalid"] = sum(r.get("actual_invalid", 0) for r in rr)
        G[g]["frame_target"] = rr[0]["frame_target"] if rr else "—"
        G[g]["actual_target"] = rr[0]["actual_target"] if rr else "—"
        G[g]["send_note"] = rr[0]["send_note"] if rr else "—"
        G[g]["xcorr"] = [(r["run"], r.get("xcorr_lag_s"), r.get("xcorr_r")) for r in rr]
        G[g]["pairs_frame"] = st([abs(v) for v in vals(pairs, g, "frame_minus_state_s")])
        G[g]["pairs_frame_signed"] = st(vals(pairs, g, "frame_minus_state_s"))
        G[g]["pairs_near_actual"] = st(vals(pairs, g, "nearest_actual_s"))
        G[g]["pairs_bracket"] = st(vals(pairs, g, "actual_bracket_s"))
        pg = [p for p in pairs if p["group"] == g]
        G[g]["pairs_n"] = len(pg)
        G[g]["pairs_over_gap"] = sum(p["interp_over_gap"] for p in pg)
        G[g]["pairs_over_gap_moving"] = sum(1 for p in pg if p["interp_over_gap"] and p["bracket_move_deg"] > 0.5)
        G[g]["onset"] = st([o["lag_s"] for o in onsets if o["group"] == g])
        G[g]["onset_unc"] = st([o["unc_s"] for o in onsets if o["group"] == g])
        G[g]["gaps"] = {}
        for p in [x for x in gaps if x["group"] == g]:
            key = (p["kind"], p["phase"])
            G[g]["gaps"][key] = G[g]["gaps"].get(key, 0) + 1
    # 元の値を合わせた統計 (run ごとの統計の統計にしない)
    pooled = pool_raw(results, demo, policy, pad)
    for g in groups:
        G[g].update(pooled[g])

    sim_e, sim_m = [], []
    for run_dir, _ in policy:
        try:
            e, m = interp_error_sim(run_dir)
            sim_e += e; sim_m += m
        except Exception as ex:
            print(f"[WARN] 補間の見積もり {run_dir.name}: {type(ex).__name__}: {ex}")
    G["sim"] = {"err": st(sim_e), "err_moving": st([e for e, m in zip(sim_e, sim_m) if m > 0.5]),
                "n_send_windows": len(set(sim_m)) if sim_m else 0}

    write_csv(out / "per_run.csv", [flatten(r) for r in results])
    write_csv(out / "frame_actual_offset.csv", offs)
    write_csv(out / "gaps.csv", gaps)
    write_csv(out / "camera_lag_onsets.csv", onsets)
    write_csv(out / "camera_lag_xcorr.csv",
              [{"group": g, "run": a, "lag_s": b, "r": c} for g in groups for a, b, c in G[g]["xcorr"]])
    write_csv(out / "pairs_dataset.csv", pairs)
    write_csv(out / "state_match.csv", match)
    make_figs(out, offs, pairs, onsets, G)
    write_summary(out, G, demo, policy, pad, pad_all, match, args)
    print(f"[DONE] {out}")


def pool_raw(results, demo, policy, pad):
    """各 run の元の値を合わせた統計."""
    out = {}
    for g, items in (("demo", demo), ("policy", policy), ("pad_corr", pad)):
        fdt, adt, srv, sdt, rpc, arr, lat, inf, padr = [], [], [], [], [], [], [], [], []
        for run_dir, _ in items:
            rec = run_dir / "recording"
            try:
                rows, at_all, _n, _inv = read_states(rec / "states.csv")
                _fi, fts = bde.load_frame_log(rec / "top_frame_log.csv")
            except Exception:
                continue
            fdt += list(np.diff(fts)); adt += list(np.diff(np.sort(at_all)))
            srv += read_currents_ms(rec / "currents.csv")
            if g == "demo":
                trial = json.loads((run_dir / f"{run_dir.name}.json").read_text())
                segs = [s for s in trial.get("segments") or [] if s.get("kind") == "move"]
                sdt += list(np.diff([r["_ts"] for r in rows if r.get("event_type") == "stage"]))
                rpc += [s.get("send_rtt_sec") for s in segs]
                arr += [s.get("segment_elapsed_sec") for s in segs]
            else:
                sends = [r for r in rows if r.get("event_type") == "send_angles"]
                sdt += list(np.diff([r["_ts"] for r in sends]))
                rpc += [note_val(r.get("note"), "rpc_sec") for r in sends]
                log = read_log(run_dir / "log.jsonl")
                ch = [j for j in log if "chunk" in j and "type" not in j]
                lat += [c.get("latency_s") for c in ch]
                inf += list(np.diff([c["t"] for c in ch if "t" in c]))
                arr += [c["t_exec_end"] - c["t_exec_start"] for c in ch if c.get("t_exec_end") and c.get("t_exec_start")]
                padr += [p.get("elapsed_sec") for p in log if p.get("type") == "pad" and p.get("elapsed_sec") is not None]
        out[g] = {"P_frame_dt": st(fdt), "P_actual_dt": st(adt), "P_servo_ms": st(srv), "P_send_dt": st(sdt),
                  "P_send_rpc": st(rpc), "P_arrival": st(arr), "P_latency": st(lat), "P_infer_dt": st(inf),
                  "P_pad_reach": st(padr)}
    return out


def flatten(r):
    o = {}
    for k, v in r.items():
        if isinstance(v, dict) and "median" in v:
            for kk in ("n", "median", "p95", "max"):
                o[f"{k}_{kk}"] = None if v[kk] is None else (round(v[kk], 5) if isinstance(v[kk], float) else v[kk])
        else:
            o[k] = v
    return o


def make_figs(out, offs, pairs, onsets, G):
    try:
        import matplotlib
        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
    except Exception as e:
        print(f"[WARN] 図を作れない: {e}")
        return
    colors = {"demo": "#2a6fdb", "policy": "#e07b39", "pad_corr": "#3a9e5f"}
    fig, axes = plt.subplots(1, 3, figsize=(15, 4))
    for g, c in colors.items():
        v = [abs(float(o["nearest_actual_minus_capture_s"])) * 1000 for o in offs if o["group"] == g]
        if v:
            axes[0].hist(v, bins=60, range=(0, 600), alpha=0.5, color=c, label=g, density=True)
        p = [float(x["frame_minus_state_s"]) * 1000 for x in pairs if x["group"] == g]
        if p:
            axes[1].hist(p, bins=40, range=(-80, 80), alpha=0.5, color=c, label=g, density=True)
        on = [o["lag_s"] * 1000 for o in onsets if o["group"] == g]
        if on:
            axes[2].hist(on, bins=30, range=(-300, 600), alpha=0.5, color=c, label=g)
    axes[0].set_title("1 frame: |nearest actual - capture_ts| (ms)")
    axes[1].set_title("dataset pair: frame capture_ts - state t (ms)")
    axes[2].set_title("camera lag by motion onset (ms, + = video later)")
    for a in axes:
        a.legend(); a.grid(alpha=0.3)
    fig.tight_layout(); fig.savefig(out / "fig_offsets.png", dpi=110); plt.close(fig)


def write_summary(out, G, demo, policy, pad, pad_all, match, args):
    L = []
    gn = {"demo": "お手本 (split10_v2)", "policy": f"実機推論 (直近{len(policy)}本)", "pad_corr": "補正お手本 (corr_v5 のゲームパッド分)"}
    groups = ["demo", "policy", "pad_corr"]
    L.append("# 依頼249 映像と関節の時刻のずれ・制御の間隔\n")
    L.append(f"作成 {datetime.now().isoformat(timespec='seconds')} / `diag/measure_timing_alignment.py`"
             f"{' --no-video' if args.no_video else ''}\n")
    L.append("読んだ記録:\n")
    L.append(f"- お手本: {DEMO_DS}/raw_episodes ({len(demo)} 本) ← 元 {RUNS_PP}/<run>/recording")
    L.append(f"- 実機推論: {RUNS_POL} の {policy[0][0].name} 〜 {policy[-1][0].name} ({len(policy)} 本)" if policy else "- 実機推論: なし")
    L.append(f"- 補正お手本: {CORR_DS}/raw_episodes のうちゲームパッド補正の {len(pad)} 本 "
             f"({', '.join(p[0].name for p in pad)}) ← 元 {RUNS_POL}/<run>. ゲームパッド補正の run は全部で {len(pad_all)} 本\n")
    L.append("表の値は 中央値 / 95%点 / 最大 (n=数).\n")

    L.append("## 1. 映像と関節の時刻のずれ (記録そのもの)\n")
    L.append("| 項目 | " + " | ".join(gn[g] for g in groups) + " |")
    L.append("|---|" + "---|" * len(groups))
    L.append("| 1コマと最寄りの actual の差 (ms) | " + " | ".join(fmt(G[g]["frame_actual_abs"], 1000, 0) for g in groups) + " |")
    L.append("| 映像のコマ間隔 狙い | " + " | ".join(str(G[g]["frame_target"]) for g in groups) + " |")
    L.append("| 映像のコマ間隔 実際 (ms) | " + " | ".join(fmt(G[g]["P_frame_dt"], 1000, 0) for g in groups) + " |")
    L.append("| 関節を読む間隔 狙い | " + " | ".join(str(G[g]["actual_target"]) for g in groups) + " |")
    L.append("| 関節を読む間隔 実際 (ms) | " + " | ".join(fmt(G[g]["P_actual_dt"], 1000, 0) for g in groups) + " |")
    L.append("| 読み取りの失敗 (数) / 弾いた値 | " + " | ".join(f"{G[g]['read_fail']} / {G[g]['actual_invalid']}" for g in groups) + " |")
    L.append("| コマ数 / actual 数 | " + " | ".join(f"{G[g]['n_frames']} / {G[g]['n_actual']}" for g in groups) + " |")
    L.append("")
    L.append("## 1b. 学習データでの組のずれ (作り直した格子で)\n")
    L.append("組み方 (コードで確認): 10Hz の格子 t を置き, state の関節 6 列 = actual の **線形補間** (np.interp)"
             " (補正は actual の間が 0.25 秒を超える所を speed20 の直線で埋める), 爪 = その時刻までの最後の指令,"
             " 画像 = capture_ts が t に **いちばん近い** コマ (補正は除いた区間のコマを候補から外す).\n")
    L.append("| 項目 | " + " | ".join(gn[g] for g in groups if G[g]["pairs_n"]) + " |")
    L.append("|---|" + "---|" * sum(1 for g in groups if G[g]["pairs_n"]))
    pg = [g for g in groups if G[g]["pairs_n"]]
    L.append("| ステップ数 | " + " | ".join(str(G[g]["pairs_n"]) for g in pg) + " |")
    L.append("| 画像の時刻 − state の時刻 の絶対値 (ms) | " + " | ".join(fmt(G[g]["pairs_frame"], 1000, 0) for g in pg) + " |")
    L.append("| state の時刻と最寄りの実測の差 (ms) | " + " | ".join(fmt(G[g]["pairs_near_actual"], 1000, 0) for g in pg) + " |")
    L.append("| 補間に使った 2 つの実測の間 (ms) | " + " | ".join(fmt(G[g]["pairs_bracket"], 1000, 0) for g in pg) + " |")
    L.append("| 0.25 秒を超える間をまたいで補間したステップ (うち 0.5° 超動いた) | "
             + " | ".join(f"{G[g]['pairs_over_gap']} ({G[g]['pairs_over_gap_moving']})" for g in pg) + " |")
    me = [m for m in match if m.get("state_match_max_err_deg") is not None]
    L.append(f"\n補間の誤差の見積もり (実機推論 {len(policy)} 本の密な actual で, 送るたびに {DEMO_BLOCK_SEC} 秒"
             f" 読めなかったことにして線形補間し, 消した実測と比べた. 6 関節の最大誤差): "
             f"全体 {fmt(G['sim']['err'], 1, 2)}°, 前後で 0.5° 超動いた所 {fmt(G['sim']['err_moving'], 1, 2)}°."
             " 実機推論の 1 回の動きはお手本の区間の動きより小さいので, お手本の誤差はこれより大きくなりうる.")
    L.append(f"\n格子の見つけ方の確かめ: エピソードの state と作り直した state の差の最大 = "
             f"{max((m['state_match_max_err_deg'] for m in me), default=None)}° ({len(me)}/{len(match)} 本で一致を確認. state_match.csv)\n")

    L.append("## 1c. カメラ自体の遅れの見積もり\n")
    L.append(f"やり方 A (動き出し): 関節の速さが {STILL_BEFORE_SEC} 秒以上 {STILL_DEG_S}°/秒未満のあと {MOVE_DEG_S}°/秒を超えた区間"
             f" (前後の読みの間 ≤ {MAX_JOINT_GAP_SEC} 秒) を関節の動き出し (区間の中点) とし,"
             f" 映像のコマ間差分 (96x54 灰色・1 秒あたり) が直前の止まりの 中央値 + {VID_K_MAD}×MAD を初めて超えたコマ間 (中点) を映像の動き出しとする."
             " 差 = 映像 − 関節 (正 = 映像が遅れる). 1 件ごとの確からしさ = 関節の読みの間の半分 + コマ間隔の半分.\n")
    L.append("やり方 B (相互相関): 関節の速さと映像の動きの量を 10ms の格子にのせ, −0.3〜+0.6 秒ずらして相関がいちばん高いずれ.\n")
    L.append("| 項目 | " + " | ".join(gn[g] for g in groups) + " |")
    L.append("|---|" + "---|" * len(groups))
    L.append("| A: 映像の遅れ (ms) | " + " | ".join(fmt(G[g]["onset"], 1000, 0) for g in groups) + " |")
    L.append("| A: 1件の確からしさ ± (ms) | " + " | ".join(fmt(G[g]["onset_unc"], 1000, 0) for g in groups) + " |")
    for g in groups:
        xs = [(a, b, c) for a, b, c in G[g]["xcorr"] if b is not None]
        lags = [b for _, b, _ in xs]; rs = [c for _, _, c in xs]
        G[g]["xc"] = (st(lags), st(rs))
    L.append("| B: 相関の山のずれ (ms) run ごと | " + " | ".join(fmt(G[g]["xc"][0], 1000, 0) for g in groups) + " |")
    L.append("| B: 山の相関係数 | " + " | ".join(fmt(G[g]["xc"][1], 1, 2) for g in groups) + " |")
    L.append("")

    L.append("## 2. 制御の1回の間隔\n")
    L.append("| 項目 | " + " | ".join(gn[g] for g in groups) + " |")
    L.append("|---|" + "---|" * len(groups))
    L.append("| 指令を送った間隔 (s) | " + " | ".join(fmt(G[g]["P_send_dt"], 1, 2) for g in groups) + " |")
    L.append("| 送る命令の往復 (s) | " + " | ".join(fmt(G[g]["P_send_rpc"], 1, 3) for g in groups) + " |")
    L.append("| 送ってから届くまで (s) | " + " | ".join(fmt(G[g]["P_arrival"], 1, 2) for g in groups) + " |")
    L.append("| パッドの 1 刻み 送って着くまで (s) | " + " | ".join(fmt(G[g]["P_pad_reach"], 1, 2) for g in groups) + " |")
    L.append("| サーボを読む時間 (ms) | " + " | ".join(fmt(G[g]["P_servo_ms"], 1, 0) for g in groups) + " |")
    L.append("| 推論 1 回の待ち latency_s (s) | " + " | ".join(fmt(G[g]["P_latency"], 1, 2) for g in groups) + " |")
    L.append("| 推論の間隔 (s) | " + " | ".join(fmt(G[g]["P_infer_dt"], 1, 2) for g in groups) + " |")
    L.append("\n送る・届くの意味: " + " / ".join(f"{gn[g]}: {G[g]['send_note']}" for g in groups) + "\n")
    L.append("### 中央値の 2 倍を超えて空いた所 (数)\n")
    L.append("| 組 | 種類 | つかむ前 | つかんだ後 | 放した後 | その他 |")
    L.append("|---|---|---|---|---|---|")
    for g in groups:
        for kind in ("send", "actual", "frame"):
            d = {ph: n for (k, ph), n in G[g]["gaps"].items() if k == kind}
            other = sum(n for ph, n in d.items() if ph not in ("つかむ前", "つかんだ後", "放した後"))
            L.append(f"| {gn[g]} | {kind} | {d.get('つかむ前', 0)} | {d.get('つかんだ後', 0)} | {d.get('放した後', 0)} | {other} |")
    L.append("\n(stage 別の内訳は gaps.csv)\n")
    (out / "summary.md").write_text("\n".join(L) + "\n")


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

補足。いちばん大きいのは、お手本の関節の値の半分ほどが、実際に読んだ値ではなく、前後の読みを直線でつないだ値だったこと。お手本を集めるときは、1区間ごとに角度を送り、届くまで待つ作りになっていて、送る命令の往復に約1.04秒かかる。その間は関節を読めず、そのうえ爪を開け閉めする間も読めていなかった。抜けは長いところで約6秒。動いている途中を直線でつなぐと、実際の動きと数度ずれる見込みで、実機推論の密な記録で模擬すると、95%点で5.4°だった。MicroFactory が専用の制御基板と Rust の制御で守っているのは、まさにこういう所だと思う。

- ねらい：人が直したデータで学習し直す前に、今のお手本と補正のデータが、何度も学習し直しても崩れないほどそろっているかを確かめる
- 変わったこと：お手本の関節の値の約半分が補間の値だったこと、映像が約70〜80ミリ秒遅れていること、実機推論では読み取りの失敗が461回あったことが、数字で分かった。今までは、データのそろい方を測っていなかった
- 見込める効果：お手本を集める仕組みで、送る命令の往復の間も関節を読めるようにすれば、学習データの関節の値の誤差が数度から小さくなる見込み。どれだけ良くなるかは、直したあとに同じスクリプトで測り直して確かめる

どの問題をどう直すかは、まだ決めていない。報告の「決めてほしいこと」として残っている。


## 研究ブログを読んで、「モデルを小さくした」という説明を直す

（ここで、研究ブログを読むよう頼んだ。あわせて、確実さと費用に見合う効果の両方を1つの決断で取るという考えは、アーム型のロボットでなくても同じように必要ではないか、と聞いた）

研究ブログは Notion で作られていて、ふつうの読み込みでは中身が取れなかった。Claude は、私のパソコンのアプリの中のブラウザでページを開き、下まで送りながら本文を読み取った。題は「Steps towards continual learning（学習し続けることへの一歩）」。

**— 研究ブログには何が書いてあり、前の説明のどこを直すべきか。アーム以外のロボットでも同じ考えが要るか。**

研究ブログも全部読めました。まず、前の説明に誤りがありました。

訂正：モデルは「小さい」わけではない

- 大きさは π0.5 とほぼ同じです。
- それを量子化（QAT。数字の細かさを落として計算を軽くするのを、学習のときから織り込むやり方）と自作の CUDA の処理で軽くして、Jetson Orin Nano で動かしています。
- 学習し直しが1回約5ドルで済むのは、作業を区間に分けて、直した区間のモデルだけを数本の例で学習し直すからです。

ブログで新しく分かったこと

- 結果：結束バンドを通す作業で成功率97%。π0.6＋強化学習の 85〜90% を上回り、データは29分（相手は5時間＋強化学習500回）。
- 始め方：最初の例は10〜15本。動かして、直しを3〜5本集めて学習し直す。これを繰り返す。
- データのノイズ対策：専用の制御基板、タイミングを合わせたグローバルシャッターのカメラ、ガベージコレクションの止まりがない Rust、高分解能のエンコーダー。「間隔をそろえる」は、まさにこの話です。
- 巻き戻し：間違えた姿勢を記録しないよう、2〜4秒巻き戻してから直す。このプロジェクトでも10月に取り入れた方式です。
- 直し方：人が操作を奪うのではなく、モデルの動きに差分を足す。動きは 1:4 に縮める（人が4動かすとロボットは1）。
- 事前学習：作業の知識は入れず、動きの安定だけを受け継ぐ。2本の例から動く。
- 止める仕組み：悪い状態を素早く見つけて、やり直すか人を呼ぶ。
- 直すのはお客さん：プログラムの知識がなくても直しを記録できる画面を作っている。
- Claude Code も使っている：経由点を調整して、例20本のうち17本を作らせている。
- 向いている作業：1〜5分で終わる繰り返し作業。電子部品の組み立て、食品、繊維など。

アーム以外でも同じか

同じだと思います。形が何であれ、決めることは同じ3つです。

- 推論を現場の機械で済ませるか（ネットが切れても止まらないか）
- 作業をどこまで絞るか
- 直す1回あたりの費用はいくらか

配膳ロボットや搬送ロボットなら、「現場の人が数秒で直せて、その場で学習し直せる」形が作れれば、同じやり方が成り立ちます。ただ、移動ロボットは間違えても部品が壊れにくい分、強化学習やシミュレーションも使いやすいという違いはあります。

補足。ブログの中で、いちばん効いたのは「お客さんにとっての評価の作業は、そのままお客さんの役に立つ仕事になる」という所だった。研究所の人がロボットの横に張り付くのではなく、毎日その作業をする現場の人が、数秒で直しを記録する。直す人がいちばんその作業に詳しい、というのは、店や病院のロボットにもそのまま当てはまる。


## Founders, Inc. の紹介動画と公式サイトから、製品の仕様を確かめる

（ここで、Founders, Inc. の YouTube の動画「He invented a "microfactory"」の住所を渡し、仕様を確かめるよう頼んだ）

**— 紹介動画と公式サイトから分かる、MicroFactory の製品の仕様は何か。**

動画は Founders, Inc. が2026年7月に出した7分ほどの紹介動画で、話しているのは Igor さんです。字幕を読んで仕様を拾い、公式サイトの仕様と照らし合わせました。

動画で分かった仕様

- 遠隔操作の機材（自社製）：ロボットと同じ形の小さな腕を人が動かす方式。軽くするために炭素の棒を使い、精度の高い自作のエンコーダーと、姿勢を保つための磁石が付いています。
- ペダル：踏むと動きが縮まります。動画では「人が5インチ動かすとロボットは1インチ」。ブログの 1:4 とは数字が違います。
- 直し方：失敗したら時間を巻き戻し、モデルに動かさせたまま、クラッチで動きをその場で足して直します。
- 成果：結束バンド100本で成功率97%、学習データは40分未満。ほかの最良のモデルは、仕上げの学習だけで5〜10時間かけて約85%。
- キノコをすくう現場：お客さんは深度カメラとプログラムで1か月ほど試してもうまくいかなかったのに、最初のモデルを約20分で学習させられた。
- 最初の試作：背景と照明を固定した狭い環境で始めた。3Dプリントの腕に安いモーターを使い、2個のモーターを互いに押し付けてガタを消した。
- 製品は2つ：
  - どの産業用アームにも付けられる、遠隔操作の機材などの一式
  - 電子部品の組み立てセル（市販のアーム、箱型の枠、遠隔操作の一式）

公式サイトの仕様（組み立てセル「microfactory single」）

- アーム：6軸、届く範囲 622 mm、可搬重量 3 kg（固定の爪の場合）。繰り返しの位置精度 0.02 mm（ISO 9283）、先端の速さは約 1 m/s
- 使えるアーム：今は Fairino のアームに対応していて、大きさも選べる
- センサー：6軸の力センサーと、アクティブステレオカメラ
- 大きさ・重さ・寿命：160 × 90 × 85 cm、80 kg、想定寿命 30,000 時間
- 価格と中身：$11,950 から。アーム（設置・設定済み）、付け替えできる爪、ステレオカメラ、制御ボックス、光学ブレッドボード、位置合わせ用の照明パネル、箱型の枠
- データの置き場所：保存は Cloudflare、学習は Modal、機械の管理は Fly.io。推論は手元で行う
- 費用：学習や設定し直しで使った Anthropic か OpenAI の料金を払う。動き出したあとは使用料なし（手元のモデルの5年分の利用権込み）
- 返品：届いてから30日以内なら返金

このプロジェクトにとってのポイント

- FAIRINO に対応している：このプロジェクトが π0.5 を使うつもりの FAIRINO で、このやり方が実際に売られています。比べる相手として、いちばん近い実例です。
- サイトの説明が変わってきている：今のサイトは、言葉の指示で動きを組み立て、学習には Claude や OpenAI を使う方向に寄っています。7月の動画（人が遠隔操作で直す）からの変化です。ブログにあった「Claude Code に経由点を調整させて例を作る」と同じ流れに見えます。
- 公式サイトに載っていない仕様：計算機（Jetson）、遠隔操作の機材、ペダルの仕様。これらはブログと動画でしか分かりません。


## 紹介動画は、映像ではなく字幕しか読んでいなかった

> 動画見てる？

**— 前の答えは、動画の映像を見て書いたものか。**

いいえ、映像そのものは見ていません。読んだのは動画の字幕（自動の文字起こし）と説明文、それに公式サイトの文字だけです。なので前の返事のうち動画の部分は、Igor さんが話した内容だけで、映っている物（腕の形、ペダル、カメラの数や置き方、配線など）は確かめていません。

場面を指定して画面を切り取って見ることはできます。たとえば次の場面です。

- 2:13 ごろ：遠隔操作の機材
- 3:00 ごろ：ペダル
- 5:50 ごろ：最初の試作
- 6:44 ごろ：今のアーム

補足。AI に「動画を見て」と頼んでも、実際には字幕の文字だけを読んで答えていることがある。この答えのあと、映像はコマを切り出して並べて見る形に変えた。


## LinkedIn の投稿と動画から、1か月前の方向転換を知る

（ここで、Igor さんの LinkedIn の投稿の一覧の住所を渡し、投稿の中身と動画を確かめるよう頼んだ）

Claude は、アプリの中のブラウザで LinkedIn を開いて投稿の文を読み、動画は1本につき12コマを切り出して1枚に並べ、大事な場面だけ大きくして見た。

**— Igor さんの最近の投稿と動画から、何が分かるか。**

最近の投稿4本のうち3本の動画を見ました。見たのは、LLM に切り替えた話、ソフトボール、AI インテグレーターの3本です。音声は聞いていないので、話している内容までは分かりません。

いちばん大事な発見：1か月前にやり方を大きく変えている

研究ブログ（3か月前）では、自社の VLA モデル（Loop Model v1）に人の直しを足して学習し直す、というやり方でした。それが1か月前の投稿では、こう変わっています。

- 実際のお客さんの現場で、ロボットを動かすのを最先端の LLM に全面的に切り替えた。
- 考える役は Opus と「Astra」で動くエージェント。素早く動かす役は、そのエージェントが書いた画像認識のコード。
- 新しい状況が出てきたら、エージェントが入ってきてコードを書き直す。それが「学習し続ける」の代わりになる。

インテグレーターの動画には、この考えを1枚にした図がありました。

- AI モデルがロボットを直接動かす → 遅い・確実でない
- AI モデルがコードを書き、そのコードがロボットを動かす → 速い・確実

動画ごとに分かったこと

- LLM に切り替えた動画（97秒、3〜5倍速）：
  - 白い6軸の協働アームが2台。根元の関節にオレンジの輪があり、公式サイトの「Fairino 対応」と見た目は合います。ただし映像だけでは型番まで断定できません。
  - 左の腕はねじ回し、右の腕は爪とカメラ。
  - 台は穴の開いた光学ブレッドボード。ねじを1本ずつ出す機械、部品の皿、基板の皿、爪の置き台が並び、上に照明パネルがあります。
- AI インテグレーターの動画（128秒）：
  - Claude の画面が映っていました。「チューブをつかんで、何かの立てに入れて」と写真付きで頼むと、エージェントがプロジェクトのルールのファイル（igor_standing_rules.md）を読み、コマンドを打って作業を始めます。
  - 治具を設計し（精度 0.1 mm と出ていた）、ずれを逃がす取り付け台を使い、最後は全部自動で動かしています。
  - 人の役目は「材料を足す・治具を付ける・作業を足す・変える」だけ。
  - 最後に、セルを2段×2列に積んだ絵が出てきます。
- ソフトボールの動画（94秒）：頼まれて2時間後に、エージェントがソフトボールを縫う手順を作りました。
  - 2本の腕で革のカバーを縫う。1球88針。
  - 空の動作確認でぶつかったのは0回、1球あたり約2.7時間の見積もり、治具は印刷物5点と指1組。
  - ただし全部シミュレーションです。画面にも「実機ではまだ確かめていない（糸の扱い、力で締める所、革に針を通す所）」と書いてありました。

このプロジェクトにとっての意味

ここまでいちばん参考になると考えていた「人が直して学習し直す」やり方を、本人たちが1か月前に主役から外しています。今の方向は、LLM がコードと治具を作り、コードが動かすやり方です。依頼箱で Claude Code に仕事を回している今のこのプロジェクトのやり方に、むしろ近い考え方です。

ただし、決まった作業の確実さを出すのは治具と画像認識のコードで、それは LLM が書いています。π0.5 のような VLA とどちらが良いかは、作業の種類しだいです。研究室で π0.5 を続ける判断と、ぶつかるものではないと思います。

自己複製工場の動画（86秒）と、半年以上前の動画はまだ見ていません。

補足。「主役から外した」は、この時点の読み違いだった。次の節で字幕を読んで、π0.5 は柔らかい物の担当として残っていると分かる。


## 字幕があれば、音声は聞かなくてよかった

音声も聞けないのかと聞いたあと、インテグレーターの動画を Mac の画面収録で撮って渡した。1本目は音声が入っておらず、映像だけだった。Claude は映像を全部見て、前に12コマ抜き出したときに飛ばしていた場面を見つけた。1分12秒ごろの「π0.5 を手元で推論する」という表だった。

| | π0.5 そのまま | MicroFactory の π0.5 |
|---|---|---|
| 学習の時間 | 12時間 | 20分（36倍速い） |
| 学習の費用 | $39.5 | $4.9（8分の1） |
| 推論の機械 | RTX 4090 クラス | Jetson Nano |
| 推論の機械の値段 | $4,000 | $500（8分の1） |

この表で、MicroFactory の中身が π0.5 だと分かった。ブログで「大きさは π0.5 並み」と書いていたのは、π0.5 そのものを手直しして使っているという意味だった。作業の種類やデータの量が同じ条件で比べた数字かは、この表だけでは分からない。

音声を録り直すかを話していたところで、私はこう聞いた。

> 字幕あれば音声いらないんじゃない？

**— 字幕が出ている画面収録から、Igor さんの話を読めるか。**

字幕から全部読めました。英語の自動字幕なので聞き違いがいくつかありますが（「π0.5」が「05」、「integrator」が「Region」になっているなど）、中身は十分に分かります。動画は、さっき見た「AI インテグレーター」の紹介です。

Igor さんが話していること

1. 新しい段階に入った：これまで大きなモデルにロボットを直接動かさせると、遅くて高くて確実ではなかった。今は Opus や Astra にロボットのコードを書かせ、そのコードが動かすので、速くて確実で、ほぼタダ。現場で使うときの一番の壁がなくなった。
2. 1年かけて準備してきた：その成果として、導入を最初から最後まで受け持つ「AI インテグレーター」を発表。
3. 例：試験管の作業：試験管を適当に置いた写真と短い指示を渡しただけで、エージェントがやったこと。
   - MicroFactory にそのまま付けられる、試験管用の爪の受けと皿を設計した。
   - 2台のカメラから試験管の位置を割り出してつかむ、制御のコードを書いた。
   - 大事なのは、それが実際に動いたこと。
4. 配線のような扱いにくい物：π0.5 を手直しして、安い Jetson で手元で動くようにした。学習し直しは12時間ではなく20分。これで「学習し続ける」ループが回り、確実さが上がる。
5. 作業の段階ごとに：エージェントが合う手法を選び、確かめの手順を足し、治具を設計し、人への作業指示を書く。要するに全部を組み上げる。
6. 作業の切り替え：作業と治具の組み合わせは、同じセルでも別のセルでも呼び戻せるので、作業の切り替えがすぐできる。
7. 24時間動かすには：材料を足すパートの人がたまにいれば十分。新しい作業は、技術の知識がない人でも言葉で頼むだけで足せる。
8. 締め：組み立てという退屈な仕事から離れて、製品づくりに集中できる。セルを足せば生産も増やせる。初日から自動の工場を。

大事な点

LLM と π0.5 は、どちらかに乗り換えたのではなく、使い分けていました。

- 位置が決まる作業（試験管など）：LLM が書いた画像認識と制御のコード
- 配線のような柔らかくて扱いにくい物：π0.5 を人が直して学習し直す

前の節で「直して学習し直すやり方を主役から外した」と書いたのは言い過ぎでした。そのやり方は、柔らかい物の担当として残っています。


## MicroFactory は、できることから確実に組み立てている

> MicroFactoryはLLMモデルを使った最適解をかなりのレベルで作れているね。現実的にできそうな方法を確実にかつ、できることから提案しているという感じだね。

**— MicroFactory のやり方の、何がうまいのか。注意して見る所はどこか。**

同じ見方です。いちばん感心するのは、「何でもできる1つのモデル」を目指さず、作業ごとに一番確実な手段を選んでいるところです。

- 位置が決まる作業：LLM がコードと治具を書く。速くて、確実で、中身を直せる。
- 柔らかい物：π0.5 を人が直して学習し直す。
- それでも無理な所：材料の補充など、人に任せる（パートの人が時々でいい）。
- 治具で解く：AI の賢さで解かず、治具で問題そのものを小さくしている。製造の現場の昔からの知恵と同じです。

順番も現実的です。セル1台がまず確実に動き、作業を切り替えられ、セルを足せば生産が増える。自己複製工場のような大きな話は、その先に置いています。

一方で、見るときの注意もあります。

- ソフトボールの例は、シミュレーションで「動きそう」と言えた段階です。本人も実機ではまだだと書いています。
- π0.5 の「20分・5ドル」も、どの作業で何本のデータを使った数字かは出ていません。

それでも、技術の先端を追うより、今の時点で運用に耐える落とし所を作る、という考え方を、MicroFactory は製品の形で見せている例です。Pixels to Motors で発信するなら、「なぜこの順番と使い分けが正しいのか」を、自分の mechArm や SO-101 の経験から語れるのが強みになります。


## LLM の進化は、1年積んだ土台の上で一気に効いた

> 半年？もっと前か？くらい前から注目していたけど、LLMの進化で一気に作業効率が上がったって感じだね。

**— MicroFactory の作業の速さが一気に上がったのは、なぜか。**

投稿を並べると、その変化がよく見えます。

- 約1年前：MicroFactory を発表。開発キットを出し、自分でアームも作る。
- 約6か月前：自社の VLA モデル「Loop Model v1」を発表。この頃は、モデルを強くする方向。
- 約3か月前：ブログで「人が直して学習し直す」やり方をまとめる。16本の例で100回中100回成功。
- 約1か月前：最先端の LLM に切り替え。AI インテグレーターを発表。ソフトボールの例は、頼まれて2時間後。

前の1年は、ハードウェア、制御、データ集め、学習し直しを積み上げてきた時間です。そこに、コードも治具も書ける LLM が来て、その土台の上で一気に効いた、という形に見えます。もし土台がなかったら、LLM がコードを書いても、ガタのあるアームや時刻のずれたカメラでは確実に動かなかったはずです。

なので、このプロジェクトへの示唆は「LLM が来たから土台は要らない」ではありません。「土台ができていれば、LLM の進化をすぐ取り込める」です。依頼249で、時刻のずれと制御の間隔を測るのも、まさにその土台づくりです。

補足。依頼249の結果を見ると、この土台の話は他人事ではなかった。お手本の関節の値の約半分が補間の値で、映像は約70〜80ミリ秒遅れていた。LLM がどれだけ賢くなっても、学習に渡すデータがこのままでは、学習し直すたびに同じずれを覚え直すことになる。


## 3D CAD と 3Dプリンタで、治具と爪まで一緒に作れるのが強い

> 3Dプリンタもあって3D CADと組み合わせて治具やグリッパーの爪の作成なども一緒にできて提案できるのは強いね

**— 治具や爪まで自分たちで作れることは、何を強くしているのか。**

強いですね。理由は「考える → 作る → 試す」の輪が、1つのセルの中で数時間で閉じることだと思います。

- 治具で問題を小さくする：位置が決まれば、画像認識もつかみ方も簡単になります。AI に難しいことをさせるより、物の側を変えるほうが確実です。
- 爪を作業に合わせる：汎用の爪で頑張らず、物の形に合わせた爪を作るので、つかみ損ねが減ります。
- すぐ作り直せる：うまくいかなければ設計を直して、数十分で刷り直せます。人の業者に頼むと何日もかかる部分です。
- AI が CAD を書ける：CadQuery や OpenSCAD のようなコードで書く CAD なら、LLM がそのまま形を作れます。ソフトボールの例の「印刷する治具5点と指1組」も、たぶんこの流れです。

これは、ものづくりの現場で、離れた工場がそのまま作れる仕様書を書いてきた経験にも近い話です。「治具と爪で現場の問題を小さくする」発想そのもので、AI が設計を手伝える今、その経験の価値はむしろ上がっていると思います。

（このあと、3Dプリンタはまだ持っていないこと、FAIRINO を入れる少し前の時期に買うことを考えていることを伝えた）

**— 3Dプリンタを買うまでの間に、何を準備できるか。**

良い順番だと思います。作業場所が決まってからのほうが、置き場所、音、においのことも含めて選びやすいですし、「実際に必要になってから買う」という設備投資の方針にも合っています。

それまでの間は、プリンタがなくても2つ準備しておけます。

- 設計だけ先に試す：コードで書く CAD で、Claude Code に SO-101 の爪や置き台を設計させる。形の確認は画面上でできます。
- 刷るのは外に頼む：どうしても実物が要るときは、DMM.make のような出力サービスに1個だけ頼む。「買う前に借りて測る」と同じ考え方で、どのくらいの頻度で刷り直したくなるかも分かります。

その頻度が分かっていれば、FAIRINO を入れる頃に、どのくらいのプリンタが要るかを迷わず決められると思います。


## 締め ― 確実さは、賢いモデル1つではなく、手段の選び方とデータのそろい方から来る

**MicroFactory の確実さは、1つの賢い AI からではなく、作業ごとに手段を選び、治具で問題を小さくし、学習に渡すデータのずれを先に抑えることから来ていた。**

| 作業の種類 | MicroFactory の手段 | このプロジェクトで当てはめると |
|---|---|---|
| 位置が決まる作業（試験管・ねじ） | LLM が画像認識と制御のコードと治具を書く | 置き場所が決まった赤いブロックは、コードで動かす道も比べる |
| 柔らかい物（配線） | π0.5 を人が差分で直し、区間ごとに約20分で学習し直す | ゲームパッドの補正で π0.5 を学習し直す。その前に、お手本と補正のデータのずれを直す |
| それでも無理な所（材料の補充） | パートの人がたまに足す | 失敗したときの戻し方を速くする |
| 土台 | 専用の制御基板・同期したカメラ・Rust の制御 | 依頼249 の結果：お手本の関節の約半分が補間・映像は約70〜80ミリ秒遅れ |

LLM の進化は、これからも速い。そのたびに乗り換えを考えるより、学習に渡すデータがそろっているかを先に測っておくほうが、次の道具をすぐに使える。mechArm でいちばん小さく始めるなら、お手本を集めるときに、送る命令の往復の間も関節を読めるようにして、同じスクリプトで測り直すことになる。

### 出典

- [22Astronauts Ep 104「How to Train 99.9% Reliable Robots for $5（w/ Igor Kulakov）」](https://www.youtube.com/watch?v=aoBAdHjOhLM)
- [MicroFactory の研究ブログ「Steps towards continual learning」](https://research.microfactory.com/)
- [Founders, Inc.「He invented a "microfactory"」（YouTube・2026年7月）](https://www.youtube.com/watch?v=DhcWVqxF_wo)
- [Igor Kulakov さんの LinkedIn の投稿の一覧](https://www.linkedin.com/in/igor-kulakov-364a1553/recent-activity/all/)
- [MicroFactory の公式サイト](https://microfactory.com/)
- [TechCrunch「This $30M startup built a dog crate-sized robot factory that learns by watching humans」（2025年9月）](https://techcrunch.com/2025/09/16/this-30m-startup-built-a-dog-crate-sized-robot-factory-that-learns-by-watching-humans/)
- [π0.6*: a VLA That Learns From Experience（arXiv 2511.14759）](https://arxiv.org/pdf/2511.14759)
