def _build_code(self, last_layer):
with tf.name_scope('Code'):
with tf.name_scope('mean'):
mean_weights = util.get_weights_he((self.encoder_layers_size[-2],
self.encoder_layers_size[-1]))
mean_biases = util.get_bias(self.encoder_layers_size[-1])
tf.summary.histogram('Code_mean_weights_summary', mean_weights)
tf.summary.histogram('Code_mean_biases_summary', mean_biases)
self.code_mean = tf.nn.bias_add(tf.matmul(last_layer, mean_weights), mean_biases,
name='layer')
with tf.name_scope('stddev'):
stddev_weights = util.get_weights_he((self.encoder_layers_size[-2],
self.encoder_layers_size[-1]))
stddev_biases = util.get_bias(self.encoder_layers_size[-1])
tf.summary.histogram('Code_stddev_weights_summary', stddev_weights)
tf.summary.histogram('Code_stddev_biases_summary', stddev_biases)
self.code_log_sigma_sq = tf.nn.bias_add(tf.matmul(last_layer, stddev_weights),
stddev_biases, name='layer')
epsilon = tf.random_normal([self.batch_size[0], self.encoder_layers_size[-1]])
self.code = tf.add(self.code_mean,
tf.multiply(tf.sqrt(tf.exp(self.code_log_sigma_sq)), epsilon), name='layer')
def _build_code(self):
self._flatten()
fan_in = self.current_layer.get_shape().as_list()[1]
with tf.name_scope('Code'):
with tf.name_scope('mean'):
mean_weights = util.get_weights_he(
(fan_in, self.code_dimension))
mean_biases = util.get_bias(self.code_dimension)
self.code_mean = tf.nn.bias_add(tf.matmul(
self.current_layer, mean_weights),
mean_biases,
name='layer')
with tf.name_scope('stddev'):
stddev_weights = util.get_weights_he(
(fan_in, self.code_dimension))
stddev_biases = util.get_bias(self.code_dimension)
self.code_log_sigma_sq = tf.nn.bias_add(tf.matmul(
self.current_layer, stddev_weights),
stddev_biases,
name='layer')
epsilon = tf.random_normal(
[self.batch_size[0], self.code_dimension])
self.code = tf.add(self.code_mean,
tf.multiply(
tf.sqrt(tf.exp(self.code_log_sigma_sq)),
epsilon),
name='layer')
self.current_layer = self.code
self.code_built = True
self.decoder_layers_counter = 1
def from_seqrecord(cls, sr, featuretype='CDS', name=None):
if not name:
name = sr.name
CDS = [f for f in sr.features if f.type == featuretype]
_data = pd.DataFrame(np.zeros((len(CDS), 64), dtype=int),
columns = util.list_codons())
_second_order = pd.DataFrame(np.zeros((64,64), dtype=int),
index = util.list_codons(),
columns = util.list_codons())
_scores = pd.DataFrame(np.zeros((len(CDS), 2)),
columns = ['first', 'second',])
_seqs = [util._extract(sr, cds) for cds in CDS]
for i,seq in enumerate(_seqs):
_data.loc[i,:] = util.get_bias(seq)
util.add_second_order(_second_order, seq)
#calculate scores
_nd = util.normalise(_data.sum(0))
_nso= util.so_normalise(_second_order)
for i,seq in enumerate(_seqs):
_scores.at[i,'first'] = util.score(_nd, seq)
_scores.at[i,'second'] = util.so_score(_nso, seq)
return cls(name, _data, _second_order, _scores, _nd, _nso)
def add_sequence(self, label, seq):
if isinstance(seq, basestring):
bias = util.get_bias(seq)
else:
bias = util.get_bias(str(seq.seq))
original = self._data.loc[112]
#make sure the ordering is the same as the original
bias = bias.reindex(self._data.columns)
#normalise
bias = self._normalise(bias)
#get score
self._scores.loc[label] = np.dot(self._pca.components_, bias)
#set label
self._labels[label] = [
label,
]
def _build_output(self, last_layer):
with tf.name_scope('Output'):
W = util.get_weights_xavier((self.decoder_layers_size[-2],
self.decoder_layers_size[-1]))
b = util.get_bias(self.decoder_layers_size[-1])
tf.summary.histogram('Output_weights_summary', W)
tf.summary.histogram('Output_biases_summary', b)
self.logits = tf.nn.bias_add(tf.matmul(last_layer, W), b, name='logits')
self.output_layer = tf.sigmoid(self.logits, name='layer')
def _build_network(self):
"""Create the classifier network."""
self.input_layer = tf.placeholder(tf.float32,
[None, self.input_dimension])
weights = util.get_weights_xavier(
(self.input_dimension, self.possible_classes_count))
if self._add_bias:
bias = util.get_bias(self.possible_classes_count)
self.prediction_logits = tf.nn.bias_add(
tf.matmul(self.input_layer, weights), bias)
else:
self.prediction_logits = tf.matmul(self.input_layer, weights)
def _build_output(self, filter_shape):
stride = self.image_dimension // self.current_layer.get_shape(
).as_list()[1]
with tf.name_scope('Output'):
W = util.get_weights_xavier(filter_shape)
b = util.get_bias(filter_shape[2])
final_layer = tf.nn.bias_add(tf.nn.conv2d_transpose(
self.current_layer, W, [
self.batch_size[0], self.image_dimension,
self.image_dimension, 1
], [1, stride, stride, 1], 'SAME'),
b,
name='logits')
self.logits = tf.reshape(
final_layer, [self.batch_size[0], self.image_dimension**2])
self.output_layer = tf.sigmoid(self.logits, name='layer')
del self.current_layer