def forward_alexnet(self, inp, weights, reuse=False):
# reuse is for the normalization parameters.
conv1 = conv_block(inp, weights['conv1_weights'], weights['conv1_biases'], stride_y=4, stride_x=4, groups=1, reuse=reuse, scope='conv1')
norm1 = lrn(conv1, 2, 1e-05, 0.75)
pool1 = max_pool(norm1, 3, 3, 2, 2, padding='VALID')
# 2nd Layer: Conv (w ReLu) -> Lrn -> Pool with 2 groups
conv2 = conv_block(pool1, weights['conv2_weights'], weights['conv2_biases'], stride_y=1, stride_x=1, groups=2, reuse=reuse, scope='conv2')
norm2 = lrn(conv2, 2, 1e-05, 0.75)
pool2 = max_pool(norm2, 3, 3, 2, 2, padding='VALID')
# 3rd Layer: Conv (w ReLu)
conv3 = conv_block(pool2, weights['conv3_weights'], weights['conv3_biases'], stride_y=1, stride_x=1, groups=1, reuse=reuse, scope='conv3')
# 4th Layer: Conv (w ReLu) splitted into two groups
conv4 = conv_block(conv3, weights['conv4_weights'], weights['conv4_biases'], stride_y=1, stride_x=1, groups=2, reuse=reuse, scope='conv4')
# 5th Layer: Conv (w ReLu) -> Pool splitted into two groups
conv5 = conv_block(conv4, weights['conv5_weights'], weights['conv5_biases'], stride_y=1, stride_x=1, groups=2, reuse=reuse, scope='conv5')
pool5 = max_pool(conv5, 3, 3, 2, 2, padding='VALID')
# 6th Layer: Flatten -> FC (w ReLu) -> Dropout
flattened = tf.reshape(pool5, [-1, 6 * 6 * 256])
fc6 = fc(flattened, weights['fc6_weights'], weights['fc6_biases'], activation='relu')
dropout6 = dropout(fc6, self.KEEP_PROB)
# 7th Layer: FC (w ReLu) -> Dropout
fc7 = fc(dropout6, weights['fc7_weights'], weights['fc7_biases'], activation='relu')
dropout7 = dropout(fc7, self.KEEP_PROB)
# 8th Layer: FC and return unscaled activations
fc8 = fc(dropout7, weights['fc8_weights'], weights['fc8_biases'])
return fc7, fc8
def UNet(x, keep_probability):
layer1 = conv_block(x, 1)
pool1 = utils.max_pool(layer1, 2)
layer2 = conv_block(pool1, 2)
pool2 = utils.max_pool(layer2, 2)
layer3 = conv_block(pool2, 3)
pool3 = utils.max_pool(layer3, 2)
layer4 = conv_block(pool3, 4)
#upsampling
up5 = upsampling_bolck(layer3, layer4, 5)
layer5 = conv_block(up5, 5)
up6 = upsampling_bolck(layer2, layer5, 6)
layer6 = conv_block(up6, 6)
up7 = upsampling_bolck(layer1, layer6, 7)
layer7 = conv_block(up7, 7)
W6 = utils.weight_variable([1, 1, layer7.get_shape()[3].value, 1],
name='W6')
b6 = utils.bias_variable([1], 'bias6')
conv6_1 = utils.conv2d(layer7, W6, b6, 'conv_6')
return conv6_1
def inference(image):
with tf.variable_scope('inference'):
with tf.name_scope('1.unit'):
w1 = utils.weight_variable([5, 5, 3, 32], name='w1')
print(w1.name)
b1 = utils.bias_variable([32], name='b1')
tf.summary.histogram('b1', b1)
x = utils.conv2d_activtion(image, w1, b1, batchnorm=True)
x = utils.max_pool(x)
with tf.name_scope('2.unit'):
w2 = utils.weight_variable([5, 5, 32, 64], 'w2')
tf.summary.histogram('w2', w2)
b2 = utils.bias_variable([64], 'b2')
tf.summary.histogram('b2', b2)
x = utils.conv2d_activtion(x, w2, b2, batchnorm=True)
x = utils.max_pool(x)
with tf.name_scope('3.unit'):
w3 = utils.weight_variable([5, 5, 64, 96], 'w3')
b3 = utils.bias_variable([96], 'b3')
x = utils.conv2d_activtion(x, w3, b3, batchnorm=True)
x = utils.max_pool(x)
with tf.name_scope('4.unit'):
w4 = utils.weight_variable([5, 5, 96, 128], 'w4')
b4 = utils.bias_variable([128], 'b4')
x = utils.conv2d_activtion(x, w4, b4, batchnorm=True)
x = utils.max_pool(x)
with tf.name_scope('fc1'):
layers = int(x.shape[1]) * int(x.shape[2]) * int(x.shape[3])
w5 = utils.weight_variable([layers, 128], 'w5')
b5 = utils.bias_variable([128], 'b5')
x = tf.reshape(x, [-1, layers])
x = tf.matmul(x, w5) + b5
x = tf.nn.elu(x)
# x = tf.nn.dropout(x, 0.5)
with tf.name_scope('fc2'):
w6 = utils.weight_variable([128, 128], 'w6')
b6 = utils.bias_variable([128], 'b6')
x = tf.matmul(x, w6) + b6
x = tf.nn.elu(x)
# x = tf.nn.dropout(x, 0.5)
with tf.name_scope('out_put'):
w7 = utils.weight_variable([128, 5], 'w7')
b7 = utils.bias_variable([5], 'b7')
x = tf.matmul(x, w7) + b7
pred = tf.nn.softmax(x)
return pred
def eval(self, data, dropout_keep_prob=1.0):
activations_1x1 = self.calc_activations(data, self.weights_1x1,
self.biases_1x1)
activations_3x3_reduced = self.calc_activations(
data, self.weights_3x3_reduced, self.biases_3x3_reduced)
activations_3x3 = self.calc_activations(activations_3x3_reduced,
self.weights_3x3,
self.biases_3x3)
activations_5x5_reduced = self.calc_activations(
data, self.weights_5x5_reduced, self.biases_5x5_reduced)
activations_5x5 = self.calc_activations(activations_5x5_reduced,
self.weights_5x5,
self.biases_5x5)
activations_max_pool_3x3 = utils.max_pool(data,
block_size=3,
stride=1,
padding='SAME')
activations_pool_reduced = self.calc_activations(
activations_max_pool_3x3, self.weights_pool_reduced,
self.biasespool_reduced)
depth_concat = tf.concat(3, [
activations_3x3, activations_1x1, activations_5x5,
activations_pool_reduced
])
return depth_concat
def inference(self, x):
with tf.variable_scope("conv0"):
conv1 = utils.relu(utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=True), training=self.is_training))
with tf.name_scope("pool1"):
pool1 = utils.max_pool(conv1, 3, 3, 2, 2)
with tf.variable_scope("group0"):
res2a = self.residual(pool1, 256, name='block0')
res2b = self.residual(res2a, 256, name='block1')
res2c = self.residual(res2b, 256, name='block2')
with tf.variable_scope("group1"):
res3a = self.residual(res2c, 512, 2, name='block0')
res3b = self.residual(res3a, 512, name='block1')
res3c = self.residual(res3b, 512, name='block2')
res3d = self.residual(res3c, 512, name='block3')
with tf.variable_scope("group2"):
res4a = self.residual(res3d, 1024, 2, name='block0')
res4b = self.residual(res4a, 1024, name='block1')
res4c = self.residual(res4b, 1024, name='block2')
res4d = self.residual(res4c, 1024, name='block3')
res4e = self.residual(res4d, 1024, name='block4')
res4f = self.residual(res4e, 1024, name='block5')
with tf.variable_scope("group3"):
res5a = self.residual(res4f, 2048, 2, name='block0')
res5b = self.residual(res5a, 2048, name='block1')
res5c = self.residual(res5b, 2048, name='block2')
with tf.name_scope("pool5"):
pool5 = utils.global_pool(res5c)
with tf.variable_scope("linear"):
dropout = tf.nn.dropout(pool5, keep_prob=self.keep_prob)
out = utils.linear(dropout, 1000)
return out
def encode(self, inputs, lengths, fr=0):
bsz, max_len = inputs.size()
e_hidden_init = self.e_hidden_init.expand(
2, bsz, self.hidden_dim).contiguous()
e_cell_init = self.e_cell_init.expand(2, bsz,
self.hidden_dim).contiguous()
lens, indices = torch.sort(lengths, 0, True)
if fr and not self.share_vocab:
in_embs = self.embedding_fr(inputs)
else:
in_embs = self.embedding(inputs)
if fr and not self.share_encoder:
if self.dropout > 0:
F.dropout(in_embs, training=self.training)
all_hids, (enc_last_hid, _) = self.lstm_fr(
pack(in_embs[indices], lens.tolist(), batch_first=True),
(e_hidden_init, e_cell_init))
else:
if self.dropout > 0:
F.dropout(in_embs, training=self.training)
all_hids, (enc_last_hid, _) = self.lstm(
pack(in_embs[indices], lens.tolist(), batch_first=True),
(e_hidden_init, e_cell_init))
_, _indices = torch.sort(indices, 0)
all_hids = unpack(all_hids, batch_first=True)[0][_indices]
if self.pool == "max":
embs = utils.max_pool(all_hids, lengths, self.gpu)
elif self.pool == "mean":
embs = utils.mean_pool(all_hids, lengths, self.gpu)
return embs
def graph(self, input, is_training):
with tf.name_scope('model'):
net = ut.conv_layer(input, 64, 7, 2, name='conv1')
net = ut.bottleneck(net,
128,
stride=1,
training=is_training,
name='res1')
net = ut.max_pool(net, 2, 2, 'max_pool')
net = ut.bottleneck(net,
int(self.nFeats / 2),
stride=1,
training=is_training,
name='res2')
net = ut.bottleneck(net,
self.nFeats,
stride=1,
training=is_training,
name='res3')
with tf.name_scope('stacks'):
stack_out = []
with tf.name_scope('stage_0'):
hg = ut.hourglass(net, self.nLow, self.nFeats, 'hourglass')
drop = ut.dropout(hg, self.dropout_rate, is_training,
'dropout')
ll = ut.conv_layer_bn(drop, self.nFeats, 1, 1, is_training)
out = ut.conv_layer(ll, self.num_points, 1, 1, name='out')
out_ = ut.conv_layer(out, self.nFeats, 1, 1, name='out_')
sum_ = tf.add(net, out_, name='merge')
stack_out.append(out)
for i in range(1, self.nStacks):
with tf.name_scope('stage_' + str(i)):
hg = ut.hourglass(sum_, self.nLow, self.nFeats,
'hourglass')
drop = ut.dropout(hg, self.dropout_rate, is_training,
'dropout')
ll = ut.conv_layer_bn(drop, self.nFeats, 1, 1,
is_training)
out = ut.conv_layer(ll,
self.num_points,
1,
1,
name='out')
out_ = ut.conv_layer(ll,
self.nFeats,
1,
1,
name='out_')
sum_ = tf.add(sum_, out_, name='merge')
stack_out.append(out)
with tf.name_scope('upsampling'):
net = ut.batch_norm(sum_, is_training)
net = ut.conv_layer_bn(net, self.nFeats, 3, 1, is_training)
up1 = ut.deconv_layer(net, self.num_points, 1, 2, name='up_1')
net = ut.conv_layer_bn(up1, self.nFeats, 3, 1, is_training)
up2 = ut.deconv_layer(net, self.num_points, 1, 2, name='up_2')
return tf.stack(stack_out, axis=1, name='stack_out'), up1, up2
def set_up(self):
with tf.variable_scope('conv1'):
network = conv2d(self.input, [7, 7], 32, scope='conv1_1')
network = conv2d(network, [3, 3], 32, scope='conv1_2')
network = max_pool(network, 'pool1') # downsample
with tf.variable_scope('conv1'):
network = conv2d(network, [3, 3], 64, scope='conv1_1')
network = conv2d(network, [3, 3], 64, scope='conv1_2')
network = max_pool(network, 'pool2') # downsample
with tf.variable_scope('conv1'):
network = conv2d(network, [3, 3], 128, scope='conv1_1')
network = conv2d(network, [3, 3], 128, scope='conv1_2')
with tf.variable_scope('deconv1'):
network = deconv2d(network, [3, 3], 64,
scope='deconv1_1') # upsample
network = deconv2d(network, [3, 3],
64,
stride=1,
scope='deconv1_1')
with tf.variable_scope('deconv2'):
network = deconv2d(network, [3, 3], 32,
scope='deconv1_1') # upsample
network = deconv2d(network, [3, 3],
32,
stride=1,
scope='deconv1_1')
with tf.variable_scope('out_class'):
logits = conv2d(network, [3, 3],
2,
bn=False,
relu=False,
scope='logits')
self.pred_prob = tf.nn.softmax(logits, name='predictions')[:, :, :, 1]
self.pred = tf.argmax(logits, 3)
self.loss = iou_loss(self.pred_prob, self.label)
self.train_score = iou_loss(tf.cast(self.pred, tf.float32), self.label)
self.optimizer = tf.train.AdamOptimizer(
learning_rate=self.learning_rate, epsilon=1e-4).minimize(self.loss)
def forward(self, x):
self._ims = []
self._cols = []
new_rows = []
for row in x:
im = row.reshape((1,self.im_rect[0],self.im_rect[1]))
col = utils.im2col(im, self.pool_rect, self.pool_stride)
new_row = utils.max_pool(col)
new_rows.append(new_row)
self._ims.append(im)
self._cols.append(col)
return np.array(new_rows)
def eval(self, data, dropout_keep_prob=1.0):
if self.activation_func == 'maxpool':
pooled_data = utils.max_pool(data,
block_size=self.filter_size,
stride=self.stride,
padding=self.padding)
else:
pooled_data = utils.avg_pool(data,
block_size=self.filter_size,
stride=self.stride,
padding=self.padding)
return pooled_data
def forward(self, x):
self._ims = []
self._cols = []
new_rows = []
for row in x:
im = row.reshape((1, self.im_rect[0], self.im_rect[1]))
col = utils.im2col(im, self.pool_rect, self.pool_stride)
new_row = utils.max_pool(col)
new_rows.append(new_row)
self._ims.append(im)
self._cols.append(col)
return np.array(new_rows)
def net_1(input, is_train):
conv1 = conv(input,
filter_h=5,
filter_w=5,
num_filters=32,
stride_y=1,
stride_x=1,
name='conv1')
pool1 = max_pool(conv1,
filter_h=2,
filter_w=2,
stride_y=2,
stride_x=2,
name='pool1')
conv2 = conv(pool1, 5, 5, 64, 1, 1, 'conv2')
pool2 = max_pool(conv2, 2, 2, 2, 2, 'pool2')
flattened = flatten_3d(pool2, name='flattening')
fc3 = fc(flattened, out_neurons=1000, name='fc3')
dropout3 = dropout(fc3,
keep_prob=prob_close(is_train, 0.5),
name='dropout3')
fc4 = fc(dropout3, out_neurons=10, name='fc4', relu=False)
return fc4
def encode(self, idxs, lengths, fr=0):
if fr and not self.share_vocab:
word_embs = self.embedding_fr(idxs)
else:
word_embs = self.embedding(idxs)
if self.dropout > 0:
F.dropout(word_embs, training=self.training)
if self.pool == "max":
word_embs = utils.max_pool(word_embs, lengths, self.args.gpu)
elif self.pool == "mean":
word_embs = utils.mean_pool(word_embs, lengths, self.args.gpu)
return word_embs
def inference(self, x, grah):
with tf.variable_scope("conv0"):
if self.res_name == "resnet50":
net = utils.relu(
utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=True),
training=self.is_training))
else:
net = utils.relu(
utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=False),
training=self.is_training))
with tf.name_scope("pool1"):
net = utils.max_pool(net, 3, 3, 2, 2)
with tf.variable_scope("group0"):
for i in range(grah[0]):
net = self.residual(net, 256, name='block' + str(i))
with tf.variable_scope("group1"):
for i in range(grah[1]):
if i == 0:
net = self.residual(net, 512, 2, name='block' + str(i))
else:
net = self.residual(net, 512, name='block' + str(i))
with tf.variable_scope("group2"):
for i in range(grah[2]):
if i == 0:
net = self.residual(net, 1024, 2, name='block' + str(i))
else:
net = self.residual(net, 1024, name='block' + str(i))
with tf.variable_scope("group3"):
for i in range(grah[3]):
if i == 0:
net = self.residual(net, 2048, 2, name='block' + str(i))
else:
net = self.residual(net, 2048, name='block' + str(i))
with tf.name_scope("pool5"):
net = utils.global_pool(net)
with tf.variable_scope("linear"):
net = tf.nn.dropout(net, keep_prob=self.keep_prob)
net = utils.linear(net, 1000)
return net
def inference(self, x):
with tf.variable_scope("conv0"):
conv1 = utils.relu(utils.Bn(utils.conv2d(x, 64, 7, 7, 2, 2, bias=False), training=self.is_training))
with tf.name_scope("pool1"):
pool1 = utils.max_pool(conv1, 3, 3, 2, 2)
with tf.variable_scope("group0"):
res2a = self.residual(pool1, 64, branch=True, name='block0')
res2b = self.residual(res2a, 64, name='block1')
with tf.variable_scope("group1"):
res3a = self.residual(res2b, 128, 2, name='block0')
res3b = self.residual(res3a, 128, name='block1')
with tf.variable_scope("group2"):
res4a = self.residual(res3b, 256, 2, name='block0')
res4b = self.residual(res4a, 256, name='block1')
with tf.variable_scope("group3"):
res5a = self.residual(res4b, 512, 2, name='block0')
res5b = self.residual(res5a, 512, name='block1')
with tf.name_scope("pool5"):
pool5 = utils.global_pool(res5b)
with tf.variable_scope("linear"):
dropout = tf.nn.dropout(pool5, keep_prob=self.keep_prob)
out = utils.linear(dropout, 1000)
return out
def create_conv_network(x,
channels_x,
channels_y,
layers=3,
feature_base=64,
filter_size=5,
pool_size=2,
keep_prob=0.8,
create_summary=True):
"""
:param x: input_tensor, shape should be [None, n, m, channels_x]
:param channels_x: number of channels in the input image. For Mri, input has 4 channels.
:param channels_y: number of channels in the output image. For Mri, output has 2 channels.
:param layers: number of layers in u-net architecture.
:param feature_base: Neurons in first layer of cnn. Next layers have twice the number of neurons in previous layers.
:param filter_size: size of convolution filter
:param pool_size: size of pooling layer
:create_summary: Creates Tensorboard summary if True
"""
logging.info(
"Layers: {layers}, features: {features}, filter size {fill_size}x{fill_size}, pool size {pool_size}x{pool_size},"
"input channels {in_channels}, output channels {out_channels}".format(
layers=layers,
features=feature_base,
fill_size=filter_size,
pool_size=pool_size,
in_channels=channels_x,
out_channels=channels_y))
#placeholder for input image
with tf.name_scope("input_image"):
n = tf.shape(x)[1]
m = tf.shape(x)[2]
x_image = tf.reshape(x, tf.stack([-1, n, m, channels_x]))
input_node = x_image
weights = []
biases = []
convs = []
pools = OrderedDict()
deconv = OrderedDict()
dw_h_convs = OrderedDict()
up_h_convs = OrderedDict()
# down layers
for layer in range(layers):
with tf.name_scope("down_conv_layer{}".format(str(layer))):
features = (2**layer) * feature_base
std_dev = np.sqrt(2. / (filter_size * filter_size * features))
if layer == 0:
w1 = utils.weight_variable(
[filter_size, filter_size, channels_x, features], std_dev,
"w1")
else:
w1 = utils.weight_variable(
[filter_size, filter_size, features // 2, features],
std_dev, "w1")
w2 = utils.weight_variable(
[filter_size, filter_size, features, features], std_dev, "w2")
b1 = utils.bias_variable([features], "b1")
b2 = utils.bias_variable([features], "b2")
conv_1 = utils.conv2d(input_node, w1, b1, keep_prob)
conv_2 = utils.conv2d(tf.nn.relu(conv_1), w2, b2, keep_prob)
dw_h_convs[layer] = tf.nn.relu(conv_2)
weights.append((w1, w2))
biases.append((b1, b2))
convs.append((conv_1, conv_2))
# do max pooling if not the last layer
if layer < layers - 1:
pools[layer] = utils.max_pool(dw_h_convs[layer], pool_size)
input_node = pools[layer]
input_node = dw_h_convs[layers - 1]
#up layers
for layer in range(layers - 2, -1, -1):
with tf.name_scope("up_conv_layer{}".format(str(layer))):
features = (2**(layer + 1)) * feature_base
std_dev = np.sqrt(2. / (filter_size * filter_size * features))
wd = utils.weight_variable_devonc(
[pool_size, pool_size, features // 2, features], std_dev, "wd")
bd = utils.bias_variable([features // 2], "bd")
h_deconv = tf.nn.relu(
utils.deconv2d(input_node, wd, pool_size) + bd)
h_deconv_concat = tf.concat([dw_h_convs[layer], h_deconv], 3)
deconv[layer] = h_deconv_concat
w1 = utils.weight_variable(
[filter_size, filter_size, features, features // 2], std_dev,
"w1")
w2 = utils.weight_variable(
[filter_size, filter_size, features // 2, features // 2],
std_dev, "w2")
b1 = utils.bias_variable([features // 2], "b1")
b2 = utils.bias_variable([features // 2], "b2")
conv_1 = utils.conv2d(h_deconv_concat, w1, b1, keep_prob)
conv_2 = utils.conv2d(tf.nn.relu(conv_1), w2, b2, keep_prob)
input_node = tf.nn.relu(conv_2)
up_h_convs[layer] = input_node
weights.append((w1, w2))
biases.append((b1, b2))
convs.append((conv_1, conv_2))
#Output image
with tf.name_scope("output_image"):
weight = utils.weight_variable([1, 1, feature_base, channels_y],
std_dev, "out_weight")
bias = utils.bias_variable([channels_y], "out_bias")
output_image = tf.add(
utils.conv2d(input_node, weight, bias, tf.constant(1.0)), x_image)
up_h_convs["out"] = output_image
# Create Summaries
if create_summary:
with tf.name_scope("summaries"):
for i, (c1, c2) in enumerate(convs):
tf.summary.image("summary_conv_{:02}_01".format(i),
utils.get_image_summary(c1))
tf.summary.image("summary_conv_{:02}_02".format(i),
utils.get_image_summary(c2))
for k in pools.keys():
tf.summary.image("summary_pool_{:02}".format(k),
utils.get_image_summary(pools[k]))
for k in deconv.keys():
tf.summary.image("summary_deconv_concat_{:02}".format(k),
utils.get_image_summary(deconv[k]))
for k in dw_h_convs.keys():
tf.summary.histogram(
"dw_convolution_{:02}/activations".format(k),
dw_h_convs[k])
for k in up_h_convs.keys():
tf.summary.histogram("up_convolution_{}/activations".format(k),
up_h_convs[k])
variables = []
for w1, w2 in weights:
variables.append(w1)
variables.append(w2)
for b1, b2 in biases:
variables.append(b1)
variables.append(b2)
return output_image, variables
def deeplab(x):
W1 = utils.weight_variable([3, 3, x.get_shape()[3].value, 128], name='W1')
b1 = utils.bias_variable([128], 'bias1')
conv1_1 = utils.conv2d(x, W1, b1)
conv1_2 = tf.nn.relu(conv1_1)
conv1_3 = utils.max_pool(conv1_2, 2)
W2 = utils.weight_variable([3, 3, conv1_3.get_shape()[3].value, 128],
name='W2')
b2 = utils.bias_variable([128], 'bias2')
conv2_1 = utils.conv2d(conv1_3, W2, b2)
conv2_2 = tf.nn.relu(conv2_1)
conv2_3 = utils.max_pool(conv2_2, 2)
W3 = utils.weight_variable([3, 3, conv2_3.get_shape()[3].value, 128],
name='W3')
b3 = utils.bias_variable([128], 'bias3')
conv3_1 = utils.atrous_conv2d(conv2_3, W2, b2)
conv3_2 = tf.nn.relu(conv3_1)
W4 = utils.weight_variable([3, 3, conv2_3.get_shape()[3].value, 128],
name='W4')
b4 = utils.bias_variable([128], 'bias4')
conv4_1 = utils.atrous_conv2d(conv3_2, W4, b4)
conv4_2 = tf.nn.relu(conv4_1)
# fully connection
W5 = utils.weight_variable([3, 3, conv4_2.get_shape()[3].value, 128],
name='W5')
b5 = utils.bias_variable([128], 'bias5')
conv5_1 = utils.conv2d(conv4_2, W5, b5)
conv5_2 = tf.nn.relu(conv5_1)
# upscale
inputs_shape = tf.shape(conv1_3)
outputs_shape = [
inputs_shape[0], inputs_shape[1], inputs_shape[2],
conv1_3.get_shape()[3].value
]
W_t1 = utils.weight_variable(
[4, 4, conv1_3.get_shape()[3].value, 128], name='W_t1')
b_t1 = utils.bias_variable([conv1_3.get_shape()[3].value], name='b_t1')
conv_t1 = utils.conv2d_transpose(conv5_2,
W_t1,
b_t1,
outputs_shape,
stride=2)
fuse_1 = tf.add(conv_t1, conv1_3, name='fuse_1')
# inputs_shape = tf.shape(conv1_3)
# outputs_shape = [inputs_shape[0], inputs_shape[1], inputs_shape[2], conv1_3.get_shape()[3].value]
# W_t2 = utils.weight_variable([4, 4, conv1_3.get_shape()[3].value,fuse_1.get_shape()[3].value], name='W_t2')
# b_t2 = utils.bias_variable([conv1_3.get_shape()[3].value], name='b_t2')
# conv_t2 = utils.conv2d_transpose(fuse_1,W_t2, b_t2, outputs_shape,stride=2)
# fuse_2=tf.add(conv_t2,conv1_1_3,name='fuse_2')
inputs_shape = tf.shape(x)
outputs_shape = [inputs_shape[0], inputs_shape[1], inputs_shape[2], 128]
W_t3 = utils.weight_variable(
[4, 4, 128, fuse_1.get_shape()[3].value], name='W_t3')
b_t3 = utils.bias_variable([128], name='b_t3')
conv_t3 = utils.conv2d_transpose(fuse_1,
W_t3,
b_t3,
outputs_shape,
stride=2)
# annotation_pred = tf.argmax(conv_t3, dimension=3, name="prediction")
# return annotation_pred, conv_t3
W0 = utils.weight_variable([1, 1, conv_t3.get_shape()[3].value, 1],
name='W0')
b0 = utils.bias_variable([1], 'bias0')
conv0_1 = utils.conv2d(conv_t3, W0, b0)
return conv0_1
def inference(self, images):
print '================== Resnet structure ======================='
print 'num_residual_units: ', self.num_residual_units
print 'channels in each block: ', self.filters
print 'stride in each block: ', self.strides
print '================== constructing network ===================='
x = utils.input_data(images, self.data_format)
x = tf.cast(x, self.float_type)
print 'shape input: ', x.get_shape()
with tf.variable_scope('conv1'):
trainable_ = False if self.fix_blocks > 0 else True
self.fix_blocks -= 1
x = utils.conv2d_same(x,
64,
7,
2,
trainable=trainable_,
data_format=self.data_format,
initializer=self.initializer,
float_type=self.float_type)
x = utils.batch_norm('BatchNorm',
x,
trainable_,
self.data_format,
self.mode,
use_gamma=self.bn_use_gamma,
use_beta=self.bn_use_beta,
bn_epsilon=self.bn_epsilon,
bn_ema=self.bn_ema,
float_type=self.float_type)
x = utils.relu(x)
x = utils.max_pool(x, 3, 2, self.data_format)
print 'shape after pool1: ', x.get_shape()
for block_index in range(len(self.num_residual_units)):
for unit_index in range(self.num_residual_units[block_index]):
with tf.variable_scope('block%d' % (block_index + 1)):
with tf.variable_scope('unit_%d' % (unit_index + 1)):
stride = 1
if unit_index == self.num_residual_units[
block_index] - 1:
stride = self.strides[block_index]
trainable_ = False if self.fix_blocks > 0 else True
self.fix_blocks -= 1
x = utils.bottleneck_residual(
x,
self.filters[block_index],
stride,
data_format=self.data_format,
initializer=self.initializer,
rate=self.rate[block_index],
trainable=trainable_,
bn_mode=self.mode,
bn_use_gamma=self.bn_use_gamma,
bn_use_beta=self.bn_use_beta,
bn_epsilon=self.bn_epsilon,
bn_ema=self.bn_ema,
float_type=self.float_type)
print 'shape after block %d: ' % (block_index + 1), x.get_shape()
with tf.variable_scope('logits'):
x = utils.global_avg_pool(x, self.data_format)
self.logits = utils.fully_connected(x,
self.num_classes,
trainable=True,
data_format=self.data_format,
initializer=self.initializer,
float_type=self.float_type)
self.logits = tf.reshape(self.logits, (-1, self.num_classes))
self.predictions = tf.nn.softmax(self.logits)
print '================== network constructed ===================='
return self.logits
pickle.dump(images, open(tmp_image_file, "wb")) ### model sess = tf.Session() # input layer X = tf.placeholder(tf.float32, shape=[None, max_shape[0], max_shape[1], 1]) y = tf.placeholder(tf.float32, shape=[None, 1]) keep_prob = tf.placeholder(tf.float32) # first convolution W_conv1 = weight_variable([10, 10, 1, n_convo_layer1]) b_conv1 = bias_variable([n_convo_layer1]) h_conv1 = tf.nn.sigmoid(conv2d(X, W_conv1) + b_conv1) h_pool1 = max_pool(h_conv1, ksize=[1, 2, 2, 1]) # second convolution W_conv2 = weight_variable([10, 10, n_convo_layer1, n_convo_layer2]) b_conv2 = bias_variable([n_convo_layer2]) h_conv2 = tf.nn.sigmoid(conv2d(h_pool1, W_conv2) + b_conv2) h_pool2 = max_pool(h_conv2, ksize=[1, 2, 2, 1]) # first fully connected layer W_fc1 = weight_variable([inner_layer_size * inner_layer_size * n_convo_layer2, percep_size]) b_fc1 = bias_variable([percep_size]) h_pool2_flat = tf.reshape(h_pool2, [-1, inner_layer_size * inner_layer_size * n_convo_layer2]) h_fc1 = tf.nn.sigmoid(tf.matmul(h_pool2_flat, W_fc1) + b_fc1) h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
def __init__(self,
inp,
dropout=False,
drop_prob=0.25,
histogram=True,
num_class=11,
def_cp_name='mnist_seg',
def_cp_path='checkpoints/mnist_seg_mp',
def_log_name='mnist_seg_mp',
def_log_path='./log/',
version=1):
"""
inp: Input placeholder.
shape: Tensorflow tensor shape used in the input placeholder.
It must be a list object.
dropout: Flag used to indicate if dropout will be used
drop_prob: Percentage of neurons to be turned off
histogram: Indicates if information for tensorboard should be annexed.
"""
self.def_cp_name = def_cp_name
self.def_cp_path = def_cp_path + 'v' + str(version)
if self.def_cp_path[-1] != '/':
self.def_cp_path += '/'
self.def_log_name = def_log_name + 'v' + str(version)
self.def_log_path = def_log_path
if self.def_log_path[-1] != '/':
self.def_log_path += '/'
self.reg = [] # Contains l2 regularizaton for weights
self.dropout = dropout
self.drop_prob = drop_prob
self.x = inp
# shape vs get_shape https://stackoverflow.com/a/43290897/5969548
self.im_h = int(self.x.get_shape()[1])
self.im_w = int(self.x.get_shape()[2])
self.im_c = int(self.x.get_shape()[3])
self.num_class = num_class
##### Network Specs
ks1 = 3
num_k1 = 8
ks2 = 3
num_k2 = 8
ks3 = 3
num_k3 = 16
ks4 = 3
num_k4 = 16
ks5 = 3
num_k5 = 32
ks6 = 3
num_k6 = 32
##### Core model
c1_shape = [ks1, ks1, self.im_c, num_k1]
self.conv1, reg = ut.conv2(inp=self.x,
shape=c1_shape,
name='conv1',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
c2_shape = [ks2, ks2, num_k1, num_k2]
self.conv2, reg = ut.conv2(inp=self.conv1,
shape=c2_shape,
name='conv2',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
self.pool1, self.ind1 = ut.max_pool(self.conv2,
args=True,
name='maxpool1')
c3_shape = [ks3, ks3, num_k2, num_k3]
self.conv3, reg = ut.conv2(inp=self.pool1,
shape=c3_shape,
name='conv3',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
c4_shape = [ks4, ks4, num_k3, num_k4]
self.conv4, reg = ut.conv2(inp=self.conv3,
shape=c4_shape,
name='conv4',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
self.pool2, self.ind2 = ut.max_pool(self.conv4,
args=True,
name='maxpool2')
c5_shape = [ks5, ks5, num_k4, num_k5]
self.conv5, reg = ut.conv2(inp=self.pool2,
shape=c5_shape,
name='conv5',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
c6_shape = [ks6, ks6, num_k5, num_k6]
self.conv6, reg = ut.conv2(inp=self.conv5,
shape=c6_shape,
name='conv6',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
d1_shape = [ks6, ks6, num_k6, num_k6]
self.deconv1, reg = ut.deconv2(inp=self.conv6,
shape=d1_shape,
relu=True,
name='deconv1',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
d2_shape = [ks5, ks5, num_k4, num_k5]
self.deconv2, reg = ut.deconv2(inp=self.deconv1,
shape=d2_shape,
relu=True,
name='deconv2',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
self.unpool1 = ut.unpool_with_argmax(
self.deconv2,
self.ind2,
input_shape=[self.x.get_shape()[0].value, 7, 7, num_k4],
name='unpool1')
#self.sum1 = self.unpool1 + self.conv4
d3_shape = [ks4, ks4, num_k3, num_k4]
self.deconv3, reg = ut.deconv2(inp=self.unpool1,
shape=d3_shape,
relu=True,
name='deconv3',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
self.sum1 = self.deconv3 + self.conv4
d4_shape = [ks3, ks3, num_k2, num_k3]
self.deconv4, reg = ut.deconv2(inp=self.deconv3,
shape=d4_shape,
relu=True,
name='deconv4',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
self.unpool2 = ut.unpool_with_argmax(
self.deconv4,
self.ind1,
input_shape=[self.x.get_shape()[0].value, 14, 14, num_k2],
name='unpool2')
#self.sum2 = self.unpool2 + self.conv2
d5_shape = [ks2, ks2, num_k2, num_k2]
self.deconv5, reg = ut.deconv2(inp=self.unpool2,
shape=d5_shape,
relu=True,
name='deconv5',
dropout=self.dropout,
drop_prob=self.drop_prob,
histogram=histogram,
l2=True)
self.reg.append(reg)
self.sum2 = self.deconv5 + self.conv2
d6_shape = [ks1, ks1, self.num_class, num_k2]
self.deconv6, reg = ut.deconv2(inp=self.sum2,
shape=d6_shape,
relu=False,
name='deconv6',
histogram=histogram,
l2=True)
self.reg.append(reg)
self.pre_logits = self.deconv6
msg = '\n\t{0} \n\t{1} \n\t{2} \n\t{3} \n\t{4} \n\t{5} '
msg += '\n\t{6} \n\t{7}'
msg = msg.format(self.conv1, self.conv2, self.pool1, self.conv3,
self.conv4, self.pool2, self.conv5, self.conv6)
msg += '\n\t{0} \n\t{1} \n\t{2} \n\t{3} \n\t{4} \n\t{5} '
msg += '\n\t{6} \n\t{7}'
msg = msg.format(self.deconv1, self.deconv2, self.unpool1,
self.deconv3, self.deconv4, self.unpool2,
self.deconv5, self.deconv6)
print(msg)
def main(argv=None):
if tf.gfile.Exists(FLAGS.train_dir):
tf.gfile.DeleteRecursively(FLAGS.train_dir)
tf.gfile.MakeDirs(FLAGS.train_dir)
global_step = tf.contrib.framework.get_or_create_global_step()
save_path = os.path.join(FLAGS.train_dir, 'model_ckpt')
#获取(image, label)batch pair
image_batch, label_batch = inputs(data_type='train')
#损失函数sparse_softmax_cross_entropy_with_logits要求rank_of_labels = rank_of_images - 1
#对label_batch作扁平化处理
label_batch = tf.reshape(label_batch, [50])
#扩展image维度，从[batch, row, col]转换为[batch, row, col, depth=1]
expand_image_batch = tf.expand_dims(image_batch, -1)
input_placeholder = tf.placeholder_with_default(expand_image_batch,
shape=[None, 28, 28, 1],
name='input')
# 构建模型
# 第一个卷积层
with tf.variable_scope('conv1') as scope:
kernal = weight_variable('weights', shape=[5, 5, 1, 32])
biases = bias_variable('biases', shape=[32])
pre_activation = tf.nn.bias_add(conv2d(input_placeholder, kernal),
biases)
conv1 = tf.nn.relu(pre_activation, name=scope.name)
# 第一个池化层
pool1 = max_pool(conv1)
# 第二个卷积层
with tf.variable_scope('conv2') as scope:
kernal = weight_variable('weights', shape=[5, 5, 32, 64])
biases = bias_variable('biases', shape=[64])
pre_activation = tf.nn.bias_add(conv2d(pool1, kernal), biases)
conv2 = tf.nn.relu(pre_activation, name=scope.name)
# 第二个池化层
# 7*7*64
pool2 = max_pool(conv2)
# 全连接层
with tf.variable_scope('fc1') as scope:
weight_fc1 = weight_variable('weights', shape=[7 * 7 * 64, 1024])
biases = bias_variable('biases', shape=[1024])
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
fc1 = tf.nn.relu((tf.matmul(pool2_flat, weight_fc1) + biases),
name=scope.name)
print('Tensor fc1/relu: ', fc1.name)
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
fc1_drop = tf.nn.dropout(fc1, keep_prob, name='fc1_drop')
print('>>Tensor dropout: ', fc1_drop.name)
# 输出层
with tf.variable_scope('softmax_linear') as scope:
weight_fc2 = weight_variable('weight', shape=[1024, 10])
biases = bias_variable('biases', shape=[10])
softmax_output = tf.add(tf.matmul(fc1_drop, weight_fc2),
biases,
name=scope.name)
print('>>Tensor softmax_linear/softmax_output: ', softmax_output.name)
loss = softmax_loss(logits=softmax_output, labels=label_batch)
print('>>Tensor loss: ', loss.name)
accuracy = train_accuracy(softmax_output, label_batch)
print('>>Tensor accuracy: ', accuracy.name)
train_op = train(loss, global_step)
print('>>Tensor train_op: ', train_op.name)
#初始化所有参数
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
coord = tf.train.Coordinator()
try:
threads = []
for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
threads.extend(
qr.create_threads(sess, coord, daemon=True, start=True))
saver = tf.train.Saver()
step = 1
while step <= 20000 and not coord.should_stop():
if step % 100 == 0:
# 每隔100步打印一次accuracy
runtime_accuracy = sess.run(accuracy,
feed_dict={keep_prob: 1.0})
print(">>step %d, training accuracy %g" %
(step, runtime_accuracy))
# 每隔1000步保存一次模型
if step % 1000 == 0:
saver.save(sess, save_path, global_step=step)
# 训练模型
sess.run(train_op, feed_dict={keep_prob: 0.5})
# 步数更新
step += 1
except Exception as e:
coord.request_stop(e)
coord.request_stop()
coord.join(threads, stop_grace_period_secs=10)
def _add_layers(self, x):
def residual(x, in_channel, out_channel, is_training, norm):
"""residual unit with 2 layers
convolution:
width filter: 1
height filter: 3
"""
orig_x = x
with tf.variable_scope('conv1'):
conv1 = utils.conv(x, [1, 3, in_channel, out_channel],
[out_channel],
padding='SAME')
if norm:
conv1 = utils.batch_norm(conv1, is_training)
relu1 = utils.activation(conv1)
with tf.variable_scope('conv2'):
conv2 = utils.conv(relu1, [1, 3, out_channel, out_channel],
[out_channel],
padding='SAME')
if norm:
conv2 = utils.batch_norm(conv2, is_training)
with tf.variable_scope('add'):
if in_channel != out_channel:
orig_x = utils.conv(x, [1, 1, in_channel, out_channel],
[out_channel],
padding='SAME')
return utils.activation(conv2 + orig_x)
x_shape = x.get_shape()
with tf.variable_scope('residual1'):
r1 = residual(x, x_shape[-1], 32, self.is_training, self.norm)
tf.summary.histogram('res_output1', r1)
with tf.variable_scope('residual2'):
r2 = residual(r1,
r1.get_shape()[-1], 32, self.is_training, self.norm)
tf.summary.histogram('res_output2', r2)
with tf.variable_scope('pool0'):
h_pool0 = utils.max_pool(r2, 1, 2, 1, 2, padding='SAME')
with tf.variable_scope('residual3'):
r3 = residual(h_pool0,
h_pool0.get_shape()[-1], 64, self.is_training,
self.norm)
tf.summary.histogram('res_output3', r3)
with tf.variable_scope('residual4'):
r4 = residual(r3,
r3.get_shape()[-1], 64, self.is_training, self.norm)
tf.summary.histogram('res_output4', r4)
with tf.variable_scope('pool1'):
h_pool1 = utils.max_pool(r4, 1, 5, 1, 5, padding='SAME')
with tf.variable_scope('full_conn_1'):
flat_size = 5 * 64
h_pool2_flat = tf.reshape(h_pool1, [-1, flat_size])
h_fc1 = utils.full_conn(h_pool2_flat, [flat_size, 1024], [1024])
h_fc1 = utils.activation(h_fc1)
with tf.variable_scope('full_conn_2'):
h_fc2 = utils.full_conn(h_fc1, [1024, 128], [128])
h_fc2 = utils.activation(h_fc2)
return h_fc2
def fcnLayerNew(x, keep_probability):
W1 = utils.weight_variable([3, 3, x.get_shape()[3].value, 128], name='W1')
b1 = utils.bias_variable([128], 'bias1')
conv1_1 = utils.conv2d(x, W1, b1, 'conv_1')
conv1_2 = tf.nn.relu(conv1_1)
W2 = utils.weight_variable([3, 3, conv1_2.get_shape()[3].value, 128],
name='W2')
b2 = utils.bias_variable([128], 'bias2')
conv2_1 = utils.conv2d(conv1_2, W2, b2, 'conv_2')
conv2_2 = tf.nn.relu(conv2_1, 'relu_2')
W3 = utils.weight_variable([3, 3, conv2_2.get_shape()[3].value, 64],
name='W3')
b3 = utils.bias_variable([64], 'bias3')
conv3_1 = utils.conv2d(conv2_2, W3, b3, 'conv_3')
conv3_2 = tf.nn.relu(conv3_1, 'relu_3')
conv3_3 = utils.max_pool(conv3_2, 2, name='conv_p3')
W4 = utils.weight_variable([3, 3, conv3_3.get_shape()[3].value, 64],
name='W4')
b4 = utils.bias_variable([64], 'bias4')
conv4_1 = utils.conv2d(conv3_3, W4, b4, 'conv_4')
conv4_2 = tf.nn.relu(conv4_1, 'relu_4')
conv4_3 = utils.max_pool(conv4_2, 2, name='conv_p4')
W5 = utils.weight_variable([3, 3, conv4_3.get_shape()[3].value, 64],
name='W5')
b5 = utils.bias_variable([64], 'bias5')
conv5_1 = utils.conv2d(conv4_3, W5, b5, 'conv_5')
conv5_2 = tf.nn.relu(conv5_1, 'relu_5')
conv5_3 = utils.max_pool(conv5_2, 2, name='conv_p5')
# W6 = utils.weight_variable([1, 1, conv5_3.get_shape()[3].value, 1], name='W6')
# b6 = utils.bias_variable([1], 'bias6')
# conv6_1 = utils.conv2d(conv5_3, W6, b6, 'conv_6')
# conv6_2 = tf.nn.relu(conv6_1, 'relu_6')
# upscale
deconv_shape1 = conv4_3.get_shape()
W_t1 = utils.weight_variable([4, 4, deconv_shape1[3].value, 64],
name='W_t1')
b_t1 = utils.bias_variable([deconv_shape1[3].value], name='b_t1')
conv_t1 = utils.conv2d_transpose(conv5_3,
W_t1,
b_t1,
tf.shape(conv4_3),
stride=2)
# fuse_1=tf.add(conv_t1,conv4_3,name='fuse_1')
deconv_shape2 = conv3_3.get_shape()
W_t2 = utils.weight_variable(
[4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name='W_t2')
b_t2 = utils.bias_variable([deconv_shape2[3].value], name='b_t2')
conv_t2 = utils.conv2d_transpose(conv_t1,
W_t2,
b_t2,
tf.shape(conv3_3),
stride=2)
# fuse_2 = tf.add(conv_t2, conv3_3, name='fuse_2')
# deconv_shape1=conv5_3.get_shape()
shape = tf.shape(x)
deconv_shape3 = tf.stack([shape[0], shape[1], shape[2], 1])
W_t3 = utils.weight_variable([4, 4, 1, deconv_shape1[3].value],
name='W_t3')
b_t3 = utils.bias_variable([1], name='b_t3')
conv_t3 = utils.conv2d_transpose(conv_t2,
W_t3,
b_t3,
deconv_shape3,
stride=2,
name='out')
return conv_t3
def alexnet(X, trainlayers=[], weights=None):
# current = X
# layers = ['conv1', 'conv2', 'conv3', 'conv4', 'conv5']
# for layer in layers:
# if 'conv' in layer:
# pass
# 1st Layer: Conv (w ReLu) -> Lrn -> Poolwith 1 groups
trainable = False
if 'conv1' in trainlayers:
# and, or, weights==None and init_wb=weights['conv1'] or None
# conv1 = conv(X, 11, 11, 96, 4, 4, padding='VALID', name='conv1', trainable=True, init_wb=weights)
trainable = True
conv1 = conv(X,
11,
11,
96,
4,
4,
padding='VALID',
name='conv1',
init_wb=weights,
trainable=trainable)
norm1 = lrn(conv1, 2, 2e-05, 0.75, name='norm1')
pool1 = max_pool(norm1, 3, 3, 2, 2, padding='VALID', name='pool1')
# 2nd Layer: Conv (w ReLu) -> Lrn -> Poolwith 2 groups
trainable = False
if 'conv2' in trainlayers:
trainable = True
conv2 = conv(pool1,
5,
5,
256,
1,
1,
groups=2,
name='conv2',
init_wb=weights,
trainable=trainable)
norm2 = lrn(conv2, 2, 2e-05, 0.75, name='norm2')
pool2 = max_pool(norm2, 3, 3, 2, 2, padding='VALID', name='pool2')
# 3rd Layer: Conv (w ReLu)
trainable = False
if 'conv3' in trainlayers:
trainable = True
conv3 = conv(pool2,
3,
3,
384,
1,
1,
name='conv3',
trainable=trainable,
init_wb=weights)
# 4th Layer: Conv (w ReLu) splitted into two groups
trainable = False
if 'conv4' in trainlayers:
trainable = True
conv4 = conv(conv3,
3,
3,
384,
1,
1,
groups=2,
name='conv4',
trainable=trainable,
init_wb=weights)
# 5th Layer: Conv (w ReLu) -> Pool splitted into two groups
trainable = False
if 'conv5' in trainlayers:
trainable = True
conv5 = conv(conv4,
3,
3,
256,
1,
1,
groups=2,
name='conv5',
trainable=trainable,
init_wb=weights)
return conv5
