|
| 1 | +# Feature Extraction |
| 2 | + |
| 3 | +All of the models in `timm` have consistent mechanisms for obtaining various types of features from the model for tasks besides classification. |
| 4 | + |
| 5 | +## Penultimate Layer Features (Pre-Classifier Features) |
| 6 | + |
| 7 | +The features from the penultimate model layer can be obtained in severay ways without requiring model surgery (although feel free to do surgery). One must first decide if they want pooled or un-pooled features. |
| 8 | + |
| 9 | +### Unpooled |
| 10 | + |
| 11 | +There are three ways to obtain unpooled features. |
| 12 | + |
| 13 | +Without modifying the network, one can call `model.forward_features(input)` on any model instead of the usual `model(input)`. This will bypass the head classifier and global pooling for networks. |
| 14 | + |
| 15 | +If one wants to explicitly modify the network to return unpooled features, they can either create the model without a classifier and pooling, or remove it later. Both paths remove the parameters associated with the classifier from the network. |
| 16 | + |
| 17 | +#### forward_features() |
| 18 | +```python hl_lines="3 6" |
| 19 | +import torch |
| 20 | +import timm |
| 21 | +m = timm.create_model('xception41', pretrained=True) |
| 22 | +o = m(torch.randn(2, 3, 299, 299)) |
| 23 | +print(f'Original shape: {o.shape}') |
| 24 | +o = m.forward_features(torch.randn(2, 3, 299, 299)) |
| 25 | +print(f'Unpooled shape: {o.shape}') |
| 26 | +``` |
| 27 | +Output: |
| 28 | +```text |
| 29 | +Original shape: torch.Size([2, 1000]) |
| 30 | +Unpooled shape: torch.Size([2, 2048, 10, 10]) |
| 31 | +``` |
| 32 | + |
| 33 | +#### Create with no classifier and pooling |
| 34 | +```python hl_lines="3" |
| 35 | +import torch |
| 36 | +import timm |
| 37 | +m = timm.create_model('resnet50', pretrained=True, num_classes=0, global_pool='') |
| 38 | +o = m(torch.randn(2, 3, 224, 224)) |
| 39 | +print(f'Unpooled shape: {o.shape}') |
| 40 | +``` |
| 41 | +Output: |
| 42 | +```text |
| 43 | +Unpooled shape: torch.Size([2, 2048, 7, 7]) |
| 44 | +``` |
| 45 | + |
| 46 | +#### Remove it later |
| 47 | +```python hl_lines="3 6" |
| 48 | +import torch |
| 49 | +import timm |
| 50 | +m = timm.create_model('densenet121', pretrained=True) |
| 51 | +o = m(torch.randn(2, 3, 224, 224)) |
| 52 | +print(f'Original shape: {o.shape}') |
| 53 | +m.reset_classifier(0, '') |
| 54 | +o = m(torch.randn(2, 3, 224, 224)) |
| 55 | +print(f'Unpooled shape: {o.shape}') |
| 56 | +``` |
| 57 | +Output: |
| 58 | +```text |
| 59 | +Original shape: torch.Size([2, 1000]) |
| 60 | +Unpooled shape: torch.Size([2, 1024, 7, 7]) |
| 61 | +``` |
| 62 | + |
| 63 | +### Pooled |
| 64 | + |
| 65 | +To modify the network to return pooled features, one can use `forward_features()` and pool/flatten the result themselves, or modify the network like above but keep pooling intact. |
| 66 | + |
| 67 | +#### Create with no classifier |
| 68 | +```python hl_lines="3" |
| 69 | +import torch |
| 70 | +import timm |
| 71 | +m = timm.create_model('resnet50', pretrained=True, num_classes=0) |
| 72 | +o = m(torch.randn(2, 3, 224, 224)) |
| 73 | +print(f'Pooled shape: {o.shape}') |
| 74 | +``` |
| 75 | +Output: |
| 76 | +```text |
| 77 | +Pooled shape: torch.Size([2, 2048]) |
| 78 | +``` |
| 79 | + |
| 80 | +#### Remove it later |
| 81 | +```python hl_lines="3 6" |
| 82 | +import torch |
| 83 | +import timm |
| 84 | +m = timm.create_model('ese_vovnet19b_dw', pretrained=True) |
| 85 | +o = m(torch.randn(2, 3, 224, 224)) |
| 86 | +print(f'Original shape: {o.shape}') |
| 87 | +m.reset_classifier(0) |
| 88 | +o = m(torch.randn(2, 3, 224, 224)) |
| 89 | +print(f'Pooled shape: {o.shape}') |
| 90 | +``` |
| 91 | +Output: |
| 92 | +```text |
| 93 | +Pooled shape: torch.Size([2, 1024]) |
| 94 | +``` |
| 95 | + |
| 96 | + |
| 97 | +## Multi-scale Feature Maps (Feature Pyramid) |
| 98 | + |
| 99 | +Object detection, segmentation, keypoint, and a variety of dense pixel tasks require access to feature maps from the backbone network at multiple scales. This is often done by modifying the original classification network. Since each network varies quite a bit in structure, it's not uncommon to see only a few backbones supported in any given obj detection or segmentation library. |
| 100 | + |
| 101 | +`timm` allows a consistent interface for creating any of the included models as feature backbones that output feature maps for selected levels. |
| 102 | + |
| 103 | +A feature backbone can be created by adding the argument `features_only=True` to any `create_model` call. By default 5 strides will be output from most models (not all have that many), with the first starting at 2 (some start at 1 or 4). |
| 104 | + |
| 105 | +### Create a feature map extraction model |
| 106 | +```python hl_lines="3" |
| 107 | +import torch |
| 108 | +import timm |
| 109 | +m = timm.create_model('resnest26d', features_only=True, pretrained=True) |
| 110 | +o = m(torch.randn(2, 3, 224, 224)) |
| 111 | +for x in o: |
| 112 | + print(x.shape) |
| 113 | +``` |
| 114 | +Output: |
| 115 | +```text |
| 116 | +torch.Size([2, 64, 112, 112]) |
| 117 | +torch.Size([2, 256, 56, 56]) |
| 118 | +torch.Size([2, 512, 28, 28]) |
| 119 | +torch.Size([2, 1024, 14, 14]) |
| 120 | +torch.Size([2, 2048, 7, 7]) |
| 121 | +``` |
| 122 | + |
| 123 | +### Query the feature information |
| 124 | + |
| 125 | +After a feature backbone has been created, it can be queried to provide channel or resolution reduction information to the downstream heads without requiring static config or hardcoded constants. The `.feature_info` attribute is a class encapsulating the information about the feature extraction points. |
| 126 | + |
| 127 | +```python hl_lines="3 4" |
| 128 | +import torch |
| 129 | +import timm |
| 130 | +m = timm.create_model('regnety_032', features_only=True, pretrained=True) |
| 131 | +print(f'Feature channels: {m.feature_info.channels()}') |
| 132 | +o = m(torch.randn(2, 3, 224, 224)) |
| 133 | +for x in o: |
| 134 | + print(x.shape) |
| 135 | +``` |
| 136 | +Output: |
| 137 | +```text |
| 138 | +Feature channels: [32, 72, 216, 576, 1512] |
| 139 | +torch.Size([2, 32, 112, 112]) |
| 140 | +torch.Size([2, 72, 56, 56]) |
| 141 | +torch.Size([2, 216, 28, 28]) |
| 142 | +torch.Size([2, 576, 14, 14]) |
| 143 | +torch.Size([2, 1512, 7, 7]) |
| 144 | +``` |
| 145 | + |
| 146 | +### Select specific feature levels or limit the stride |
| 147 | + |
| 148 | +There are to additional creation arguments impacting the output features. |
| 149 | + |
| 150 | +* `out_indices` selects which indices to output |
| 151 | +* `output_stride` limits the feature output stride of the network (also works in classification mode BTW) |
| 152 | + |
| 153 | +`out_indices` is supported by all models, but not all models have the same index to feature stride mapping. Look at the code or check feature_info to compare. The out indices generally correspond to the `C(i+1)th` feature level (a `2^(i+1)` reduction). For most models, index 0 is the stride 2 features, and index 4 is stride 32. |
| 154 | + |
| 155 | +`output_stride` is achieved by converting layers to use dilated convolutions. Doing so is not always straightforward, some networks only support `output_stride=32`. |
| 156 | + |
| 157 | +```python hl_lines="3 4 5" |
| 158 | +import torch |
| 159 | +import timm |
| 160 | +m = timm.create_model('ecaresnet101d', features_only=True, output_stride=8, out_indices=(2, 4), pretrained=True) |
| 161 | +print(f'Feature channels: {m.feature_info.channels()}') |
| 162 | +print(f'Feature reduction: {m.feature_info.reduction()}') |
| 163 | +o = m(torch.randn(2, 3, 320, 320)) |
| 164 | +for x in o: |
| 165 | + print(x.shape) |
| 166 | +``` |
| 167 | +Output: |
| 168 | +```text |
| 169 | +Feature channels: [512, 2048] |
| 170 | +Feature reduction: [8, 8] |
| 171 | +torch.Size([2, 512, 40, 40]) |
| 172 | +torch.Size([2, 2048, 40, 40]) |
| 173 | +``` |
0 commit comments