8892830258

Committed 30 Apr 2024 09:55AM UTC coverage: 51.805% (+0.05%) from 51.751%

Build # 8892830258

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1633 from AntonioCarta/updatable_objects

Updatable objects

Run Details

248 of 436 new or added lines in 20 files covered. (56.88%)

9 existing lines in 1 file now uncovered.

15081 of 29111 relevant lines covered (51.81%)

0.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.49

/tests/training/test_regularization.py

import unittest
from types import SimpleNamespace

import torch
from torch.utils.data import DataLoader

from avalanche.models import SimpleMLP, MTSimpleMLP
from avalanche.models.utils import avalanche_model_adaptation
from avalanche.training.regularization import LearningWithoutForgetting
from tests.unit_tests_utils import get_fast_benchmark
import numpy as np
import random


class TestLwF(unittest.TestCase):
    def test_lwf(self):
        seed = 0
        torch.manual_seed(seed)
        np.random.seed(seed)
        random.seed(seed)
        torch.use_deterministic_algorithms(True)
        lwf = LearningWithoutForgetting()
        bm = get_fast_benchmark()

        teacher = SimpleMLP(input_size=6)
        model = SimpleMLP(input_size=6)
        for exp in bm.train_stream:
            mb_x, mb_y, mb_tl = list(DataLoader(exp.dataset))[0]
            mb_pred = model(mb_x)
            loss = lwf(mb_x, mb_pred, model)

            # non-zero loss after first task
            if lwf.expcount == 0:
                assert loss == 0
            else:
                assert loss > 0.0
            lwf.post_adapt(SimpleNamespace(model=teacher), exp)

        lwf = LearningWithoutForgetting()
        teacher = MTSimpleMLP(input_size=6)
        model = MTSimpleMLP(input_size=6)
        for exp in bm.train_stream:
            avalanche_model_adaptation(teacher, exp)
            avalanche_model_adaptation(model, exp)
            mb_x, mb_y, mb_tl = list(DataLoader(exp.dataset))[0]
            mb_pred = model(mb_x, task_labels=mb_tl)
            loss = lwf(mb_x, mb_pred, model)

            # non-zero loss after first task
            if lwf.expcount == 0:
                assert loss == 0
            else:
                assert loss > 0.0

                # non-zero loss for all the previous heads
                loss.backward()
                for tid in lwf.prev_classes_by_task.keys():
                    head = model.classifier.classifiers[str(tid)]
                    weight = head.classifier.weight
                    assert weight.grad is not None
                    assert torch.norm(weight.grad) > 0
                model.zero_grad()

            lwf.post_adapt(SimpleNamespace(model=teacher), exp)


if __name__ == "__main__":
    unittest.main()

1	import unittest	1✔
2	from types import SimpleNamespace	1✔
3
4	import torch	1✔
5	from torch.utils.data import DataLoader	1✔
6
7	from avalanche.models import SimpleMLP, MTSimpleMLP	1✔
8	from avalanche.models.utils import avalanche_model_adaptation	1✔
9	from avalanche.training.regularization import LearningWithoutForgetting	1✔
10	from tests.unit_tests_utils import get_fast_benchmark	1✔
11	import numpy as np	1✔
12	import random	1✔
13
14
15	class TestLwF(unittest.TestCase):	1✔
16	def test_lwf(self):	1✔
17	seed = 0	×
18	torch.manual_seed(seed)	×
19	np.random.seed(seed)	×
20	random.seed(seed)	×
21	torch.use_deterministic_algorithms(True)	×
22	lwf = LearningWithoutForgetting()	×
23	bm = get_fast_benchmark()	×
24
25	teacher = SimpleMLP(input_size=6)	×
26	model = SimpleMLP(input_size=6)	×
27	for exp in bm.train_stream:	×
28	mb_x, mb_y, mb_tl = list(DataLoader(exp.dataset))[0]	×
29	mb_pred = model(mb_x)	×
30	loss = lwf(mb_x, mb_pred, model)	×
31
32	# non-zero loss after first task
33	if lwf.expcount == 0:	×
34	assert loss == 0	×
35	else:
36	assert loss > 0.0	×
NEW 37	lwf.post_adapt(SimpleNamespace(model=teacher), exp)	×
38
39	lwf = LearningWithoutForgetting()	×
40	teacher = MTSimpleMLP(input_size=6)	×
41	model = MTSimpleMLP(input_size=6)	×
42	for exp in bm.train_stream:	×
43	avalanche_model_adaptation(teacher, exp)	×
44	avalanche_model_adaptation(model, exp)	×
45	mb_x, mb_y, mb_tl = list(DataLoader(exp.dataset))[0]	×
46	mb_pred = model(mb_x, task_labels=mb_tl)	×
47	loss = lwf(mb_x, mb_pred, model)	×
48
49	# non-zero loss after first task
50	if lwf.expcount == 0:	×
51	assert loss == 0	×
52	else:
53	assert loss > 0.0	×
54
55	# non-zero loss for all the previous heads
56	loss.backward()	×
57	for tid in lwf.prev_classes_by_task.keys():	×
58	head = model.classifier.classifiers[str(tid)]	×
59	weight = head.classifier.weight	×
60	assert weight.grad is not None	×
61	assert torch.norm(weight.grad) > 0	×
62	model.zero_grad()	×
63
NEW 64	lwf.post_adapt(SimpleNamespace(model=teacher), exp)	×
65
66
67	if __name__ == "__main__":	1✔
68	unittest.main()	×

ContinualAI / avalanche / 8892830258

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous