File size: 14,614 Bytes
06ba1d4 0eeed4c 06ba1d4 0eeed4c 06ba1d4 | 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 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 | """ALIGN-NEW donor-composition parity and independent output-head geometry checks."""
import contextlib
import copy
import hashlib
import importlib.machinery
import importlib.util
import json
import pathlib
import sys
import types
import unittest
from mp_opd_source_checks import assert_source_hash
import test_mp_opd_port as fixtures
ROOT = pathlib.Path(__file__).resolve().parents[1]
if fixtures.HAS_TORCH:
import torch
def original_scope():
"""Original guard/head-pair copies and donor method bodies, no adapter calls.
Existing v1 Gram/credit/chunk helpers are frozen, source-hash checked dependencies.
"""
from kdflow.algorithms._mp_opd_port import _mp_opd_grass_span as span
from kdflow.algorithms._mp_opd_port import _mp_opd_grass_chunk as chunk
from kdflow.algorithms._mp_opd_port import _mp_opd_align as align
from kdflow.algorithms._mp_opd_port._mp_opd_credit import soft_partition_loss
root = ROOT / 'tests/fixtures/align_new'
package = types.ModuleType('_align_original')
package.__path__ = [str(root)]
sys.modules['_align_original'] = package
sys.modules['_align_original._mp_opd_grass_span'] = span
for name in ('_mp_opd_head_pair', '_mp_opd_align_new'):
full = '_align_original.' + name
loader = importlib.machinery.SourceFileLoader(full, str(root / (name + '.py.txt')))
spec = importlib.util.spec_from_loader(full, loader)
module = importlib.util.module_from_spec(spec)
sys.modules[full] = module
loader.exec_module(module)
pair = sys.modules['_align_original._mp_opd_head_pair']
guard = sys.modules['_align_original._mp_opd_align_new']
scope = dict(torch=torch, contextlib=contextlib, chunk_head_gram=chunk.chunk_head_gram,
chunk_partition=chunk.chunk_partition, align_chunks=align.align_chunks,
align_metrics=align.align_metrics, head_pair_geometry=pair.head_pair_geometry,
align_new_guard=guard.align_new_guard, soft_partition_loss=soft_partition_loss,
run_chunk_assignment=chunk.run_chunk_assignment,
atom_chunk_ids_from_tokens=chunk.atom_chunk_ids_from_tokens)
for name in ('_align_loss', '_grass_chunk_assignment'):
exec(compile((root / (name + '.py.txt')).read_text(), 'donor_' + name, 'exec'), scope)
return scope
@unittest.skipUnless(fixtures.HAS_TORCH, 'requires existing PyTorch; no bootstrap')
class AlignNewTests(unittest.TestCase):
errors = []
@classmethod
def tearDownClass(cls):
if cls.errors:
print('ALIGN_NEW_PARITY ' + json.dumps({'cases': len(cls.errors),
'max_loss_abs_error': max(v[0] for v in cls.errors),
'max_gradient_abs_error': max(v[1] for v in cls.errors)}))
def setup_pair(self, *, source='run', cap=None, rho=.1):
from kdflow.algorithms.mp_opd_align_new import AlignNewMPOnPolicyKD
helper = fixtures.MPPortTests()
mp, student, teacher = helper.fixture(source=source, cap=cap)
mp.kd.mp_opd_align_new_min_descent_fraction = rho
mp.kd.mp_opd_align_new_eps_g = 1e-12
algo = AlignNewMPOnPolicyKD(mp.strategy, student, teacher, fixtures.Tokenizer(), fixtures.Tokenizer())
scope = original_scope()
reference = types.SimpleNamespace(mode='align_new', grass_chunk_source=source,
grass_chunk_run_length=mp.kd.mp_opd_chunk_run_length,
grass_chunk_straddle=mp.kd.mp_opd_chunk_straddle, grass_aligner=algo.aligner,
grass_geometry='exact_head', grass_softcap=cap, grass_head_bias=False,
align_eps_h=mp.kd.mp_opd_align_eps_h, align_new_min_descent_fraction=rho, trust_eps_g=1e-12)
reference._grass_chunk_assignment = types.MethodType(scope['_grass_chunk_assignment'], reference)
return helper, algo, student, teacher, scope, reference
def reference_loss(self, algo, student, teacher, batch, scope, reference):
from kdflow.algorithms._mp_opd_port._mp_opd_credit import build_atom_credits
sm, tm = batch['stu_loss_mask'], batch['tea_loss_mask']
sh = student(batch['stu_input_ids'])['hidden_states'][-1][sm]
th = batch['teacher_hiddens']
sy, ty = batch['stu_input_ids'].roll(-1, 1), batch['tea_input_ids'].roll(-1, 1)
total, so, to = sh.sum() * 0.0, 0, 0
for row in range(sm.shape[0]):
sid, tid = sy[row][sm[row]].tolist(), ty[row][tm[row]].tolist()
atoms = algo.atomizer.atomize(sid, tid, sample_id='original')
self.assertTrue(atoms.valid)
ns, nt = atoms.covered_student_events, atoms.covered_teacher_events
sl = student.model.lm_head(sh[so:so+ns], skip=False)
tl = teacher(th[to:to+nt]).detach()
if algo.student_cap is not None:
sl = torch.tanh(sl / algo.student_cap) * algo.student_cap
tl = torch.tanh(tl / algo.teacher_cap) * algo.teacher_cap
labels, tea_labels = sy[row][sm[row]][:ns], ty[row][tm[row]][:nt]
credits = build_atom_credits(atoms.atoms, sl, labels, tl, tea_labels)
loss, _ = scope['_align_loss'](reference, credits, atoms.atoms,
student_logits=sl, student_labels=labels, student_hidden=sh[so:so+ns],
student_ids=sid[:ns], teacher_ids=tid[:nt])
total = total + loss
so, to = so + len(sid), to + len(tid)
return total / batch['avg_micro_batch_token_num']
def test_full_adapter_loss_and_gradients_match_original_composition(self):
for source, cap, rho in [('run', None, .1), ('run', 3., .1), ('xtoken', None, .1),
('xtoken', 3., .1), ('run', None, 0.), ('run', None, 1.)]:
with self.subTest(source=source, cap=cap, rho=rho):
helper, algo, student, teacher, scope, reference = self.setup_pair(source=source, cap=cap, rho=rho)
rs, rt = copy.deepcopy(student), copy.deepcopy(teacher)
batch = helper.batch(copies=2)
actual = algo.training_step(batch)['train/loss']
expected = self.reference_loss(algo, rs, rt, batch, scope, reference)
ga = torch.autograd.grad(actual, tuple(student.parameters()))
gb = torch.autograd.grad(expected, tuple(rs.parameters()))
torch.testing.assert_close(actual, expected, atol=1e-6, rtol=1e-5)
for a, b in zip(ga, gb):
torch.testing.assert_close(a, b, atol=1e-6, rtol=1e-5)
self.errors.append((float((actual-expected).detach().abs()),
max(float((a-b).abs().max()) for a, b in zip(ga, gb))))
teacher_grads = torch.autograd.grad(algo.training_step(batch)['train/loss'],
(*teacher.parameters(), batch['teacher_hiddens']), allow_unused=True)
self.assertTrue(all(g is None for g in teacher_grads))
def test_active_global_guard_matches_original_loss_and_head_gradient(self):
from kdflow.algorithms._mp_opd_port._mp_opd_credit import AtomCreditTensors
_, algo, student, _, scope, ref = self.setup_pair()
ref.grass_chunk_run_length = 2
with torch.no_grad():
student.model.lm_head.weight.zero_()
hidden = torch.tensor([[1.,0.,0.,0.],[-1.,1.,0.,0.],[-.4,-1.,0.,0.]], requires_grad=True)
logits = student.model.lm_head(hidden, skip=False)
labels = torch.ones(3, dtype=torch.long)
nll = -logits.log_softmax(-1)[:, 1]
rate = torch.ones(3)
credits = AtomCreditTensors(-nll.detach()+1, -nll.detach(), rate, rate, rate, nll, nll)
atoms = tuple(types.SimpleNamespace(student_start=i, student_end=i+1) for i in range(3))
effective, metrics = algo._effective_rates(credits, atoms, ((0,2),(2,3)), hidden, labels)
actual = (effective*nll).sum()
expected, donor_metrics = scope['_align_loss'](ref, credits, atoms, student_logits=logits,
student_labels=labels, student_hidden=hidden, student_ids=[1]*3, teacher_ids=[1]*3)
torch.testing.assert_close(actual, expected)
ga = torch.autograd.grad(actual, student.model.lm_head.weight, retain_graph=True)[0]
gb = torch.autograd.grad(expected, student.model.lm_head.weight)[0]
torch.testing.assert_close(ga, gb)
beta = float(metrics['mp_opd_align_new_beta'])
self.assertGreater(beta, 0)
self.assertLess(beta, 1)
self.assertGreaterEqual(float(metrics['mp_opd_align_new_retained_descent_fraction']), .1-1e-6)
torch.testing.assert_close(metrics['mp_opd_align_new_beta'], donor_metrics['mp_opd_align_new_beta'])
self.errors.append((float((actual-expected).detach().abs()), float((ga-gb).abs().max())))
def test_full_head_pair_includes_cross_chunk_terms_bias_and_softcap(self):
from kdflow.algorithms._mp_opd_port._mp_opd_head_pair import head_pair_geometry
torch.manual_seed(123)
hidden = torch.randn(5,3)
weight = torch.randn(7,3, requires_grad=True)
bias = torch.randn(7, requires_grad=True)
labels = torch.tensor([0,1,2,3,4])
ranges = ((0,2),(2,3),(3,5))
first, second = torch.tensor([1.,-2.,.3]), torch.tensor([-.4,1.,2.])
raw = hidden @ weight.T + bias
logits = torch.tanh(raw / 2.) * 2.
lp = logits.log_softmax(-1).gather(1, labels[:,None]).squeeze(1)
sums = torch.stack([-lp[a:b].sum() for a,b in ranges])
ga = torch.cat([g.flatten() for g in torch.autograd.grad((first*sums).sum(), (weight,bias), retain_graph=True)])
gb = torch.cat([g.flatten() for g in torch.autograd.grad((second*sums).sum(), (weight,bias))])
expected = (float(ga.double().square().sum()), float(gb.double().square().sum()), float((ga.double()*gb.double()).sum()))
for tile in (1,3,4096):
pair = head_pair_geometry(logits.detach(), hidden, labels, ranges, first, second,
selected_log_prob=lp.detach(), softcap=2., head_bias=True, vocab_chunk=tile)
torch.testing.assert_close(torch.tensor([pair.first_norm2,pair.second_norm2,pair.dot]), torch.tensor(expected), atol=1e-5, rtol=1e-5)
def test_microbatch_invariance_and_no_state_collision_with_v1(self):
helper, algo, student, _, _, _ = self.setup_pair()
full, one = helper.batch(2), helper.batch()
one['avg_micro_batch_token_num'] *= 2
a = algo.training_step(full)['train/loss']
b = algo.training_step(one)['train/loss'] + algo.training_step(one)['train/loss']
torch.testing.assert_close(a,b)
for x,y in zip(torch.autograd.grad(a, tuple(student.parameters())), torch.autograd.grad(b, tuple(student.parameters()))):
torch.testing.assert_close(x,y)
old, _, _ = helper.fixture('mp_opd_align')
with self.assertRaises(ValueError):
algo.load_state_dict(old.state_dict())
def test_ambient_autocast_uses_same_credit_logits_as_original(self):
from kdflow.algorithms._mp_opd_port._mp_opd_credit import build_atom_credits
helper, algo, student, teacher, scope, ref = self.setup_pair()
batch = helper.batch()
sy = batch['stu_input_ids'].roll(-1,1)[batch['stu_loss_mask']]
ty = batch['tea_input_ids'].roll(-1,1)[batch['tea_loss_mask']]
atomized = algo.atomizer.atomize(sy.tolist(), ty.tolist(), sample_id='autocast')
ns,nt = atomized.covered_student_events,atomized.covered_teacher_events
hidden = student(batch['stu_input_ids'])['hidden_states'][-1][batch['stu_loss_mask']][:ns]
with torch.autocast(device_type='cpu',dtype=torch.bfloat16):
logits = student.model.lm_head(hidden,skip=False)
teacher_logits = teacher(batch['teacher_hiddens'][:nt])
credits = build_atom_credits(atomized.atoms,logits,sy[:ns],teacher_logits,ty[:nt])
partition,_,_ = algo._partition(atomized.atoms,sy[:ns].tolist(),ty[:nt].tolist())
effective,metrics = algo._effective_rates(credits,atomized.atoms,partition,hidden,sy[:ns])
actual = (credits.current_nll*effective).sum()
expected,donor_metrics = scope['_align_loss'](ref,credits,atomized.atoms,
student_logits=logits,student_labels=sy[:ns],student_hidden=hidden,
student_ids=sy[:ns].tolist(),teacher_ids=ty[:nt].tolist())
torch.testing.assert_close(actual,expected,atol=1e-6,rtol=1e-5)
for key in ('atomic_head_norm2','candidate_head_norm2','candidate_atomic_dot','beta'):
name = 'mp_opd_align_new_'+key
torch.testing.assert_close(metrics[name],donor_metrics[name],atol=1e-5,rtol=1e-5)
def test_guard_edge_cases_and_invalid_geometry_fail_closed(self):
from kdflow.algorithms._mp_opd_port._mp_opd_align_new import align_new_guard
rate, candidate = torch.tensor([1.,2.]), torch.tensor([3.,4.])
for a,b,d in [(0.,1.,0.), (1.,1.,1.), (1.,1.,-1.)]:
actual, metrics = align_new_guard(rate,candidate,a,b,d)
expected, ref_metrics = original_scope()['align_new_guard'](rate,candidate,a,b,d)
torch.testing.assert_close(actual,expected)
torch.testing.assert_close(metrics['mp_opd_align_new_beta'],ref_metrics['mp_opd_align_new_beta'])
for a,b,d in [(1.,1.,2.), (-1.,1.,0.), (float('nan'),1.,0.)]:
with self.assertRaises((ValueError,FloatingPointError)):
align_new_guard(rate,candidate,a,b,d)
def test_argument_guards_and_registry(self):
from kdflow.arguments.distillation_args import DistillationArguments
from kdflow.algorithms import ALGO_DICT
opts = dict(kd_algorithm='mp_opd_align_new', kd_ratio=1., kd_loss_fn='rkl')
self.assertIn('mp_opd_align_new', ALGO_DICT)
self.assertEqual(DistillationArguments(**opts).mp_opd_align_new_min_descent_fraction, .1)
for kwargs in ({'mp_opd_grass_geometry':'diag'}, {'mp_opd_align_new_eps_g':-1},
{'mp_opd_align_new_min_descent_fraction':1.1}, {'mp_opd_align_new_eps_g':float('nan')}):
with self.assertRaises(ValueError):
DistillationArguments(**opts, **kwargs)
class AlignNewSourceTests(unittest.TestCase):
def test_source_hashes_and_unchanged_existing_algorithms(self):
manifest = json.loads((ROOT / 'docs/ALIGN_NEW_SOURCE.json').read_text())
for row in manifest['files'] + manifest['unchanged_existing_files']:
assert_source_hash(self, ROOT, row)
if __name__ == '__main__':
unittest.main()
|