def __init__(self, nef=64, n_layers = 3, in_channels=3, oneconv = True, grayedge = True,
embeding_size=128, n_mlp=4):
super(Generator256, self).__init__()
self.oneconv = oneconv
self.grayedge = grayedge
self.rgbchannels = 3
self.edgechannels = 3
if self.grayedge:
self.edgechannels = 1
if self.oneconv:
self.edgechannels = self.edgechannels + self.rgbchannels
self.embeding_size = embeding_size
self.embedding = StyleGenerator(embeding_size, n_mlp)
modelList = []
# 3*256*256 x --> 64*256*256 x1
self.pad1 = ReflectionPad2d(padding=1)
self.conv1 = Conv2d(out_channels=nef, kernel_size=3, padding=0, in_channels=in_channels)
# 64*256*256 x1 --> 128*128*128 x2
self.rcb1 = RCBBlock(nef, nef*2, 3, 1, embeding_size)
# 128*128*128 x2+y --> 128*128*128 x3
for n in range(n_layers):
modelList.append(ResnetBlock(nef*2, nef*2, weight=1.0, embeding_size=embeding_size))
# 128*128*128 x3 --> 64*256*256
self.rdcb1 = RDCBBlock(nef*2, nef, 3, 1, embeding_size, True)
self.resblocks = nn.Sequential(*modelList)
# 64*256*256 x4 --> 6*256*256
self.pad2 = ReflectionPad2d(padding=1)
self.relu = ReLU()
self.conv2 = Conv2d(out_channels=self.edgechannels, kernel_size=3, padding=0, in_channels=nef*2)
self.tanh = Tanh()
self.conv3 = Conv2d(out_channels=self.rgbchannels, kernel_size=3, padding=0, in_channels=nef*2)
def build_layers(input_dim, hidden_dims, output_dim):
'''
Returns a list of Linear and Tanh layers with the specified layer sizes
Parameters
----------
input_dim : int
the input dimension of the first linear layer
hidden_dims : list
a list of type int specifying the sizes of the hidden layers
output_dim : int
the output dimension of the final layer in the list
Returns
-------
layers : list
a list of Linear layers, each one followed by a Tanh layer, excluding the
final layer
'''
layer_sizes = [input_dim] + hidden_dims + [output_dim]
layers = []
for i in range(len(layer_sizes) - 1):
layers.append(Linear(layer_sizes[i], layer_sizes[i + 1], bias=True))
if i != len(layer_sizes) - 2:
layers.append(Tanh())
return layers
def create(self, architecture: Architecture, metadata: Metadata,
arguments: Configuration) -> Any:
# create input layer
input_layer = self.create_other(
"SingleInputLayer", architecture, metadata,
Configuration({"input_size": architecture.arguments.code_size}))
# conditional
if "conditional" in architecture.arguments:
# wrap the input layer with a conditional layer
input_layer = ConditionalLayer(
input_layer, metadata, **architecture.arguments.conditional)
# create the hidden layers factory
hidden_layers_factory = self.create_other(
"HiddenLayers", architecture, metadata,
arguments.get("hidden_layers", {}))
# create the output layer factory
output_layer_factory = self.create_output_layer_factory(
architecture, metadata, arguments)
# create the decoder
return FeedForward(input_layer,
hidden_layers_factory,
output_layer_factory,
default_hidden_activation=Tanh())
def get_activation(name):
act_name = name.lower()
m = re.match(r"(\w+)\((\d+\.\d+)\)", act_name)
if m is not None:
act_name, alpha = m.groups()
alpha = float(alpha)
print(act_name, alpha)
else:
alpha = 1.0
if act_name == 'softplus':
return Softplus()
elif act_name == 'ssp':
return SSP()
elif act_name == 'elu':
return ELU(alpha)
elif act_name == 'relu':
return ReLU()
elif act_name == 'selu':
return SELU()
elif act_name == 'celu':
return CELU(alpha)
elif act_name == 'sigmoid':
return Sigmoid()
elif act_name == 'tanh':
return Tanh()
else:
raise NameError("Not supported activation: {}".format(name))
def __init__(self, config):
super().__init__()
self.config = config
self.stride = config['encoder']['stride']
self.alphabet = config['labels']['labels']
self.seqdist = CTC_CRF(config['global_norm']['state_len'],
self.alphabet)
insize = config['input']['features']
winlen = config['encoder']['winlen']
activation = activations[config['encoder']['activation']]()
rnn = rnns[config['encoder']['rnn_type']]
size = config['encoder']['features']
self.encoder = Sequential(
conv(insize, 4, ks=5, bias=True),
activation,
conv(4, 16, ks=5, bias=True),
activation,
conv(16, size, ks=winlen, stride=self.stride, bias=True),
activation,
Permute(2, 0, 1),
rnn(size, size, reverse=True),
rnn(size, size),
rnn(size, size, reverse=True),
rnn(size, size),
rnn(size, size, reverse=True),
Linear(size, self.seqdist.n_score(), bias=True),
Tanh(),
Scale(config['encoder']['scale']),
)
self.global_norm = GlobalNorm(self.seqdist)
def __init__(self,
image_size: int = 256,
image_channels: int = 4,
pose_size: int = 3,
intermediate_channels: int = 64,
bottleneck_image_size: int = 32,
bottleneck_block_count: int = 6,
initialization_method: str = 'he'):
super().__init__()
self.main_body = UNetModule(
image_size=image_size,
image_channels=2 * image_channels + pose_size,
output_channels=intermediate_channels,
bottleneck_image_size=bottleneck_image_size,
bottleneck_block_count=bottleneck_block_count,
initialization_method=initialization_method)
self.combine_alpha_mask = Sequential(
Conv7(intermediate_channels, image_channels,
initialization_method), Sigmoid())
self.retouch_alpha_mask = Sequential(
Conv7(intermediate_channels, image_channels,
initialization_method), Sigmoid())
self.retouch_color_change = Sequential(
Conv7(intermediate_channels, image_channels,
initialization_method), Tanh())
def __init__(self, noise_dim, output_channels=3):
super(Generator, self).__init__()
self.noise_dim = noise_dim
####################################
# YOUR CODE HERE #
####################################
self.hidden0 = Sequential(
# input size noise dimension, which for PA3 is 100
ConvTranspose2d(noise_dim,
1024,
kernel_size=4,
stride=1,
padding=0,
bias=False),
BatchNorm2d(1024),
ReLU(True))
self.hidden1 = Sequential(
# state size (1024) x 4 x 4
# Inverse of Formula (W - K + 2P / S) + 1 for up-sampling
# W is input size, K is kernel size, P is padding, S is stride
ConvTranspose2d(1024,
512,
kernel_size=4,
stride=2,
padding=1,
bias=False),
BatchNorm2d(512),
ReLU(True))
self.hidden2 = Sequential(
# state size (512) x 8 x 8
ConvTranspose2d(512,
256,
kernel_size=4,
stride=2,
padding=1,
bias=False),
BatchNorm2d(256),
ReLU(True))
self.hidden3 = Sequential(
# state size (256) x 16 x 16
ConvTranspose2d(256,
128,
kernel_size=4,
stride=2,
padding=1,
bias=False),
BatchNorm2d(128),
ReLU(True))
self.out = Sequential(
# state size (128) x 32 x 32
ConvTranspose2d(128,
output_channels,
kernel_size=4,
stride=2,
padding=1,
bias=False),
# output size (3) x 64 x 64
Tanh())
def __init__(self, **kwargs):
super(SimpleStochasticModelDynamics, self).__init__()
self.__acoustic_state_dim = kwargs['goal_dim']
self.__action_dim = kwargs['action_dim']
self.__state_dim = kwargs['state_dim']
self.__linears_size = kwargs['linear_layers_size']
input_size = self.__acoustic_state_dim + self.__state_dim + self.__action_dim
self.__bn1 = torch.nn.BatchNorm1d(input_size)
self.linears = ModuleList([Linear(input_size, self.__linears_size[0])])
self.linears.extend([
Linear(self.__linears_size[i - 1], self.__linears_size[i])
for i in range(1, len(self.__linears_size))
])
self.goal_mu = Linear(self.__linears_size[-1], kwargs['goal_dim'])
self.goal_log_var = Linear(self.__linears_size[-1], kwargs['goal_dim'])
self.state_mu = Linear(self.__linears_size[-1], kwargs['state_dim'])
self.state_log_var = Linear(self.__linears_size[-1],
kwargs['state_dim'])
self.state_log_var_const = torch.zeros(kwargs['state_dim'])
self.relu = ReLU()
self.tanh = Tanh()
self.apply(init_weights) # xavier uniform init
def __init__(self, **kwargs):
super(DeterministicLstmModelDynamics, self).__init__()
self.__acoustic_state_dim = kwargs['goal_dim']
self.__action_dim = kwargs['action_dim']
self.__state_dim = kwargs['state_dim']
self.__lstm_sizes = kwargs['lstm_layers_size']
self.__linears_size = kwargs['linear_layers_size']
input_size = self.__acoustic_state_dim + self.__state_dim + self.__action_dim
self.__bn1 = torch.nn.BatchNorm1d(input_size)
self.lstms = ModuleList(
[LSTM(input_size, self.__lstm_sizes[0], batch_first=True)])
self.lstms.extend([
LSTM(self.__lstm_sizes[i - 1],
self.__lstm_sizes[i],
batch_first=True) for i in range(1, len(self.__lstm_sizes))
])
self.hiddens = [None] * len(self.__lstm_sizes)
self.linears = ModuleList(
[Linear(self.__lstm_sizes[-1], self.__linears_size[0])])
self.linears.extend([
Linear(self.__linears_size[i - 1], self.__linears_size[i])
for i in range(1, len(self.__linears_size))
])
self.goal = Linear(self.__linears_size[-1], kwargs['goal_dim'])
self.state = Linear(self.__linears_size[-1], kwargs['state_dim'])
self.relu = ReLU()
self.tanh = Tanh()
self.apply(init_weights) # xavier uniform init
def __init__(self, args, word_embeddings: TextFieldEmbedder,
vocab: Vocabulary) -> None:
super().__init__(vocab)
# parameters
self.args = args
self.word_embeddings = word_embeddings
# gate
self.W_z = nn.Linear(self.args.embedding_size, 1, bias=False)
self.U_z = nn.Linear(self.args.embedding_size, 1, bias=False)
self.W_r = nn.Linear(self.args.embedding_size, 1, bias=False)
self.U_r = nn.Linear(self.args.embedding_size, 1, bias=False)
self.W = nn.Linear(self.args.embedding_size, 1, bias=False)
self.U = nn.Linear(self.args.embedding_size, 1, bias=False)
# layers
self.event_embedding = EventEmbedding(args, self.word_embeddings)
self.attention = Attention(self.args.embedding_size,
score_function='mlp')
self.sigmoid = Sigmoid()
self.tanh = Tanh()
self.score = Score(self.args.embedding_size,
self.args.embedding_size,
threshold=self.args.threshold)
# metrics
self.accuracy = BooleanAccuracy()
self.f1_score = F1Measure(positive_label=1)
self.loss_function = BCELoss()
def __init__(self, query_dim, hidden_dim, non_linearity=Tanh()):
super(ScoreNetwork, self).__init__()
self.query_dim = query_dim
self.hidden_dim = hidden_dim
self.query_proj = Linear(query_dim, hidden_dim, bias=True)
self.non_lin = non_linearity
self.hidden_to_out_proj = Linear(hidden_dim, 1)
def __init__(self, **kwargs):
super().__init__(kwargs)
nb_channels_noise = 8
nb_channels_input = 256
self.shared_layers = kwargs.get(
"decoder_shared_layers",
ResBlock(nb_channels_input, norm=InstanceNorm2d))
nb_input_channels = nb_channels_input + nb_channels_noise + \
kwargs.get("nb_domains", 3)
self.decoder_steps = [
Sequential(*[
ResBlock(nb_input_channels, norm=InstanceNorm2d)
for _ in range(3)
])
]
for _ in range(2):
nb_output_channels = nb_input_channels // 2
self.decoder_steps.append(
ConvBlock(nb_input_channels,
nb_output_channels,
conv_layer=ConvTranspose2d,
transposed=True,
stride=2,
norm=LayerNorm))
nb_input_channels = nb_output_channels + nb_channels_noise
nb_output_channels = nb_input_channels // 2
self.decoder_steps.append(
Sequential(
ConvTranspose2d(nb_input_channels, 3, kernel_size=1, stride=1),
Tanh()))
def __init__(self, im_size, latent_size, num_blocks):
"""
Generator class.
"""
super(Generator, self).__init__()
def block(in_channels, out_channels, kernel_size, stride, padding):
return torch.nn.Sequential(
ConvTranspose2d(in_channels,
out_channels,
kernel_size,
stride,
padding,
bias=False), ReLU())
# Layers
# ------
layers = []
# First block
num_filters = min(im_size * 2**(num_blocks - 1), im_size * 8)
layers.append(block(latent_size, num_filters, 4, 1, 0))
# Middle blocks
for i in range(num_blocks - 1):
num_filters_ = num_filters
num_filters = min(im_size * 2**(num_blocks - 2 - i),
latent_size * 8)
layer = block(num_filters_, num_filters, 4, 2, 1)
layers.append(layer)
# End block
layers.extend([ConvTranspose2d(num_filters, 1, 4, 2, 1), Tanh()])
self.layers = torch.nn.Sequential(*layers)
def create_color_change_block(self):
return Sequential(
create_conv3_from_block_args(in_channels=self.args.start_channels,
out_channels=self.args.image_channels,
bias=True,
block_args=self.args.block_args),
Tanh())
def __init__(self, args):
super(GIN, self).__init__()
self.args = args
self.num_layer = int(self.args["num_layers"])
assert self.num_layer > 2, "Number of layers in GIN should not less than 3"
missing_keys = list(
set([
"features_num", "num_class", "num_graph_features",
"num_layers", "hidden", "dropout", "act", "mlp_layers", "eps"
]) - set(self.args.keys()))
if len(missing_keys) > 0:
raise Exception("Missing keys: %s." % ','.join(missing_keys))
if not self.num_layer == len(self.args['hidden']) + 1:
LOGGER.warn(
'Warning: layer size does not match the length of hidden units'
)
self.num_graph_features = self.args['num_graph_features']
if self.args["act"] == "leaky_relu":
act = LeakyReLU()
elif self.args["act"] == "relu":
act = ReLU()
elif self.args["act"] == "elu":
act = ELU()
elif self.args["act"] == "tanh":
act = Tanh()
else:
act = ReLU()
train_eps = True if self.args["eps"] == "True" else False
self.convs = torch.nn.ModuleList()
self.bns = torch.nn.ModuleList()
nn = [Linear(self.args["features_num"], self.args["hidden"][0])]
for _ in range(self.args["mlp_layers"] - 1):
nn.append(act)
nn.append(Linear(self.args["hidden"][0], self.args["hidden"][0]))
# nn.append(BatchNorm1d(self.args['hidden'][0]))
self.convs.append(GINConv(Sequential(*nn), train_eps=train_eps))
self.bns.append(BatchNorm1d(self.args["hidden"][0]))
for i in range(self.num_layer - 3):
nn = [Linear(self.args["hidden"][i], self.args["hidden"][i + 1])]
for _ in range(self.args["mlp_layers"] - 1):
nn.append(act)
nn.append(
Linear(self.args["hidden"][i + 1],
self.args["hidden"][i + 1]))
# nn.append(BatchNorm1d(self.args['hidden'][i+1]))
self.convs.append(GINConv(Sequential(*nn), train_eps=train_eps))
self.bns.append(BatchNorm1d(self.args["hidden"][i + 1]))
self.fc1 = Linear(
self.args["hidden"][self.num_layer - 3] + self.num_graph_features,
self.args["hidden"][self.num_layer - 2],
)
self.fc2 = Linear(self.args["hidden"][self.num_layer - 2],
self.args["num_class"])
def __init__(self, **kwargs):
super(SimpleStochasticActorCritic, self).__init__()
hidden_size = kwargs['hidden_size']
# actor
self.actor_bn = BatchNorm1d(kwargs['state_dim'])
self.actor_linears = ModuleList(
[Linear(kwargs['state_dim'], hidden_size[0])])
self.actor_linears.extend([
Linear(hidden_size[i - 1], hidden_size[i])
for i in range(1, len(hidden_size))
])
self.mu = Linear(hidden_size[-1], kwargs['action_dim'])
self.log_var = Linear(hidden_size[-1], kwargs['action_dim'])
self.log_var_const = torch.zeros(kwargs['action_dim'])
# critic
self.critic_bn = BatchNorm1d(kwargs['state_dim'])
self.critic_linears = ModuleList(
[Linear(kwargs['state_dim'], hidden_size[0])])
self.critic_linears.extend([
Linear(hidden_size[i - 1], hidden_size[i])
for i in range(1, len(hidden_size))
])
self.v = Linear(hidden_size[-1], 1)
self.relu = ReLU()
self.tanh = Tanh()
self.apply(init_weights) # xavier uniform init
def __init__(self, nX, nZ, nH, nXi, nLayer, cluster_interval, activation):
'''
Constructor
'''
super(WaeAgent, self).__init__()
Activation = None
if activation == "relu":
Activation = ReLU()
if activation == "tanh":
Activation = Tanh()
assert Activation is not None
stacks = [Linear(nX, nH), Activation]
for _ in range(nLayer - 1):
stacks.append(Linear(nH, nH))
stacks.append(Activation)
stacks.append(Linear(nH, nXi))
enc = Sequential(*stacks)
stacks = [Linear(nXi, nH), Activation]
for _ in range(nLayer - 1):
stacks.append(Linear(nH, nH))
stacks.append(Activation)
stacks.append(Linear(nH, nX))
dec = Sequential(*stacks)
self.enc = enc
self.dec = dec
self.nZ = nZ
self.nXi = nXi
self.cluster_interval = cluster_interval
def __init__(self, **kwargs):
super(SimpleDDPGAgent, self).__init__()
hidden_size = kwargs['hidden_size']
# actor
self.actor_linears = ModuleList(
[Linear(kwargs['state_dim'], hidden_size[0])])
self.actor_linears.extend([
Linear(hidden_size[i - 1], hidden_size[i])
for i in range(1, len(hidden_size))
])
self.action = Linear(hidden_size[-1], kwargs['action_dim'])
# critic
self.critic_linears = ModuleList([
Linear(kwargs['state_dim'] + kwargs['action_dim'], hidden_size[0])
])
self.critic_linears.extend([
Linear(hidden_size[i - 1], hidden_size[i])
for i in range(1, len(hidden_size))
])
self.q = Linear(hidden_size[-1], 1)
self.relu = ReLU()
self.sigmoid = Sigmoid()
self.tanh = Tanh()
self.apply(init_weights) # xavier uniform init
def __init__(self, ll_scaling=1.0, dim_z=latent_dim):
super(ConditionalDecoder, self).__init__()
self.dim_z = dim_z
ngf = 32
self.init = genUpsample(self.dim_z, ngf * 16, 1, 0)
self.embedding = Sequential(
Linear(labels_dim, self.dim_z),
BatchNorm1d(self.dim_z, momentum=momentum),
LeakyReLU(negative_slope=negative_slope),
)
self.dense_init = Sequential(
Linear(self.dim_z * 2, self.dim_z),
BatchNorm1d(self.dim_z, momentum=momentum),
LeakyReLU(negative_slope=negative_slope),
)
self.m_modules = ModuleList() # to 4x4
self.c_modules = ModuleList()
for i in range(4):
self.m_modules.append(
genUpsample2(ngf * 2**(4 - i), ngf * 2**(3 - i), 3))
self.c_modules.append(
Sequential(
Conv2d(ngf * 2**(3 - i), colors_dim, 3, 1, 1, bias=False),
Tanh()))
self.set_optimizer(optimizer,
lr=learning_rate * ll_scaling,
betas=betas)
def __init__(self, ngf=32, n_layers = 5):
super(GlyphGenerator, self).__init__()
encoder = []
encoder.append(ReplicationPad2d(padding=4))
encoder.append(Conv2d(out_channels=ngf, kernel_size=9, padding=0, in_channels=3))
encoder.append(LeakyReLU(0.2))
encoder.append(myGConv(ngf*2, 2, ngf))
encoder.append(myGConv(ngf*4, 2, ngf*2))
transformer = []
for n in range(int(n_layers/2)-1):
transformer.append(myGCombineBlock(ngf*4,p=0.0))
# dropout to make model more robust
transformer.append(myGCombineBlock(ngf*4,p=0.5))
transformer.append(myGCombineBlock(ngf*4,p=0.5))
for n in range(int(n_layers/2)+1,n_layers):
transformer.append(myGCombineBlock(ngf*4,p=0.0))
decoder = []
decoder.append(ConvTranspose2d(out_channels=ngf*2, kernel_size=4, stride=2, padding=0, in_channels=ngf*4))
decoder.append(BatchNorm2d(num_features=ngf*2, track_running_stats=True))
decoder.append(LeakyReLU(0.2))
decoder.append(ConvTranspose2d(out_channels=ngf, kernel_size=4, stride=2, padding=0, in_channels=ngf*2))
decoder.append(BatchNorm2d(num_features=ngf, track_running_stats=True))
decoder.append(LeakyReLU(0.2))
decoder.append(ReplicationPad2d(padding=1))
decoder.append(Conv2d(out_channels=3, kernel_size=9, padding=0, in_channels=ngf))
decoder.append(Tanh())
self.encoder = nn.Sequential(*encoder)
self.transformer = nn.Sequential(*transformer)
self.decoder = nn.Sequential(*decoder)
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, in_channels = 4, ngf = 32, n_layers = 5):
super(SketchGenerator, self).__init__()
encoder = []
encoder.append(Conv2d(out_channels=ngf, kernel_size=9, padding=4, in_channels=in_channels))
encoder.append(ReLU())
encoder.append(mySConv(ngf*2, 2, ngf))
encoder.append(mySConv(ngf*4, 2, ngf*2))
transformer = []
for n in range(n_layers):
transformer.append(mySBlock(ngf*4+1))
decoder1 = []
decoder2 = []
decoder3 = []
decoder1.append(ConvTranspose2d(out_channels=ngf*2, kernel_size=4, stride=2, padding=0, in_channels=ngf*4+2))
decoder1.append(InstanceNorm2d(num_features=ngf*2))
decoder1.append(ReLU())
decoder2.append(ConvTranspose2d(out_channels=ngf, kernel_size=4, stride=2, padding=0, in_channels=ngf*2+1))
decoder2.append(InstanceNorm2d(num_features=ngf))
decoder2.append(ReLU())
decoder3.append(Conv2d(out_channels=3, kernel_size=9, padding=1, in_channels=ngf+1))
decoder3.append(Tanh())
self.encoder = nn.Sequential(*encoder)
self.transformer = nn.Sequential(*transformer)
self.decoder1 = nn.Sequential(*decoder1)
self.decoder2 = nn.Sequential(*decoder2)
self.decoder3 = nn.Sequential(*decoder3)
def __init__(self, input_shape, input_channels, \
n_fc_filters, h_shape, conv3d_filter_shape):
super(recurrent_layer, self).__init__()
#nonlinearities of the network
self.leaky_relu = LeakyReLU(negative_slope=0.01)
self.sigmoid = Sigmoid()
self.tanh = Tanh()
#find the input feature map size of the fully connected layer
#fc7_feat_w, fc7_feat_h = self.fc_in_featmap_size(input_shape, num_pooling=6)
fc7_feat_w, fc7_feat_h = 5, 5
#define the fully connected layer
self.fc7 = Linear(int(input_channels * fc7_feat_w * fc7_feat_h),
n_fc_filters[0])
#define the FCConv3DLayers in 3d convolutional gru unit
#conv3d_filter_shape = (self.n_deconvfilter[0], self.n_deconvfilter[0], 3, 3, 3)
self.t_x_s_update = BN_FCConv3DLayer_torch(n_fc_filters[0],
conv3d_filter_shape,
h_shape)
self.t_x_s_reset = BN_FCConv3DLayer_torch(n_fc_filters[0],
conv3d_filter_shape, h_shape)
self.t_x_rs = BN_FCConv3DLayer_torch(n_fc_filters[0],
conv3d_filter_shape, h_shape)
def __init__(self, ngf = 32, n_layers = 5):
super(TextureGenerator, self).__init__()
modelList = []
modelList.append(ReplicationPad2d(padding=4))
modelList.append(Conv2d(out_channels=ngf, kernel_size=9, padding=0, in_channels=3))
modelList.append(ReLU())
modelList.append(myTConv(ngf*2, 2, ngf))
modelList.append(myTConv(ngf*4, 2, ngf*2))
for n in range(int(n_layers/2)):
modelList.append(myTBlock(ngf*4, p=0.0))
# dropout to make model more robust
modelList.append(myTBlock(ngf*4, p=0.5))
for n in range(int(n_layers/2)+1,n_layers):
modelList.append(myTBlock(ngf*4, p=0.0))
modelList.append(ConvTranspose2d(out_channels=ngf*2, kernel_size=4, stride=2, padding=0, in_channels=ngf*4))
modelList.append(BatchNorm2d(num_features=ngf*2, track_running_stats=True))
modelList.append(ReLU())
modelList.append(ConvTranspose2d(out_channels=ngf, kernel_size=4, stride=2, padding=0, in_channels=ngf*2))
modelList.append(BatchNorm2d(num_features=ngf, track_running_stats=True))
modelList.append(ReLU())
modelList.append(ReplicationPad2d(padding=1))
modelList.append(Conv2d(out_channels=3, kernel_size=9, padding=0, in_channels=ngf))
modelList.append(Tanh())
self.model = nn.Sequential(*modelList)
def get_activation_from_name(a):
act = ReLU(inplace=True)
if a == configuration.sigmoid:
act = Sigmoid()
if a == configuration.tanh:
act = Tanh()
return act
def __init__(self, input_shape, n_convfilter, \
n_fc_filters, h_shape, conv3d_filter_shape):
print("\ninitializing \"encoder\"")
#input_shape = (self.batch_size, 3, img_w, img_h)
super(encoder, self).__init__()
self.input_shape = input_shape
self.n_convfilter = n_convfilter
self.n_fc_filters = n_fc_filters
self.h_shape = h_shape
self.conv3d_filter_shape = conv3d_filter_shape
# #conv1
# self.conv1a = Conv2d(input_shape[1], n_convfilter[0], 7, padding=3)
# self.conv1b = Conv2d(n_convfilter[0], n_convfilter[0], 3, padding=1)
# #conv2
# self.conv2a = Conv2d(n_convfilter[0], n_convfilter[1], 3, padding=1)
# self.conv2b = Conv2d(n_convfilter[1], n_convfilter[1], 3, padding=1)
# self.conv2c = Conv2d(n_convfilter[0], n_convfilter[1], 1)
# #conv3
# self.conv3a = Conv2d(n_convfilter[1], n_convfilter[2], 3, padding=1)
# self.conv3b = Conv2d(n_convfilter[2], n_convfilter[2], 3, padding=1)
# self.conv3c = Conv2d(n_convfilter[1], n_convfilter[2], 1)
# #conv4
# self.conv4a = Conv2d(n_convfilter[2], n_convfilter[3], 3, padding=1)
# self.conv4b = Conv2d(n_convfilter[3], n_convfilter[3], 3, padding=1)
# #conv5
# self.conv5a = Conv2d(n_convfilter[3], n_convfilter[4], 3, padding=1)
# self.conv5b = Conv2d(n_convfilter[4], n_convfilter[4], 3, padding=1)
# self.conv5c = Conv2d(n_convfilter[3], n_convfilter[4], 1)
# #conv6
# self.conv6a = Conv2d(n_convfilter[4], n_convfilter[5], 3, padding=1)
# self.conv6b = Conv2d(n_convfilter[5], n_convfilter[5], 3, padding=1)
#pooling layer
self.pool = MaxPool2d(kernel_size=2, padding=1)
#nonlinearities of the network
self.leaky_relu = LeakyReLU(negative_slope=0.01)
self.sigmoid = Sigmoid()
self.tanh = Tanh()
#find the input feature map size of the fully connected layer
fc7_feat_w, fc7_feat_h = self.fc_in_featmap_size(input_shape,
num_pooling=6)
#define the fully connected layer
# self.fc7 = Linear(int(n_convfilter[5] * fc7_feat_w * fc7_feat_h), n_fc_filters[0])
#define the FCConv3DLayers in 3d convolutional gru unit
self.t_x_s_update = FCConv3DLayer_torch(n_fc_filters[0],
conv3d_filter_shape, h_shape)
self.t_x_s_reset = FCConv3DLayer_torch(n_fc_filters[0],
conv3d_filter_shape, h_shape)
self.t_x_rs = FCConv3DLayer_torch(n_fc_filters[0], conv3d_filter_shape,
h_shape)
def __init__(self, hidden, num_aggr, config, **kwargs):
super(ExpandingBConv, self).__init__(aggr='add', **kwargs)
self.hidden = hidden
self.num_aggr = num_aggr
if config.fea_activation == 'ELU':
self.fea_activation = ELU()
elif config.fea_activation == 'ReLU':
self.fea_activation = ReLU()
self.fea_mlp = Sequential(
Linear(hidden * self.num_aggr, hidden),
ReLU(),
Linear(hidden, hidden),
self.fea_activation)
self.aggr_mlp = Sequential(
Linear(hidden * 2, self.num_aggr),
Tanh())
if config.BN == 'Y':
self.BN = BN(hidden)
else:
self.BN = None
self.edge_encoder = torch.nn.Linear(7, hidden)
self.reset_parameters()
def create(self, architecture: Architecture, metadata: Metadata,
arguments: Configuration) -> Any:
# create the input layer
input_layer = self.create_input_layer(architecture, metadata,
arguments)
# wrap the input layer with the special gain input layer (to receive the mask)
input_layer = GAINInputLayer(input_layer, metadata.get_num_features())
# create the hidden layers factory
hidden_layers_factory = self.create_other(
"HiddenLayers", architecture, metadata,
arguments.get("hidden_layers", {}))
# create the output layer factory
# this is different from a normal discriminator
# because the output has the size of the input
# it predicts if each feature is real or fake
output_layer_factory = SingleOutputLayerFactory(
metadata.get_num_features(), activation=Sigmoid())
# create the encoder
return FeedForward(input_layer,
hidden_layers_factory,
output_layer_factory,
default_hidden_activation=Tanh())
def __init__(self):
super(autoencoder, self).__init__()
self.encoder = Sequential(Linear(28 * 28, 128), ReLU(True),
Linear(128, 64), ReLU(True), Linear(64, 12),
ReLU(True), Linear(12, 3))
self.decoder = Sequential(Linear(3, 12), ReLU(True), Linear(12, 64),
ReLU(True), Linear(64, 128), ReLU(True),
Linear(128, 28 * 28), Tanh())
def get_activation(name):
"""Get activation function by name."""
return {
"relu": ReLU(),
"sigmoid": Sigmoid(),
"tanh": Tanh(),
"identity": Identity(),
}[name]
