def make_fcnet(self):
n_ffnet_inputs = self.n_ffnet_input
n_ffnet_outputs = self.n_ffnet_output
y_image = self.fcnet_input
print("FCNET: Inputs: ", n_ffnet_inputs, " outputs: ", n_ffnet_outputs)
W_fc1 = my_ops.weight_variable([n_ffnet_inputs, 40], 0.1)
b_fc1 = my_ops.bias_variable([40])
W_fc2 = my_ops.weight_variable([40, 10], 0.1)
b_fc2 = my_ops.bias_variable([10])
W_fc3 = my_ops.weight_variable([10, 1], 0.1)
b_fc3 = my_ops.bias_variable([1])
h1 = tf.tanh(tf.matmul(y_image, W_fc1) + b_fc1)
h2 = tf.tanh(tf.matmul(h1, W_fc2) + b_fc2)
self.y_fc = tf.tanh(tf.matmul(h2, W_fc3) + b_fc3)
self.fcloss = tf.squared_difference(self.y_fc, self.fcnet_target)
self.fcnet_train_step = tf.train.AdamOptimizer(
self.learning_rate).minimize(self.fcloss)
self.fcaccuracy = tf.reduce_mean(self.fcloss)
def make_ffnet(self):
n_ffnet_inputs = self.n_ffnet_input
n_ffnet_outputs = self.n_ffnet_output
print ("FFNET: in: ", n_ffnet_inputs, " hid: ", self.n_ffnet_hidden, " out: ", n_ffnet_outputs)
W_layer1 = my_ops.weight_variable([n_ffnet_inputs, self.n_ffnet_hidden[0]])
b_layer1 = my_ops.bias_variable([self.n_ffnet_hidden[0]])
W_layer2 = my_ops.weight_variable([self.n_ffnet_hidden[0], self.n_ffnet_hidden[1]])
b_layer2 = my_ops.bias_variable([self.n_ffnet_hidden[1]])
W_layer3 = my_ops.weight_variable([self.n_ffnet_hidden[1], n_ffnet_outputs])
b_layer3 = my_ops.bias_variable([n_ffnet_outputs])
h_1 = tf.nn.relu(tf.matmul(self.ffnet_input, W_layer1) + b_layer1)
h_2 = tf.nn.relu(tf.matmul(h_1, W_layer2) + b_layer2)
# dropout
#print("output shape: ", self.ffnet_output.get_shape(), "target shape: ", self.ffnet_target.get_shape())
#print("W3: ", W_layer3.get_shape(), " bias3: ", b_layer3.get_shape())
self.ffnet_output = tf.matmul(h_2, W_layer3) + b_layer3
#print("output shape: ", self.ffnet_output.get_shape(), "target shape: ", self.ffnet_target.get_shape())
#print("W3: ", W_layer3.get_shape(), " bias3: ", b_layer3.get_shape())
self.loss = tf.squared_difference(self.ffnet_output, self.ffnet_target)
self.ffnet_train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.loss)
self.accuracy = tf.reduce_mean(self.loss)
def __init__(self, name, config, is_train):
self.name = name
self.is_train = is_train
self.reuse = None
with tf.variable_scope(self.name, reuse=self.reuse):
G_W1 = utils.weight_variable([3, 3, 1, 32], name="G_W1")
G_b1 = utils.bias_variable([32], name="G_b1")
G_W2 = utils.weight_variable([3, 3, 32, 64], name="G_W2")
G_b2 = utils.bias_variable([64], name="G_b2")
G_W3 = utils.weight_variable([3, 3, 64, 64], name="G_W3")
G_b3 = utils.bias_variable([64], name="G_b3")
G_W4 = utils.weight_variable([3, 3, 64, 128], name="G_W4")
G_b4 = utils.bias_variable([128], name="G_b4")
G_W5 = utils.weight_variable([3, 3, 128, 128], name="G_W5")
G_b5 = utils.bias_variable([128], name="G_b5")
G_W6 = utils.weight_variable([3, 3, 128, 128], name="G_W6")
G_b6 = utils.bias_variable([128], name="G_b6")
G_W7 = utils.weight_variable([3, 3, 128, 64], name="G_W7")
G_b7 = utils.bias_variable([64], name="G_b7")
G_W8 = utils.weight_variable([1, 1, 64, 32], name="G_W8")
G_b8 = utils.bias_variable([32], name="G_b8")
G_W9 = utils.weight_variable([3, 3, 32, config.ClusterNo],
name="G_W9")
G_b9 = utils.bias_variable([config.ClusterNo], name="G_b9")
self.Param = {
'G_W1': G_W1,
'G_b1': G_b1,
'G_W2': G_W2,
'G_b2': G_b2,
'G_W3': G_W3,
'G_b3': G_b3,
'G_W4': G_W4,
'G_b4': G_b4,
'G_W5': G_W5,
'G_b5': G_b5,
'G_W6': G_W6,
'G_b6': G_b6,
'G_W7': G_W7,
'G_b7': G_b7,
'G_W8': G_W8,
'G_b8': G_b8,
'G_W9': G_W9,
'G_b9': G_b9
}
if self.reuse is None:
self.var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope=self.name)
self.saver = tf.train.Saver(self.var_list)
self.reuse = True
def __init__(self, name, config, is_train):
self.name = name
self.is_train = is_train
self.reuse = None
with tf.variable_scope(self.name, reuse=self.reuse):
G_W1 = utils.weight_variable([3, 3, 1, 32], name="G_W1")
G_b1 = utils.bias_variable([32], name="G_b1")
G_W2 = utils.weight_variable([3, 3, 32, 64], name="G_W2")
G_b2 = utils.bias_variable([64], name="G_b2")
G_W3 = utils.weight_variable([3, 3, 64, 64], name="G_W3")
G_b3 = utils.bias_variable([64], name="G_b3")
G_W4 = utils.weight_variable([3, 3, 64, 128], name="G_W4")
G_b4 = utils.bias_variable([128], name="G_b4")
G_W5 = utils.weight_variable([3, 3, 128, 128], name="G_W5")
G_b5 = utils.bias_variable([128], name="G_b5")
G_W6 = utils.weight_variable([3, 3, 128, 128], name="G_W6")
G_b6 = utils.bias_variable([128], name="G_b6")
G_W7 = utils.weight_variable([3, 3, 128, 64], name="G_W7")
G_b7 = utils.bias_variable([64], name="G_b7")
G_W8 = utils.weight_variable([1, 1, 64, 32], name="G_W8")
G_b8 = utils.bias_variable([32], name="G_b8")
G_W9 = utils.weight_variable([3, 3, 32, config.ClusterNo], name="G_W9")
G_b9 = utils.bias_variable([config.ClusterNo], name="G_b9")
self.Param = {'G_W1':G_W1, 'G_b1':G_b1,
'G_W2':G_W2, 'G_b2':G_b2,
'G_W3':G_W3, 'G_b3':G_b3,
'G_W4':G_W4, 'G_b4':G_b4,
'G_W5':G_W5, 'G_b5':G_b5,
'G_W6':G_W6, 'G_b6':G_b6,
'G_W7':G_W7, 'G_b7':G_b7,
'G_W8':G_W8, 'G_b8':G_b8,
'G_W9':G_W9, 'G_b9':G_b9 }
if self.reuse is None:
self.var_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=self.name)
self.saver = tf.train.Saver(self.var_list)
self.reuse = True
def make_convnet(self):
n_ffnet_inputs = self.n_ffnet_input
n_ffnet_outputs = self.n_ffnet_output
print("COVNET: Inputs: ", n_ffnet_inputs, " outputs: ", n_ffnet_outputs)
with tf.name_scope('reshape'):
x_image = tf.reshape(self.covnet_input, [-1, self.resolution[0], self.resolution[1], 1])
with tf.name_scope('conv1'):
W_conv1 = my_ops.weight_variable([5, 5, 1, 32])
b_conv1 = my_ops.bias_variable([32])
h_conv1 = tf.nn.relu(my_ops.conv2d(x_image, W_conv1) + b_conv1)
with tf.name_scope('pool1'):
h_pool1 = my_ops.max_pool_2x2(h_conv1)
with tf.name_scope('conv2'):
W_conv2 = my_ops.weight_variable([5, 5, 32, 64])
b_conv2 = my_ops.bias_variable([64])
h_conv2 = tf.nn.relu(my_ops.conv2d(h_pool1, W_conv2) + b_conv2)
with tf.name_scope('pool2'):
h_pool2 = my_ops.max_pool_2x2(h_conv2)
with tf.name_scope('fc1'):
W_fc1 = my_ops.weight_variable([int(self.resolution[0]/4) * int(self.resolution[1]/4) * 64, 64])
b_fc1 = my_ops.bias_variable([64])
h_pool2_flat = tf.reshape(h_pool2, [-1, int(self.resolution[0]/4) * int(self.resolution[1]/4) * 64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
# single output:
with tf.name_scope('fc2'):
W_fc2 = my_ops.weight_variable([64, 1])
b_fc2 = my_ops.bias_variable([1])
self.y_conv = tf.tanh(tf.matmul(h_fc1, W_fc2) + b_fc2)
self.covloss = tf.squared_difference(self.y_conv, self.covnet_target)
self.covnet_train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.covloss)
self.covaccuracy = tf.reduce_mean(self.covloss)
batch_size = 100 # Training batch size
display_freq = 100 # Frequency of displaying the training results
# Network Parameters
num_input = 28 # MNIST data input (img shape: 28*28)
timesteps = 28 # Timesteps
num_hidden_units = 128 # Number of hidden units of the RNN
n_classes = 10 # Number of classes, one class per digit
# Create the graph for the linear model
# Placeholders for inputs (x) and outputs(y)
x = tf.placeholder(tf.float32, shape=[None, timesteps, num_input], name='X')
y = tf.placeholder(tf.float32, shape=[None, n_classes], name='Y')
# create weight matrix initialized randomely from N~(0, 0.01)
W = weight_variable(shape=[num_hidden_units, n_classes])
# create bias vector initialized as zero
b = bias_variable(shape=[n_classes])
output_logits = RNN(x, W, b, timesteps, num_hidden_units)
y_pred = tf.nn.softmax(output_logits)
# Model predictions
cls_prediction = tf.argmax(output_logits, axis=1, name='predictions')
# Define the loss function, optimizer, and accuracy
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
labels=y, logits=output_logits),
name='loss')
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate,
def make_convnet(self):
# # self.resolution is [width, height]
# x_image = tf.reshape(self.covnet_input, [-1, self.resolution[0], self.resolution[1], 1])
#
# n_features_maps = 20
# filter_width = int(2)
# filter_height = int(2)
#
# W_conv1 = my_ops.weight_variable([filter_width, filter_height, 1, n_features_maps], 0.001)
# b_conv1 = my_ops.bias_variable([n_features_maps])
# h_conv1 = tf.nn.tanh(my_ops.conv2d(x_image, W_conv1) + b_conv1)
#
# h_pool1 = my_ops.max_pool_2x2(h_conv1)
# # h_pool1 = h_conv1
#
# W_fc1 = my_ops.weight_variable([int(self.resolution[0]/2) * int(self.resolution[1]/2) * n_features_maps, 20], 0.001)
# b_fc1 = my_ops.bias_variable([20])
#
# h_pool1_flat = tf.reshape(h_pool1, [-1, int(self.resolution[0]/2) * int(self.resolution[1]/2) * n_features_maps])
# h_fc1 = tf.nn.tanh(tf.matmul(h_pool1_flat, W_fc1) + b_fc1)
#
# # single output:
# W_fc2 = my_ops.weight_variable([20, 1], 0.01)
# b_fc2 = my_ops.bias_variable([1])
#
# self.y_conv = tf.tanh(tf.matmul(h_fc1, W_fc2) + b_fc2)
#
# self.covloss = tf.squared_difference(self.y_conv, self.covnet_target)
# self.covnet_train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.covloss)
# self.covaccuracy = tf.reduce_mean(self.covloss)
with tf.name_scope('reshape'):
x_image = tf.reshape(
self.covnet_input,
[-1, self.resolution[0], self.resolution[1], 1])
# First convolutional layer - maps one grayscale image to 32 feature maps.
with tf.name_scope('conv1'):
W_conv1 = my_ops.weight_variable([5, 5, 1, 8], 0.1)
b_conv1 = my_ops.bias_variable([8])
h_conv1 = tf.nn.relu(my_ops.conv2d(x_image, W_conv1) + b_conv1)
# Pooling layer - downsamples by 2X.
with tf.name_scope('pool1'):
h_pool1 = my_ops.max_pool_2x2(h_conv1)
# Second convolutional layer -- maps 32 feature maps to 64.
with tf.name_scope('conv2'):
W_conv2 = my_ops.weight_variable([5, 5, 8, 8], 0.1)
b_conv2 = my_ops.bias_variable([8])
h_conv2 = tf.nn.relu(my_ops.conv2d(h_pool1, W_conv2) + b_conv2)
# Second pooling layer.
with tf.name_scope('pool2'):
h_pool2 = my_ops.max_pool_2x2(h_conv2)
# Fully connected layer 1 -- after 2 round of downsampling, our 28x28 image
# is down to 7x7x64 feature maps -- maps this to 1024 features.
with tf.name_scope('fc1'):
W_fc1 = my_ops.weight_variable([
int(self.resolution[0] / 4) * int(self.resolution[1] / 4) * 8,
10
], 0.001)
b_fc1 = my_ops.bias_variable([10])
h_pool2_flat = tf.reshape(h_pool2, [
-1,
int(self.resolution[0] / 4) * int(self.resolution[1] / 4) * 8
])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
# Map the 1024 features to 10 classes, one for each digit
with tf.name_scope('fc2'):
W_fc2 = my_ops.weight_variable([10, 1], 0.1)
b_fc2 = my_ops.bias_variable([1])
self.y_conv = tf.tanh(tf.matmul(h_fc1, W_fc2) + b_fc2)
self.covloss = tf.squared_difference(self.y_conv,
self.covnet_target)
self.covnet_train_step = tf.train.AdamOptimizer(
self.learning_rate).minimize(self.covloss)
self.covaccuracy = tf.reduce_mean(self.covloss)
