def _setup_convolution(self, layer):
blobs = layer.blobs
param = layer.convolution_param
ksize = _get_ksize(param)
stride = _get_stride(param)
pad = _get_pad(param)
num = _get_num(blobs[0])
channels = _get_channels(blobs[0])
bias_term = param.bias_term
n_in = channels * param.group
n_out = num
func = convolution_2d.Convolution2D(
n_in,
n_out,
ksize,
stride,
pad,
nobias=not bias_term,
initialW=_ConvolutionBlob(blobs[0], param.group),
initial_bias=_Blob(blobs[1]) if bias_term else None)
with self.init_scope():
setattr(self, layer.name, func)
self.forwards[layer.name] = _CallChildLink(self, layer.name)
self._add_layer(layer)
def _setup_convolution(self, layer):
blobs = layer.blobs
param = layer.convolution_param
ksize = _get_ksize(param)
stride = _get_stride(param)
pad = _get_pad(param)
num = _get_num(blobs[0])
channels = _get_channels(blobs[0])
n_in = channels * param.group
n_out = num
func = convolution_2d.Convolution2D(n_in, n_out, ksize, stride, pad,
nobias=not param.bias_term)
func.W.data[...] = 0
part_size = len(blobs[0].data) // param.group
for i in six.moves.range(param.group):
in_slice = slice(i * n_in // param.group,
(i + 1) * n_in // param.group)
out_slice = slice(i * n_out // param.group,
(i + 1) * n_out // param.group)
w = func.W.data[out_slice, in_slice]
data = numpy.array(
blobs[0].data[i * part_size:(i + 1) * part_size])
w[:] = data.reshape(w.shape)
if param.bias_term:
func.b.data[:] = blobs[1].data
self.add_link(layer.name, func)
self.forwards[layer.name] = _CallChildLink(self, layer.name)
self._add_layer(layer)
def inception_0(input_channel, pool_channel):
# 1x1
s1 = AuxConv(
C.Convolution2D(input_channel, 64, 1, use_cudnn=use_cudnn))
# 5x5
s21 = AuxConv(
C.Convolution2D(input_channel, 48, 1, use_cudnn=use_cudnn))
s22 = AuxConv(
C.Convolution2D(48, 64, 5, pad=2, use_cudnn=use_cudnn))
s2 = Sequential(s21, s22)
# double 3x3
s31 = AuxConv(
C.Convolution2D(input_channel, 64, 1, use_cudnn=use_cudnn))
s32 = AuxConv(
C.Convolution2D(64, 96, 3, pad=1, use_cudnn=use_cudnn))
s33 = AuxConv(
C.Convolution2D(96, 96, 3, pad=1, use_cudnn=use_cudnn))
s3 = Sequential(s31, s32, s33)
# pool
s4 = AuxConv(C.Convolution2D(input_channel,
pool_channel,
3,
pad=1,
use_cudnn=use_cudnn),
pool=M.MaxPooling2D(3, 1, 1, use_cudnn=use_cudnn))
return Inception(s1, s2, s3, s4)
def __init__(self,
in_channels,
out_channels,
ksize=None,
stride=1,
pad=0,
activation=relu.relu,
*args,
**kwargs):
# If `args` is not empty, users assume the API for v1 and
# specify `wscale` as a positonal argument, which we want
# to detect and forbid with an explicit error message.
msg = ('wscale is not supported anymore. '
'Use conv_init and bias_init argument to change '
'the scale of initial parameters.')
if args:
raise TypeError(msg)
argument.check_unexpected_kwargs(kwargs, wscale=msg)
conv_init, bias_init = argument.parse_kwargs(kwargs,
('conv_init', None),
('bias_init', None))
if ksize is None:
out_channels, ksize, in_channels = in_channels, out_channels, None
assert len(out_channels) > 0
convs = [
convolution_2d.Convolution2D(in_channels,
out_channels[0],
ksize,
stride,
pad,
initialW=conv_init,
initial_bias=bias_init)
]
for n_in, n_out in zip(out_channels, out_channels[1:]):
convs.append(
convolution_2d.Convolution2D(n_in,
n_out,
1,
initialW=conv_init,
initial_bias=bias_init))
super(MLPConvolution2D, self).__init__(*convs)
self.activation = activation
def inception_2(input_channel):
# 1x1
s1 = AuxConv(
C.Convolution2D(input_channel, 320, 1, use_cudnn=use_cudnn))
# 3x3
s21 = AuxConv(
C.Convolution2D(input_channel, 384, 1, use_cudnn=use_cudnn))
s22 = Inception(
AuxConv(
C.Convolution2D(384,
384, (1, 3),
pad=(0, 1),
use_cudnn=use_cudnn)),
AuxConv(
C.Convolution2D(384,
384, (3, 1),
pad=(1, 0),
use_cudnn=use_cudnn)))
s2 = Sequential(s21, s22)
# double 3x3
s31 = AuxConv(
C.Convolution2D(input_channel, 448, 1, use_cudnn=use_cudnn))
s32 = AuxConv(
C.Convolution2D(448, 384, 3, pad=1, use_cudnn=use_cudnn))
s331 = AuxConv(
C.Convolution2D(384,
384, (1, 3),
pad=(0, 1),
use_cudnn=use_cudnn))
s332 = AuxConv(
C.Convolution2D(384,
384, (3, 1),
pad=(1, 0),
use_cudnn=use_cudnn))
s33 = Inception(s331, s332)
s3 = Sequential(s31, s32, s33)
# pool
s4 = AuxConv(C.Convolution2D(input_channel,
192,
3,
pad=1,
use_cudnn=use_cudnn),
pool=A.AveragePooling2D(3, 1, 1, use_cudnn=use_cudnn))
return Inception(s1, s2, s3, s4)
def __init__(self, in_size, ch, out_size, stride=2, use_cudnn=True):
w = math.sqrt(2)
super(BottleNeckA, self).__init__(
conv1=convolution_2d.Convolution2D(in_size,
ch,
1,
stride,
0,
w,
nobias=True,
use_cudnn=use_cudnn),
bn1=batch_normalization.BatchNormalization(ch),
conv2=convolution_2d.Convolution2D(ch,
ch,
3,
1,
1,
w,
nobias=True,
use_cudnn=use_cudnn),
bn2=batch_normalization.BatchNormalization(ch),
conv3=convolution_2d.Convolution2D(ch,
out_size,
1,
1,
0,
w,
nobias=True,
use_cudnn=use_cudnn),
bn3=batch_normalization.BatchNormalization(out_size),
conv4=convolution_2d.Convolution2D(in_size,
out_size,
1,
stride,
0,
w,
nobias=True,
use_cudnn=use_cudnn),
bn4=batch_normalization.BatchNormalization(out_size),
)
def __init__(self,
ich,
och,
ksize,
stride,
pad,
init_weights,
pool=None,
nobias=False):
super(Conv,
self).__init__(conv=C.Convolution2D(ich, och, ksize, stride, pad,
nobias), )
self.pool = pool
def __init__(self, use_cudnn=True):
super(VGG_A, self).__init__(
conv1=convolution_2d.Convolution2D(3, 64, 3, pad=1, use_cudnn=use_cudnn),
conv2=convolution_2d.Convolution2D(64, 128, 3, pad=1, use_cudnn=use_cudnn),
conv3_1=convolution_2d.Convolution2D(128, 256, 3, pad=1, use_cudnn=use_cudnn),
conv3_2=convolution_2d.Convolution2D(256, 256, 3, pad=1, use_cudnn=use_cudnn),
conv4_1=convolution_2d.Convolution2D(256, 512, 3, pad=1, use_cudnn=use_cudnn),
conv4_2=convolution_2d.Convolution2D(512, 512, 3, pad=1, use_cudnn=use_cudnn),
conv5_1=convolution_2d.Convolution2D(512, 512, 3, pad=1, use_cudnn=use_cudnn),
conv5_2=convolution_2d.Convolution2D(512, 512, 3, pad=1, use_cudnn=use_cudnn),
fc6=linear.Linear(512 * 7 * 7, 4096),
fc7=linear.Linear(4096, 4096),
fc8=linear.Linear(4096, 1000)
)
self.use_cudnn = use_cudnn
def __init__(self, ich, och, ksize, stride, pad, init_weights, pool=None):
super(ConvBN, self).__init__(
conv=C.Convolution2D(ich, och, ksize, stride, pad, nobias=True),
bn=B.BatchNormalization(och),
)
self.pool = pool
if init_weights:
f = h5py.File('%s/data/dump/%s.h5' % (os.getcwd(), init_weights),
'r')
self.conv.W.data = np.array(f['weights']).transpose([3, 2, 0, 1])
self.bn.beta.data = np.array(f['beta'])
self.bn.gamma.data = np.array(f['gamma'])
self.bn.avg_mean = np.array(f['mean'])
self.bn.avg_var = np.array(f['var'])
def __init__(self, in_channels, out1, proj3, out3, proj5, out5, proj_pool):
super(Inception, self).__init__(
conv1=convolution_2d.Convolution2D(in_channels, out1, 1),
proj3=convolution_2d.Convolution2D(in_channels, proj3, 1),
conv3=convolution_2d.Convolution2D(proj3, out3, 3, pad=1),
proj5=convolution_2d.Convolution2D(in_channels, proj5, 1),
conv5=convolution_2d.Convolution2D(proj5, out5, 5, pad=2),
projp=convolution_2d.Convolution2D(in_channels, proj_pool, 1),
)
def __init__(self,
in_channels,
out_channels,
ksize,
stride=1,
pad=0,
wscale=1,
activation=relu.relu,
use_cudnn=True):
assert len(out_channels) > 0
convs = [
convolution_2d.Convolution2D(in_channels,
out_channels[0],
ksize,
stride,
pad,
wscale=wscale,
use_cudnn=use_cudnn)
]
for n_in, n_out in zip(out_channels, out_channels[1:]):
convs.append(
convolution_2d.Convolution2D(n_in, n_out, 1, wscale=wscale))
super(MLPConvolution2D, self).__init__(*convs)
self.activation = activation
def __init__(self, in_channels, out1, proj3, out3, proj33, out33,
pooltype, proj_pool=None, stride=1, conv_init=None,
dtype=numpy.float32):
super(InceptionBN, self).__init__(
proj3=convolution_2d.Convolution2D(
in_channels, proj3, 1, nobias=True, initialW=conv_init),
conv3=convolution_2d.Convolution2D(
proj3, out3, 3, pad=1, stride=stride, nobias=True,
initialW=conv_init),
proj33=convolution_2d.Convolution2D(
in_channels, proj33, 1, nobias=True, initialW=conv_init),
conv33a=convolution_2d.Convolution2D(
proj33, out33, 3, pad=1, nobias=True, initialW=conv_init),
conv33b=convolution_2d.Convolution2D(
out33, out33, 3, pad=1, stride=stride, nobias=True,
initialW=conv_init),
proj3n=batch_normalization.BatchNormalization(proj3, dtype=dtype),
conv3n=batch_normalization.BatchNormalization(out3, dtype=dtype),
proj33n=batch_normalization.BatchNormalization(proj33,
dtype=dtype),
conv33an=batch_normalization.BatchNormalization(out33,
dtype=dtype),
conv33bn=batch_normalization.BatchNormalization(out33,
dtype=dtype),
)
if out1 > 0:
assert stride == 1
assert proj_pool is not None
self.add_link('conv1',
convolution_2d.Convolution2D(in_channels, out1, 1,
stride=stride,
nobias=True,
initialW=conv_init))
self.add_link('conv1n', batch_normalization.BatchNormalization(
out1, dtype=dtype))
self.out1 = out1
if proj_pool is not None:
self.add_link('poolp', convolution_2d.Convolution2D(
in_channels, proj_pool, 1, nobias=True, initialW=conv_init))
self.add_link('poolpn', batch_normalization.BatchNormalization(
proj_pool, dtype=dtype))
self.proj_pool = proj_pool
self.stride = stride
self.pooltype = pooltype
if pooltype != 'max' and pooltype != 'avg':
raise NotImplementedError()
self.train = True
def __init__(self, in_channels, out1, proj3, out3, proj33, out33,
pooltype, proj_pool=None, stride=1, conv_init=None,
dtype=None):
super(InceptionBN, self).__init__()
self.out1 = out1
self.proj_pool = proj_pool
self.stride = stride
self.pooltype = pooltype
if pooltype != 'max' and pooltype != 'avg':
raise NotImplementedError()
dtype = chainer.get_dtype(dtype)
with self.init_scope():
self.proj3 = convolution_2d.Convolution2D(
in_channels, proj3, 1, nobias=True, initialW=conv_init)
self.conv3 = convolution_2d.Convolution2D(
proj3, out3, 3, pad=1, stride=stride, nobias=True,
initialW=conv_init)
self.proj33 = convolution_2d.Convolution2D(
in_channels, proj33, 1, nobias=True, initialW=conv_init)
self.conv33a = convolution_2d.Convolution2D(
proj33, out33, 3, pad=1, nobias=True, initialW=conv_init)
self.conv33b = convolution_2d.Convolution2D(
out33, out33, 3, pad=1, stride=stride, nobias=True,
initialW=conv_init)
self.proj3n = batch_normalization.BatchNormalization(
proj3, dtype=dtype)
self.conv3n = batch_normalization.BatchNormalization(
out3, dtype=dtype)
self.proj33n = batch_normalization.BatchNormalization(
proj33, dtype=dtype)
self.conv33an = batch_normalization.BatchNormalization(
out33, dtype=dtype)
self.conv33bn = batch_normalization.BatchNormalization(
out33, dtype=dtype)
if out1 > 0:
assert stride == 1
assert proj_pool is not None
self.conv1 = convolution_2d.Convolution2D(
in_channels, out1, 1, stride=stride, nobias=True,
initialW=conv_init)
self.conv1n = batch_normalization.BatchNormalization(
out1, dtype=dtype)
if proj_pool is not None:
self.poolp = convolution_2d.Convolution2D(
in_channels, proj_pool, 1, nobias=True, initialW=conv_init)
self.poolpn = batch_normalization.BatchNormalization(
proj_pool, dtype=dtype)
def __init__(self, use_cudnn=True):
w = math.sqrt(2)
super(ResNet50, self).__init__(
conv1=convolution_2d.Convolution2D(3,
64,
7,
2,
3,
w,
nobias=True,
use_cudnn=use_cudnn),
bn1=batch_normalization.BatchNormalization(64),
res2=Block(3, 64, 64, 256, 1, use_cudnn=use_cudnn),
res3=Block(4, 256, 128, 512, use_cudnn=use_cudnn),
res4=Block(6, 512, 256, 1024, use_cudnn=use_cudnn),
res5=Block(3, 1024, 512, 2048, use_cudnn=use_cudnn),
fc=linear.Linear(2048, 1000),
)
self.use_cudnn = use_cudnn
self.train = True
def __init__(self,
in_channels,
out1,
proj3,
out3,
proj5,
out5,
proj_pool,
conv_init=None,
bias_init=None):
super(Inception, self).__init__()
with self.init_scope():
self.conv1 = convolution_2d.Convolution2D(in_channels,
out1,
1,
initialW=conv_init,
initial_bias=bias_init)
self.proj3 = convolution_2d.Convolution2D(in_channels,
proj3,
1,
initialW=conv_init,
initial_bias=bias_init)
self.conv3 = convolution_2d.Convolution2D(proj3,
out3,
3,
pad=1,
initialW=conv_init,
initial_bias=bias_init)
self.proj5 = convolution_2d.Convolution2D(in_channels,
proj5,
1,
initialW=conv_init,
initial_bias=bias_init)
self.conv5 = convolution_2d.Convolution2D(proj5,
out5,
5,
pad=2,
initialW=conv_init,
initial_bias=bias_init)
self.projp = convolution_2d.Convolution2D(in_channels,
proj_pool,
1,
initialW=conv_init,
initial_bias=bias_init)
def __init__(self, use_cudnn=True):
convolution = link.ChainList(
AuxConv(C.Convolution2D(3, 32, 3, 2, use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(32, 32, 3, use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(32, 64, 3, 1, 1, use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(64, 80, 3, 1, 1, use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(80, 192, 3, use_cudnn=use_cudnn)))
def inception_0(input_channel, pool_channel):
# 1x1
s1 = AuxConv(
C.Convolution2D(input_channel, 64, 1, use_cudnn=use_cudnn))
# 5x5
s21 = AuxConv(
C.Convolution2D(input_channel, 48, 1, use_cudnn=use_cudnn))
s22 = AuxConv(
C.Convolution2D(48, 64, 5, pad=2, use_cudnn=use_cudnn))
s2 = Sequential(s21, s22)
# double 3x3
s31 = AuxConv(
C.Convolution2D(input_channel, 64, 1, use_cudnn=use_cudnn))
s32 = AuxConv(
C.Convolution2D(64, 96, 3, pad=1, use_cudnn=use_cudnn))
s33 = AuxConv(
C.Convolution2D(96, 96, 3, pad=1, use_cudnn=use_cudnn))
s3 = Sequential(s31, s32, s33)
# pool
s4 = AuxConv(C.Convolution2D(input_channel,
pool_channel,
3,
pad=1,
use_cudnn=use_cudnn),
pool=M.MaxPooling2D(3, 1, 1, use_cudnn=use_cudnn))
return Inception(s1, s2, s3, s4)
inception0 = Sequential(*[
inception_0(input_channel, pool_channel) for input_channel,
pool_channel in zip([192, 256, 288], [32, 64, 64])
])
grid_reduction0 = Inception(
# strided 3x3
AuxConv(C.Convolution2D(288, 384, 3, 2, use_cudnn=use_cudnn)),
# double 3x3
Sequential(
AuxConv(C.Convolution2D(288, 64, 1, use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(64, 96, 3, pad=1,
use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(96, 96, 3, 2, use_cudnn=use_cudnn))),
# pool
pool=M.MaxPooling2D(3, 2))
def inception_1(hidden_channel):
# 1x1
s1 = AuxConv(C.Convolution2D(768, 192, 1, use_cudnn=use_cudnn))
# 7x7
s21 = AuxConv(
C.Convolution2D(768, hidden_channel, 1, use_cudnn=use_cudnn))
s22 = AuxConv(
C.Convolution2D(hidden_channel,
hidden_channel, (1, 7),
pad=(0, 3),
use_cudnn=use_cudnn))
s23 = AuxConv(
C.Convolution2D(hidden_channel,
192, (7, 1),
pad=(3, 0),
use_cudnn=use_cudnn))
s2 = Sequential(s21, s22, s23)
# double 7x7
s31 = AuxConv(
C.Convolution2D(768, hidden_channel, 1, use_cudnn=use_cudnn))
s32 = AuxConv(
C.Convolution2D(hidden_channel,
hidden_channel, (1, 7),
pad=(0, 3),
use_cudnn=use_cudnn))
s33 = AuxConv(
C.Convolution2D(hidden_channel,
hidden_channel, (7, 1),
pad=(3, 0),
use_cudnn=use_cudnn))
s34 = AuxConv(
C.Convolution2D(hidden_channel,
hidden_channel, (1, 7),
pad=(0, 3),
use_cudnn=use_cudnn))
s35 = AuxConv(
C.Convolution2D(hidden_channel,
192, (7, 1),
pad=(3, 0),
use_cudnn=use_cudnn))
s3 = Sequential(s31, s32, s33, s34, s35)
# pool
s4 = AuxConv(C.Convolution2D(768,
192,
3,
pad=1,
use_cudnn=use_cudnn),
pool=A.AveragePooling2D(3, 1, 1, use_cudnn=use_cudnn))
return Inception(s1, s2, s3, s4)
inception1 = Sequential(
*[inception_1(c) for c in [128, 160, 160, 192]])
grid_reduction1 = Inception(
# strided 3x3
Sequential(
AuxConv(C.Convolution2D(768, 192, 1, use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(192, 320, 3, 2, use_cudnn=use_cudnn))),
# 7x7 and 3x3
Sequential(
AuxConv(C.Convolution2D(768, 192, 1, use_cudnn=use_cudnn)),
AuxConv(
C.Convolution2D(192,
192, (1, 7),
pad=(0, 3),
use_cudnn=use_cudnn)),
AuxConv(
C.Convolution2D(192,
192, (7, 1),
pad=(3, 0),
use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(192, 192, 3, 2, use_cudnn=use_cudnn))),
# pool
pool=M.MaxPooling2D(3, 2, use_cudnn=use_cudnn))
def inception_2(input_channel):
# 1x1
s1 = AuxConv(
C.Convolution2D(input_channel, 320, 1, use_cudnn=use_cudnn))
# 3x3
s21 = AuxConv(
C.Convolution2D(input_channel, 384, 1, use_cudnn=use_cudnn))
s22 = Inception(
AuxConv(
C.Convolution2D(384,
384, (1, 3),
pad=(0, 1),
use_cudnn=use_cudnn)),
AuxConv(
C.Convolution2D(384,
384, (3, 1),
pad=(1, 0),
use_cudnn=use_cudnn)))
s2 = Sequential(s21, s22)
# double 3x3
s31 = AuxConv(
C.Convolution2D(input_channel, 448, 1, use_cudnn=use_cudnn))
s32 = AuxConv(
C.Convolution2D(448, 384, 3, pad=1, use_cudnn=use_cudnn))
s331 = AuxConv(
C.Convolution2D(384,
384, (1, 3),
pad=(0, 1),
use_cudnn=use_cudnn))
s332 = AuxConv(
C.Convolution2D(384,
384, (3, 1),
pad=(1, 0),
use_cudnn=use_cudnn))
s33 = Inception(s331, s332)
s3 = Sequential(s31, s32, s33)
# pool
s4 = AuxConv(C.Convolution2D(input_channel,
192,
3,
pad=1,
use_cudnn=use_cudnn),
pool=A.AveragePooling2D(3, 1, 1, use_cudnn=use_cudnn))
return Inception(s1, s2, s3, s4)
inception2 = Sequential(
*[inception_2(input_channel) for input_channel in [1280, 2048]])
auxiliary_convolution = Sequential(
AuxConv(C.Convolution2D(768, 128, 1, use_cudnn=use_cudnn),
pool=A.AveragePooling2D(5, 3, use_cudnn=use_cudnn)),
AuxConv(C.Convolution2D(128, 768, 5, use_cudnn=use_cudnn)))
super(InceptionV3, self).__init__(
convolution=convolution,
inception=link.ChainList(inception0, inception1, inception2),
grid_reduction=link.ChainList(grid_reduction0, grid_reduction1),
auxiliary_convolution=auxiliary_convolution,
auxiliary_linear=linear.Linear(768, 1000),
linear=linear.Linear(2048, 1000))
def __init__(self, *args, **kwargs):
conv = C.Convolution2D(*args, **kwargs)
out_channel = len(conv.W.data)
batch_norm = B.BatchNormalization(out_channel)
super(ConvBN, self).__init__(conv=conv, batch_norm=batch_norm)
def __init__(self, use_cudnn=True):
super(Alex, self).__init__(
conv1a=convolution_2d.Convolution2D(3,
48,
11,
stride=4,
pad=2,
use_cudnn=use_cudnn),
conv1b=convolution_2d.Convolution2D(3,
48,
11,
stride=4,
pad=2,
use_cudnn=use_cudnn),
conv2a=convolution_2d.Convolution2D(48,
128,
5,
pad=2,
use_cudnn=use_cudnn),
conv2b=convolution_2d.Convolution2D(48,
128,
5,
pad=2,
use_cudnn=use_cudnn),
conv3a=convolution_2d.Convolution2D(128,
192,
3,
pad=1,
use_cudnn=use_cudnn),
conv3b=convolution_2d.Convolution2D(128,
192,
3,
pad=1,
use_cudnn=use_cudnn),
conv3c=convolution_2d.Convolution2D(128,
192,
3,
pad=1,
use_cudnn=use_cudnn),
conv3d=convolution_2d.Convolution2D(128,
192,
3,
pad=1,
use_cudnn=use_cudnn),
conv4a=convolution_2d.Convolution2D(192,
192,
3,
pad=1,
use_cudnn=use_cudnn),
conv4b=convolution_2d.Convolution2D(192,
192,
3,
pad=1,
use_cudnn=use_cudnn),
conv5a=convolution_2d.Convolution2D(192,
128,
3,
pad=1,
use_cudnn=use_cudnn),
conv5b=convolution_2d.Convolution2D(192,
128,
3,
pad=1,
use_cudnn=use_cudnn),
fc6a=linear.Linear(4608, 4096),
fc6b=linear.Linear(4608, 4096),
fc7=linear.Linear(4096, 4096),
fc8=linear.Linear(4096, 1000))
