def test_VGG19():
seq = tg.Sequential()
seq.add(VGG19())
seq.add(Flatten())
seq.add(Linear(this_dim=nclass))
seq.add(Softmax())
train(seq)
def model():
with tf.name_scope('MnistCNN'):
seq = tg.Sequential()
seq.add(Conv2D(num_filters=32, kernel_size=(3, 3), stride=(1, 1), padding='SAME'))
seq.add(BatchNormalization())
seq.add(RELU())
seq.add(MaxPooling(poolsize=(2, 2), stride=(2,2), padding='SAME'))
seq.add(LRN())
seq.add(Conv2D(num_filters=64, kernel_size=(3, 3), stride=(1, 1), padding='SAME'))
seq.add(BatchNormalization())
seq.add(RELU())
seq.add(MaxPooling(poolsize=(2, 2), stride=(2,2), padding='SAME'))
seq.add(LRN())
seq.add(Flatten())
seq.add(Linear(128))
seq.add(BatchNormalization())
seq.add(Tanh())
seq.add(Dropout(0.8))
seq.add(Linear(256))
seq.add(BatchNormalization())
seq.add(Tanh())
seq.add(Dropout(0.8))
seq.add(Linear(10))
seq.add(Softmax())
return seq
def test_ResNetBase():
seq = tg.Sequential()
seq.add(ResNetBase(config=[1,1,1,1]))
seq.add(MaxPooling(poolsize=(1,1), stride=(1,1), padding='VALID'))
seq.add(Flatten())
seq.add(Linear(this_dim=nclass))
seq.add(Softmax())
train(seq)
def test_DenseNet():
seq = tg.Sequential()
seq.add(DenseNet(ndense=1, growth_rate=1, nlayer1blk=1))
seq.add(MaxPooling(poolsize=(3,3), stride=(1,1), padding='VALID'))
seq.add(Flatten())
seq.add(Linear(this_dim=nclass))
seq.add(Softmax())
train(seq)
def test_UNet():
seq = tg.Sequential()
seq.add(UNet(input_shape=(h, w)))
seq.add(MaxPooling(poolsize=(3,3), stride=(1,1), padding='VALID'))
seq.add(Flatten())
seq.add(Linear(this_dim=nclass))
seq.add(Softmax())
train(seq)
def __init__(self, nclass, h, w, c):
layers = []
layers.append(AllCNN(nclass, h, w, c))
layers.append(Linear(nclass, nclass))
layers.append(Softmax())
self.startnode = tg.StartNode(input_vars=[None])
model_hn = tg.HiddenNode(prev=[self.startnode], layers=layers)
self.endnode = tg.EndNode(prev=[model_hn])
def train_with_Resnet():
from tensorgraph.trainobject import train as mytrain
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
X_train, y_train, X_test, y_test = Cifar10(contrast_normalize=False,
whiten=False)
_, h, w, c = X_train.shape
_, nclass = y_train.shape
print('X max', np.max(X_train))
print('X min', np.min(X_train))
seq = tg.Sequential()
id1 = IdentityBlock(input_channels=c,
input_shape=(h, w),
nlayers=4,
filters=[32, 64])
seq.add(id1)
trans1 = TransitionLayer(input_channels=id1.output_channels,
input_shape=id1.output_shape)
seq.add(trans1)
id2 = IdentityBlock(input_channels=trans1.output_channels,
input_shape=trans1.output_shape,
nlayers=4,
filters=[64, 128])
seq.add(id2)
trans2 = TransitionLayer(input_channels=id2.output_channels,
input_shape=id2.output_shape)
seq.add(trans2)
seq.add(Flatten())
ldim = trans2.output_channels * np.prod(trans2.output_shape)
seq.add(Linear(ldim, nclass))
seq.add(Softmax())
X_ph = tf.placeholder('float32', [None, h, w, c])
y_ph = tf.placeholder('float32', [None, nclass])
y_train_sb = seq.train_fprop(X_ph)
y_test_sb = seq.test_fprop(X_ph)
train_cost_sb = entropy(y_ph, y_train_sb)
optimizer = tf.train.AdamOptimizer(0.001)
test_accu_sb = accuracy(y_ph, y_test_sb)
mytrain(session=sess,
feed_dict={
X_ph: X_train,
y_ph: y_train
},
train_cost_sb=train_cost_sb,
valid_cost_sb=-test_accu_sb,
optimizer=optimizer,
epoch_look_back=5,
max_epoch=100,
percent_decrease=0,
train_valid_ratio=[5, 1],
batchsize=64,
randomize_split=False)
def model3D(img=(84, 256, 256)):
with tf.name_scope('WMH'):
seq = tg.Sequential()
convStride = (1, 1, 1)
poolStride = (2, 2, 2)
seq.add(
Conv3D(input_channels=1,
num_filters=10,
kernel_size=(3, 3, 3),
stride=convStride,
padding='SAME'))
seq.add(TFBatchNormalization(name='b1'))
seq.add(
MaxPool3D(poolsize=(2, 2, 2), stride=poolStride, padding='SAME'))
layerSize1 = updateConvLayerSize(img, poolStride)
#print("layer1: "+str(layerSize1))
seq.add(RELU())
seq.add(
Conv3D(input_channels=10,
num_filters=20,
kernel_size=(3, 3, 3),
stride=convStride,
padding='SAME'))
seq.add(TFBatchNormalization(name='b2'))
#layerSize2 = updateConvLayerSize(layerSize1,convStride)
#print("layer1: "+str(layerSize2))
seq.add(RELU())
seq.add(
Conv3D_Tranpose1(input_channels=20,
num_filters=10,
output_shape=layerSize1,
kernel_size=(3, 3, 3),
stride=convStride,
padding='SAME'))
seq.add(RELU())
seq.add(
Conv3D_Tranpose1(input_channels=10,
num_filters=3,
output_shape=img,
kernel_size=(3, 3, 3),
stride=(2, 2, 2),
padding='SAME'))
##
seq.add(RELU())
seq.add(
Conv3D(input_channels=3,
num_filters=2,
kernel_size=(3, 3, 3),
stride=convStride,
padding='SAME'))
##
seq.add(Softmax())
#seq.add(Sigmoid())
return seq
def test_VGG19():
seq = tg.Sequential()
vgg = VGG19(input_channels=c, input_shape=(h, w))
print('output channels:', vgg.output_channels)
print('output shape:', vgg.output_shape)
out_dim = np.prod(vgg.output_shape) * vgg.output_channels
seq.add(vgg)
seq.add(Flatten())
seq.add(Linear(int(out_dim), nclass))
seq.add(Softmax())
train(seq)
def train_with_Densenet():
from tensorgraph.trainobject import train as mytrain
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
X_train, y_train, X_test, y_test = Cifar10(contrast_normalize=False,
whiten=False)
_, h, w, c = X_train.shape
_, nclass = y_train.shape
print('X max', np.max(X_train))
print('X min', np.min(X_train))
seq = tg.Sequential()
dense = DenseNet(input_channels=c,
input_shape=(h, w),
ndense=3,
growth_rate=4,
nlayer1blk=4)
seq.add(dense)
seq.add(Flatten())
ldim = dense.output_channels
seq.add(Linear(ldim, nclass))
seq.add(Softmax())
X_ph = tf.placeholder('float32', [None, h, w, c])
y_ph = tf.placeholder('float32', [None, nclass])
y_train_sb = seq.train_fprop(X_ph)
y_test_sb = seq.test_fprop(X_ph)
train_cost_sb = entropy(y_ph, y_train_sb)
optimizer = tf.train.AdamOptimizer(0.001)
test_accu_sb = accuracy(y_ph, y_test_sb)
print(tf.global_variables())
print('..total number of global variables: {}'.format(
len(tf.global_variables())))
count = 0
for var in tf.global_variables():
count += int(np.prod(var.get_shape()))
print('..total number of global parameters: {}'.format(count))
mytrain(session=sess,
feed_dict={
X_ph: X_train,
y_ph: y_train
},
train_cost_sb=train_cost_sb,
valid_cost_sb=-test_accu_sb,
optimizer=optimizer,
epoch_look_back=5,
max_epoch=100,
percent_decrease=0,
train_valid_ratio=[5, 1],
batchsize=64,
randomize_split=False)
def test_DenseNet():
seq = tg.Sequential()
model = DenseNet(input_channels=c, input_shape=(h, w), ndense=1, growth_rate=1, nlayer1blk=1)
print('output channels:', model.output_channels)
print('output shape:', model.output_shape)
seq.add(model)
seq.add(MaxPooling(poolsize=tuple(model.output_shape), stride=(1,1), padding='VALID'))
seq.add(Flatten())
seq.add(Linear(model.output_channels, nclass))
seq.add(Softmax())
train(seq)
def test_UNet():
seq = tg.Sequential()
model = UNet(input_channels=c, input_shape=(h, w))
print('output channels:', model.output_channels)
print('output shape:', model.output_shape)
out_dim = np.prod(model.output_shape) * model.output_channels
seq.add(model)
seq.add(MaxPooling(poolsize=tuple(model.output_shape), stride=(1,1), padding='VALID'))
seq.add(Flatten())
seq.add(Linear(model.output_channels, nclass))
seq.add(Softmax())
train(seq)
def model(word_len, sent_len, nclass):
unicode_size = 1000
ch_embed_dim = 20
h, w = valid(ch_embed_dim,
word_len,
stride=(1, 1),
kernel_size=(ch_embed_dim, 5))
h, w = valid(h, w, stride=(1, 1), kernel_size=(1, 5))
h, w = valid(h, w, stride=(1, 2), kernel_size=(1, 5))
conv_out_dim = int(h * w * 60)
X_ph = tf.placeholder('int32', [None, sent_len, word_len])
input_sn = tg.StartNode(input_vars=[X_ph])
charcnn_hn = tg.HiddenNode(prev=[input_sn],
layers=[
Reshape(shape=(-1, word_len)),
Embedding(cat_dim=unicode_size,
encode_dim=ch_embed_dim,
zero_pad=True),
Reshape(shape=(-1, ch_embed_dim, word_len,
1)),
Conv2D(input_channels=1,
num_filters=20,
padding='VALID',
kernel_size=(ch_embed_dim, 5),
stride=(1, 1)),
RELU(),
Conv2D(input_channels=20,
num_filters=40,
padding='VALID',
kernel_size=(1, 5),
stride=(1, 1)),
RELU(),
Conv2D(input_channels=40,
num_filters=60,
padding='VALID',
kernel_size=(1, 5),
stride=(1, 2)),
RELU(),
Flatten(),
Linear(conv_out_dim, nclass),
Reshape((-1, sent_len, nclass)),
ReduceSum(1),
Softmax()
])
output_en = tg.EndNode(prev=[charcnn_hn])
graph = tg.Graph(start=[input_sn], end=[output_en])
y_train_sb = graph.train_fprop()[0]
y_test_sb = graph.test_fprop()[0]
return X_ph, y_train_sb, y_test_sb
def model(nclass, h, w, c):
with tf.name_scope('Cifar10AllCNN'):
seq = tg.Sequential()
seq.add(Conv2D(input_channels=c, num_filters=96, kernel_size=(3, 3), stride=(1, 1), padding='SAME'))
seq.add(RELU())
seq.add(TFBatchNormalization(name='b1'))
h, w = same(in_height=h, in_width=w, stride=(1,1), kernel_size=(3,3))
seq.add(Conv2D(input_channels=96, num_filters=96, kernel_size=(3, 3), stride=(1, 1), padding='SAME'))
seq.add(RELU())
h, w = same(in_height=h, in_width=w, stride=(1,1), kernel_size=(3,3))
seq.add(Dropout(0.5))
seq.add(Conv2D(input_channels=96, num_filters=96, kernel_size=(3, 3), stride=(2, 2), padding='SAME'))
seq.add(RELU())
seq.add(TFBatchNormalization(name='b3'))
h, w = same(in_height=h, in_width=w, stride=(2,2), kernel_size=(3,3))
seq.add(Conv2D(input_channels=96, num_filters=192, kernel_size=(3, 3), stride=(1, 1), padding='SAME'))
seq.add(RELU())
h, w = same(in_height=h, in_width=w, stride=(1,1), kernel_size=(3,3))
seq.add(Dropout(0.5))
seq.add(Conv2D(input_channels=192, num_filters=192, kernel_size=(3, 3), stride=(1, 1), padding='SAME'))
seq.add(RELU())
seq.add(TFBatchNormalization(name='b5'))
h, w = same(in_height=h, in_width=w, stride=(1,1), kernel_size=(3,3))
seq.add(Conv2D(input_channels=192, num_filters=192, kernel_size=(3, 3), stride=(2, 2), padding='SAME'))
seq.add(RELU())
h, w = same(in_height=h, in_width=w, stride=(2,2), kernel_size=(3,3))
seq.add(Dropout(0.5))
seq.add(Conv2D(input_channels=192, num_filters=192, kernel_size=(3, 3), stride=(1, 1), padding='SAME'))
seq.add(RELU())
seq.add(TFBatchNormalization(name='b7'))
h, w = same(in_height=h, in_width=w, stride=(1,1), kernel_size=(3,3))
seq.add(Conv2D(input_channels=192, num_filters=192, kernel_size=(1, 1), stride=(1, 1), padding='SAME'))
seq.add(RELU())
h, w = same(in_height=h, in_width=w, stride=(1,1), kernel_size=(1,1))
seq.add(Dropout(0.5))
seq.add(Conv2D(input_channels=192, num_filters=nclass, kernel_size=(1, 1), stride=(1, 1), padding='SAME'))
seq.add(RELU())
seq.add(TFBatchNormalization(name='b9'))
h, w = same(in_height=h, in_width=w, stride=(1,1), kernel_size=(1,1))
seq.add(AvgPooling(poolsize=(h, w), stride=(1,1), padding='VALID'))
seq.add(Flatten())
seq.add(Softmax())
return seq
def __init__(self, nclass, h, w, c):
layers = []
template = TemplateModel(nclass, h, w, c)
layers.append(template)
layers.append(Flatten())
layers.append(Linear(template.output_dim, 200))
layers.append(RELU())
layers.append(Linear(200, nclass))
layers.append(Softmax())
self.startnode = tg.StartNode(input_vars=[None])
model_hn = tg.HiddenNode(prev=[self.startnode], layers=layers)
self.endnode = tg.EndNode(prev=[model_hn])
def __init__(self, nclass, h, w, c):
layers = []
identityblk = IdentityBlock(input_channels=c,
input_shape=[h, w],
nlayers=10)
layers.append(identityblk)
layers.append(
Conv2D(input_channels=c,
num_filters=16,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(3, 3))
layers.append(BatchNormalization(input_shape=[h, w, 16]))
denseblk = DenseBlock(input_channels=16,
input_shape=[h, w],
growth_rate=4,
nlayers=4)
layers.append(denseblk)
layers.append(
Conv2D(input_channels=denseblk.output_channels,
num_filters=32,
kernel_size=(3, 3),
stride=(2, 2),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(2, 2), kernel_size=(3, 3))
layers.append(Dropout(0.5))
layers.append(
Conv2D(input_channels=32,
num_filters=nclass,
kernel_size=(1, 1),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(1, 1))
layers.append(BatchNormalization(input_shape=[h, w, nclass]))
layers.append(
AvgPooling(poolsize=(h, w), stride=(1, 1), padding='VALID'))
layers.append(Flatten())
layers.append(Softmax())
self.startnode = tg.StartNode(input_vars=[None])
model_hn = tg.HiddenNode(prev=[self.startnode], layers=layers)
self.endnode = tg.EndNode(prev=[model_hn])
def test_ResNetBase():
seq = tg.Sequential()
model = ResNetBase(input_channels=c, input_shape=(h, w), config=[1,1,1,1])
print('output channels:', model.output_channels)
print('output shape:', model.output_shape)
seq.add(model)
seq.add(MaxPooling(poolsize=tuple(model.output_shape), stride=(1,1), padding='VALID'))
outshape = valid_nd(model.output_shape, kernel_size=model.output_shape, stride=(1,1))
print(outshape)
out_dim = model.output_channels
seq.add(Flatten())
seq.add(Linear(int(out_dim), nclass))
seq.add(Softmax())
train(seq)
def __init__(self, nclass, h, w, c):
layers = []
model = UNet(input_channels=c, input_shape=(h, w))
layers.append(model)
layers.append(
MaxPooling(poolsize=tuple(model.output_shape),
stride=(1, 1),
padding='VALID'))
layers.append(Flatten())
layers.append(Linear(model.output_channels, nclass))
layers.append(Softmax())
self.startnode = tg.StartNode(input_vars=[None])
model_hn = tg.HiddenNode(prev=[self.startnode], layers=layers)
self.endnode = tg.EndNode(prev=[model_hn])
def model():
with tf.name_scope('MnistCNN'):
seq = tg.Sequential()
seq.add(
Conv2D(input_channels=1,
num_filters=32,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
h, w = same(in_height=28,
in_width=28,
stride=(1, 1),
kernel_size=(3, 3))
seq.add(BatchNormalization(input_shape=[h, w, 32]))
seq.add(RELU())
seq.add(MaxPooling(poolsize=(2, 2), stride=(2, 2), padding='SAME'))
h, w = same(in_height=h, in_width=w, stride=(2, 2), kernel_size=(2, 2))
seq.add(LRN())
seq.add(
Conv2D(input_channels=32,
num_filters=64,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(3, 3))
seq.add(BatchNormalization(input_shape=[h, w, 64]))
seq.add(RELU())
seq.add(MaxPooling(poolsize=(2, 2), stride=(2, 2), padding='SAME'))
h, w = same(in_height=h, in_width=w, stride=(2, 2), kernel_size=(2, 2))
seq.add(LRN())
seq.add(Flatten())
seq.add(Linear(int(h * w * 64), 128))
seq.add(BatchNormalization(input_shape=[128]))
seq.add(Tanh())
seq.add(Dropout(0.8))
seq.add(Linear(128, 256))
seq.add(BatchNormalization(input_shape=[256]))
seq.add(Tanh())
seq.add(Dropout(0.8))
seq.add(Linear(256, 10))
seq.add(Softmax())
return seq
def train_with_VGG():
from tensorgraph.trainobject import train as mytrain
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
X_train, y_train, X_test, y_test = Cifar10(contrast_normalize=False,
whiten=False)
_, h, w, c = X_train.shape
_, nclass = y_train.shape
print('X max', np.max(X_train))
print('X min', np.min(X_train))
from tensorgraph.layers import VGG19
seq = tg.Sequential()
layer = VGG19(input_channels=c, input_shape=(h, w))
seq.add(layer)
seq.add(Flatten())
seq.add(Linear(512, nclass))
seq.add(Softmax())
X_ph = tf.placeholder('float32', [None, h, w, c])
y_ph = tf.placeholder('float32', [None, nclass])
y_train_sb = seq.train_fprop(X_ph)
y_test_sb = seq.test_fprop(X_ph)
train_cost_sb = entropy(y_ph, y_train_sb)
optimizer = tf.train.AdamOptimizer(0.001)
test_accu_sb = accuracy(y_ph, y_test_sb)
mytrain(session=sess,
feed_dict={
X_ph: X_train,
y_ph: y_train
},
train_cost_sb=train_cost_sb,
valid_cost_sb=-test_accu_sb,
optimizer=optimizer,
epoch_look_back=5,
max_epoch=100,
percent_decrease=0,
train_valid_ratio=[5, 1],
batchsize=64,
randomize_split=False)
def discriminator(self):
if not self.generator_called:
raise Exception(
'self.generator() has to be called first before self.discriminator()'
)
scope = 'Discriminator'
with self.tf_graph.as_default():
with tf.name_scope(scope):
h1, w1 = valid(self.h,
self.w,
kernel_size=(5, 5),
stride=(1, 1))
h2, w2 = valid(h1, w1, kernel_size=(5, 5), stride=(2, 2))
h3, w3 = valid(h2, w2, kernel_size=(5, 5), stride=(2, 2))
flat_dim = int(h3 * w3 * 32)
dis_real_sn = tg.StartNode(input_vars=[self.real_ph])
# fake_ph = tf.placeholder('float32', [None, self.h, self.w, 1], name='fake')
# fake_sn = tg.StartNode(input_vars=[fake_ph])
disc_hn = tg.HiddenNode(
prev=[dis_real_sn, self.gen_hn],
layers=[
Conv2D(input_channels=self.c,
num_filters=32,
kernel_size=(5, 5),
stride=(1, 1),
padding='VALID'),
TFBatchNormalization(name=scope + '/d1'),
# BatchNormalization(layer_type='conv', dim=32, short_memory=0.01),
LeakyRELU(),
Conv2D(input_channels=32,
num_filters=32,
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
TFBatchNormalization(name=scope + '/d2'),
# BatchNormalization(layer_type='conv', dim=32, short_memory=0.01),
LeakyRELU(),
Conv2D(input_channels=32,
num_filters=32,
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
TFBatchNormalization(name=scope + '/d3'),
# BatchNormalization(layer_type='conv', dim=32, short_memory=0.01),
LeakyRELU(),
# Conv2D(input_channels=32, num_filters=32, kernel_size=(5,5), stride=(2,2), padding='VALID'),
# RELU(),
Flatten(),
Linear(flat_dim, self.bottleneck_dim),
# BatchNormalization(layer_type='fc', dim=self.bottleneck_dim, short_memory=0.01),
TFBatchNormalization(name=scope + '/d4'),
LeakyRELU(),
# Dropout(0.5),
])
class_hn = tg.HiddenNode(prev=[disc_hn],
layers=[
Linear(self.bottleneck_dim,
self.nclass),
Softmax()
])
judge_hn = tg.HiddenNode(
prev=[disc_hn],
layers=[Linear(self.bottleneck_dim, 1),
Sigmoid()])
real_class_en = tg.EndNode(prev=[class_hn])
real_judge_en = tg.EndNode(prev=[judge_hn])
fake_class_en = tg.EndNode(prev=[class_hn])
fake_judge_en = tg.EndNode(prev=[judge_hn])
graph = tg.Graph(start=[dis_real_sn],
end=[real_class_en, real_judge_en])
real_train = graph.train_fprop()
real_valid = graph.test_fprop()
graph = tg.Graph(start=[self.noise_sn, self.gen_real_sn],
end=[fake_class_en, fake_judge_en])
fake_train = graph.train_fprop()
fake_valid = graph.test_fprop()
dis_var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=scope)
return self.real_ph, real_train, real_valid, fake_train, fake_valid, dis_var_list
def model_Inception_Resnet(img=(84, 256, 256)):
with tf.name_scope('WMH'):
seq = tg.Sequential()
convStride = (1, 1, 1)
poolStride = (2, 2, 2)
kernelSize = (3, 3, 3)
seq.add(
Conv3D(input_channels=1,
num_filters=8,
kernel_size=(5, 5, 5),
stride=convStride,
padding='SAME'))
#seq.add(TFBatchNormalization(name='b1'))
seq.add(
MaxPool3D(poolsize=(2, 2, 2), stride=poolStride, padding='SAME'))
layerSize1 = updateConvLayerSize(img, poolStride)
seq.add(RELU())
seq.add(InceptionResnet_3D(8, type='v2_out8'))
seq.add(
Conv3D(input_channels=8,
num_filters=16,
kernel_size=kernelSize,
stride=convStride,
padding='SAME'))
#seq.add(TFBatchNormalization(name='b2'))
seq.add(
MaxPool3D(poolsize=(2, 2, 2), stride=poolStride, padding='SAME'))
layerSize2 = updateConvLayerSize(layerSize1, poolStride)
seq.add(RELU())
seq.add(InceptionResnet_3D(16, type='v1_out16'))
seq.add(
Conv3D(input_channels=16,
num_filters=16,
kernel_size=kernelSize,
stride=convStride,
padding='SAME'))
seq.add(RELU())
seq.add(
Conv3D(input_channels=16,
num_filters=32,
kernel_size=kernelSize,
stride=convStride,
padding='SAME'))
#seq.add(TFBatchNormalization(name='b3'))
seq.add(
MaxPool3D(poolsize=(2, 2, 2), stride=poolStride, padding='SAME'))
#layerSize3 = updateConvLayerSize(layerSize2,poolStride)
seq.add(RELU())
seq.add(InceptionResnet_3D(32, type='v1_out16'))
seq.add(
Conv3D_Tranpose1(input_channels=16,
num_filters=16,
output_shape=layerSize2,
kernel_size=kernelSize,
stride=poolStride,
padding='SAME'))
seq.add(RELU())
seq.add(InceptionResnet_3D(16, type='v1_out16'))
seq.add(
Conv3D(input_channels=16,
num_filters=16,
kernel_size=kernelSize,
stride=convStride,
padding='SAME'))
seq.add(RELU())
seq.add(
Conv3D_Tranpose1(input_channels=16,
num_filters=8,
output_shape=layerSize1,
kernel_size=kernelSize,
stride=poolStride,
padding='SAME'))
seq.add(RELU())
seq.add(InceptionResnet_3D(8, type='v2_out8'))
seq.add(
Conv3D(input_channels=8,
num_filters=8,
kernel_size=kernelSize,
stride=convStride,
padding='SAME'))
seq.add(RELU())
# num_filter=3 --> Background, WhiteMatter, Others
seq.add(
Conv3D_Tranpose1(input_channels=8,
num_filters=3,
output_shape=img,
kernel_size=kernelSize,
stride=poolStride,
padding='SAME'))
##
seq.add(RELU())
seq.add(
Conv3D(input_channels=3,
num_filters=3,
kernel_size=(1, 1, 1),
stride=convStride,
padding='SAME'))
##
seq.add(Softmax())
return seq
def Residual_UNET(input, img=(84, 256, 256)):
with tf.name_scope('WMH'):
convStride = (1, 1, 1)
poolStride = (2, 2, 2)
kSize3 = (3, 3, 3)
#kSize5 = (5,5,5)
#x_dim = 50
#component_dim = 100
#batchsize = 32
#learning_rate = 0.01
#x_ph = tf.placeholder('float32', [None, x_dim])
#start = StartNode(input_vars=[x_ph])
#h1 = HiddenNode(prev=[start], layers=[Linear(x_dim, component_dim), Softmax()])
#e1 = EndNode(prev=[h1], input_merge_mode=Sum())
#e3 = EndNode(prev=[h1, h2, h3], input_merge_mode=Sum())
start = StartNode(input_vars=[input])
Layer01 = [
Conv3D(input_channels=1,
num_filters=8,
kernel_size=kSize3,
stride=convStride,
padding='SAME')
]
#Layer01.append(RELU())
LayerPool = MaxPool3D(poolsize=(2, 2, 2),
stride=poolStride,
padding='SAME')
Layer02 = [LayerPool]
#Layer02.append(Testing(1))
Layer02.append(
Conv3D(input_channels=8,
num_filters=16,
kernel_size=kSize3,
stride=convStride,
padding='SAME'))
#Layer02.append(RELU())
#Layer02.append(Testing(2))
Layer02.append(ResidualBlock3D(16, 'L02'))
#Layer02.append(Testing(3))
layerSize1 = updateConvLayerSize(img, poolStride)
Layer03 = [LayerPool]
Layer03.append(
Conv3D(input_channels=16,
num_filters=32,
kernel_size=kSize3,
stride=convStride,
padding='SAME'))
#Layer03.append(RELU())
Layer03.append(ResidualBlock3D(32, 'L03'))
#layerSize2 = updateConvLayerSize(layerSize1,poolStride)
Layer03.append(
Conv3D_Tranpose1(input_channels=32,
num_filters=16,
output_shape=layerSize1,
kernel_size=kSize3,
stride=poolStride,
padding='SAME'))
#Layer03.append(RELU())
#Layer04 = [Conv3D(input_channels=32, num_filters=64, kernel_size=kSize5, stride=convStride, padding='SAME')]
#Layer04.append(ResidualBlock3D(64,'L03'))
conv8 = HiddenNode(prev=[start], layers=Layer01)
resBlock16 = HiddenNode(prev=[conv8], layers=Layer02)
resBlock32_16 = HiddenNode(prev=[resBlock16], layers=Layer03)
residualLong16 = HiddenNode(prev=[resBlock32_16, resBlock16],
input_merge_mode=Sum())
Layer04 = [ResidualBlock3D(16, 'L04')]
Layer04.append(
Conv3D_Tranpose1(input_channels=16,
num_filters=8,
output_shape=img,
kernel_size=kSize3,
stride=poolStride,
padding='SAME'))
Layer04.append(RELU())
resBlock16_8 = HiddenNode(prev=[residualLong16], layers=Layer04)
residualLong8 = HiddenNode(prev=[resBlock16_8, conv8],
input_merge_mode=Sum())
Layer05 = [ResidualBlock3D(8, 'L05')]
Layer05.append(
Conv3D(input_channels=8,
num_filters=2,
kernel_size=kSize3,
stride=convStride,
padding='SAME'))
Layer05.append(Softmax())
resBlock8_2 = HiddenNode(prev=[residualLong8], layers=Layer05)
endNode = EndNode(prev=[resBlock8_2], input_merge_mode=NoChange())
graph = Graph(start=[start], end=[endNode])
#o1, o2, o3 = graph.train_fprop()
#o1_mse = tf.reduce_mean((y1_ph - o1)**2)
#o2_mse = tf.reduce_mean((y2_ph - o2)**2)
return graph
def __init__(self, nclass, h, w, c):
layers = []
layers.append(
Conv2D(input_channels=c,
num_filters=96,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(3, 3))
layers.append(BatchNormalization(input_shape=[h, w, 96]))
layers.append(
Conv2D(input_channels=96,
num_filters=96,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(3, 3))
layers.append(Dropout(0.5))
layers.append(
Conv2D(input_channels=96,
num_filters=96,
kernel_size=(3, 3),
stride=(2, 2),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(2, 2), kernel_size=(3, 3))
layers.append(BatchNormalization(input_shape=[h, w, 96]))
layers.append(
Conv2D(input_channels=96,
num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(3, 3))
layers.append(Dropout(0.5))
layers.append(
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(3, 3))
layers.append(BatchNormalization(input_shape=[h, w, 192]))
layers.append(
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(3, 3),
stride=(2, 2),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(2, 2), kernel_size=(3, 3))
layers.append(Dropout(0.5))
layers.append(
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(3, 3))
layers.append(BatchNormalization(input_shape=[h, w, 192]))
layers.append(
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(1, 1),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(1, 1))
layers.append(Dropout(0.5))
layers.append(
Conv2D(input_channels=192,
num_filters=nclass,
kernel_size=(1, 1),
stride=(1, 1),
padding='SAME'))
layers.append(RELU())
h, w = same(in_height=h, in_width=w, stride=(1, 1), kernel_size=(1, 1))
layers.append(BatchNormalization(input_shape=[h, w, nclass]))
layers.append(
AvgPooling(poolsize=(h, w), stride=(1, 1), padding='VALID'))
layers.append(Flatten())
layers.append(Softmax())
self.startnode = tg.StartNode(input_vars=[None])
model_hn = tg.HiddenNode(prev=[self.startnode], layers=layers)
self.endnode = tg.EndNode(prev=[model_hn])
def model3D_2(img=(84, 256, 256)):
with tf.name_scope('WMH_2Chan_Input'):
seq = tg.Sequential()
convStride = (1, 1, 1)
poolStride = (2, 2, 2)
seq.add(
Conv3D(input_channels=1,
num_filters=8,
kernel_size=(5, 5, 5),
stride=convStride,
padding='SAME'))
seq.add(TFBatchNormalization(name='b1'))
seq.add(
MaxPool3D(poolsize=(2, 2, 2), stride=poolStride, padding='SAME'))
layerSize1 = updateConvLayerSize(img, poolStride)
seq.add(RELU())
seq.add(
Conv3D(input_channels=8,
num_filters=16,
kernel_size=(3, 3, 3),
stride=convStride,
padding='SAME'))
seq.add(TFBatchNormalization(name='b2'))
## Extra MaxPool
#seq.add(MaxPool3D(poolsize=(2,2,2), stride=poolStride, padding='SAME'))
#layerSize2 = updateConvLayerSize(layerSize1,convStride)
#seq.add(RELU())
## Extra Conv
#seq.add(Conv3D(input_channels=16, num_filters=16, kernel_size=(3,3,3), stride=convStride, padding='SAME'))
#seq.add(TFBatchNormalization(name='b3'))
seq.add(
Conv3D_Tranpose1(input_channels=16,
num_filters=8,
output_shape=layerSize1,
kernel_size=(3, 3, 3),
stride=convStride,
padding='SAME'))
seq.add(TFBatchNormalization(name='b4'))
seq.add(RELU())
seq.add(
Conv3D_Tranpose1(input_channels=8,
num_filters=2,
output_shape=img,
kernel_size=(3, 3, 3),
stride=poolStride,
padding='SAME'))
#seq.add(TFBatchNormalization(name='b5'))
#seq.add(RELU())
#seq.add(Conv3D(input_channels=2, num_filters=2, kernel_size=(1,1,1), stride=convStride, padding='SAME'))
##
##
#seq.add(RELU())
#seq.add(Conv3D(input_channels=2, num_filters=2, kernel_size=(3,3,3), stride=convStride, padding='SAME'))
# seq.add(RELU())
# seq.add(Conv3D(input_channels=3, num_filters=3, kernel_size=(3,3,3), stride=convStride, padding='SAME'))
# seq.add(RELU())
# seq.add(Conv3D(input_channels=3, num_filters=3, kernel_size=(3,3,3), stride=convStride, padding='SAME'))
#
##
seq.add(Softmax())
#seq.add(Sigmoid())
return seq
def discriminator(self):
if not self.generator_called:
raise Exception(
'self.generator() has to be called first before self.discriminator()'
)
scope = 'Discriminator'
with self.tf_graph.as_default():
with tf.name_scope(scope):
h1, w1 = valid(self.h,
self.w,
kernel_size=(5, 5),
stride=(1, 1))
h2, w2 = valid(h1, w1, kernel_size=(5, 5), stride=(2, 2))
h3, w3 = valid(h2, w2, kernel_size=(5, 5), stride=(2, 2))
flat_dim = int(h3 * w3 * 32)
real_ph = tf.placeholder('float32', [None, self.h, self.w, 1],
name='real')
real_sn = tg.StartNode(input_vars=[real_ph])
# fake_ph = tf.placeholder('float32', [None, self.h, self.w, 1], name='fake')
# fake_sn = tg.StartNode(input_vars=[fake_ph])
disc_hn = tg.HiddenNode(
prev=[real_sn, self.gen_hn],
layers=[
Conv2D(input_channels=1,
num_filters=32,
kernel_size=(5, 5),
stride=(1, 1),
padding='VALID'),
TFBatchNormalization(name=scope + '/c1'),
LeakyRELU(),
Conv2D(input_channels=32,
num_filters=32,
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
TFBatchNormalization(name=scope + '/c2'),
LeakyRELU(),
Conv2D(input_channels=32,
num_filters=32,
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
TFBatchNormalization(name=scope + '/c3'),
LeakyRELU(),
# Conv2D(input_channels=32, num_filters=32, kernel_size=(5,5), stride=(2,2), padding='VALID'),
# RELU(),
Flatten(),
Linear(flat_dim, self.bottleneck_dim),
TFBatchNormalization(name=scope + '/l1'),
LeakyRELU(),
# Dropout(0.5),
])
class_hn = tg.HiddenNode(prev=[disc_hn],
layers=[
Linear(self.bottleneck_dim,
self.nclass),
Softmax()
])
judge_hn = tg.HiddenNode(
prev=[disc_hn],
layers=[
Linear(self.bottleneck_dim, 1),
# Sigmoid()
])
real_class_en = tg.EndNode(prev=[class_hn])
real_judge_en = tg.EndNode(prev=[judge_hn])
fake_class_en = tg.EndNode(prev=[class_hn])
fake_judge_en = tg.EndNode(prev=[judge_hn])
graph = tg.Graph(start=[real_sn],
end=[real_class_en, real_judge_en])
real_train = graph.train_fprop()
real_valid = graph.test_fprop()
# dis_var_list = graph.variables
# for var in dis_var_list:
# print var.name
graph = tg.Graph(start=[self.noise_sn, self.y_sn],
end=[fake_class_en, fake_judge_en])
fake_train = graph.train_fprop()
fake_valid = graph.test_fprop()
# print('========')
# for var in graph.variables:
# print var.name
dis_var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=scope)
# for var in dis_var_list:
# print(var.name)
#
# print('=========')
# for var in tf.global_variables():
# print(var.name)
# import pdb; pdb.set_trace()
# print()
# graph = tg.Graph(start=[G_sn], end=[class_en, judge_en])
# class_train_sb, judge_train_sb = graph.train_fprop() # symbolic outputs
# class_test_sb, judge_test_sb = graph.test_fprop() # symbolic outputs
return real_ph, real_train, real_valid, fake_train, fake_valid, dis_var_list
def discriminator(self):
if not self.generator_called:
raise Exception(
'self.generator() has to be called first before self.discriminator()'
)
scope = 'Discriminator'
with self.tf_graph.as_default():
with tf.name_scope(scope):
h1, w1 = valid(self.h,
self.w,
kernel_size=(5, 5),
stride=(1, 1))
h2, w2 = valid(h1, w1, kernel_size=(5, 5), stride=(2, 2))
h3, w3 = valid(h2, w2, kernel_size=(5, 5), stride=(2, 2))
flat_dim = int(h3 * w3 * 32)
h1, w1 = valid(self.char_embed_dim,
self.word_len,
kernel_size=(self.char_embed_dim, 3),
stride=(1, 1))
print('h1:{}, w1:{}'.format(h1, w1))
h2, w2 = valid(h1, w1, kernel_size=(1, 3), stride=(1, 1))
print('h2:{}, w2:{}'.format(h2, w2))
h3, w3 = valid(h2, w2, kernel_size=(1, 3), stride=(1, 1))
print('h3:{}, w3:{}'.format(h3, w3))
# h4, w4 = valid(h3, w3, kernel_size=(1,6), stride=(1,1))
# print('h4:{}, w4:{}'.format(h4, w4))
# hf, wf = h4, w4
hf, wf = h3, w3
n_filters = 100
real_sn = tg.StartNode(input_vars=[self.real_ph])
real_hn = tg.HiddenNode(prev=[real_sn],
layers=[
OneHot(self.char_embed_dim),
Transpose(perm=[0, 3, 2, 1])
])
disc_hn = tg.HiddenNode(
prev=[real_hn, self.gen_hn],
layers=[
Conv2D(input_channels=self.sent_len,
num_filters=100,
kernel_size=(self.char_embed_dim, 3),
stride=(1, 1),
padding='VALID'),
TFBatchNormalization(name=scope + '/d1'),
LeakyRELU(),
Conv2D(input_channels=100,
num_filters=100,
kernel_size=(1, 3),
stride=(1, 1),
padding='VALID'),
TFBatchNormalization(name=scope + '/d2'),
LeakyRELU(),
Conv2D(input_channels=100,
num_filters=100,
kernel_size=(1, 3),
stride=(1, 1),
padding='VALID'),
TFBatchNormalization(name=scope + '/d3'),
LeakyRELU(),
# Conv2D(input_channels=32, num_filters=128, kernel_size=(1,6), stride=(1,1), padding='VALID'),
# RELU(),
Flatten(),
Linear(int(hf * wf * n_filters), self.bottleneck_dim),
TFBatchNormalization(name=scope + '/d4'),
LeakyRELU(),
])
class_hn = tg.HiddenNode(prev=[disc_hn],
layers=[
Linear(self.bottleneck_dim,
self.nclass),
Softmax()
])
judge_hn = tg.HiddenNode(
prev=[disc_hn],
layers=[
Linear(self.bottleneck_dim, 1),
# Sigmoid()
])
real_class_en = tg.EndNode(prev=[class_hn])
real_judge_en = tg.EndNode(prev=[judge_hn])
fake_class_en = tg.EndNode(prev=[class_hn])
fake_judge_en = tg.EndNode(prev=[judge_hn])
graph = tg.Graph(start=[real_sn],
end=[real_class_en, real_judge_en])
real_train = graph.train_fprop()
real_valid = graph.test_fprop()
graph = tg.Graph(start=[self.noise_sn],
end=[fake_class_en, fake_judge_en])
fake_train = graph.train_fprop()
fake_valid = graph.test_fprop()
dis_var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=scope)
return self.real_ph, real_train, real_valid, fake_train, fake_valid, dis_var_list
def generator(self):
self.generator_called = True
with self.tf_graph.as_default():
scope = 'Generator'
with tf.name_scope(scope):
h1, w1 = valid(self.h,
self.w,
kernel_size=(5, 5),
stride=(1, 1))
h2, w2 = valid(h1, w1, kernel_size=(5, 5), stride=(2, 2))
h3, w3 = valid(h2, w2, kernel_size=(5, 5), stride=(2, 2))
flat_dim = int(h3 * w3 * 32)
print('h1:{}, w1:{}'.format(h1, w1))
print('h2:{}, w2:{}'.format(h2, w2))
print('h3:{}, w3:{}'.format(h3, w3))
print('flat dim:{}'.format(flat_dim))
self.gen_real_sn = tg.StartNode(input_vars=[self.real_ph])
enc_hn = tg.HiddenNode(
prev=[self.gen_real_sn],
layers=[
Conv2D(input_channels=self.c,
num_filters=32,
kernel_size=(5, 5),
stride=(1, 1),
padding='VALID'),
TFBatchNormalization(name=scope + '/genc1'),
RELU(),
Conv2D(input_channels=32,
num_filters=32,
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
TFBatchNormalization(name=scope + '/genc2'),
RELU(),
Conv2D(input_channels=32,
num_filters=32,
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
TFBatchNormalization(name=scope + '/genc3'),
RELU(),
# Conv2D(input_channels=32, num_filters=32, kernel_size=(5,5), stride=(2,2), padding='VALID'),
# RELU(),
Flatten(),
Linear(flat_dim, 300),
TFBatchNormalization(name=scope + '/genc4'),
RELU(),
Linear(300, self.bottleneck_dim),
Tanh(),
])
embed_end = tg.EndNode(prev=[enc_hn])
graph_embed = tg.Graph(start=[self.gen_real_sn],
end=[embed_end])
G_train_embed = graph_embed.train_fprop()[0]
G_test_embed = graph_embed.test_fprop()[0]
enc_clf = tg.HiddenNode(prev=[enc_hn],
layers=[
Linear(self.bottleneck_dim,
self.nclass),
Softmax()
])
end_node = tg.EndNode(prev=[enc_clf])
graph_enc = tg.Graph(start=[self.gen_real_sn], end=[end_node])
G_train_enc = graph_enc.train_fprop()[0]
G_test_enc = graph_enc.test_fprop()[0]
self.noise_sn = tg.StartNode(input_vars=[self.noise_ph])
self.gen_hn = tg.HiddenNode(
prev=[self.noise_sn, enc_hn],
input_merge_mode=Sum(),
layers=[
Linear(self.bottleneck_dim, flat_dim),
RELU(),
Reshape((-1, 1, 1, flat_dim)),
# Reshape((-1, h))
Conv2D_Transpose(input_channels=flat_dim,
num_filters=200,
output_shape=(h3, w3),
kernel_size=(h3, w3),
stride=(1, 1),
padding='VALID'),
# BatchNormalization(layer_type='conv', dim=200, short_memory=0.01),
TFBatchNormalization(name=scope + '/g1'),
RELU(),
Conv2D_Transpose(input_channels=200,
num_filters=100,
output_shape=(h2, w2),
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
TFBatchNormalization(name=scope + '/g2'),
RELU(),
Conv2D_Transpose(input_channels=100,
num_filters=50,
output_shape=(h1, w1),
kernel_size=(5, 5),
stride=(2, 2),
padding='VALID'),
# BatchNormalization(layer_type='conv', dim=50, short_memory=0.01),
TFBatchNormalization(name=scope + '/g3'),
RELU(),
Conv2D_Transpose(input_channels=50,
num_filters=self.c,
output_shape=(self.h, self.w),
kernel_size=(5, 5),
stride=(1, 1),
padding='VALID'),
SetShape((-1, self.h, self.w, self.c)),
Sigmoid()
])
h, w = valid(self.h, self.w, kernel_size=(5, 5), stride=(1, 1))
h, w = valid(h, w, kernel_size=(5, 5), stride=(2, 2))
h, w = valid(h, w, kernel_size=(5, 5), stride=(2, 2))
h, w = valid(h, w, kernel_size=(h3, w3), stride=(1, 1))
y_en = tg.EndNode(prev=[self.gen_hn])
graph = tg.Graph(start=[self.noise_sn, self.gen_real_sn],
end=[y_en])
G_train_sb = graph.train_fprop()[0]
G_test_sb = graph.test_fprop()[0]
gen_var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=scope)
return self.y_ph, self.noise_ph, G_train_sb, G_test_sb, gen_var_list, G_train_enc, G_test_enc, G_train_embed, G_test_embed
def discriminator_allconv(self):
if not self.generator_called:
raise Exception(
'self.generator() has to be called first before self.discriminator()'
)
scope = 'Discriminator'
with self.tf_graph.as_default():
with tf.name_scope(scope):
# h1, w1 = valid(self.h, self.w, kernel_size=(5,5), stride=(1,1))
# h2, w2 = valid(h1, w1, kernel_size=(5,5), stride=(2,2))
# h3, w3 = valid(h2, w2, kernel_size=(5,5), stride=(2,2))
# flat_dim = int(h3*w3*32)
dis_real_sn = tg.StartNode(input_vars=[self.real_ph])
# fake_ph = tf.placeholder('float32', [None, self.h, self.w, 1], name='fake')
# fake_sn = tg.StartNode(input_vars=[fake_ph])
h, w = same(in_height=self.h,
in_width=self.w,
stride=(1, 1),
kernel_size=(3, 3))
h, w = same(in_height=h,
in_width=w,
stride=(1, 1),
kernel_size=(3, 3))
h, w = same(in_height=h,
in_width=w,
stride=(2, 2),
kernel_size=(3, 3))
h, w = same(in_height=h,
in_width=w,
stride=(1, 1),
kernel_size=(3, 3))
h, w = same(in_height=h,
in_width=w,
stride=(1, 1),
kernel_size=(3, 3))
h, w = same(in_height=h,
in_width=w,
stride=(2, 2),
kernel_size=(3, 3))
h, w = same(in_height=h,
in_width=w,
stride=(1, 1),
kernel_size=(1, 1))
h, w = same(in_height=h,
in_width=w,
stride=(1, 1),
kernel_size=(3, 3))
h, w = same(in_height=h,
in_width=w,
stride=(1, 1),
kernel_size=(1, 1))
print('h, w', h, w)
print('===============')
# h, w = valid(in_height=h, in_width=w, stride=(1,1), kernel_size=(h,w))
disc_hn = tg.HiddenNode(
prev=[dis_real_sn, self.gen_hn],
layers=[
Dropout(0.2),
# TFBatchNormalization(name='b0'),
Conv2D(input_channels=self.c,
num_filters=96,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'),
LeakyRELU(),
TFBatchNormalization(name='b1'),
# Dropout(0.5),
Conv2D(input_channels=96,
num_filters=96,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'),
LeakyRELU(),
# TFBatchNormalization(name='b2'),
Dropout(0.5),
Conv2D(input_channels=96,
num_filters=96,
kernel_size=(3, 3),
stride=(2, 2),
padding='SAME'),
LeakyRELU(),
TFBatchNormalization(name='b3'),
# Dropout(0.5),
Conv2D(input_channels=96,
num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'),
LeakyRELU(),
# TFBatchNormalization(name='b4'),
Dropout(0.5),
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'),
LeakyRELU(),
TFBatchNormalization(name='b5'),
# Dropout(0.5),
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(3, 3),
stride=(2, 2),
padding='SAME'),
LeakyRELU(),
# TFBatchNormalization(name='b6'),
Dropout(0.5),
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'),
LeakyRELU(),
TFBatchNormalization(name='b7'),
# Dropout(0.5),
Conv2D(input_channels=192,
num_filters=192,
kernel_size=(1, 1),
stride=(1, 1),
padding='SAME'),
LeakyRELU(),
# TFBatchNormalization(name='b8'),
Dropout(0.5),
Conv2D(input_channels=192,
num_filters=self.nclass,
kernel_size=(1, 1),
stride=(1, 1),
padding='SAME'),
LeakyRELU(),
TFBatchNormalization(name='b9'),
# Dropout(0.5),
AvgPooling(poolsize=(h, w),
stride=(1, 1),
padding='VALID'),
Flatten(),
])
print('h,w', h, w)
print('==============')
class_hn = tg.HiddenNode(
prev=[disc_hn],
layers=[Linear(self.nclass, self.nclass),
Softmax()])
judge_hn = tg.HiddenNode(
prev=[disc_hn],
layers=[
Linear(self.nclass, 1),
# Sigmoid()
])
real_class_en = tg.EndNode(prev=[class_hn])
real_judge_en = tg.EndNode(prev=[judge_hn])
fake_class_en = tg.EndNode(prev=[class_hn])
fake_judge_en = tg.EndNode(prev=[judge_hn])
graph = tg.Graph(start=[dis_real_sn],
end=[real_class_en, real_judge_en])
real_train = graph.train_fprop()
real_valid = graph.test_fprop()
graph = tg.Graph(start=[self.noise_sn, self.gen_real_sn],
end=[fake_class_en, fake_judge_en])
fake_train = graph.train_fprop()
fake_valid = graph.test_fprop()
dis_var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=scope)
return self.real_ph, real_train, real_valid, fake_train, fake_valid, dis_var_list
def model(nclass, h, w, c):
with tf.name_scope('Cifar10AllCNN'):
seq = tg.Sequential()
seq.add(
Conv2D(num_filters=96,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
seq.add(RELU())
seq.add(BatchNormalization())
seq.add(
Conv2D(num_filters=96,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
seq.add(RELU())
seq.add(Dropout(0.5))
seq.add(
Conv2D(num_filters=96,
kernel_size=(3, 3),
stride=(2, 2),
padding='SAME'))
seq.add(RELU())
seq.add(BatchNormalization())
seq.add(
Conv2D(num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
seq.add(RELU())
seq.add(Dropout(0.5))
seq.add(
Conv2D(num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
seq.add(RELU())
seq.add(BatchNormalization())
seq.add(
Conv2D(num_filters=192,
kernel_size=(3, 3),
stride=(2, 2),
padding='SAME'))
seq.add(RELU())
seq.add(Dropout(0.5))
seq.add(
Conv2D(num_filters=192,
kernel_size=(3, 3),
stride=(1, 1),
padding='SAME'))
seq.add(RELU())
seq.add(BatchNormalization())
seq.add(
Conv2D(num_filters=192,
kernel_size=(1, 1),
stride=(1, 1),
padding='SAME'))
seq.add(RELU())
seq.add(Dropout(0.5))
seq.add(
Conv2D(num_filters=nclass,
kernel_size=(1, 1),
stride=(1, 1),
padding='SAME'))
seq.add(RELU())
seq.add(BatchNormalization())
seq.add(AvgPooling(poolsize=(8, 8), stride=(1, 1), padding='VALID'))
seq.add(Flatten())
seq.add(Softmax())
return seq
