def __init__(self, features, num_classes, sobel): super(AlexNet, self).__init__() self.features = features self.classifier = nn.Sequential(nn.Dropout(0.5), nn.Linear(256 * 6 * 6, 4096), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(inplace=True)) self.top_layer = nn.Linear(4096, num_classes) self.l2norm = Normalize(2) self._initialize_weights() if sobel: grayscale = nn.Conv2d(3, 1, kernel_size=1, stride=1, padding=0) grayscale.weight.data.fill_(1.0 / 3.0) grayscale.bias.data.zero_() sobel_filter = nn.Conv2d(1, 2, kernel_size=3, stride=1, padding=1) sobel_filter.weight.data[0, 0].copy_( torch.FloatTensor([[1, 0, -1], [2, 0, -2], [1, 0, -1]]) ) sobel_filter.weight.data[1, 0].copy_( torch.FloatTensor([[1, 2, 1], [0, 0, 0], [-1, -2, -1]]) ) sobel_filter.bias.data.zero_() self.sobel = nn.Sequential(grayscale, sobel_filter) for p in self.sobel.parameters(): p.requires_grad = False else: self.sobel = None
def __init__(self, block, layers, low_dim=128): self.inplanes = 64 super(ResNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.avgpool = nn.AvgPool2d(7, stride=1) self.fc = nn.Linear(512 * block.expansion, low_dim) self.l2norm = Normalize(2) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
def __init__(self, num_features=0, out_planes=0, norm=False, dropout=0, num_classes=0, num_triplet_features=0): super(ShareNet, self).__init__() self.num_features = num_features self.norm = norm self.dropout = dropout self.has_embedding = num_features > 0 self.num_classes = num_classes self.num_triplet_features = num_triplet_features self.l2norm = Normalize(2) # Append new layers if self.has_embedding: self.feat = nn.Linear(out_planes * 2, self.num_features) self.feat_bn = nn.BatchNorm1d(self.num_features) init.kaiming_normal_(self.feat.weight, mode='fan_out') init.constant_(self.feat.bias, 0) init.constant_(self.feat_bn.weight, 1) init.constant_(self.feat_bn.bias, 0) else: # Change the num_features to CNN output channels self.num_features = out_planes if self.dropout >= 0: self.drop = nn.Dropout(self.dropout) if self.num_classes > 0: self.classifier = nn.Linear(self.num_features, self.num_classes) init.normal_(self.classifier.weight, std=0.001) init.constant_(self.classifier.bias, 0)
def __init__(self, out_size=128, channels=128, window_size=512, stride=512, embd_size=8, log_stride=None): super(MalConv, self).__init__() self.embd = nn.Embedding(257, embd_size, padding_idx=0) if not log_stride is None: stride = 2**log_stride self.conv_1 = nn.Conv1d(embd_size, channels, window_size, stride=stride, bias=True) self.conv_2 = nn.Conv1d(embd_size, channels, window_size, stride=stride, bias=True) self.fc_1 = nn.Linear(channels, channels) self.fc_2 = nn.Linear(channels, out_size) self.l2norm = Normalize(2)
def __init__(self, nfeatures=128, nclass=10, T=0.1): super(_Head_fc, self).__init__() self.nclass = nclass self.l2norm = Normalize(2) self.weight = nn.Parameter(torch.empty(nfeatures, nclass)) self.softmax = nn.Softmax(dim=1) self.T = T nn.init.normal_(self.weight)
def __init__(self, low_dim, tau2): super(FeatureDecorrelation, self).__init__() self.low_dim = torch.tensor(low_dim) self.tau2 = torch.tensor(tau2) self.l2norm = Normalize(2) self.ce = torch.nn.CrossEntropyLoss() # self.seq = torch.tensor(torch.range(0, low_dim-1), dtype=torch.long).to(get_dev()) self.seq = torch.arange(low_dim, dtype=torch.long, device=get_dev())
def __init__(self, block, num_blocks, low_dim=128): super(ResNetwithSobel, self).__init__() self.in_planes = 64 self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1) self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2) self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2) self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2) self.in_planes = 64 self.conv1_sobel = nn.Conv2d(2, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1_sobel = nn.BatchNorm2d(64) self.layer1_sobel = self._make_layer(block, 64, num_blocks[0], stride=1) self.layer2_sobel = self._make_layer(block, 128, num_blocks[1], stride=2) self.layer3_sobel = self._make_layer(block, 256, num_blocks[2], stride=2) self.layer4_sobel = self._make_layer(block, 512, num_blocks[3], stride=2) self.linear = nn.Linear(512 * 2 * block.expansion, low_dim) self.l2norm = Normalize(2) grayscale = nn.Conv2d(3, 1, kernel_size=1, stride=1, padding=0) grayscale.weight.data.fill_(1.0 / 3.0) grayscale.bias.data.zero_() sobel_filter = nn.Conv2d(1, 2, kernel_size=3, stride=1, padding=1) sobel_filter.weight.data[0, 0].copy_( torch.FloatTensor([[1, 0, -1], [2, 0, -2], [1, 0, -1]])) sobel_filter.weight.data[1, 0].copy_( torch.FloatTensor([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])) sobel_filter.bias.data.zero_() self.sobel = nn.Sequential(grayscale, sobel_filter) for p in self.sobel.parameters(): p.requires_grad = False
def __init__(self, depth, pretrained=True, cut_at_pooling=False, num_features=0, norm=False, dropout=0, num_classes=0, num_triplet_features=0): super(ResNet, self).__init__() self.depth = depth self.pretrained = pretrained self.cut_at_pooling = cut_at_pooling # Construct base (pretrained) resnet if depth not in ResNet.__factory: raise KeyError("Unsupported depth:", depth) self.base = ResNet.__factory[depth](pretrained=pretrained) # Fix layers [conv1 ~ layer2] fixed_names = [] for name, module in self.base._modules.items(): if name == "layer3": # assert fixed_names == ["conv1", "bn1", "relu", "maxpool", "layer1", "layer2"] break fixed_names.append(name) for param in module.parameters(): param.requires_grad = False if not self.cut_at_pooling: self.num_features = num_features self.norm = norm self.dropout = dropout self.has_embedding = num_features > 0 self.num_classes = num_classes self.num_triplet_features = num_triplet_features self.l2norm = Normalize(2) out_planes = self.base.fc.in_features # Append new layers if self.has_embedding: self.feat = nn.Linear(out_planes, self.num_features) self.feat_bn = nn.BatchNorm1d(self.num_features) init.kaiming_normal_(self.feat.weight, mode='fan_out') init.constant_(self.feat.bias, 0) init.constant_(self.feat_bn.weight, 1) init.constant_(self.feat_bn.bias, 0) else: # Change the num_features to CNN output channels self.num_features = out_planes if self.dropout >= 0: self.drop = nn.Dropout(self.dropout) if self.num_classes > 0: self.classifier = nn.Linear(self.num_features, self.num_classes) init.normal_(self.classifier.weight, std=0.001) init.constant_(self.classifier.bias, 0) if not self.pretrained: self.reset_params()
def __init__(self, block, num_blocks, low_dim=128): super(ResNet, self).__init__() self.in_planes = 64 self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1) self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2) self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2) self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2) self.linear = nn.Linear(512*block.expansion, low_dim) self.l2norm = Normalize(2)
def __init__(self, block, num_blocks, low_dim=128, multitask=False): super(ResNet, self).__init__() self.multitask = multitask self.in_planes = 23 self.conv1 = P4MConvZ2(3, 23, kernel_size=7, stride=2, padding=3, bias=False, batch_norm=True, max_pool=True) self.layer1 = self._make_layer(block, 23, num_blocks[0], stride=1) self.layer2 = self._make_layer(block, 45, num_blocks[1], stride=2) self.layer3 = self._make_layer(block, 91, num_blocks[2], stride=2) self.layer4 = self._make_layer(block, 181, num_blocks[3], stride=2) self.linear = nn.Linear(181*8*block.expansion, low_dim) self.l2norm = Normalize(2)
def __init__(self, block, nblocks, num_classes=[10], final_pool=True, mlp_depth=1, stride=2, color_channels=3, color_temp=1, num_color_classes=313, normalize=False): super(ResNet, self).__init__() blocks = [block, block, block] factor = 1 self.factor = factor self.in_planes = int(32 * factor) self.pre_layers_conv = conv_task(color_channels, int(32 * factor), 1) self.layer1 = self._make_layer(blocks[0], int(64 * factor), nblocks[0], stride=stride) self.layer2 = self._make_layer(blocks[1], int(128 * factor), nblocks[1], stride=stride) self.layer3 = self._make_layer(blocks[2], int(256 * factor), nblocks[2], stride=stride) self.end_bns = nn.Sequential(nn.BatchNorm2d(int(256 * factor)), nn.ReLU(True)) self.avgpool = nn.AdaptiveAvgPool2d(1) self.final_pool = final_pool self.stride = stride self.normalize = normalize if normalize: self.l2norm = Normalize(2) linear_ins = int(256 * factor) if final_pool else int(256 * 8 * 8 * factor) self.linears = self._mlp_layer(int(linear_ins), num_classes, depth=mlp_depth) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
def __init__(self, block, num_blocks, low_dim=128, medium_dim=128, mlp=False, pool_len=4, normlinear=False): super(ResNet, self).__init__() self.pool_len = pool_len self.in_planes = 64 linear_layer = NormedLinear if normlinear else nn.Linear self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1) self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2) self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2) self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2) self.mlp = mlp if self.mlp: self.pre_fc = nn.Sequential( nn.Linear(512 * block.expansion, medium_dim), ) self.linear = linear_layer(medium_dim, low_dim) self.l2norm = Normalize(2) else: self.linear = linear_layer(512 * block.expansion, low_dim) self.l2norm = Normalize(2) self.groupDis = nn.Sequential( linear_layer(512 * block.expansion, low_dim), Normalize(2))
def __init__(self, depth, num_classes, widen_factor=1, dropRate=0.0, norm=True): super(WideResNet, self).__init__() n_channels = [ 16, 16 * widen_factor, 32 * widen_factor, 64 * widen_factor ] assert ((depth - 4) % 6 == 0) n = (depth - 4) / 6 block = BasicBlock # 1st conv before any network block self.conv1 = nn.Conv2d(3, n_channels[0], kernel_size=3, stride=1, padding=1, bias=False) # 1st block self.block1 = NetworkBlock(n, n_channels[0], n_channels[1], block, 1, dropRate) # 2nd block self.block2 = NetworkBlock(n, n_channels[1], n_channels[2], block, 2, dropRate) # 3rd block self.block3 = NetworkBlock(n, n_channels[2], n_channels[3], block, 2, dropRate) # global average pooling and classifier self.bn1 = nn.BatchNorm2d(n_channels[3]) self.relu = nn.ReLU(inplace=True) self.fc = nn.Linear(n_channels[3], num_classes) self.nChannels = n_channels[3] for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_() elif isinstance(m, nn.Linear): m.bias.data.zero_() self.l2norm = Normalize(2) self.norm = norm
def wrapper(request, *args, **kwargs): validation = valid_dict if resolve: target = request.resolver_match.url_name.split('.') else: target = a.split('.') for t in target: validation = validation[t] data = {} document = dict(request.GET) schema = validation[request.method] if not document and request.method not in ['GET']: if isinstance(request._stream.stream, io.BufferedReader): data = request._stream.stream.peek() else: data = request._stream.stream.read() if re.match(r'^[0-9a-fA-F]{2}', data.decode()): split = data.split(b'\r\n') data = b'' for i in range(len(split)): if i % 2: data += split[i] meta = request.META['CONTENT_TYPE'] data = data.decode() parser = None if re.match(r'^(text/plain|application/json)', meta): parser = json.loads elif re.match(r'^application/yaml', meta): parser = yaml.safe_load elif re.match(r'^application/xml', meta): parser = lambda x: xmltodict.parse(x)['root'] try: document.update(parser(data) if data else {}) except Exception as e: 'Failed parsing payload ({})'.format(e), 512 converted = {} for k, v in schema['parameters'].items(): converted[k] = v if 'coerce' not in converted[k]: converted[k]['coerce'] = Normalize(converted[k]['type'], converted[k]).convert v = BaseValidator(converted, update=True, purge_unknown=True) document = v.normalized(document) if document is None: return v.errors, 428 if not v.validate(document): return v.errors, 428 data = document return f(request, validated=data, *args, **kwargs)
def __init__(self, negM, T, batchSize, device): super(Criterion, self).__init__() self.negM = negM self.T = T self.diag_mat = 1 - torch.eye(batchSize*2).to(device) self.l2norm = Normalize(2)
def __init__(self, block, layers, low_dim=128, multitask=False, showfeature=False, finetune=False, domain=False, args=None): self.inplanes = 64 super(ResNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) # self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, # bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.avgpool = nn.AvgPool2d(7, stride=1) # 7 if input is 224 !!!!!!!!!! self.fc = nn.Linear(512 * block.expansion, low_dim) self.l2norm = Normalize(2) self.saveembed = args.saveembed self.showfeature = showfeature self.multitask = multitask self.finetune = finetune self.domain = domain if self.finetune: self.finetune_layer = nn.Sequential( Flatten(), nn.Linear(128, 128, bias=False), nn.BatchNorm1d(128), nn.ReLU(inplace=True), nn.Linear(128, 2, bias=False), ) if self.multitask and self.domain: self.domain_classifier = nn.Linear(128, 2) self.pool = nn.MaxPool2d(kernel_size=3, stride=2) self.fc_block = nn.Sequential( Flatten(), # 3*3 if input is 224 nn.Linear(512 * 3 * 3, 256, bias=False), nn.BatchNorm1d(256), nn.ReLU(inplace=True), nn.Linear(256, 256, bias=False), nn.BatchNorm1d(256), nn.ReLU(inplace=True), ) if self.multitask: self.rotation_classifier = nn.Linear(128, 4) self.pool = nn.MaxPool2d(kernel_size=3, stride=2) self.fc_block = nn.Sequential( Flatten(), # 3*3 if input is 224 nn.Linear(512 * 3 * 3, 256, bias=False), nn.BatchNorm1d(256), nn.ReLU(inplace=True), nn.Linear(256, 256, bias=False), nn.BatchNorm1d(256), nn.ReLU(inplace=True), ) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()