| from __future__ import annotations |
|
|
| import timm |
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
| from torchvision.models import ResNet18_Weights, resnet18 |
|
|
|
|
| class Encoder(nn.Module): |
| output_dim = 512 |
|
|
| def __init__(self, pretrained: bool = True): |
| super().__init__() |
| model = resnet18(weights=ResNet18_Weights.DEFAULT if pretrained else None) |
| model.conv1 = nn.Conv2d(3, 64, 3, 1, 1, bias=False) |
| model.maxpool = nn.Identity() |
| model.fc = nn.Identity() |
| self.model = model |
|
|
| def forward(self, images): |
| return F.normalize(self.model(images), dim=1) |
|
|
|
|
| class SSLModel(nn.Module): |
| def __init__(self, method: str, pretrained: bool = True, projection_dim: int = 128): |
| super().__init__() |
| self.method = method |
| self.encoder = Encoder(pretrained) |
| dim = self.encoder.output_dim |
| self.projector = nn.Sequential(nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, projection_dim)) if method in {"simclr", "joint"} else None |
| self.rotation_head = nn.Linear(dim, 4) if method in {"rotation", "joint"} else None |
| self.decoder = nn.Sequential( |
| nn.Linear(dim, 512 * 4 * 4), nn.Unflatten(1, (512, 4, 4)), |
| nn.ConvTranspose2d(512, 256, 4, 2, 1), nn.ReLU(), |
| nn.ConvTranspose2d(256, 128, 4, 2, 1), nn.ReLU(), |
| nn.ConvTranspose2d(128, 64, 4, 2, 1), nn.ReLU(), |
| nn.ConvTranspose2d(64, 3, 4, 2, 1), nn.Sigmoid(), |
| ) if method in {"autoencoder", "joint"} else None |
|
|
| def embedding(self, images): |
| return self.encoder(images) |
|
|
| def project(self, images): |
| return F.normalize(self.projector(self.encoder(images)), dim=1) |
|
|
| def reconstruct(self, images): |
| return self.decoder(self.encoder(images)) |
|
|
| def predict_rotation(self, images): |
| return self.rotation_head(self.encoder(images)) |
|
|
|
|
| class DINOEncoder(nn.Module): |
| def __init__(self, model_name="convnext_tiny.dinov3_lvd1689m"): |
| super().__init__() |
| self.model = timm.create_model(model_name, pretrained=True, num_classes=0) |
|
|
| def forward(self, images): |
| features = self.model(images) |
| if features.ndim > 2: |
| features = features.flatten(2).mean(-1) |
| return F.normalize(features.float(), dim=1) |
|
|
|
|
