def __init__(self, backbone, input_dim): super().__init__() self.student_backbone = backbone self.student_head = DINOProjectionHead(input_dim, 512, 64, 2048) self.teacher_backbone = copy.deepcopy(backbone) self.teacher_head = DINOProjectionHead(input_dim, 512, 64, 2048) deactivate_requires_grad(self.teacher_backbone) deactivate_requires_grad(self.teacher_head)
def test_activate_requires_grad(self): model = nn.Sequential( nn.Linear(32, 32), nn.ReLU(), ) self.assertTrue(has_grad(model)) deactivate_requires_grad(model) self.assertFalse(has_grad(model)) activate_requires_grad(model) self.assertTrue(has_grad(model))
def __init__(self, backbone): super().__init__() self.backbone = backbone self.projection_head = MoCoProjectionHead(512, 512, 128) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum)
def __init__(self, backbone): super().__init__() self.backbone = backbone self.projection_head = BYOLProjectionHead(512, 1024, 256) self.prediction_head = BYOLProjectionHead(256, 1024, 256) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum)
def __init__(self, backbone): super().__init__() # use the pretrained ResNet backbone self.backbone = backbone # freeze the backbone deactivate_requires_grad(backbone) # create a linear layer for our downstream classification model self.fc = nn.Linear(512, 10) self.criterion = nn.CrossEntropyLoss()
def __init__(self): super().__init__() resnet = torchvision.models.resnet18() self.backbone = nn.Sequential(*list(resnet.children())[:-1]) self.projection_head = MoCoProjectionHead(512, 512, 128) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum) self.criterion = NTXentLoss(memory_bank_size=4096)
def __init__(self): super().__init__() resnet = torchvision.models.resnet18() self.backbone = nn.Sequential(*list(resnet.children())[:-1]) self.projection_head = BYOLProjectionHead(512, 1024, 256) self.prediction_head = BYOLProjectionHead(256, 1024, 256) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum) self.criterion = NegativeCosineSimilarity()
def __init__(self, dataloader_kNN, num_classes): super().__init__(dataloader_kNN, num_classes) # create a ResNet backbone and remove the classification head resnet = lightly.models.ResNetGenerator('resnet-18') self.backbone = nn.Sequential(*list(resnet.children())[:-1], nn.AdaptiveAvgPool2d(1)) # create a byol model based on ResNet self.projection_head = BYOLProjectionHead(512, 1024, 256) self.prediction_head = BYOLProjectionHead(256, 1024, 256) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum) self.criterion = lightly.loss.SymNegCosineSimilarityLoss()
def __init__(self): super().__init__() resnet = torchvision.models.resnet18() backbone = nn.Sequential(*list(resnet.children())[:-1]) input_dim = 512 # instead of a resnet you can also use a vision transformer backbone as in the # original paper (you might have to reduce the batch size in this case): # backbone = torch.hub.load('facebookresearch/dino:main', 'dino_vits16', pretrained=False) # input_dim = backbone.embed_dim self.student_backbone = backbone self.student_head = DINOProjectionHead(input_dim, 512, 64, 2048) self.teacher_backbone = copy.deepcopy(backbone) self.teacher_head = DINOProjectionHead(input_dim, 512, 64, 2048) deactivate_requires_grad(self.teacher_backbone) deactivate_requires_grad(self.teacher_head) self.criterion = DINOLoss(output_dim=2048, warmup_teacher_temp_epochs=5)
def __init__(self, dataloader_kNN, num_classes): super().__init__(dataloader_kNN, num_classes) # create a ResNet backbone and remove the classification head num_splits = 0 if sync_batchnorm else 8 resnet = lightly.models.ResNetGenerator('resnet-18', num_splits=num_splits) self.backbone = nn.Sequential(*list(resnet.children())[:-1], nn.AdaptiveAvgPool2d(1)) # create a moco model based on ResNet self.projection_head = MoCoProjectionHead(512, 512, 128) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum) # create our loss with the optional memory bank self.criterion = lightly.loss.NTXentLoss( temperature=0.1, memory_bank_size=memory_bank_size)
def __init__(self, dataloader_kNN, num_classes): super().__init__(dataloader_kNN, num_classes) # create a ResNet backbone and remove the classification head resnet = torchvision.models.resnet18() last_conv_channels = list(resnet.children())[-1].in_features self.backbone = nn.Sequential( *list(resnet.children())[:-1], nn.Conv2d(last_conv_channels, num_ftrs, 1), nn.AdaptiveAvgPool2d(1) ) # create a byol model based on ResNet self.projection_head = BYOLProjectionHead(512, 1024, 256) self.prediction_head = BYOLProjectionHead(256,1024,256) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum) self.criterion = lightly.loss.SymNegCosineSimilarityLoss()
def __init__(self, dataloader_kNN, num_classes): super().__init__(dataloader_kNN, num_classes) # create a ResNet backbone and remove the classification head resnet = torchvision.models.resnet18() last_conv_channels = list(resnet.children())[-1].in_features self.backbone = nn.Sequential( *list(resnet.children())[:-1], nn.Conv2d(last_conv_channels, num_ftrs, 1), nn.AdaptiveAvgPool2d(1) ) # create a moco model based on ResNet self.projection_head = MoCoProjectionHead(num_ftrs, num_ftrs, 128) self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum) # create our loss with the optional memory bank self.criterion = lightly.loss.NTXentLoss( temperature=0.1, memory_bank_size=memory_bank_size)
def __init__(self): super().__init__() # create a ResNet backbone and remove the classification head resnet = torchvision.models.resnet18() self.backbone = nn.Sequential( *list(resnet.children())[:-1], ) # The backbone has output dimension 512 which defines # also the size of the hidden dimension. We select 128 # for the output dimension. self.projection_head = MoCoProjectionHead(512, 512, 128) # add the momentum network self.backbone_momentum = copy.deepcopy(self.backbone) self.projection_head_momentum = copy.deepcopy(self.projection_head) deactivate_requires_grad(self.backbone_momentum) deactivate_requires_grad(self.projection_head_momentum) # create our loss with the memory bank self.criterion = lightly.loss.NTXentLoss( temperature=0.1, memory_bank_size=4096 )