TensorFlow: Wie klassifiziere ich eine binäre Sequenz mit RNN?

Question

bekomme ich folgendes Stück Code für TensorFlow Sequence Classification (siehe den Code am Ende dieses quesiton):

https://gist.github.com/danijar/c7ec9a30052127c7a1ad169eeb83f159

Ich brauche den Code zu ändern, mein Binärsequenz Klassifikationsproblem zu lösen.

Mein Trainingseingang ist eine CSV-Datei (sehr groß), das Format der CSV-Datei ist:

binary_sequence(fixed sequence length of 100),result 
1>0>1>1>0>0>0>0>...>0,1 
0>1>0>1>0>0>0>0>...>0,0 
... 
0>1>0>1>0>0>0>0>...>0,0 

Ich brauche einen Klassifikator zu trainieren neue binary_sequences zu klassifizieren.

Meine Testeingabe ist auch eine CSV-Datei im ähnlichen Format.

Jeder, der Vorschläge zum Ändern des folgenden Codes für mein Problem geben kann, wird sehr geschätzt!

# Example for my blog post at: 
# https://danijar.com/introduction-to-recurrent-networks-in-tensorflow/ 
import functools 
import sets 
import tensorflow as tf 


def lazy_property(function): 
    attribute = '_' + function.__name__ 

    @property 
    @functools.wraps(function) 
    def wrapper(self): 
     if not hasattr(self, attribute): 
      setattr(self, attribute, function(self)) 
     return getattr(self, attribute) 
    return wrapper 


class SequenceClassification: 

    def __init__(self, data, target, dropout, num_hidden=200, num_layers=3): 
     self.data = data 
     self.target = target 
     self.dropout = dropout 
     self._num_hidden = num_hidden 
     self._num_layers = num_layers 
     self.prediction 
     self.error 
     self.optimize 

    @lazy_property 
    def prediction(self): 
     # Recurrent network. 
     network = tf.contrib.rnn.GRUCell(self._num_hidden) 
     network = tf.contrib.rnn.DropoutWrapper(
      network, output_keep_prob=self.dropout) 
     network = tf.contrib.rnn.MultiRNNCell([network] * self._num_layers) 
     output, _ = tf.nn.dynamic_rnn(network, self.data, dtype=tf.float32) 
     # Select last output. 
     output = tf.transpose(output, [1, 0, 2]) 
     last = tf.gather(output, int(output.get_shape()[0]) - 1) 
     # Softmax layer. 
     weight, bias = self._weight_and_bias(
      self._num_hidden, int(self.target.get_shape()[1])) 
     prediction = tf.nn.softmax(tf.matmul(last, weight) + bias) 
     return prediction 

    @lazy_property 
    def cost(self): 
     cross_entropy = -tf.reduce_sum(self.target * tf.log(self.prediction)) 
     return cross_entropy 

    @lazy_property 
    def optimize(self): 
     learning_rate = 0.003 
     optimizer = tf.train.RMSPropOptimizer(learning_rate) 
     return optimizer.minimize(self.cost) 

    @lazy_property 
    def error(self): 
     mistakes = tf.not_equal(
      tf.argmax(self.target, 1), tf.argmax(self.prediction, 1)) 
     return tf.reduce_mean(tf.cast(mistakes, tf.float32)) 

    @staticmethod 
    def _weight_and_bias(in_size, out_size): 
     weight = tf.truncated_normal([in_size, out_size], stddev=0.01) 
     bias = tf.constant(0.1, shape=[out_size]) 
     return tf.Variable(weight), tf.Variable(bias) 


def main(): 
    # We treat images as sequences of pixel rows. 
    train, test = sets.Mnist() 
    _, rows, row_size = train.data.shape 
    num_classes = train.target.shape[1] 
    data = tf.placeholder(tf.float32, [None, rows, row_size]) 
    target = tf.placeholder(tf.float32, [None, num_classes]) 
    dropout = tf.placeholder(tf.float32) 
    model = SequenceClassification(data, target, dropout) 
    sess = tf.Session() 
    sess.run(tf.global_variables_initializer()) 
    for epoch in range(10): 
     for _ in range(100): 
      batch = train.sample(10) 
      sess.run(model.optimize, { 
       data: batch.data, target: batch.target, dropout: 0.5}) 
     error = sess.run(model.error, { 
      data: test.data, target: test.target, dropout: 1}) 
     print('Epoch {:2d} error {:3.1f}%'.format(epoch + 1, 100 * error)) 


if __name__ == '__main__': 
    main() 

Answer 1

Der Großteil des Codes kann direkt wiederverwendet werden. Das einzige, was Sie tun müssen, ist, einen Teil davon an Ihr Datenformat anzupassen. Zum Beispiel

num_classes = 2 
data = tf.placeholder(tf.float32, [None, your_seq_length, your_feature_length]) 
batch = make_your_own_batch 

Schauen Sie in das Tutorial Ihres Codes. Es ist here. Und wenn Sie RNN nicht kennen, ist here eine gute Einführung für Sie.