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_Resnet():
from tensorgraphx.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 __init__(self, h, w, c, nclass):
layers = []
layers.append(CBR(h,w,c))
layers.append(Flatten())
layers.append(Linear(1*h*w, nclass))
self.startnode = tg.StartNode(input_vars=[None])
hn = tg.HiddenNode(prev=[self.startnode], layers=layers)
self.endnode = tg.EndNode(prev=[hn])
def train_with_Densenet():
from tensorgraphx.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_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 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 test_Dropout():
X_ph = tf.placeholder('float32', [None, 32])
seq = tg.Sequential()
seq.add(Linear(32, 20))
seq.add(Dropout(0.2, noise_shape=[-1, 20]))
out = seq.train_fprop(X_ph)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
out = sess.run(out, feed_dict={X_ph: np.random.rand(1, 32)})
print(out)
print(out.shape)
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 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 train_with_VGG():
from tensorgraphx.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 tensorgraphx.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 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)