Question

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

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

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)

修改后的代码如下所示：

{{1}}

我收到错误消息： “排名不匹配：标签排名（收到2）应该等于logits排名减1（收到2）。”

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

Answer 1

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

Answer 2

将形状更改为 [无] 可能会有所帮助。 ys_ = tf.placeholder(shape=[None], dtype=tf.int32)

调整张量流LSTM代码以进行二进制分类

2 个答案: