def build_model(cfg): backbone = build_backbone(cfg) head = build_head(cfg) model = Sequential(OrderedDict([("backbone", backbone), ("head", head)])) if cfg.MODEL.PRETRAIN == "imagenet": backbone_name = cfg.MODEL.BACKBONE.NAME if backbone_name.startswith('resnet50_replaceFIRST'): backbone_name = 'resnet50' pretrained_path = os.path.expanduser( cfg.MODEL.PRETRIANED_PATH[backbone_name]) print( f">>> Loading imagenet pretrianed model from {pretrained_path}...") model.backbone.load_param(pretrained_path) elif os.path.exists(cfg.MODEL.PRETRAIN): print(f">>> Loading cfg model from {cfg.MODEL.PRETRAIN}...") ckp = torch.load(cfg.MODEL.PRETRAIN) model.load_state_dict(ckp["model"]) elif cfg.MODEL.PRETRAIN == "scratch": print(">>> train from scratch") else: assert ( False ), f"not imagenet pretrain and not exist model path: {cfg.MODEL.PRETRAIN}" return model
def __init__(self, in_channels=256, out_channels=None, inter_channels=256, depth=5, num_modules=3): super().__init__() if out_channels is None: out_channels = inter_channels self.channel_list1 = [ in_channels ] + [inter_channels] * (num_modules - 1) + [out_channels] self.channel_list2 = [ in_channels ] + [inter_channels] * (num_modules - 1) + [inter_channels] assert len(self.channel_list1) == num_modules + 1 self.depth = depth self.num_modules = num_modules self.res_list1 = Sequential(*[ ResidualModule(self.channel_list1[i], self.channel_list1[i + 1]) for i in range(self.num_modules) ]) self.res_list2 = Sequential(*[ ResidualModule(self.channel_list2[i], self.channel_list2[i + 1]) for i in range(self.num_modules) ]) if self.depth > 1: self.sub_hourglass = HourglassModule(inter_channels, out_channels, inter_channels, depth - 1, num_modules) else: self.res_waist = ResidualModule(inter_channels, out_channels) self.out_branch = ResidualModule(out_channels, out_channels)
def graduam( features: StochasticModule, classifier: StochasticModule, input_image: Tensor, num_samples: int = 50, ) -> Tensor: """Creates a gradient uncertainty attribution heatmap from the input image. Args: features: spatial feature part as stochastic module classifier: classifier part as stochastic module input_image: image tensor of dimensions (c, h, w) or (1, c, h, w) num_samples: number of stochastic samples to run Returns: a GradUAM heatmap of dimensions (h, w) """ input_image = _prepare_input(input_image) ensemble_start = EnsembleBegin(num_samples).stochastic_eval() feature_ensemble = EnsembleLayer(features).stochastic_eval() classifier_ensemble = EnsembleLayer(Sequential(classifier, Softmax(dim=1))) classifier_ensemble.stochastic_eval() gradam = GradAM( Sequential(classifier_ensemble, MutualInformationUncertainty()), SplitSelector(Identity(), []), Sequential(ensemble_start, feature_ensemble), SpatialSplit(), ) result = gradam.visualize(input_image).sum(-1) return _upscale(result, tuple(input_image.size()[2:]))
def guided_gradcam( feature_layers: List[Module], classifier_layers: List[Module], input_image: Tensor, n_top_classes: int = 3, ) -> Tensor: """Performs Guided GradCAM on an input image. For further explanations about Guided GradCam, see https://arxiv.org/abs/1610.02391. Args: feature_layers: the spatial feature layers of the model, before classifier classifier_layers: the classifier layers of the model, after spatial features input_image: image tensor of dimensions (c, h, w) or (1, c, h, w) n_top_classes: the number of classes to calculate GradCAM for Returns: a Guided GradCAM heatmap of dimensions (h, w) """ input_image = _prepare_input(input_image) # Create scaled up gradcam image cam = gradcam( Sequential(*feature_layers).eval(), Sequential(*classifier_layers).eval(), input_image, n_top_classes, ) # Create guided backprop image guided_backprop = guided_backpropagation( feature_layers + classifier_layers, input_image, n_top_classes ) # Multiply return cam.mul_(guided_backprop)
def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1, stride=1, padding=1, activation='PReLU', bias=False, asymmetric=False, dropout_prob=0): super(RegularBottleNeck, self).__init__() internal_channels = in_channels // 4 self.conv_down = Sequential( Conv2d(in_channels, internal_channels, kernel_size=1, stride=1, padding=0, bias=bias), BatchNorm2d(internal_channels), PReLU() if activation == 'PReLU' else ReLU()) if asymmetric is False: self.conv_main = Sequential( Conv2d(internal_channels, internal_channels, kernel_size=kernel_size, dilation=dilation, stride=stride, padding=padding, bias=bias), BatchNorm2d(internal_channels), PReLU() if activation == 'PReLU' else ReLU()) else: self.conv_main = Sequential( Conv2d(internal_channels, internal_channels, kernel_size=(kernel_size, 1), dilation=dilation, stride=stride, padding=(padding, 0), bias=bias), BatchNorm2d(internal_channels), PReLU() if activation == 'PReLU' else ReLU(), Conv2d(internal_channels, internal_channels, kernel_size=(1, kernel_size), dilation=dilation, stride=stride, padding=(0, padding), bias=bias), BatchNorm2d(internal_channels), PReLU() if activation == 'PReLU' else ReLU()) self.conv_up = Sequential( Conv2d(internal_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=bias), BatchNorm2d(out_channels), PReLU() if activation == 'PReLU' else ReLU()) self.regularizer = Dropout2d(p=dropout_prob) self.out_activation = PReLU() if activation == 'PReLU' else ReLU()
def n_layer_nn(optimiser_function, layer_dims=[28*28 + 1, 128, 10], learning_rate=0.1, epochs=100): layers = len(layer_dims) assert layers >= 3, "Please give at leaset 3 dimensions" modules = [Linear(layer_dims[0], layer_dims[1]), Relu()] for i in range(1, layers - 2): modules.append(Linear(layer_dims[i], layer_dims[i+1])) modules.append(Relu()) modules.append(Linear(layer_dims[layers-2], layer_dims[layers-1])) modules.append(Sigmoid()) print(modules) model = Sequential(*modules).cuda('cuda:0') loss_function = CrossEntropyLoss() optimiser = optimiser_function(model.parameters(), lr=learning_rate) stopper = EarlyStop(patience=3) train_losses=[] val_losses=[] accuracy=[] for epoch in range(epochs): losses=[] for i,(X, y) in enumerate(get_minibatches(train_loader, device)): optimiser.zero_grad() yhat = model.forward(X) loss = loss_function(yhat, y.argmax(1)) losses.append(loss.item()) loss.backward() optimiser.step() train_losses.append(np.mean(losses)) if epoch % 3 == 0: with torch.no_grad(): losses = [] corrects = 0 for i,(X, y) in enumerate(get_minibatches(val_loader, device)): y = y.argmax(1) yhat = model.forward(X) losses.append(loss_function(yhat, y).item()) ypred = yhat.argmax(1) corrects += (ypred == y).sum() val_loss = np.mean(losses) val_losses.append(val_loss) acc = corrects.cpu().numpy() / val_size #print("Accuracy {}".format(acc)) accuracy.append(acc) if not stopper.continue_still(val_loss): print("Early stop at epoch {}".format(epoch)) break return val_losses, accuracy
def __init__(self, in_channels, n_classes=13, bias=True, mode='B'): super(DFANet, self).__init__() channels = {'A': 72, 'B': 48} ch = channels[mode] self.conv1 = Sequential(Conv2d(in_channels, 8, 3, 2, 1, bias=bias), bna(8)) self.enc2_1 = enc(in_channels=8, stage=2, mode=mode, bias=bias) self.enc3_1 = enc(in_channels=ch, stage=3, mode=mode, bias=bias) self.enc4_1 = enc(in_channels=ch * 2, stage=4, mode=mode, bias=bias) self.fca1 = fca(ch * 4, ch * 4, bias=bias) self.enc2_2 = enc(in_channels=ch * 5, stage=2, mode=mode, bias=bias) self.enc3_2 = enc(in_channels=ch * 3, stage=3, mode=mode, bias=bias) self.enc4_2 = enc(in_channels=ch * 6, stage=4, mode=mode, bias=bias) self.fca2 = fca(ch * 4, ch * 4, bias=bias) self.enc2_3 = enc(in_channels=ch * 5, stage=2, mode=mode, bias=bias) self.enc3_3 = enc(in_channels=ch * 3, stage=3, mode=mode, bias=bias) self.enc4_3 = enc(in_channels=ch * 6, stage=4, mode=mode, bias=bias) self.fca3 = fca(ch * 4, ch * 4, bias=bias) self.de2_1 = Sequential(Conv2d(ch, ch // 2, 1, bias=bias), bna(ch // 2)) self.de2_2 = Sequential(Conv2d(ch, ch // 2, 1, bias=bias), bna(ch // 2)) self.de2_3 = Sequential(Conv2d(ch, ch // 2, 1, bias=bias), bna(ch // 2)) self.final = Sequential(Conv2d(ch // 2, n_classes, 1, bias=bias), bna(n_classes)) self.de4_1 = Sequential(Conv2d(ch * 4, n_classes, 1, bias=bias), bna(n_classes)) self.de4_2 = Sequential(Conv2d(ch * 4, n_classes, 1, bias=bias), bna(n_classes)) self.de4_3 = Sequential(Conv2d(ch * 4, n_classes, 1, bias=bias), bna(n_classes))
def __init__( self, in_shape: Tuple[int, int, int], outdims: int, bias: bool, init_noise: float = 1e-3, attention_kernel: int = 1, attention_layers: int = 1, mean_activity: Optional[Mapping[str, float]] = None, feature_reg_weight: float = 1.0, gamma_readout: Optional[ float] = None, # deprecated, use feature_reg_weight instead **kwargs: Any, ) -> None: super().__init__() self.in_shape = in_shape self.outdims = outdims self.feature_reg_weight = self.resolve_deprecated_gamma_readout( feature_reg_weight, gamma_readout) # type: ignore[no-untyped-call] self.mean_activity = mean_activity c, w, h = in_shape self.features = Parameter(torch.Tensor(self.outdims, c)) attention = Sequential() for i in range(attention_layers - 1): attention.add_module( f"conv{i}", Conv2d(c, c, attention_kernel, padding=attention_kernel > 1), ) attention.add_module( f"norm{i}", BatchNorm2d(c)) # type: ignore[no-untyped-call] attention.add_module(f"nonlin{i}", ELU()) else: attention.add_module( f"conv{attention_layers}", Conv2d(c, outdims, attention_kernel, padding=attention_kernel > 1), ) self.attention = attention self.init_noise = init_noise if bias: bias_param = Parameter(torch.Tensor(self.outdims)) self.register_parameter("bias", bias_param) else: self.register_parameter("bias", None) self.initialize(mean_activity)
def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1, stride=2, padding=1, output_padding=1, activation='PReLU', bias=False, dropout_prob=0.1): super(UpsamplingBottleNeck, self).__init__() internal_channels = in_channels // 4 self.conv_down = Sequential( Conv2d(in_channels, internal_channels, kernel_size=1, stride=1, padding=0, bias=bias), BatchNorm2d(internal_channels), PReLU() if activation == 'PReLU' else ReLU()) self.conv_main = Sequential( ConvTranspose2d(internal_channels, internal_channels, kernel_size=kernel_size, stride=stride, padding=padding, output_padding=output_padding, dilation=dilation, bias=bias), BatchNorm2d(internal_channels), PReLU() if activation == 'PReLU' else ReLU()) self.conv_up = Sequential( Conv2d(internal_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=bias), BatchNorm2d(out_channels), PReLU() if activation == 'PReLU' else ReLU()) self.main_conv = Sequential( Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=bias), BatchNorm2d(out_channels)) self.mainmaxunpool = MaxUnpool2d(kernel_size=2, stride=2, padding=0) self.regularizer = Dropout2d(p=dropout_prob) self.out_activation = PReLU() if activation == 'PReLU' else ReLU()
def build_model(cfg): backbone = build_backbone(cfg) head = build_head(cfg) model = Sequential(OrderedDict([('backbone', backbone), ('head', head)])) if cfg.MODEL.PRETRAIN == 'imagenet': print('Loading imagenet pretrianed model ...') pretrained_path = os.path.expanduser( cfg.MODEL.PRETRIANED_PATH[cfg.MODEL.BACKBONE.NAME]) model.backbone.load_param(pretrained_path) elif os.path.exists(cfg.MODEL.PRETRAIN): ckp = torch.load(cfg.MODEL.PRETRAIN) model.load_state_dict(ckp['model_state_dict']) return model
def __init__(self, vocab: Vocabulary, sentence_encoder: SentenceEncoder, question_encoder: SlotSequenceEncoder, span_selector: PruningSpanSelector, classify_invalids: bool = True, invalid_hidden_dim: int = 100, initializer: InitializerApplicator = InitializerApplicator(), regularizer: Optional[RegularizerApplicator] = None): super(QuestionToSpanModel, self).__init__(vocab, regularizer) self._sentence_encoder = sentence_encoder self._question_encoder = question_encoder self._span_selector = span_selector self._classify_invalids = classify_invalids self._invalid_hidden_dim = invalid_hidden_dim injected_embedding_dim = self._sentence_encoder.get_output_dim( ) + self._question_encoder.get_output_dim() extra_input_dim = self._span_selector.get_extra_input_dim() if injected_embedding_dim != extra_input_dim: raise ConfigurationError( "Sum of pred rep and question embedding dim %s did not match span selector injection dim of %s" % (injected_embedding_dim, extra_input_dim)) if self._classify_invalids: self._invalid_pred = Sequential( Linear(extra_input_dim, self._invalid_hidden_dim), ReLU(), Linear(self._invalid_hidden_dim, 1)) self._invalid_metric = BinaryF1()
def __init__(self, vocab: Vocabulary, sentence_encoder: SentenceEncoder, tan_ffnn: FeedForward, inject_predicate: bool = False, initializer: InitializerApplicator = InitializerApplicator(), regularizer: Optional[RegularizerApplicator] = None): super(SpanToTanModel, self).__init__(vocab, regularizer) self._sentence_encoder = sentence_encoder self._tan_ffnn = tan_ffnn self._inject_predicate = inject_predicate self._span_extractor = EndpointSpanExtractor( input_dim=self._sentence_encoder.get_output_dim(), combination="x,y") prediction_input_dim = (3 * self._sentence_encoder.get_output_dim() ) if self._inject_predicate else ( 2 * self._sentence_encoder.get_output_dim()) self._tan_pred = TimeDistributed( Sequential( Linear(prediction_input_dim, self._tan_ffnn.get_input_dim()), ReLU(), self._tan_ffnn, Linear(self._tan_ffnn.get_output_dim(), self.vocab.get_vocab_size("tan-string-labels")))) self._metric = BinaryF1()
def mini_vgg_decoder(): model = Sequential( # 8 x 8 UpsamplingBilinear2d(scale_factor=2), ConvTranspose2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), ConvTranspose2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), ConvTranspose2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), # 16 x 16 UpsamplingBilinear2d(scale_factor=2), ConvTranspose2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), # 32 x 32 UpsamplingBilinear2d(scale_factor=2), ConvTranspose2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), ConvTranspose2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), Tanh(), ) return model
def _make_layers(self): layers = [] layers += [ TiConv2d_acc23(in_channels=1, out_channels=20, kernel_size=5, stride=1, bias=False), TiReLU(), TiMaxpool2d(2, 2) ] layers += [ TiConv2d_acc23(in_channels=20, out_channels=50, kernel_size=5, stride=1, bias=False), TiReLU(), TiMaxpool2d(2, 2) ] layers += [TiFlat()] layers += [TiLinear(in_features=800, out_features=500)] layers += [TiReLU()] layers += [TiLinear(in_features=500, out_features=10)] return Sequential(*layers)
def mini_vgg_features(): model = Sequential( # 32 x 32 Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), # 16 x 16 Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), # 8 x 8 Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), ReLU(), MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), # 4 x 4 ) return model
def gradcam( features: Module, classifier: Module, input_image: Tensor, n_top_classes: int = 3 ) -> Tensor: """Performs GradCAM on an input image. For further explanations about GradCam, see https://arxiv.org/abs/1610.02391. Args: features: the spatial feature part of the model, before classifier classifier: the classifier part of the model, after spatial features input_image: image tensor of dimensions (c, h, w) or (1, c, h, w) n_top_classes: the number of classes to calculate GradCAM for Returns: a GradCAM heatmap of dimensions (h, w) """ # Get selector for top k classes input_image = _prepare_input(input_image) class_selector = _top_k_selector( Sequential(features.eval(), classifier.eval()), input_image, n_top_classes ) # Apply spatial GradAM on classes gradam = GradAM(classifier, class_selector, features, SpatialSplit()) result = gradam.visualize(input_image) return _upscale(result, tuple(input_image.size()[2:]))
def __init__(self, total_style): super(StyleBankNet, self).__init__() self.total_style = total_style self.alpha = args.alpha self.encoder_net = Sequential( ConvLayer(3, int(32 * self.alpha), kernel_size=9, stride=1), nn.InstanceNorm2d(int(32 * self.alpha)), nn.ReLU(inplace=True), ConvLayer(int(32 * self.alpha), int(64 * self.alpha), kernel_size=3, stride=2), nn.InstanceNorm2d(int(64 * self.alpha)), nn.ReLU(inplace=True), ConvLayer(int(64 * self.alpha), int(128 * self.alpha), kernel_size=3, stride=2), nn.InstanceNorm2d(int(128 * self.alpha)), nn.ReLU(inplace=True), ) self.decoder_net = Sequential( UpsampleConvLayer(int(128 * self.alpha), int(64 * self.alpha), kernel_size=3, stride=1, upsample=2), nn.InstanceNorm2d(int(64 * self.alpha)), nn.ReLU(inplace=True), UpsampleConvLayer(int(64 * self.alpha), int(32 * self.alpha), kernel_size=3, stride=1, upsample=2), nn.InstanceNorm2d(int(32 * self.alpha)), nn.ReLU(inplace=True), ConvLayer(int(32 * self.alpha), 3, kernel_size=9, stride=1), ) self.style_bank = nn.ModuleList([ Sequential( ConvLayer(int(128 * self.alpha), int(128 * self.alpha), kernel_size=3, stride=1), ) for i in range(total_style) ])
def __init__(self,in_channels,out_channels,stride,bias,down_sampling=False): super(block,self).__init__() if down_sampling or in_channels != out_channels[2]: self.shortcut = Sequential(Conv2d(in_channels,out_channels[2],1,stride,padding=0,groups=1,bias=bias),bna(out_channels[2])) else: self.shortcut = None self.conv1 = dsc(in_channels,out_channels[0],3,stride=1,bias=bias) self.conv2 = dsc(out_channels[0],out_channels[1],3,stride=1,bias=bias) self.conv3 = dsc(out_channels[1],out_channels[2],3,stride=stride,bias=bias)
def __init__(self, state_feats, max_actions, hidden=16): super().__init__() self.in_dim = state_feats self.hidden = hidden self.max_actions = max_actions self.lin = Sequential(Linear(self.in_dim, self.hidden), Tanh()) self.out = Linear(self.hidden, self.max_actions)
def __init__(self, K): super(MBPANet, self).__init__() self.K = K self.encoder_net = MyEncoder(self.K) self.decoder_net = MyDecoder(self.K) self.alg_bank = nn.ModuleList([Sequential( ConvLayer(8,8,kernel_size=3,stride=1), nn.ReLU() ) for i in range(2)])
def __init__(self, state_feats, action_feats, hidden=16, layers=1): super().__init__() self.in_dim = state_feats + action_feats self.hidden = hidden self.lin = Sequential(Linear(self.in_dim, self.hidden), Tanh(), Linear(self.hidden, self.hidden//10), Tanh()) self.out = Linear(self.hidden//10, 1)
def __init__(self,in_channels,stage=2,mode='A',bias=True): super(enc,self).__init__() assert stage in [2,3,4] repeats = [4, 6, 4] channels = [[12,12,48],[24,24,96],[48,48,192]] if mode=='A' else [[8,8,32],[16,16,64],[32,32,128]] channel = channels[stage-2] inter_channels=in_channels ops = [] for i in range(repeats[stage-2]): ops.append(block(inter_channels,channel,stride=2 if i==0 else 1,bias=bias,down_sampling=True if i==0 else False)) inter_channels = channel[2] self.ops = Sequential(*ops)
def __init__(self, in_channels, out_channels, activation='PReLU', bias=False): super(InitialBlock, self).__init__() self.conv = Conv2d(in_channels=in_channels, out_channels=out_channels - 3, kernel_size=3, stride=2, padding=1) self.maxpooling = MaxPool2d(kernel_size=2, stride=2, padding=0) self.bnActivate = Sequential( BatchNorm2d(out_channels), PReLU() if activation == 'PReLU' else ReLU())
def guided_backpropagation( layers: List[Module], input_image: Tensor, n_top_classes: int = 3 ) -> Tensor: """Calculates a simple saliency map of the pixel influence on the top n classes. Args: layers: the whole model in its layers input_image: image tensor of dimensions (c, h, w) or (1, c, h, w) n_top_classes: the number of classes to take into account Returns: a saliency heatmap of dimensions (h, w) """ # Find classes to analyze input_image = _prepare_input(input_image) net = Sequential(*layers).eval() class_selector = _top_k_selector(net, input_image, n_top_classes) # Apply guided backpropagation backprop = GuidedBackpropagation(layers, class_selector, SpatialSplit()) return backprop.visualize(input_image)
def __init__(self,in_channels,n_classes=13,bias=True,mode='B'): super(DFANet,self).__init__() channels={'A':[48,96,192],'B':[32,64,128]} ch=channels[mode] self.conv1= Sequential(Conv2d(in_channels,8,3,2,1,bias=bias),bna(8)) self.enc2_1 = enc(in_channels=8,stage=2,mode=mode,bias=bias) self.enc3_1 = enc(in_channels=ch[0], stage=3, mode=mode,bias=bias) self.enc4_1 = enc(in_channels=ch[1], stage=4, mode=mode, bias=bias) self.fca1 = fca(ch[2], ch[2], bias=bias) self.enc2_2 = enc(in_channels=ch[2]+ch[0], stage=2, mode=mode, bias=bias) self.enc3_2 = enc(in_channels=ch[0]+ch[1], stage=3, mode=mode, bias=bias) self.enc4_2 = enc(in_channels=ch[1]+ch[2], stage=4, mode=mode, bias=bias) self.fca2 = fca(ch[2], ch[2], bias=bias) self.enc2_3 = enc(in_channels=ch[2]+ch[0], stage=2, mode=mode, bias=bias) self.enc3_3 = enc(in_channels=ch[0]+ch[1], stage=3, mode=mode, bias=bias) self.enc4_3 = enc(in_channels=ch[1]+ch[2], stage=4, mode=mode, bias=bias) self.fca3 = fca(ch[2], ch[2], bias=bias) self.de2_1 = Sequential(Conv2d(ch[0],ch[0]//2,1,bias=bias),bna(ch[0]//2)) self.de2_2 = Sequential(Conv2d(ch[0],ch[0]//2,1,bias=bias),bna(ch[0]//2)) self.de2_3 = Sequential(Conv2d(ch[0],ch[0]//2,1,bias=bias),bna(ch[0]//2)) self.final = Sequential(Conv2d(ch[0]//2,n_classes,1,bias=bias),bna(n_classes)) self.de4_1 = Sequential(Conv2d(ch[2],n_classes,1,bias=bias),bna(n_classes)) self.de4_2 = Sequential(Conv2d(ch[2],n_classes,1,bias=bias),bna(n_classes)) self.de4_3 = Sequential(Conv2d(ch[2],n_classes,1,bias=bias),bna(n_classes))
def __init__(self, in_channels, out_channels, **kwargs): super().__init__() self.input_dim = in_channels self.output_dim = out_channels self.conv_skip = SConv2d(self.input_dim, self.output_dim, kernel_size=1) self.bottle_neck = Sequential(*[ nn.BatchNorm2d(self.input_dim, momentum=0.9), nn.ReLU(inplace=True), SConv2d(in_channels=self.input_dim, out_channels=self.output_dim // 2, kernel_size=1, bias=False), # => bottle-neck nn.BatchNorm2d(self.output_dim // 2, momentum=0.9), nn.ReLU(inplace=True), SConv2d(in_channels=self.output_dim // 2, out_channels=self.output_dim // 2, kernel_size=3, bias=False, padding=1), # End of bottle-neck nn.BatchNorm2d(self.output_dim // 2, momentum=0.9), nn.ReLU(inplace=True), SConv2d(in_channels=self.output_dim // 2, out_channels=self.output_dim, kernel_size=1, bias=False), ]) 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, input_dim=13, num_classes=9, sequencelength=13, d_model=64, n_head=1, n_layers=3, d_inner=256, activation="relu", dropout=0.39907201621346594): super(TransformerModel, self).__init__() self.modelname = f"TransformerEncoder_input-dim={input_dim}_num-classes={num_classes}_" \ f"d-model={d_model}_d-inner={d_inner}_n-layers={n_layers}_n-head={n_head}_" \ f"dropout={dropout}" encoder_layer = TransformerEncoderLayer(d_model, n_head, d_inner, dropout, activation) encoder_norm = LayerNorm(d_model) self.sequential = Sequential( Linear(input_dim, d_model), ReLU(), TransformerEncoder(encoder_layer, n_layers, encoder_norm), Flatten(), ReLU(), Linear(d_model * sequencelength, num_classes))
def _make_layers(self, cfg, num_classes): layers = [] in_channels = 3 for idx, x in enumerate(cfg): if x == 'M': layers += [TiMaxpool2d(2, 2)] else: layers += [ TiConv2d_acc23(in_channels=in_channels, out_channels=x, kernel_size=3, stride=1, padding=1, bias=BIAS_FLAG, first_layer=(idx == 0)), TiReLU() ] in_channels = x layers += [TiFlat()] layers += [TiLinear(512, num_classes, bias=BIAS_FLAG)] return Sequential(*layers)
def __init__(self, in_channels, out_channels, inter_channels, stacked_num=2, dropout_rate=0.2, refine=False): """ :param in_channels: 3 :param out_channels: K :param inter_channels: 256 :param stacked_num: 2 """ super().__init__() self.stacked_num = stacked_num self.refine = refine self.in_branch = Sequential(*[ SConv2d(in_channels=in_channels, out_channels=64, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(64, momentum=0.9), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2) ]) self.post_in_branch = Sequential(*[ ResidualModule(in_channels=64, out_channels=128), ResidualModule(in_channels=128, out_channels=128), ResidualModule(in_channels=128, out_channels=inter_channels) ]) self.hg_list = nn.ModuleList([ HourglassModule(inter_channels, inter_channels, inter_channels) for _ in range(stacked_num) ]) self.drop_list = nn.ModuleList([ nn.Dropout2d(dropout_rate, inplace=True) for _ in range(stacked_num) ]) self.inter_heatmap = nn.ModuleList([ SConv2d(in_channels=inter_channels, out_channels=out_channels, kernel_size=1, stride=1) for _ in range(stacked_num) ]) self.inter_rechannel = nn.ModuleList([ SConv2d(in_channels=out_channels, out_channels=inter_channels, kernel_size=1, stride=1) for _ in range(stacked_num - 1) ]) self.linear_module = nn.ModuleList([ Sequential(*[ SConv2d(in_channels=inter_channels, out_channels=inter_channels, kernel_size=1, stride=1), nn.BatchNorm2d(inter_channels, momentum=0.9), nn.ReLU(inplace=True) ]) for _ in range(stacked_num) ]) self.post_linear_module = nn.ModuleList([ Sequential(*[ SConv2d(in_channels=inter_channels, out_channels=inter_channels, kernel_size=1, stride=1), # BatchNormalization(momentum=0.9, epsilon=1e-5), # Activation('relu') ]) for _ in range(stacked_num - 1) ]) self.upsample_r = ResidualModule(in_channels=out_channels, out_channels=out_channels)
def __init__(self, total_style): super(StyleBankNet, self).__init__() self.total_style = total_style self.encoder_net = Sequential( nn.Conv2d(3, 32, kernel_size=(9, 9), stride=2, padding=(4, 4), bias=False), nn.InstanceNorm2d(32), nn.ReLU(inplace=True), nn.Conv2d(32, 64, kernel_size=(3, 3), stride=2, padding=(1, 1), bias=False), nn.InstanceNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 128, kernel_size=(3, 3), stride=1, padding=(1, 1), bias=False), nn.InstanceNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 256, kernel_size=(3, 3), stride=1, padding=(1, 1), bias=False), nn.InstanceNorm2d(256), nn.ReLU(inplace=True), ) self.decoder_net = Sequential( nn.ConvTranspose2d(256, 128, kernel_size=(3, 3), stride=1, padding=(1, 1), bias=False), nn.InstanceNorm2d(128), nn.ReLU(inplace=True), nn.ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=1, padding=(1, 1), bias=False), nn.InstanceNorm2d(64), nn.ReLU(inplace=True), nn.ConvTranspose2d(64, 32, kernel_size=(3, 3), stride=2, padding=(1, 1), bias=False), nn.InstanceNorm2d(32), nn.ReLU(inplace=True), nn.ConvTranspose2d(32, 3, kernel_size=(9, 9), stride=2, padding=(4, 4), bias=False), ) self.style_bank = nn.ModuleList([ Sequential( nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False), nn.InstanceNorm2d(256), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False), nn.InstanceNorm2d(256), nn.ReLU(inplace=True)) for i in range(total_style) ])