def problem(request) -> Tuple[Tensor, Module]:
"""Problem setting.
Args:
request: pytest request, contains parameters
Yields:
inputs and model
Raises:
NotImplementedError: if problem string is unknown
"""
batch_size, in_dim, out_dim = 2, 3, 4
inputs = rand(batch_size, in_dim)
if request.param == PROBLEM_STRING[0]:
model = Sequential(Linear(in_dim, out_dim), ReLU(), Linear(out_dim, out_dim))
elif request.param == PROBLEM_STRING[1]:
model = Sequential(Linear(in_dim, out_dim), Flatten(), Linear(out_dim, out_dim))
elif request.param == PROBLEM_STRING[2]:
inputs = rand(batch_size, in_dim, in_dim)
model = Sequential(
Linear(in_dim, out_dim), Flatten(), Linear(in_dim * out_dim, out_dim)
)
else:
raise NotImplementedError(f"unknown request.param={request.param}")
yield inputs, model
def __init__(self, args, n_dyn_fea, MAX_CAT_ID, MAX_DEPT_ID):
super(dilated_CNN, self).__init__()
# params
seq_len = args.use_days
self.n_dyn_fea = n_dyn_fea
self.n_dilated_layers = 3
kernel_size = 2
n_filters = 3
max_cat_id = [MAX_DEPT_ID, MAX_CAT_ID]
n_outputs = 28
dropout_rate = 0.1
# layers for categorical input
self.lambda0 = LambdaLayer(lambda x: x[:, 0])
self.lambda1 = LambdaLayer(lambda x: x[:, 1])
self.embedding0 = Embedding(max_cat_id[0] + 1,
ceil(log(max_cat_id[0] + 1)))
self.embedding1 = Embedding(max_cat_id[1] + 1,
ceil(log(max_cat_id[1] + 1)))
self.flatten0 = Flatten()
self.flatten1 = Flatten()
# Dilated convolutional layers
self.conv1d = CausalConv1d(in_channels=n_dyn_fea,
out_channels=n_filters,
kernel_size=kernel_size,
dilation=1)
self.conv1d_dilated0 = CausalConv1d(in_channels=n_filters,
out_channels=n_filters,
kernel_size=kernel_size,
dilation=2)
self.conv1d_dilated1 = CausalConv1d(in_channels=n_filters,
out_channels=n_filters,
kernel_size=kernel_size,
dilation=2**2)
self.conv1d_dilated2 = CausalConv1d(in_channels=n_filters,
out_channels=n_filters,
kernel_size=kernel_size,
dilation=2**3)
# conv output layers
self.conv1d_out = CausalConv1d(in_channels=n_filters * 2,
out_channels=8,
kernel_size=1)
self.dropout_out = Dropout(dropout_rate)
self.flatten_out = Flatten()
# layers for concatenating with cat and num features
self.dense_concat0 = Linear(in_features=1669, out_features=56)
self.dense_concat1 = Linear(in_features=56, out_features=n_outputs)
def TictactoeNet(board_size):
x = 3 * board_size * board_size
layers_fir = 243
layers_sec = 243
y = 1
in_features, hidden_features_fir, hidden_features_sec, out_features = x, layers_fir, layers_sec, y
model_layer_fir = Sequential(Flatten(),
Linear(in_features, hidden_features_fir))
model_layer_sec = Sequential(
Flatten(), Linear(hidden_features_fir, hidden_features_sec))
model = Sequential(Flatten(), Linear(hidden_features_sec, out_features))
return model
def __init__(self, triplets_dataset: TripletsDataset, dimension: int):
super().__init__()
self.high_invariance_net = alexnet(pretrained=True)
self.low_invariance_net_1 = Sequential(
Conv2d(3, 3, 1, stride=4, padding=2),
Conv2d(3, 96, 8, stride=4, padding=4),
MaxPool2d(3, stride=4, padding=0),
Flatten(),
)
self.low_invariance_net_2 = Sequential(
Conv2d(3, 3, 1, stride=8, padding=2),
Conv2d(3, 96, 8, stride=4, padding=4),
MaxPool2d(7, stride=2, padding=3),
Flatten(),
)
def __init__(self, n_actions=4, n_channels=4):
super().__init__()
self.phi = Sequential(
# f_32 k_3 s_2 p_1
Conv2d(n_channels, 32, 3, stride=2, padding=1, bias=True),
ELU(),
Conv2d(32, 32, 3, stride=2, padding=1, bias=True),
ELU(),
Conv2d(32, 32, 3, stride=2, padding=1, bias=True),
ELU(),
Conv2d(32, 32, 3, stride=2, padding=1, bias=True),
ELU(),
Identity(), # tap
Flatten(1, -1),
)
self.gee = torch.nn.Sequential(
Linear(2 * 32 * 3 * 3, 256, bias=True),
ReLU(),
Linear(256, n_actions, bias=True),
)
self.eff = torch.nn.Sequential(
Linear(32 * 3 * 3 + n_actions, 256, bias=True),
ReLU(),
Linear(256, 32 * 3 * 3, bias=True),
)
self.n_actions, self.n_emb_dim = n_actions, 32 * 3 * 3
def __init__(self):
super(ANN, self).__init__()
self.flatten = Flatten()
self.sequential = Sequential(
Linear(in_features=input_shape, out_features=512), ReLU(),
Linear(in_features=512, out_features=512), ReLU(),
Linear(in_features=512, out_features=10), ReLU())
def __init__(self, num_layers, drop_ratio, mode='ir_se'):
super().__init__()
assert num_layers in [50, 100, 152], 'num_layers should be 50, 100 or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64),
PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512),
Dropout(drop_ratio),
Flatten(),
Linear(512 * 7 * 7, 512),
BatchNorm1d(512))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel,
bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
def Warzone_NN(board_size):
m = Sequential(
Flatten(),
Linear(in_features=6 * board_size * board_size,
out_features=1,
bias=True))
return m
def __init__(self):
super(CNN, self).__init__()
self.feature_extraction = Sequential(
OrderedDict([
('conv_1',
Conv2d(in_channels=1,
out_channels=4,
stride=1,
kernel_size=5,
padding=0)), # 4x28x28
('bn_1', BatchNorm2d(num_features=4)),
('relu_1', ReLU(inplace=False)),
('pool_1', MaxPool2d(stride=2, kernel_size=2,
padding=0)), # 4x14x14
('drop_1', Dropout(p=0.1)),
('conv_2',
Conv2d(in_channels=4,
out_channels=8,
stride=1,
kernel_size=5,
padding=0)), # 8x10x10
('bn_2', BatchNorm2d(num_features=8)),
('relu_2', ReLU(inplace=False)),
('pool_2', MaxPool2d(stride=2, kernel_size=2,
padding=0)), # 8x5x5
('drop_2', Dropout(p=0.1)),
('flatten', Flatten(start_dim=1))
]))
self.classifier = Sequential(
OrderedDict([
('fc', Linear(in_features=(8 * 5 * 5), out_features=10)), # 10
('softmax', Softmax(dim=1))
]))
def __init__(self) -> None:
super().__init__()
self.conv1 = Conv2d(3, 32, 5, padding=2)
self.maxpool1 = MaxPool2d(2)
self.conv2 = Conv2d(32, 32, 5, padding=2)
self.maxpool2 = MaxPool2d(2)
self.conv3 = Conv2d(32, 64, 5, padding=2)
self.maxpool3 = MaxPool2d(2)
self.flatten = Flatten()
self.linear1 = Linear(1024, 64)
self.linear2 = Linear(64, 10)
self.model1 = Sequential(Conv2d(3, 32, 5, padding=2), MaxPool2d(2),
Conv2d(32, 32, 5, padding=2), MaxPool2d(2),
Conv2d(32, 64, 5, padding=2), MaxPool2d(2),
Flatten(), Linear(1024, 64), Linear(64, 10))
def __init__(self):
super().__init__()
self.flatten = Flatten()
self.layer = Linear(28 * 28, 50)
self.layer1 = Linear(50, 20)
self.layer2 = Linear(20, 10)
self.softmax = LogSoftmax()
def __init__(self):
super(Will, self).__init__()
self.name = "Will"
self.__version__ = "1.1"
# self.pool = MaxPool2d(2) # 2*2 max pooling
self.cnn_relu_stack = Sequential(
Conv2d(3, 16, 3), # 3 in-channel, 16 out-channel, number of kernel
ReLU(),
# MaxPool2d(2),
Conv2d(16, 24, 4),
ReLU(),
MaxPool2d(2),
Conv2d(24, 56, 5),
ReLU(),
MaxPool2d(2),
Conv2d(56, 112, 3),
ReLU(),
Flatten(),
Linear(448, 240),
ReLU(),
Linear(240, 120),
ReLU(),
Linear(120, 10), # 10 classes, final output
)
def __new__(cls, n_outputs, *, batch_norm=True):
layers = [
('conv_0', Conv2d(4, 32, 8, 4, bias=not batch_norm)),
('bnorm0', BatchNorm2d(32, affine=True)) if batch_norm else None,
('relu_0', ReLU()),
('tap_0', Identity()), # nop tap for viewer
# ('drop_1', Dropout(p=0.5)),
('conv_1', Conv2d(32, 64, 4, 2, bias=not batch_norm)),
('bnorm1', BatchNorm2d(64, affine=True)) if batch_norm else None,
('relu_1', ReLU()),
('tap_1', Identity()), # nop tap for viewer
# ('drop_2', Dropout(p=0.2)),
('conv_2', Conv2d(64, 64, 3, 1, bias=not batch_norm)),
('bnorm2', BatchNorm2d(64, affine=True)) if batch_norm else None,
('relu_2', ReLU()),
('tap_2', Identity()), # nop tap for viewer
('flat_3', Flatten(1, -1)),
('drop_3', Dropout(p=0.5)),
('dense3', Linear(64 * 7 * 7, 512, bias=True)),
('relu_3', ReLU()),
('drop_4', Dropout(p=0.2)),
('dense4', Linear(512, n_outputs, bias=True)),
]
# filter out `None`s and build a sequential network
return Sequential(OrderedDict(list(filter(None, layers))))
def main():
"""Create and execute an experiment."""
model = AnalogSequential(
Flatten(),
AnalogLinear(INPUT_SIZE,
HIDDEN_SIZES[0],
True,
rpu_config=SingleRPUConfig(device=ConstantStepDevice())),
Sigmoid(),
AnalogLinear(HIDDEN_SIZES[0],
HIDDEN_SIZES[1],
True,
rpu_config=SingleRPUConfig(device=ConstantStepDevice())),
Sigmoid(),
AnalogLinear(HIDDEN_SIZES[1],
OUTPUT_SIZE,
True,
rpu_config=SingleRPUConfig(device=ConstantStepDevice())),
LogSoftmax(dim=1))
# Create the training Experiment.
experiment = BasicTrainingWithScheduler(dataset=FashionMNIST,
model=model,
epochs=EPOCHS,
batch_size=BATCH_SIZE)
# Create the runner and execute the experiment.
runner = LocalRunner(device=DEVICE)
results = runner.run(experiment, dataset_root=PATH_DATASET)
print(results)
def __init__(self, labels_dim=0, D_lr=2e-4):
super(Discriminator, self).__init__()
self.conv = Sequential(
Conv2d(3, 16, kernel_size=3, stride=2, padding=1),
LeakyReLU(0.2, inplace=True),
Conv2d(16, 32, kernel_size=3, stride=2, padding=1),
BatchNorm2d(32),
LeakyReLU(0.2, inplace=True),
Conv2d(32, 64, kernel_size=3, stride=2, padding=1),
BatchNorm2d(64),
LeakyReLU(0.2, inplace=True),
Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
BatchNorm2d(128),
LeakyReLU(0.2, inplace=True),
Conv2d(128, 256, kernel_size=4, stride=2, padding=0),
BatchNorm2d(256),
LeakyReLU(0.2, inplace=True),
)
self.flatten = Flatten()
self.linear = Sequential(
Linear(256, 1),
Tanh(),
)
self.set_optimizer(optimizer, lr=D_lr)
def __init__(self):
super(Net_256mp, self).__init__()
self.conv_model1 = nn.Sequential(
nn.Conv2d(in_channels=channels,
out_channels=conv_out_channels,
kernel_size=kernel_size,
padding=conv_pad,
stride=conv_stride), nn.MaxPool2d(kernel_size=2,
stride=2),
nn.ReLU(inplace=True), nn.BatchNorm2d(conv_out_channels),
nn.Dropout(p=p)).to('cuda:0')
self.conv_model2 = nn.Sequential(
nn.Conv2d(in_channels=conv_out_channels,
out_channels=conv_out_channels,
kernel_size=kernel_size,
padding=conv_pad,
stride=conv_stride), nn.MaxPool2d(kernel_size=2,
stride=2),
nn.ReLU(inplace=True), nn.BatchNorm2d(conv_out_channels),
nn.Dropout(p=p),
nn.Conv2d(in_channels=conv_out_channels,
out_channels=conv2_out_channels,
kernel_size=kernel_size,
padding=conv_pad,
stride=conv_stride), nn.MaxPool2d(kernel_size=2,
stride=2),
nn.ReLU(inplace=True), nn.BatchNorm2d(conv2_out_channels),
nn.Dropout(p=p),
nn.Conv2d(in_channels=conv2_out_channels,
out_channels=conv2_out_channels,
kernel_size=kernel_size,
padding=conv_pad,
stride=conv_stride), nn.MaxPool2d(kernel_size=2,
stride=2),
nn.ReLU(inplace=True), nn.BatchNorm2d(conv2_out_channels),
nn.Dropout(p=p),
nn.Conv2d(in_channels=conv2_out_channels,
out_channels=conv3_out_channels,
kernel_size=kernel_size,
padding=conv_pad,
stride=conv_stride), nn.MaxPool2d(kernel_size=2,
stride=2),
nn.ReLU(inplace=True), nn.BatchNorm2d(conv3_out_channels),
nn.Dropout(p=p),
nn.Conv2d(in_channels=conv3_out_channels,
out_channels=conv3_out_channels,
kernel_size=kernel_size,
padding=conv_pad,
stride=conv_stride), nn.MaxPool2d(kernel_size=2,
stride=2),
nn.ReLU(inplace=True), nn.BatchNorm2d(conv3_out_channels),
nn.Dropout(p=p)).to('cuda:1')
self.lin_model = nn.Sequential(
Flatten(),
Linear(in_features=conv3_out_channels * (256 // 64) * (256 // 64),
out_features=100), nn.ReLU(inplace=True), nn.Dropout(p=p),
Linear(in_features=100, out_features=1)).to('cuda:1')
def __init__(self, config, dropout = 0.2, temperature = None):
super(TDConway, self).__init__()
self.temperature = temperature
self.stack_1 = ConvStack(3, 64, num_layers = 2, initial_depth = config.num_channels)
self.pool = MaxPool2d(3, 3, (0,1)) # Downsample (15,19) -> (5, 7)
# See PyTorch docs for torch.nn.MaxPool2d
pooled_height = (config.rows + 2) // 3
pooled_width = (config.cols + 4) // 3
self.stack_2 = ConvStack(3, 128, num_layers = 2, initial_depth = 64)
self.fc = Sequential(
Flatten(),
Linear(128 * pooled_height * pooled_width, 256),
SELU(),
Dropout(dropout),
Linear(256, 2048),
SELU(),
Dropout(dropout),
Linear(2048, 1),
Sigmoid()
)
def ChessNet1(selection):
state = game_file.initial_state(selection)
module = Sequential(
Flatten(), Linear(3 * len(state.board) * len(state.board[0]), 1, True))
return module
def __init__(self, config, dropout = 0.2):
super(TDConway, self).__init__()
self.stack_1 = ResidualConvStack(3, 64, layer_structure = [1,2,2,2], initial_depth = config.num_channels)
self.pooler = MaxPool2d(3, 3, (0,1)) # Downsample (15,19) -> (5, 7)
# See PyTorch docs for torch.nn.MaxPool2d
pooled_height = (config.rows + 2) // 3
pooled_width = (config.cols + 4) // 3
self.stack_2 = ResidualConvStack(3, 128, layer_structure = [1,2,2,2], initial_depth = 64)
self.fc = Sequential(
Flatten(),
Linear(128 * pooled_height * pooled_width, 512),
SELU(),
Dropout(0), # Remove in eval
Linear(512, 2048),
SELU(),
Dropout(0), # Remove in eval
Linear(2048, 1),
# Sigmoid() # Remove in evaluation version
)
def _init_layers(self):
layers = []
for idx, dims in enumerate(self.layers_dims):
if idx == 0:
current_dims = 3
next_dims = dims
else:
current_dims = self.layers_dims[idx - 1]
next_dims = dims
layers.extend([
Conv2d(in_channels=current_dims,
out_channels=next_dims,
kernel_size=3,
stride=2,
padding=1),
BatchNorm2d(next_dims),
self.activation(),
])
self.flat_size = self.layers_dims[-1] * 5 * 5
layers.extend([
Flatten(),
#Dropout(p=0.25),
Linear(self.flat_size, int(self.flat_size / 9)),
ReLU(),
#Dropout(p=0.4),
])
if self.non_variational:
layers.append(Linear(int(self.flat_size / 9), self.latent_size))
else:
self.init_gaussian_params(int(self.flat_size / 9))
return layers
def __init__(self, batch_size, inputs, outputs):
#Initializing the superclass and storing the parameters
super(CnnRegressor, self).__init__()
self.batch_size = batch_size
self.inputs = inputs
self.outputs = outputs
#Defining the input layer with the input size, kernel size and output size
self.input_layer = Conv1d(inputs, batch_size, 1)
#Defining a max pooling layer with a kernel size
self.max_pooling_layer = MaxPool1d(1)
#Defining another convolutional layer
self.conv_layer = Conv1d(batch_size, 128, 1)
#Defining a flatten layer
self.flatten_layer = Flatten()
#defining a linear layer with inputs and output as the arguments
self.linear_layer = Linear(128, 64)
#Defining the output layer
self.output_layer = Linear(64, outputs)
def __init__(self, batch_size, inputs, outputs):
super(CnnRegressor, self).__init__()
self.batch_size = batch_size
self.inputs = inputs
self.outputs = outputs
self.input_bn = nn.BatchNorm1d(8) #batch normalization
self.input_layer = Conv1d(inputs, batch_size, 1) #input layer
self.max_pooling_layer = MaxPool1d(1) #max-pooling layer
self.conv_layer1 = Conv1d(batch_size, 128, 1) #first conv layer
self.conv_bn1 = nn.BatchNorm1d(128) #batch normaliation after first conv
self.conv_layer2 = Conv1d(128, 256, 1) #second conv layer
self.conv_bn2 = nn.BatchNorm1d(256) #batch normaliation after second conv
self.flatten_layer = Flatten() #flatten layer to vectorize the data
self.linear_layer = Linear(256, 64) #linear regression
self.output_layer = Linear(64, outputs) #output layer
def __init__(self):
super(CIFAR, self).__init__()
self.model = Sequential(Conv2d(3, 32, 5, padding=2), MaxPool2d(2),
Conv2d(32, 32, 5, padding=2), MaxPool2d(2),
Conv2d(32, 64, 5, padding=2), MaxPool2d(2),
Flatten(), Linear(64 * 4 * 4, 64),
Linear(64, 10))
def setup(device):
"""Load MNIST batch, create extended CNN and loss function. Load to device.
Args:
device (torch.device): Device that all objects are transferred to.
Returns:
inputs, labels, model, loss function
"""
X, y = load_one_batch_mnist(batch_size=64)
X, y = X.to(device), y.to(device)
model = extend(
Sequential(
Conv2d(1, 128, 3, padding=1),
ReLU(),
MaxPool2d(3, stride=2),
Conv2d(128, 256, 3, padding=1),
ReLU(),
MaxPool2d(3, padding=1, stride=2),
Conv2d(256, 64, 3, padding=1),
ReLU(),
MaxPool2d(3, stride=2),
Conv2d(64, 32, 3, padding=1),
ReLU(),
MaxPool2d(3, stride=2),
Flatten(),
Linear(32, 10),
).to(device)
)
lossfunc = extend(CrossEntropyLoss().to(device))
return X, y, model, lossfunc
def _make_cnn(
conv_cls: Type[Module], output_dim: int, conv_params: Tuple
) -> Sequential:
linear = Linear(output_dim, 5)
set_requires_grad(linear, False)
return Sequential(conv_cls(*conv_params), ReLU(), Flatten(), linear)
def __init__(self,
input_size,
channel_last=True,
hidden_size=50,
**kwargs):
# Defaults
self.input_length = 20
self.input_size = input_size
self.hidden_size = hidden_size
self.num_classes = 2
self.label_embedding_size = self.num_classes
self.prob_classes = torch.ones(self.num_classes)
self.dropout = 0.5
self.label_type = 'required'
self.channel_last = channel_last
# Set kwargs (might overried above attributes)
for key, value in kwargs.items():
setattr(self, key, value)
super(CNNCGANDiscriminator, self).__init__(self.input_size,
self.label_type)
# Build CNN layer
self.label_embeddings = nn.Embedding(self.num_classes,
self.label_embedding_size)
Conv1d_ = lambda k: Conv1d(hidden_size, hidden_size, k)
layers_input_size = self.input_size + self.label_embedding_size
layers_output_size = 5 * hidden_size
## Build CNN layer
self.layers = nn.Sequential(
Conv1d(layers_input_size, hidden_size, 1),
LeakyReLU(0.2),
# output size: (-1, 50, 20)
Conv1d_(3),
ReplicationPad1d(1),
LeakyReLU(0.2),
Conv1d_(3),
ReplicationPad1d(1),
LeakyReLU(0.2),
AvgPool1d(2, 2),
# output size: (-1, 50, 10)
Conv1d_(3),
ReplicationPad1d(1),
LeakyReLU(0.2),
Conv1d_(3),
ReplicationPad1d(1),
LeakyReLU(0.2),
AvgPool1d(2, 2),
# output size: (-1, 50, 5)
Flatten(),
Linear(layers_output_size, 1)
# output size: (-1, 1)
)
# Initialize all weights.
self._weight_initializer()
def __init__(self):
super(ConvNet, self).__init__()
self.input_layer = Conv1d(3, 10, 1)
self.max_pooling_layer = MaxPool1d(1)
self.conv_layer = Conv1d(10, 50, 1)
self.flatten_layer = Flatten()
self.linear_layer = Linear(50, 50)
self.output_layer = Linear(50, 1)
def __init__(self, dim_z=latent_dim):
super(ConditionalEncoder, self).__init__()
self.dim_z = dim_z
kernel_size = 3
stride = 2
padding = self.same_padding(kernel_size)
self.conv0 = Sequential(
Conv2d(colors_dim, 16, kernel_size=1, stride=1),
LeakyReLU(negative_slope=negative_slope),
)
self.conv1 = Sequential(
Conv2d(16,
32,
kernel_size=kernel_size,
stride=stride,
padding=padding),
BatchNorm2d(32, momentum=momentum),
LeakyReLU(negative_slope=negative_slope),
)
self.conv2 = Sequential(
Conv2d(32,
64,
kernel_size=kernel_size,
stride=stride,
padding=padding),
BatchNorm2d(64, momentum=momentum),
LeakyReLU(negative_slope=negative_slope),
)
self.conv3 = Sequential(
Conv2d(64,
128,
kernel_size=kernel_size,
stride=stride,
padding=padding),
BatchNorm2d(128, momentum=momentum),
LeakyReLU(negative_slope=negative_slope),
Flatten(), # next layer takes flat input with labels appended
)
self.dense1 = Sequential(Linear(8192, 2048),
BatchNorm1d(2048, momentum=momentum),
LeakyReLU(negative_slope=negative_slope))
self.dense2 = Sequential(Linear(2048, self.dim_z),
BatchNorm1d(self.dim_z, momentum=momentum),
LeakyReLU(negative_slope=negative_slope))
self.embedding = Sequential(
Linear(labels_dim, self.dim_z),
BatchNorm1d(self.dim_z, momentum=momentum),
LeakyReLU(negative_slope=negative_slope),
)
## the following take the same input from dense1
self.dense_z_mu = Linear(128 * 2, self.dim_z)
self.dense_z_std = Sequential(
Linear(self.dim_z * 2, self.dim_z),
Softplus(),
)
self.set_optimizer(optimizer, lr=learning_rate, betas=betas)
def __init__(self, in_channel, reduction_ratio):
super(ChannelFilter, self).__init__()
self.in_channel = in_channel
self.mlp = nn.Sequential(
Flatten(),
nn.Linear(in_channel, in_channel // reduction_ratio),
nn.ReLU(),
nn.Linear(in_channel // reduction_ratio, in_channel)
)
def __init__(self, in_dims=None, num_classes=None, num_samples=0, **kwargs):
super().__init__()
self.save_hyperparameters()
actfunc = torch.nn.LeakyReLU
bias = True
prior = [1., 'laplace'][0]
if self.hparams.model == 'bnn':
in_features = prod(in_dims)
self.bnn = Sequential( Flatten(1, -1),
MC_ExpansionLayer(num_MC=self.hparams.num_MC, input_dim=2),
BayesLinear(in_features,self.hparams.num_hidden, prior=prior, bias=bias),
actfunc(),
BayesLinear(self.hparams.num_hidden,self.hparams.num_hidden,prior=prior, bias=bias),
actfunc(),
BayesLinear(self.hparams.num_hidden,self.hparams.num_hidden, prior=prior, bias=bias),
actfunc(),
# BayesLinear(self.hparams.num_hidden,self.hparams.num_hidden, prior=prior, bias=bias),
# actfunc(),
# BayesLinear(self.hparams.num_hidden,self.hparams.num_hidden, prior=prior, bias=bias),
# actfunc(),
BayesLinear(self.hparams.num_hidden,num_classes, prior=prior, bias=bias)
# BayesLinear(self.hparams.num_hidden + 1,num_classes, prior=prior)
)
if self.hparams.model == 'cbnn':
debug = 1
layer_args = {'kernel_size': 5, 'padding': 2, 'stride': 1, 'num_MC': self.hparams.num_MC}
self.bnn = Sequential( MC_ExpansionLayer(num_MC=self.hparams.num_MC, input_dim=4),
# PrintModule(),
BayesConv2d(in_channels=in_dims[0], out_channels=int(96/debug), **layer_args),
MC_BatchNorm2D(int(96/debug)),
actfunc(),
MC_MaxPool2d(kernel_size=2, stride=2),
BayesConv2d(in_channels=int(96/debug), out_channels=int(128/debug), **layer_args),
MC_BatchNorm2D(int(128/debug)),
actfunc(),
MC_MaxPool2d(kernel_size=2, stride=2),
BayesConv2d(in_channels=int(128/debug), out_channels=int(256/debug), **layer_args),
MC_BatchNorm2D(int(256/debug)),
actfunc(),
MC_MaxPool2d(kernel_size=2, stride=2),
BayesConv2d(in_channels=int(256/debug), out_channels=int(128/debug), **layer_args),
MC_BatchNorm2D(int(128/debug)),
actfunc(),
MC_MaxPool2d(kernel_size=2, stride=2),
BayesAdaptiveInit_FlattenAndLinear(self.hparams.num_hidden),
actfunc(),
BayesLinear(self.hparams.num_hidden, num_classes)
)
self.bnn(torch.randn(1, *in_dims, dtype=torch.float32))
self.criterion = MC_CrossEntropyLoss(num_samples=self.hparams.num_samples)
self.summary = ModelSummary(model=self)
self.num_params = ModelSummary(model=self).param_nums[0]