调整Tensorflow LSTM代码以进行二进制分类

Question

我正在尝试采用这种基本的LSTM模型（ https://github.com/suriyadeepan/rnn-from-scratch/blob/master/lstm.py ）（它是多对多序列模型）并将其转换进入具有二进制结果的序列分类器。

我的结果和功能如下所示：

# Features: 
array([[62, 91, 57, ..., 91, 43, 87],
       [66, 20, 52, ..., 91, 33, 20],
       [66, 45, 52, ..., 70, 91, 66],
       ...,
       [72, 20, 20, ..., 17, 14, 66],
       [91, 25, 52, ..., 52, 14, 52],
       [72, 29, 66, ..., 21, 20, 52]], dtype=int32)

# Feature matrix shape
(118929, 20)


# Outcome 
array([[1],
       [0],
       [1],
       ...,
       [0],
       [1],
       [1]])

# Outcome shape
(118929, 1)

修改后的代码如下所示：

import tensorflow as tf
import numpy as np

import random
import argparse
import sys

from random import sample
import configparser
import os

import csv
import pickle as pkl

from sklearn.preprocessing import OneHotEncoder, LabelBinarizer, LabelEncoder
from sklearn.datasets import make_classification


def rand_batch_gen(x, y, batch_size):
    while True:
        sample_idx = sample(list(np.arange(len(x))), batch_size)
        yield x[sample_idx], y[sample_idx]



with open('data/paulg/metadata.pkl', 'rb') as f:
    metadata = pkl.load(f)
# read numpy arrays
X = np.load('data/paulg/idx_x.npy')
Y = np.load('data/paulg/idx_y.npy')
idx2w = metadata['idx2ch'] 
w2idx = metadata['ch2idx']


_, Y = make_classification(n_samples = 118929, n_classes = 2, n_features=2, n_redundant=0, n_informative=1, n_clusters_per_class=1)
label_encoder = LabelEncoder()
integer_encoded = label_encoder.fit_transform(Y)
Y = Y.reshape(-1,1)









BATCH_SIZE = 256

class LSTM_rnn():

    def __init__(self, state_size, num_classes,
            ckpt_path='ckpt/lstm1/',
            model_name='lstm1'):

        self.state_size = state_size
        self.num_classes = num_classes
        self.ckpt_path = ckpt_path
        self.model_name = model_name

        # build graph ops
        def __graph__():
            tf.reset_default_graph()
            # inputs
            xs_ = tf.placeholder(shape=[None, None], dtype=tf.int32)
            ys_ = tf.placeholder(shape=[None, 1], dtype=tf.int32)

            # embeddings
            embs = tf.get_variable('emb', [100, state_size])
            rnn_inputs = tf.nn.embedding_lookup(embs, xs_)

            # initial hidden state
            init_state = tf.placeholder(shape=[2, None, state_size], dtype=tf.float32, name='initial_state')
            # initializer
            xav_init = tf.contrib.layers.xavier_initializer
            # params
            W = tf.get_variable('W', shape=[4, self.state_size, self.state_size], initializer=xav_init())
            U = tf.get_variable('U', shape=[4, self.state_size, self.state_size], initializer=xav_init())
            #b = tf.get_variable('b', shape=[self.state_size], initializer=tf.constant_initializer(0.))

            # step - LSTM
            def step(prev, x):
                # gather previous internal state and output state
                st_1, ct_1 = tf.unstack(prev)

                # GATES
                #
                #  input gate
                i = tf.sigmoid(tf.matmul(x,U[0]) + tf.matmul(st_1,W[0]))
                #  forget gate
                f = tf.sigmoid(tf.matmul(x,U[1]) + tf.matmul(st_1,W[1]))
                #  output gate
                o = tf.sigmoid(tf.matmul(x,U[2]) + tf.matmul(st_1,W[2]))
                #  gate weights
                g = tf.tanh(tf.matmul(x,U[3]) + tf.matmul(st_1,W[3]))

                # new internal cell state
                ct = ct_1*f + g*i
                # output state
                st = tf.tanh(ct)*o
                return tf.stack([st, ct])



            states = tf.scan(step, 
                    tf.transpose(rnn_inputs, [1,0,2]),
                    initializer=init_state)

            # predictions
            V = tf.get_variable('V', shape=[state_size, num_classes], 
                                initializer=xav_init())
            bo = tf.get_variable('bo', shape=[num_classes], 
                                 initializer=tf.constant_initializer(0.))


            # get last state before reshape/transpose
            last_state = states[-1]


            # transpose
            states = tf.transpose(states, [1,2,0,3])[0]

            states_reshaped = tf.reshape(states, [-1, state_size])
            logits = tf.matmul(states_reshaped, V) + bo

    # predictions
            predictions = tf.nn.softmax(logits) 

            # optimization
            losses = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=ys_)
            loss = tf.reduce_mean(losses)
            train_op = tf.train.AdagradOptimizer(learning_rate=0.1).minimize(loss)

            # expose symbols
            self.xs_ = xs_
            self.ys_ = ys_
            self.loss = loss
            self.train_op = train_op
            self.predictions = predictions
            self.last_state = last_state
            self.init_state = init_state

        # build graph
        __graph__()


    ####
    # training
    def train(self, train_set, epochs=100):
        # training session
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            train_loss = 0
            try:
                for i in range(epochs):
                    for j in range(100):
                        xs, ys = train_set.__next__()
                        batch_size = xs.shape[0]
                        _, train_loss_ = sess.run([self.train_op, self.loss], feed_dict = {
                                self.xs_ : xs,
                                self.ys_ : ys.flatten(),
                                self.init_state : np.zeros([2, batch_size, self.state_size])
                            })
                        train_loss += train_loss_
                    print('[{}] loss : {}'.format(i,train_loss/100))
                    train_loss = 0
            except KeyboardInterrupt:
                print('interrupted by user at ' + str(i))

            # training ends here; 
            #  save checkpoint
            saver = tf.train.Saver()
            saver.save(sess, self.ckpt_path + self.model_name, global_step=i)







#### main function
if __name__ == '__main__':

    # create the model
    model = LSTM_rnn(state_size = 512, num_classes=1)

    # get train set
    train_set = rand_batch_gen(X, Y ,batch_size=BATCH_SIZE)

    # start training
    model.train(train_set)

我收到错误消息：“等级不匹配：标签的等级（接收到2）应等于对数的等级减去1（接收到2）。”

您知道我如何成功地将此代码用于二进制分类吗？

Answer 1

我不确定您是否还有其他错误。 该错误来自sparse_softmax_cross_entropy_with_logits 。 在您的情况下，标签应为长度为118929的向量，对数应为具有形状的矩阵（118929，2）。 不要从make_classification （ Y = Y.reshape(-1,1) ）重塑Y