Spaces:
Sleeping
Sleeping
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| from torchvision import transforms | |
| # Add more imports if required | |
| # Sample Transformation function | |
| # YOUR CODE HERE for changing the Transformation values. | |
| trnscm = transforms.Compose([ | |
| transforms.Grayscale(num_output_channels=1), | |
| transforms.Resize((100, 100)), | |
| transforms.ToTensor(), | |
| ]) | |
| ##Example Network | |
| class Siamese(torch.nn.Module): | |
| def __init__(self): | |
| super(Siamese, self).__init__() | |
| self.cnn1 = nn.Sequential( | |
| nn.ReflectionPad2d(1), #Pads the input tensor using the reflection of the input boundary, it similar to the padding. | |
| nn.Conv2d(1, 4, kernel_size=3), | |
| nn.ReLU(inplace=True), | |
| nn.BatchNorm2d(4), | |
| nn.ReflectionPad2d(1), | |
| nn.Conv2d(4, 8, kernel_size=3), | |
| nn.ReLU(inplace=True), | |
| nn.BatchNorm2d(8), | |
| nn.ReflectionPad2d(1), | |
| nn.Conv2d(8, 8, kernel_size=3), | |
| nn.ReLU(inplace=True), | |
| nn.BatchNorm2d(8), | |
| ) | |
| self.fc1 = nn.Sequential( | |
| nn.Linear(8*100*100, 500), | |
| nn.ReLU(inplace=True), | |
| nn.Linear(500, 500), | |
| nn.ReLU(inplace=True), | |
| nn.Linear(500, 25)) | |
| # forward_once is for one image. This can be used while classifying the face images | |
| def forward_once(self, x): | |
| output = self.cnn1(x) | |
| output = output.view(output.size()[0], -1) | |
| output = self.fc1(output) | |
| return output | |
| def forward(self, input1, input2): | |
| output1 = self.forward_once(input1) | |
| output2 = self.forward_once(input2) | |
| return output1, output2 | |
| class SiameseV2(nn.Module): | |
| """Stronger Siamese encoder for retraining. | |
| The original network keeps the full 100x100 spatial map until the first | |
| linear layer. This makes it parameter-heavy, weakly translation tolerant, | |
| and prone to learning dataset-specific pixel positions instead of face | |
| identity. Use this model when you retrain the Siamese checkpoint. | |
| """ | |
| def __init__(self, embedding_dim=128): | |
| super().__init__() | |
| self.cnn1 = nn.Sequential( | |
| nn.Conv2d(1, 32, kernel_size=3, padding=1, bias=False), | |
| nn.BatchNorm2d(32), | |
| nn.ReLU(inplace=True), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(32, 64, kernel_size=3, padding=1, bias=False), | |
| nn.BatchNorm2d(64), | |
| nn.ReLU(inplace=True), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False), | |
| nn.BatchNorm2d(128), | |
| nn.ReLU(inplace=True), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(128, 256, kernel_size=3, padding=1, bias=False), | |
| nn.BatchNorm2d(256), | |
| nn.ReLU(inplace=True), | |
| nn.AdaptiveAvgPool2d((1, 1)), | |
| ) | |
| self.fc1 = nn.Sequential( | |
| nn.Flatten(), | |
| nn.Linear(256, embedding_dim), | |
| ) | |
| def forward_once(self, x): | |
| output = self.cnn1(x) | |
| output = self.fc1(output) | |
| return F.normalize(output, p=2, dim=1) | |
| def forward(self, input1, input2): | |
| output1 = self.forward_once(input1) | |
| output2 = self.forward_once(input2) | |
| return output1, output2 | |
| ########################################################################################################## | |
| ## Sample classification network (Specify if you are using a pytorch classifier during the training) ## | |
| ## classifier = nn.Sequential(nn.Linear(64, 64), nn.BatchNorm1d(64), nn.ReLU(), nn.Linear...) ## | |
| ########################################################################################################## | |
| # YOUR CODE HERE for pytorch classifier | |
| # Definition of classes as dictionary | |
| classes = ['person1','person2','person3','person4','person5','person6','person7'] | |