мультимодальный ввод (текст + цифра c) в тензорном потоке

Question

Я хочу создать классификатор на основе нейронной сети, который будет прогнозировать, будет ли акция go расти или нет, основываясь на некоторых новостях об акции и некоторых числовых значениях c, таких как ее цена в определенный день и значение индекса рынка (например, Nasdaq) того же дня. Ниже приведен код, который я придумаю:

class AttLSTM:
    def __init__(self, sequence_length, num_classes, vocab_size, embedding_size,
             hidden_size, l2_reg_lambda, vocabulary_processor_path):
    # Placeholders for input, output and dropout
        self.input_text = tf.placeholder(tf.int32, shape=[None, sequence_length], name='input_text')
        self.input_y = tf.placeholder(tf.float32, shape=[None, num_classes], name='input_y')
        self.input_price = tf.placeholder(tf.float32, shape=[None, 1], name='price')
        self.input_value = tf.placeholder(tf.float32, shape=[None, 1], name='value')
        self.emb_dropout_keep_prob = tf.placeholder(tf.float32, name='emb_dropout_keep_prob')
        self.rnn_dropout_keep_prob = tf.placeholder(tf.float32, name='rnn_dropout_keep_prob')
        self.dropout_keep_prob = tf.placeholder(tf.float32, name='dropout_keep_prob')
        initializer = tf.keras.initializers.glorot_normal
    # Word Embedding Layer

        lookedUp = tf.py_function(lookup, [self.input_text], tf.float32, name="lookedUp")
        with tf.device('/cpu:0'), tf.variable_scope("word-embeddings"):
            self.embedded_chars = tf.reshape(lookedUp,[-1,sequence_length,embedding_size])

     # Bidirectional LSTM
    　　with tf.variable_scope("bi-lstm"):
            _fw_cell = tf.nn.rnn_cell.LSTMCell(hidden_size, initializer=initializer())
            fw_cell = tf.nn.rnn_cell.DropoutWrapper(_fw_cell, self.rnn_dropout_keep_prob)
            _bw_cell = tf.nn.rnn_cell.LSTMCell(hidden_size, initializer=initializer())
            bw_cell = tf.nn.rnn_cell.DropoutWrapper(_bw_cell, self.rnn_dropout_keep_prob)
            self.rnn_outputs, _ = tf.nn.bidirectional_dynamic_rnn(cell_fw=fw_cell,cell_bw=bw_cell,inputs=self.embedded_chars,sequence_length=self._length(self.input_text),dtype=tf.float32)
            self.rnn_outputs = tf.add(self.rnn_outputs[0], self.rnn_outputs[1])


    # Attention
        with tf.variable_scope('attention'):
            self.attn, self.alphas = attention(self.rnn_outputs)


    # Dropout
        with tf.variable_scope('dropout'):
            self.h_drop = tf.nn.dropout(self.attn, self.dropout_keep_prob)

   # one layer neural network accepting numerics as input
        with tf.variable_scope('one-layer'):
            self.A1 = tf.Variable(tf.random_normal(shape=[2, 5]))
            self.b1 = tf.Variable(tf.random_normal(shape=[5]))
            self.A2 = tf.Variable(tf.random_normal(shape=[5, 1]))
            self.b2 = tf.Variable(tf.random_normal(shape=[1]))
            self.hidden_output = tf.nn.relu(tf.add(tf.matmul(tf.concat([self.input_price, self.input_index], axis=1), self.A1), self.b1))
            self.final_output = tf.nn.relu(tf.add(tf.matmul(self.hidden_output, self.A2),
                                         self.b2))

    # Merged
        with tf.variable_scope('merged'):
            self.merged = tf.concat((self.h_drop, self.final_output), axis=1)

    # Fully connected layer
        with tf.variable_scope('output'):
            self.logits = tf.layers.dense(self.merged, num_classes,kernel_initializer=initializer())
            self.logits = tf.identity(self.logits, name="logits")
            self.predictions = tf.argmax(self.logits, 1, name="predictions")

    # Calculate mean cross-entropy loss
        with tf.variable_scope("loss"):
            losses = tf.nn.softmax_cross_entropy_with_logits_v2(logits=self.logits, labels=self.input_y)
            self.l2 = tf.add_n([tf.nn.l2_loss(v) for v in tf.trainable_variables()])
            self.loss = tf.reduce_mean(losses) + l2_reg_lambda * self.l2

    # Accuracy
        with tf.variable_scope("accuracy"):
           correct_predictions = tf.equal(self.predictions, tf.argmax(self.input_y, 1))
           self.accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32), name="accuracy")

Хотя код компилируется, я не уверен, имеет ли это смысл, когда я проверяю измерение.

конечное выходное измерение
[ Размер (Нет), Размер (1)]

Размер выходных данных
[Размер (Нет), Размер (40), Размер (100)]

Размеры выходных данных
[Размер (Нет), Размер (100)]

Размер h_drop
[Размер (Нет), Размер (100)]

Объединенное измерение
[Размер (Нет), Размер (101)]

Может кто-нибудь просветить меня? Я также хочу привлечь внимание к подключению к цифрам c. Любая идея о том, как это сделать, приветствуется. Большое спасибо.