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)
])
