def __init__(self, x, y1_, y2_, learning_rate):
"""Creates a NonLinearModel.
Inherits from Model.
Parameters:
x: the placeholder for the input tensor.
y1_: the placeholder for the output 1 tensor.
y2_: the placeholder for the output 2 tensor.
Returns:
A NonLinearModel object.
"""
model.Model.__init__(self)
# get sizes for the input and outputs
num_cols_in = x.get_shape().as_list()[1]
num_states_in = x.get_shape().as_list()[2]
num_states_out1 = y1_.get_shape().as_list()[1]
num_cols_out2 = y2_.get_shape().as_list()[1]
num_states_out2 = y2_.get_shape().as_list()[2]
# the first layer flattens the data so that it can be passed through a fully connected layer
x_flat = utilities.reshape(x, [-1, num_cols_in*num_states_in])
hidden1 = utilities.fc_layer(x_flat, num_cols_in*num_states_in, num_cols_in*num_states_in*4, layer_name='hidden_1')
hidden2 = utilities.fc_layer(hidden1, num_cols_in*num_states_in*4, num_cols_in*num_states_in*2, layer_name='hidden_2')
# the dropout layer reduces over fitting
dropped, self._keep_prob = utilities.dropout(hidden2)
# the network splits here:
# the first softmax layer reduces the output to a percentage chance for each of the output states
output1 = utilities.fc_layer(dropped, 2*num_cols_in*num_states_in, num_states_out1, 'softmax_1', act=tf.nn.softmax)
# the second softmax layer reduces the output to a percentage chance for each SNPs output states
with tf.name_scope('softmax_2'):
fc_layer = utilities.fc_layer(dropped, 2*num_cols_in*num_states_in, num_states_out2*num_cols_out2, layer_name='identity', act=tf.identity)
output2 = tf.nn.softmax(utilities.reshape(fc_layer, [-1, num_cols_out2, num_states_out2], name_suffix='3'))
# each of the loss layers compares the probability distributions between the correspinding outputs to get an error metric for the network's outputs
self._loss1 = utilities.calculate_cross_entropy(output1, y1_, name_suffix='1')
self._loss2 = utilities.calculate_cross_entropy(output2, y2_, name_suffix='2')
# these losses are compined into one for the training
with tf.name_scope('combined_loss'):
combined_loss = tf.add(self._loss1, self._loss2)
# the loss is used with the back propagtion algorithm to use gradient descent based ADAM optimization to teach the network
self._train_step = utilities.train(learning_rate, combined_loss, training_method=utilities.Optimizer.Adam, name_suffix='1')
# the accuracies for each output are calculated by comparing them to the correct outputs
self._accuracy1 = utilities.calculate_epi_accuracy(output1, y1_, name_suffix='1')
self._accuracy2 = utilities.calculate_snp_accuracy(output2, y2_, name_suffix='2')
# find the top predicted snps
self._epi_snps, self._count = utilities.predict_snps(output2)
# merge all the summaries
self._merged = tf.merge_all_summaries()
def testReshapeOps(self):
"""Asserts that the reshape correctly adds operations to the graph.
Arguments:
Nothing.
Returns:
Nothing.
"""
with self.test_session() as sess:
input_tensor = tf.zeros([20, 30])
_ = utilities.reshape(input_tensor, [2, 300], name_suffix='1')
op_dict = {"reshape_1/Reshape": "Reshape"}
tf.python.framework.test_util.assert_ops_in_graph(op_dict, tf.get_default_graph())
def testReshapeOps(self):
"""Asserts that the reshape correctly adds operations to the graph.
Arguments:
Nothing.
Returns:
Nothing.
"""
with self.test_session() as sess:
input_tensor = tf.zeros([20, 30])
_ = utilities.reshape(input_tensor, [2, 300], name_suffix='1')
op_dict = {"reshape_1/Reshape": "Reshape"}
tf.python.framework.test_util.assert_ops_in_graph(
op_dict, tf.get_default_graph())
def testFlattening(self):
"""Asserts that the reshape returns a result with the correct values in each dimension.
Arguments:
Nothing.
Returns:
Nothing.
"""
input_tensor = tf.zeros([20, 30])
output_tensor = utilities.reshape(input_tensor, [-1, 600])
output_tensor_shape = tf.shape(output_tensor)
with self.test_session() as sess:
sess.run(tf.initialize_all_variables())
self.assertAllEqual(np.array([1, 600]), sess.run(output_tensor_shape))
def testFlattening(self):
"""Asserts that the reshape returns a result with the correct values in each dimension.
Arguments:
Nothing.
Returns:
Nothing.
"""
input_tensor = tf.zeros([20, 30])
output_tensor = utilities.reshape(input_tensor, [-1, 600])
output_tensor_shape = tf.shape(output_tensor)
with self.test_session() as sess:
sess.run(tf.initialize_all_variables())
self.assertAllEqual(np.array([1, 600]),
sess.run(output_tensor_shape))
def __init__(self, x, y1_, y2_, learning_rate):
"""Creates a PoolConvModel.
Inherits from Model.
Parameters:
x: the placeholder for the input tensor.
y1_: the placeholder for the output 1 tensor.
y2_: the placeholder for the output 2 tensor.
Returns:
A PoolConvModel object.
"""
model.Model.__init__(self)
# get sizes for the input and outputs
num_cols_in = x.get_shape().as_list()[1]
num_states_out1 = y1_.get_shape().as_list()[1]
num_cols_out2 = y2_.get_shape().as_list()[1]
num_states_out2 = y2_.get_shape().as_list()[2]
# first layer reshapes the input to make it 4d as required by the convolution layers
x_4d = utilities.reshape(x, [-1, num_cols_in, 3, 1], name_suffix='1')
# the first convolution layer preserves the shape and increases the number of channels to 8
conv1 = utilities.conv_layer(x_4d, [3, 3, 1, 8],
padding='SAME',
name_suffix='1')
# the first pooling layer simply halves the data size along the SNP dimmension
pool1 = utilities.pool_layer(conv1,
shape=[1, 2, 1, 1],
strides=[1, 2, 1, 1],
name_suffix='1')
# the second convolution layer preserves the shape and increases the number of channels to 16
conv2 = utilities.conv_layer(pool1, [3, 3, 8, 16],
padding='SAME',
name_suffix='2')
# the second pooling layer halves the data size along the SNP dimmension
pool2 = utilities.pool_layer(conv2,
shape=[1, 2, 1, 1],
strides=[1, 2, 1, 1],
name_suffix='2')
# the third convolution layer reduces reduces the number of states dimmension to size 1 and increases the number of channels to 32
conv3 = utilities.conv_layer(pool2, [1, 3, 16, 32],
padding='VALID',
name_suffix='3')
# the third pooling layer halves the data size along the SNP dimmension
pool3 = utilities.pool_layer(conv3,
shape=[1, 2, 1, 1],
strides=[1, 2, 1, 1],
name_suffix='3')
# the next layer flattens the data so that it can be passed through a fully connected layer
final_shape = pool3.get_shape()
flatten_size = int(final_shape[1] * final_shape[2] * final_shape[3])
flatten = utilities.reshape(pool3, [-1, flatten_size], name_suffix='2')
# the first fully connected layer halves the data size
hidden1 = utilities.fc_layer(flatten,
flatten_size,
int(flatten_size / 2),
layer_name='hidden_1')
# the second fully connected layer halves the data size again
hidden2 = utilities.fc_layer(hidden1,
int(flatten_size / 2),
int(flatten_size / 4),
layer_name='hidden_2')
# the dropout layer reduces over fitting
dropped, self._keep_prob = utilities.dropout(hidden2, name_suffix='1')
# the network splits here:
# the first softmax layer reduces the output to a percentage chance for each of the output states
output1 = utilities.fc_layer(dropped,
int(flatten_size / 4),
num_states_out1,
layer_name='softmax_1',
act=tf.nn.softmax)
# the second softmax layer reduces the output to a percentage chance for each SNPs output states
with tf.name_scope('softmax_2'):
fc_layer = utilities.fc_layer(dropped,
int(flatten_size / 4),
num_states_out2 * num_cols_out2,
layer_name='identity',
act=tf.identity)
#output2 = tf.sigmoid(utilities.reshape(fc_layer, [-1, num_cols_out2, 1], name_suffix='3'))
output2 = tf.nn.softmax(
utilities.reshape(fc_layer,
[-1, num_cols_out2, num_states_out2],
name_suffix='3'))
# each of the loss layers compares the probability distributions between the correspinding outputs to get an error metric for the network's outputs
self._loss1 = utilities.calculate_cross_entropy(output1,
y1_,
name_suffix='1')
#self._loss2 = utilities.calculate_cross_entropy(output2, utilities.get_causing_epi_probs(y2_), name_suffix='2')
self._loss2 = utilities.calculate_cross_entropy(output2,
y2_,
name_suffix='2')
# these losses are compined into one for the training
with tf.name_scope('combined_loss'):
combined_loss = tf.add(self._loss1, self._loss2)
# the loss is used with the back propagtion algorithm to use gradient descent based ADAM optimization to teach the network
self._train_step = utilities.train(
learning_rate,
combined_loss,
training_method=utilities.Optimizer.Adam,
name_suffix='1')
# the accuracies for each output are calculated by comparing them to the correct outputs
self._accuracy1 = utilities.calculate_epi_accuracy(output1,
y1_,
name_suffix='1')
self._accuracy2 = utilities.calculate_snp_accuracy(output2,
y2_,
name_suffix='2')
# find the top predicted snps
self._epi_snps, self._count = utilities.predict_snps(output2)
# merge all the summaries
self._merged = tf.merge_all_summaries()
def __init__(self, x, y1_, y2_, learning_rate):
"""Creates a RecurrentModel.
Inherits from Model.
Parameters:
x: the placeholder for the input tensor.
y1_: the placeholder for the output 1 tensor.
y2_: the placeholder for the output 2 tensor.
Returns:
A RecurrentModel object.
"""
model.Model.__init__(self)
# max_length = 100
#
# print("x shape: %s" % x.get_shape())
# x = utilities.reshape(x, [-1, max_length, int(x.get_shape()[2])])
# print("x shape: %s" % x.get_shape())
# get sizes for the input and outputs
num_states_out1 = y1_.get_shape().as_list()[1]
num_cols_out2 = y2_.get_shape().as_list()[1]
num_states_out2 = y2_.get_shape().as_list()[2]
# parameters for the RNN
num_neurons = 10
num_layers = 1
self._keep_prob = tf.placeholder(tf.float32)
# setup the RNN cell
cell = GRUCell(num_neurons) # Or LSTMCell(num_neurons)
cell = DropoutWrapper(cell, output_keep_prob=self._keep_prob)
cell = MultiRNNCell([cell] * num_layers)
output, _ = tf.nn.dynamic_rnn(cell,
x,
dtype=tf.float32,
swap_memory=True,
parallel_iterations=1)
print("output shape: %s" % output.get_shape())
output = tf.transpose(output, [1, 0, 2])
print("output shape: %s" % output.get_shape())
last = tf.gather(output, int(output.get_shape()[0]) - 1)
print("last shape: %s" % last.get_shape())
hidden1 = utilities.fc_layer(last,
num_neurons,
num_neurons,
layer_name='hidden_1')
hidden2 = utilities.fc_layer(hidden1,
num_neurons,
num_neurons,
layer_name='hidden_2')
# the dropout layer reduces over fitting
dropped, _ = utilities.dropout(hidden2, keep_prob=self._keep_prob)
# the network splits here:
# the first softmax layer reduces the output to a percentage chance for each of the output states
output1 = utilities.fc_layer(dropped,
num_neurons,
num_states_out1,
'softmax_1',
act=tf.nn.softmax)
# the second softmax layer reduces the output to a percentage chance for each SNPs output states
with tf.name_scope('softmax_2'):
fc_layer = utilities.fc_layer(dropped,
num_neurons,
num_states_out2 * num_cols_out2,
layer_name='identity',
act=tf.identity)
output2 = tf.nn.softmax(
utilities.reshape(fc_layer,
[-1, num_cols_out2, num_states_out2],
name_suffix='3'))
# each of the loss layers compares the probability distributions between the correspinding outputs to get an error metric for the network's outputs
self._loss1 = utilities.calculate_cross_entropy(output1,
y1_,
name_suffix='1')
self._loss2 = utilities.calculate_cross_entropy(output2,
y2_,
name_suffix='2')
# these losses are compined into one for the training
with tf.name_scope('combined_loss'):
combined_loss = tf.add(self._loss1, self._loss2)
# the loss is used with the back propagtion algorithm to use gradient descent based ADAM optimization to teach the network
self._train_step = utilities.train(
learning_rate,
combined_loss,
training_method=utilities.Optimizer.Adam,
name_suffix='1')
# the accuracies for each output are calculated by comparing them to the correct outputs
self._accuracy1 = utilities.calculate_epi_accuracy(output1,
y1_,
name_suffix='1')
self._accuracy2 = utilities.calculate_snp_accuracy(output2,
y2_,
name_suffix='2')
# find the top predicted snps
self._epi_snps, self._count = utilities.predict_snps(output2)
# merge all the summaries
self._merged = tf.merge_all_summaries()
def __init__(self, x, y1_, y2_, learning_rate):
"""Creates a ScalingModel.
Inherits from Model.
Parameters:
x: the placeholder for the input tensor.
y1_: the placeholder for the output 1 tensor.
y2_: the placeholder for the output 2 tensor.
Returns:
A ScalingModel object.
"""
model.Model.__init__(self)
# get sizes for the input and outputs
num_cols_in = x.get_shape().as_list()[1]
num_states_out1 = y1_.get_shape().as_list()[1]
num_cols_out2 = y2_.get_shape().as_list()[1]
num_states_out2 = y2_.get_shape().as_list()[2]
self._keep_prob = tf.placeholder(tf.float32)
# first layer reshapes the input to make it 4d as required by the convolution layers
x_4d = utilities.reshape(x, [-1, num_cols_in, 3, 1], name_suffix='1')
# the first convolution layer preserves the shape and increases the number of channels to 8
conv1 = utilities.conv_layer(x_4d, [3, 3, 1, 8], padding='SAME', name_suffix='1')
# the first pooling layer simply halves the data size along the SNP dimmension
pool1 = utilities.pool_layer(conv1, shape=[1, 2, 1, 1], strides=[1, 2, 1, 1], name_suffix='1')
# the second convolution layer preserves the shape and increases the number of channels to 16
conv2 = utilities.conv_layer(pool1, [3, 3, 8, 16], padding='SAME', name_suffix='2')
# the second pooling layer halves the data size along the SNP dimmension
pool2 = utilities.pool_layer(conv2, shape=[1, 2, 1, 1], strides=[1, 2, 1, 1], name_suffix='2')
# the third convolution layer reduces reduces the number of states dimmension to size 1 and increases the number of channels to 32
conv3 = utilities.conv_layer(pool2, [1, 3, 16, 32], padding='VALID', name_suffix='3')
# the third pooling layer halves the data size along the SNP dimmension
pool3 = utilities.pool_layer(conv3, shape=[1, 2, 1, 1], strides=[1, 2, 1, 1], name_suffix='3')
# the next layer flattens the data so that it can be passed through a fully connected layer
final_shape = pool3.get_shape()
flatten_size = int(final_shape[1]*final_shape[2]*final_shape[3])
flatten = utilities.reshape(pool3, [-1, flatten_size], name_suffix='2')
# the network splits here:
# the first softmax layer reduces the output to a percentage chance for each of the output states
hidden1 = utilities.fc_layer(flatten, flatten_size, int(flatten_size/100), layer_name='hidden_1')
dropped1, _ = utilities.dropout(hidden1, name_suffix='1', keep_prob=self._keep_prob)
hiddenx = utilities.fc_layer(dropped1, int(flatten_size/100), int(flatten_size/200), layer_name='hidden_x')
droppedx, _ = utilities.dropout(hiddenx, name_suffix='x', keep_prob=self._keep_prob)
output1 = utilities.fc_layer(droppedx, int(flatten_size/200), num_states_out1, layer_name='softmax_1', act=tf.nn.softmax)
# the first fully connected layer halves the data size
hidden2_1 = utilities.fc_layer(flatten, flatten_size, 100, layer_name='hidden_2_1', act=tf.identity)
hidden2_2 = utilities.fc_layer(hidden2_1, 100, int(flatten_size/2), layer_name='hidden_2_2')
# the dropout layer reduces over fitting
dropped2, _ = utilities.dropout(hidden2_2, name_suffix='2', keep_prob=self._keep_prob)
# the second fully connected layer halves the data size again
hidden3_1 = utilities.fc_layer(dropped2, int(flatten_size/2), 100, layer_name='hidden_3_1', act=tf.identity)
hidden3_2 = utilities.fc_layer(hidden3_1, 100, int(flatten_size/4), layer_name='hidden_3_2')
dropped3, _ = utilities.dropout(hidden3_2, name_suffix='3', keep_prob=self._keep_prob)
# the second softmax layer reduces the output to a percentage chance for each SNPs output states
with tf.name_scope('softmax_2'):
fc_layer_1 = utilities.fc_layer(dropped3, int(flatten_size/4), 100, layer_name='identity_1', act=tf.identity)
fc_layer_2 = utilities.fc_layer(fc_layer_1, 100, num_states_out2*num_cols_out2, layer_name='identity_2', act=tf.identity)
output2 = tf.nn.softmax(utilities.reshape(fc_layer_2, [-1, num_cols_out2, num_states_out2], name_suffix='3'))
# each of the loss layers compares the probability distributions between the correspinding outputs to get an error metric for the network's outputs
self._loss1 = utilities.calculate_cross_entropy(output1, y1_, name_suffix='1')
self._loss2 = utilities.calculate_cross_entropy(output2, y2_, name_suffix='2')
# these losses are compined into one for the training
with tf.name_scope('combined_loss'):
combined_loss = tf.add(self._loss1, self._loss2)
# the loss is used with the back propagtion algorithm to use gradient descent based ADAM optimization to teach the network
self._train_step = utilities.train(learning_rate, combined_loss, training_method=utilities.Optimizer.Adam, name_suffix='1')
# the accuracies for each output are calculated by comparing them to the correct outputs
self._accuracy1 = utilities.calculate_epi_accuracy(output1, y1_, name_suffix='1')
self._accuracy2 = utilities.calculate_snp_accuracy(output2, y2_, name_suffix='2')
# find the top predicted snps
self._epi_snps, self._count = utilities.predict_snps(output2)
# merge all the summaries
self._merged = tf.merge_all_summaries()