def test_point_head(): inputs = [torch.randn(1, 32, 45, 45)] point_head = PointHead( in_channels=[32], in_index=[0], channels=16, num_classes=19) assert len(point_head.fcs) == 3 fcn_head = FCNHead(in_channels=32, channels=16, num_classes=19) if torch.cuda.is_available(): head, inputs = to_cuda(point_head, inputs) head, inputs = to_cuda(fcn_head, inputs) prev_output = fcn_head(inputs) test_cfg = ConfigDict( subdivision_steps=2, subdivision_num_points=8196, scale_factor=2) output = point_head.forward_test(inputs, prev_output, None, test_cfg) assert output.shape == (1, point_head.num_classes, 180, 180) # test multiple losses case inputs = [torch.randn(1, 32, 45, 45)] point_head_multiple_losses = PointHead( in_channels=[32], in_index=[0], channels=16, num_classes=19, loss_decode=[ dict(type='CrossEntropyLoss', loss_name='loss_1'), dict(type='CrossEntropyLoss', loss_name='loss_2') ]) assert len(point_head_multiple_losses.fcs) == 3 fcn_head_multiple_losses = FCNHead( in_channels=32, channels=16, num_classes=19, loss_decode=[ dict(type='CrossEntropyLoss', loss_name='loss_1'), dict(type='CrossEntropyLoss', loss_name='loss_2') ]) if torch.cuda.is_available(): head, inputs = to_cuda(point_head_multiple_losses, inputs) head, inputs = to_cuda(fcn_head_multiple_losses, inputs) prev_output = fcn_head_multiple_losses(inputs) test_cfg = ConfigDict( subdivision_steps=2, subdivision_num_points=8196, scale_factor=2) output = point_head_multiple_losses.forward_test(inputs, prev_output, None, test_cfg) assert output.shape == (1, point_head.num_classes, 180, 180) fake_label = torch.ones([1, 180, 180], dtype=torch.long) if torch.cuda.is_available(): fake_label = fake_label.cuda() loss = point_head_multiple_losses.losses(output, fake_label) assert 'pointloss_1' in loss assert 'pointloss_2' in loss
def _to_container(cfg): """ mmdet will assert the type of dict/list. So convert omegaconf objects to dict/list. """ if isinstance(cfg, DictConfig): cfg = OmegaConf.to_container(cfg, resolve=True) from mmcv.utils import ConfigDict return ConfigDict(cfg)
def test_point_head(): inputs = [torch.randn(1, 32, 45, 45)] point_head = PointHead( in_channels=[32], in_index=[0], channels=16, num_classes=19) assert len(point_head.fcs) == 3 fcn_head = FCNHead(in_channels=32, channels=16, num_classes=19) if torch.cuda.is_available(): head, inputs = to_cuda(point_head, inputs) head, inputs = to_cuda(fcn_head, inputs) prev_output = fcn_head(inputs) test_cfg = ConfigDict( subdivision_steps=2, subdivision_num_points=8196, scale_factor=2) output = point_head.forward_test(inputs, prev_output, None, test_cfg) assert output.shape == (1, point_head.num_classes, 180, 180)
def test_transformer(): config = ConfigDict( dict( encoder=dict( type='DetrTransformerEncoder', num_layers=6, transformerlayers=dict( type='BaseTransformerLayer', attn_cfgs=[ dict( type='MultiheadAttention', embed_dims=256, num_heads=8, dropout=0.1) ], feedforward_channels=2048, ffn_dropout=0.1, operation_order=('self_attn', 'norm', 'ffn', 'norm'))), decoder=dict( type='DetrTransformerDecoder', return_intermediate=True, num_layers=6, transformerlayers=dict( type='DetrTransformerDecoderLayer', attn_cfgs=dict( type='MultiheadAttention', embed_dims=256, num_heads=8, dropout=0.1), feedforward_channels=2048, ffn_dropout=0.1, operation_order=('self_attn', 'norm', 'cross_attn', 'norm', 'ffn', 'norm')), ))) transformer = Transformer(**config) transformer.init_weights()
def __init__(self, attn_cfgs=None, ffn_cfgs=dict( type='FFN', embed_dims=256, feedforward_channels=1024, num_fcs=2, ffn_drop=0., act_cfg=dict(type='ReLU', inplace=True), ), operation_order=None, norm_cfg=dict(type='LN'), init_cfg=None, batch_first=False, **kwargs): deprecated_args = dict(feedforward_channels='feedforward_channels', ffn_dropout='ffn_drop', ffn_num_fcs='num_fcs') for ori_name, new_name in deprecated_args.items(): if ori_name in kwargs: warnings.warn( f'The arguments `{ori_name}` in BaseTransformerLayer ' f'has been deprecated, now you should set `{new_name}` ' f'and other FFN related arguments ' f'to a dict named `ffn_cfgs`. ', DeprecationWarning) ffn_cfgs[new_name] = kwargs[ori_name] super(BaseTransformerLayer, self).__init__(init_cfg) self.batch_first = batch_first assert set(operation_order) & set( ['self_attn', 'norm', 'ffn', 'cross_attn']) == \ set(operation_order), f'The operation_order of' \ f' {self.__class__.__name__} should ' \ f'contains all four operation type ' \ f"{['self_attn', 'norm', 'ffn', 'cross_attn']}" num_attn = operation_order.count('self_attn') + operation_order.count( 'cross_attn') if isinstance(attn_cfgs, dict): attn_cfgs = [copy.deepcopy(attn_cfgs) for _ in range(num_attn)] else: assert num_attn == len(attn_cfgs), f'The length ' \ f'of attn_cfg {num_attn} is ' \ f'not consistent with the number of attention' \ f'in operation_order {operation_order}.' self.num_attn = num_attn self.operation_order = operation_order self.norm_cfg = norm_cfg self.pre_norm = operation_order[0] == 'norm' self.attentions = ModuleList() index = 0 for operation_name in operation_order: if operation_name in ['self_attn', 'cross_attn']: if 'batch_first' in attn_cfgs[index]: assert self.batch_first == attn_cfgs[index]['batch_first'] else: attn_cfgs[index]['batch_first'] = self.batch_first attention = build_attention(attn_cfgs[index]) # Some custom attentions used as `self_attn` # or `cross_attn` can have different behavior. attention.operation_name = operation_name self.attentions.append(attention) index += 1 self.embed_dims = self.attentions[0].embed_dims self.ffns = ModuleList() num_ffns = operation_order.count('ffn') if isinstance(ffn_cfgs, dict): ffn_cfgs = ConfigDict(ffn_cfgs) if isinstance(ffn_cfgs, dict): ffn_cfgs = [copy.deepcopy(ffn_cfgs) for _ in range(num_ffns)] assert len(ffn_cfgs) == num_ffns for ffn_index in range(num_ffns): if 'embed_dims' not in ffn_cfgs[ffn_index]: ffn_cfgs['embed_dims'] = self.embed_dims else: assert ffn_cfgs[ffn_index]['embed_dims'] == self.embed_dims self.ffns.append( build_feedforward_network(ffn_cfgs[ffn_index], dict(type='FFN'))) self.norms = ModuleList() num_norms = operation_order.count('norm') for _ in range(num_norms): self.norms.append(build_norm_layer(norm_cfg, self.embed_dims)[1])
def test_detr_transformer_dencoder_encoder_layer(): config = ConfigDict( dict( return_intermediate=True, num_layers=6, transformerlayers=dict( type='DetrTransformerDecoderLayer', attn_cfgs=dict( type='MultiheadAttention', embed_dims=256, num_heads=8, dropout=0.1), feedforward_channels=2048, ffn_dropout=0.1, operation_order=( 'norm', 'self_attn', 'norm', 'cross_attn', 'norm', 'ffn', )))) assert DetrTransformerDecoder(**config).layers[0].pre_norm assert len(DetrTransformerDecoder(**config).layers) == 6 DetrTransformerDecoder(**config) with pytest.raises(AssertionError): config = ConfigDict( dict( return_intermediate=True, num_layers=6, transformerlayers=[ dict( type='DetrTransformerDecoderLayer', attn_cfgs=dict( type='MultiheadAttention', embed_dims=256, num_heads=8, dropout=0.1), feedforward_channels=2048, ffn_dropout=0.1, operation_order=('self_attn', 'norm', 'cross_attn', 'norm', 'ffn', 'norm')) ] * 5)) DetrTransformerDecoder(**config) config = ConfigDict( dict( num_layers=6, transformerlayers=dict( type='DetrTransformerDecoderLayer', attn_cfgs=dict( type='MultiheadAttention', embed_dims=256, num_heads=8, dropout=0.1), feedforward_channels=2048, ffn_dropout=0.1, operation_order=('norm', 'self_attn', 'norm', 'cross_attn', 'norm', 'ffn', 'norm')))) with pytest.raises(AssertionError): # len(operation_order) == 6 DetrTransformerEncoder(**config)