def test_fully_connected_build():
"""
Asserts: True if a the FullyConnectedNet has correct layers and
attributes.
"""
dim_in = 4096
dim_out = 10
dim_h = 64
dim_ex = None
nonlinearity = 'ReLU'
n_levels = None
output_nonlinearity = None
layer_args = {}
expected_name_linear = 'linear_({}/{})'.format(dim_in, dim_h)
expected_name_relu = 'linear_({}/{})_{}'.format(dim_in, dim_h, 'ReLU')
expected_name_out = 'linear_({}/{})_{}'.format(dim_h, dim_out, 'out')
fully_connected_net = FullyConnectedNet(dim_in, dim_out, dim_h, dim_ex,
nonlinearity, n_levels,
output_nonlinearity, **layer_args)
layers = list(fully_connected_net.models._modules.items())
assert layers[0][0] == expected_name_linear
assert layers[1][0] == expected_name_relu
assert layers[2][0] == expected_name_out
assert isinstance(layers[0][1], nn.modules.linear.Linear)
assert isinstance(layers[1][1], nn.modules.activation.ReLU)
assert isinstance(layers[2][1], nn.modules.linear.Linear)
assert layers[0][1].in_features == dim_in
assert layers[0][1].out_features == dim_h
assert layers[2][1].in_features == dim_h
assert layers[2][1].out_features == dim_out
def build(self, topnet_args=dict(dim_h=[512, 128], batch_norm=False),
dim_int=256, dim_z=None):
'''
Args:
topnet_args: Keyword arguments for the top network.
dim_int: Intermediate layer size for discriminator.
'''
x_encoder = self.nets.x_encoder
try:
z_encoder = self.nets.z_encoder
except KeyError:
z_encoder = None
if z_encoder is not None:
z_encoder_out = list(
z_encoder.models[-1].parameters())[-1].size()[0]
dim_in = dim_int + z_encoder_out
else:
dim_in = dim_int + dim_z
topnet = FullyConnectedNet(dim_in, 1, **topnet_args)
discriminator = ALIDiscriminatorModule(x_encoder, z_encoder, topnet)
self.nets.discriminator = discriminator
def test_network_handler():
h = NetworkHandler()
try:
h.a = 1
assert 0
except TypeError:
pass
h.a = FullyConnectedNet(1, 2)
assert isinstance(h.a, torch.nn.Module)
h.b = FullyConnectedNet(2, 3)
for k, m in h.items():
assert isinstance(m, torch.nn.Module), k
def build(self,
dim_in: int = None,
discriminator_args=dict(dim_h=[200, 200])):
"""
Args:
dim_in (int): Input size
dim_out (int): Output size
classifier_args: Extra arguments for building the classifier
"""
discriminator = FullyConnectedNet(dim_in,
dim_out=1,
**discriminator_args)
self.nets.discriminator = discriminator
def build(self,
dim_in: int = None,
classifier_args=dict(dim_h=[200, 200])):
'''
Args:
dim_in (int): Input size
classifier_args: Extra arguments for building the classifier
'''
dim_l = self.get_dims('labels')
classifier = FullyConnectedNet(dim_in,
dim_out=dim_l,
**classifier_args)
self.nets.classifier = classifier
def build(self,
dim_in: int = None,
classifier_args=dict(dim_h=[200, 200])):
'''
Args:
dim_in (int): Input size
dim_out (int): Output size
dim_h (:obj:`list` of :obj:`int`): Hidden layer sizes
classifier_args: Extra arguments for building the classifier
'''
dim_a = self.get_dims('attributes')
classifier = FullyConnectedNet(dim_in,
dim_out=dim_a,
**classifier_args)
self.nets.classifier = classifier
def build(self, dim_z=None, dim_int=None, use_z_encoder=False,
z_encoder_args=dict(dim_h=256, batch_norm=True),
noise_type='normal'):
'''
Args:
use_z_encoder: Use a neural network for Z pathway in discriminator.
z_encoder_args: Arguments for the Z pathway encoder.
'''
self.add_noise('Z', dist=noise_type, size=dim_z)
if use_z_encoder:
encoder = FullyConnectedNet(dim_z, dim_int, **z_encoder_args)
self.nets.z_encoder = encoder
self.encoder.build()
self.discriminator.build()
self.bidirectional_model.build()
def build(self, d=31, c=23):
self.submodel.build()
self.nets.net = FullyConnectedNet(d, c)
def build(self, a=17, b=19):
self.nets.net = FullyConnectedNet(a, b)