File size: 7,783 Bytes
5d9f970
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
from types import SimpleNamespace

import numpy as np
import pytest
import torch
from torch import nn

from psi.runtime.swa_rollout import ReplyDebounce, body_metrics, inplace_future_progress
from psi.models.full_duplex_psi0 import QwenStreamingKVCache
from psi.models.swa_qa_branch import BranchLoRALinear


def test_inplace_phase_has_no_extra_transition_and_is_dense_stride_equivalent():
    rows = inplace_future_progress(0, 686)
    assert rows[0, 0] == pytest.approx(1 / 685)
    # Dense training and deployment ask for the same future frames.
    np.testing.assert_array_equal(inplace_future_progress(20, 686)[:10], rows[20:])
    np.testing.assert_allclose(rows[:, 2], rows[:, 0])
    np.testing.assert_array_equal(inplace_future_progress(1000, 686)[:, 0], 1)


def test_debounce_reuses_verified_two_window_rule():
    trigger = ReplyDebounce()
    assert [trigger.update(p) for p in [.8, .2, .8, .9, .9, .1, .9, .9]] == [
        False, False, False, True, False, False, False, True]


def test_motion_scores_do_not_reward_freezing_or_hide_seams():
    gt = np.zeros((60, 36))
    gt[:, 32] = 1
    gt[:, 0] = np.sin(np.arange(60) / 10)
    assert all(v == pytest.approx(0) for v in body_metrics(gt, gt).values())
    frozen = gt.copy()
    frozen[:, 0] = 0
    metrics = body_metrics(frozen, gt)
    assert metrics["joint_rmse_rad"] > 0
    assert metrics["joint_acceleration_error_rad_s2"] > 0
    jumped = gt.copy()
    jumped[20:, 0] += 1
    assert body_metrics(jumped, gt)["joint_velocity_error_rad_s"] > 0
    flipped = gt.copy()
    flipped[:, 32:36] *= -1
    assert body_metrics(flipped, gt)["root_rotation_deg"] == pytest.approx(0)


def test_private_cache_detaches_and_resets_only_selected_rows():
    from transformers.cache_utils import DynamicCache
    key = torch.ones(2, 1, 3, 2, requires_grad=True)
    private = QwenStreamingKVCache(
        source_ids=("a", "b"), past_key_values=DynamicCache(ddp_cache_data=[(key * 2, key * 3)]),
        attention_mask=torch.ones(2, 3, dtype=torch.long), token_count=3,
        logical_window_counts=(1, 1), av_next_positions=(4, 5),
    )
    main = QwenStreamingKVCache.empty(["a", "b"])
    main.qa_cache = private
    main.detach()
    assert not private.past_key_values.layers[0].keys.requires_grad
    main.rebind_rows(["c", "b"], [True, False])
    assert private.source_ids == ("c", "b")
    assert private.av_next_positions == (0, 5)
    assert private.attention_mask.tolist() == [[0, 0, 0], [1, 1, 1]]


def test_new_adapter_starts_at_base_and_trains_without_thawing_base():
    base = nn.Linear(3, 4, bias=False)
    x = torch.randn(2, 3)
    model = BranchLoRALinear(base)
    torch.testing.assert_close(model(x), base(x))
    model(x).square().sum().backward()
    assert base.weight.grad is None
    assert model.up.weight.grad.abs().sum() > 0
    down, up = torch.randn(16, 3), torch.randn(4, 16)
    with torch.no_grad():
        model.down.weight.copy_(down)
        model.up.weight.copy_(up)
    torch.testing.assert_close(model(x), base(x) + (x @ down.T) @ up.T)


def test_qa_loss_modifies_only_private_branch():
    from psi.models.full_duplex_swa import FullDuplexSwaModel
    model = FullDuplexSwaModel.__new__(FullDuplexSwaModel)
    nn.Module.__init__(model)
    model.reply_head = nn.Linear(2, 2)
    class PrivateQa(nn.Linear):
        def qa_loss(self, cache, targets):
            assert cache == "private"
            return self(torch.ones(1, 2)).square().sum(), torch.tensor(0), torch.tensor(2)
    model.qa_model = PrivateQa(2, 2)
    nn.Module.train(model)
    loss, correct, count = model.qa_loss(SimpleNamespace(qa_cache="private"), ["answer"])
    loss.backward()
    assert count == 2 and correct == 0
    assert model.reply_head.weight.grad is None
    assert model.qa_model.weight.grad.abs().sum() > 0


def test_independent_reply_readout_does_not_update_body_summary():
    """SWA readiness supervision must not perturb the action/Qwen body."""
    from psi.models.full_duplex_swa import FullDuplexSwaModel

    model = FullDuplexSwaModel.__new__(FullDuplexSwaModel)
    nn.Module.__init__(model)
    model.reply_head = nn.Linear(3, 2)
    model.swa_reply_detach_body = True
    summary = torch.randn(2, 3, requires_grad=True)
    logits = model.reply_head(model._reply_summary_for_loss(summary))
    torch.nn.functional.cross_entropy(logits, torch.tensor([0, 1])).backward()
    assert summary.grad is None
    assert model.reply_head.weight.grad is not None


def test_legacy_reply_readout_keeps_legacy_gradient_path():
    """The compatibility/shared branch is not silently changed."""
    from psi.models.full_duplex_swa import FullDuplexSwaModel

    model = FullDuplexSwaModel.__new__(FullDuplexSwaModel)
    nn.Module.__init__(model)
    model.reply_head = nn.Linear(3, 2)
    model.swa_reply_detach_body = False
    summary = torch.randn(2, 3, requires_grad=True)
    torch.nn.functional.cross_entropy(
        model.reply_head(model._reply_summary_for_loss(summary)),
        torch.tensor([0, 1]),
    ).backward()
    assert summary.grad is not None


def test_new_contract_is_explicit_and_legacy_contract_unchanged():
    from psi.models.relative_instruction_memory import architecture_contract
    cfg = SimpleNamespace()
    assert architecture_contract(cfg) == {}
    cfg.swa_visual_qa_enabled = True
    cfg.swa_qa_mode = "independent_online_lora"
    contract = architecture_contract(cfg)["swa_qa_online_v1"]
    assert contract["initialization"] == "original_pretrained_qwen_zero_lora"
    assert contract["private_online_kv"]
    assert not contract["body_receives_qa_gradient"]


def test_qa_clock_skips_silent_windows_and_survives_resume():
    from copy import deepcopy
    from psi.trainers.swa_optimizer import prepare_qa_update, split_gradient_parameters, clip_qa_gradients
    body, qa = nn.Parameter(torch.ones(2)), nn.Parameter(torch.ones(2))
    opt = torch.optim.AdamW([
        dict(params=[body]),
        dict(params=[qa], group_name="swa_qa", qa_updates=0, qa_base_lr=5e-5, qa_warmup_updates=40),
    ])
    b, q = split_gradient_parameters(opt)
    assert b == [body] and q == [qa]
    qa.grad = torch.ones(2)
    prepare_qa_update(opt, has_targets=True)
    clip_qa_gradients(q)
    opt.step()
    saved, weight = deepcopy(opt.state_dict()), qa.detach().clone()
    # Simulate a reducer manufacturing zero gradients on silent windows.
    for _ in range(19):
        qa.grad = torch.zeros_like(qa)
        prepare_qa_update(opt, has_targets=False)
        opt.step()
    torch.testing.assert_close(qa, weight, rtol=0, atol=0)
    assert opt.state[qa]["step"] == 1
    opt.load_state_dict(saved)
    qa.grad = torch.ones(2)
    body.grad = torch.ones(2)
    prepare_qa_update(opt, has_targets=True)
    clip_qa_gradients(q)
    torch.testing.assert_close(body.grad, torch.ones(2))
    assert opt.param_groups[1]["qa_updates"] == 2
    assert opt.param_groups[1]["lr"] == pytest.approx(5e-5 * 2 / 40)


def test_compact_checkpoint_keeps_frozen_qa_adapters_not_its_base():
    from psi.models.swa_qa_branch import OnlineQaBranch
    from psi.trainers.posttrain_full_duplex import PosttrainFullDuplexTrainer
    model = nn.Module()
    model.control_head = nn.Linear(2, 2)
    model.vlm_model = nn.Linear(2, 2)
    private = OnlineQaBranch.__new__(OnlineQaBranch)
    nn.Module.__init__(private)
    private.vlm_model = nn.Module()
    private.vlm_model.projection = BranchLoRALinear(nn.Linear(2, 2))
    model.qa_model = private
    model.requires_grad_(False)
    keys = PosttrainFullDuplexTrainer._hfdv2_delta_keys(model)
    assert {k for k in keys if k.startswith("qa_model.")} == {
        "qa_model.vlm_model.projection.down.weight", "qa_model.vlm_model.projection.up.weight"}
    assert {"control_head.weight", "control_head.bias"} <= keys