Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def __init__(self, size, first_pooling_size=1):
last_size = size // (2 ** 4) // first_pooling_size
super(Discriminator, self).__init__(
c0=chainer.links.Convolution2D(3, 64, 4, stride=2, pad=1),
c1=chainer.links.Convolution2D(64, 128, 4, stride=2, pad=1),
c2=chainer.links.Convolution2D(128, 256, 4, stride=2, pad=1),
c3=chainer.links.Convolution2D(256, 512, 4, stride=2, pad=1),
bn0=chainer.links.BatchNormalization(64),
bn1=chainer.links.BatchNormalization(128),
bn2=chainer.links.BatchNormalization(256),
bn3=chainer.links.BatchNormalization(512),
l0z=chainer.functions.Linear(last_size ** 2 * 512, 1, wscale=0.02 * math.sqrt(last_size ** 2 * 512)),
)
if first_pooling_size > 1:
self.first_pooling = chainer.functions.AveragePooling2D(first_pooling_size, stride=first_pooling_size)
else:
self.first_pooling = lambda x: x # through pass
def test_forward(self):
x = np.random.uniform(0, 1, [self.batch_size, self.d_in]).astype(np.float32)
c = L.Linear(self.d_in, self.d_hid, bias=np.random.uniform(0, 1, [self.d_hid]))
t = nn.Linear.from_chainer(c)
tx = Variable(torch.from_numpy(x))
co = c(x)
to = t(tx)
self.assertTrue(np.allclose(co.data, to.data.numpy()), 'co:\n{}\nto:\n{}'.format(co.data, to.data.numpy()))
def __init__(self):
super(InvalidNetwork, self).__init__()
with self.init_scope():
self.l1 = L.Linear(None, 100)
self.l2 = L.Linear(None, 10)
def __init__(self, *args, **kwargs):
oc = kwargs['out_channels'] if 'out_channels' in kwargs else args[1]
super().__init__(
conv=L.Convolution2D(*args, **kwargs),
bn=L.BatchNormalization(oc)
)
def __init__(self, n_loop, n_layer, filter_size,
residual_channels, dilated_channels, skip_channels,
# arguments for output
output_dim, quantize, log_scale_min,
# arguments for conditioning
condition_dim,
# arguments for dropout
dropout_zero_rate):
super(WaveNet, self).__init__()
with self.init_scope():
self.embed = L.Convolution2D(
1, residual_channels, (2, 1), pad=(1, 0))
self.resnet = ResidualNet(
n_loop, n_layer, filter_size,
residual_channels, dilated_channels, skip_channels,
condition_dim, dropout_zero_rate)
self.proj1 = L.Convolution2D(skip_channels, skip_channels, 1)
self.proj2 = L.Convolution2D(skip_channels, output_dim, 1)
self.output_dim = output_dim
self.input_dim = 1
self.quantize = quantize
self.skip_channels = skip_channels
self.log_scale_min = log_scale_min
def __init__(self, in_ch, out_ch, pool=True):
super(TransitionLayer, self).__init__()
self.pool = pool
with self.init_scope():
self.bn = L.BatchNormalization(in_ch)
self.conv = L.Convolution2D(in_ch, out_ch, 1, 1, 0)
def __init__(self, embed_size, hidden_size):
super(LSTMEncoder, self).__init__(
lstm = links.LSTM(embed_size, hidden_size),
)
def __init__(self, base, n_base_output, scales):
super().__init__()
with self.init_scope():
self.base = base
self.inner = chainer.ChainList()
self.outer = chainer.ChainList()
init = {'initialW': initializers.GlorotNormal()}
for _ in range(n_base_output):
self.inner.append(L.Convolution2D(256, 1, **init))
self.outer.append(L.Convolution2D(256, 3, pad=1, **init))
self.scales = scales
def __init__(self, in_shape):
super(Discriminator, self).__init__(
c0=L.Convolution2D(1, 32, 4, stride=2, pad=1),
c1=L.Convolution2D(32, 64, 4, stride=2, pad=1),
c2=L.Convolution2D(64, 128, 4, stride=2, pad=1),
c3=L.Convolution2D(128, 256, 4, stride=2, pad=1),
fc4=L.Linear(lindim(in_shape, 2**4, 256), 512),
mbd=MinibatchDiscrimination(512, 32, 8),
fc5=L.Linear(512, 512+32), # Alternative to minibatch discrimination
fc6=L.Linear(512+32, 2),
bn1=L.BatchNormalization(64),
bn2=L.BatchNormalization(128),
bn3=L.BatchNormalization(256)
)
def __init__(self, mu_link, sigma_scale=0.4):
super(FactorizedNoisyLinear, self).__init__()
self.out_size = mu_link.out_size
self.nobias = not ('/b' in [name for name, _ in mu_link.namedparams()])
W_data = mu_link.W.array
in_size = None if W_data is None else W_data.shape[1]
device_id = mu_link._device_id
with self.init_scope():
self.mu = L.Linear(in_size, self.out_size, self.nobias,
initialW=LeCunUniform(1 / numpy.sqrt(3)))
self.sigma = L.Linear(in_size, self.out_size, self.nobias,
initialW=VarianceScalingConstant(
sigma_scale),
initial_bias=VarianceScalingConstant(
sigma_scale))
if device_id is not None:
self.to_gpu(device_id)