Python 如何将字符串值传递给情绪分析RNN序列模型并返回预测

我使用自己的数据集重新创建了一个情绪分析机器学习项目，并对其进行了一些小的修改，以缩短其完成时间。我可以创建好的模型，编译它，拟合它，并测试它，而不会出现问题，然而，问题在于如何向模型传递一个新的字符串/文章，它反过来传递一个关于字符串注释是肯定的还是否定的预测，并希望有人能帮助我

我在下面发布了我的代码供您审阅

class tensor_rnn():
def __init__(self, corp_paths, hidden_layers=3, loadfile=True):
    self.h_layers = hidden_layers
    self.num_words = []
    if loadfile == False:
        data_set = pd.DataFrame(columns=['Article', 'Polarity'])
        craptopass = []
        for files in os.listdir(corp_paths[0]):
            with open(corp_paths[0] + '\\' + files, 'r', errors='replace') as text_file:
                line = text_file.readline().replace('|', '')
                text_file.close()
            if len(line.split(' ')) > 3:
                line = ''.join([i if ord(i) < 128 else ' ' for i in line])
                craptopass.append([line, 1])
        good = data_set.append(pd.DataFrame(craptopass, columns=['Article', 'Polarity']), ignore_index=True)
        data_set = pd.DataFrame(columns=['Article', 'Polarity'])
        craptopass = []
        for files in os.listdir(corp_paths[1]):
            with open(corp_paths[1] + '\\' + files, 'r', errors='replace') as text_file:
                line = text_file.readline().replace('|', '')
                text_file.close()
            if len(line.split(' ')) > 3:
                line = ''.join([i if ord(i) < 128 else ' ' for i in line])
                craptopass.append([line, -1])
        bad = data_set .append(pd.DataFrame(craptopass, columns=['Article', 'Polarity']), ignore_index=True)
        for line in good['Article'].tolist():
            counter = len(line.split())
            self.num_words.append(counter)

        for line in bad['Article'].tolist():
            counter = len(line.split())
            self.num_words.append(counter)
        self.features = pd.concat([good, bad]).reset_index(drop=True)
        # self.features = self.features.str.replace(',', '')
        self.features.to_csv('Headlines.csv', sep='|')
    else:
        self.features = pd.read_csv('Headlines.csv', sep='|')
        self.features['totalwords'] = self.features['Article'].str.count(' ') + 1
        self.num_words.extend(self.features['totalwords'].tolist())

    self.features = shuffle(self.features)
    self.max_len = len(max(self.features['Article'].tolist()))
    tokenizer = self.tok = preprocessing.text.Tokenizer(num_words=len(self.num_words), split=' ')
    self.tok.fit_on_texts(self.features['Article'].values)
    X = tokenizer.texts_to_sequences(self.features['Article'].values)
    self.X = preprocessing.sequence.pad_sequences(X)
    self.Y = pd.get_dummies(self.features['Polarity']).values
    self.X_train, self.X_test, self.Y_train, self.Y_test = train_test_split(self.X, self.Y,
                                                                            test_size=0.20, random_state=36)

def RNN(self):
    embed_dim = 128
    lstm_out = 128
    model = Sequential()
    model.add(Embedding(len(self.num_words), embed_dim, input_length=self.X.shape[1]))
    model.add(Bidirectional(CuDNNLSTM(lstm_out)))
    model.add(Dropout(0.2))
    model.add(Dense(2, activation='softmax'))
    opt = Adam(lr=0.0001, decay=1e-4)   #1e-3
    model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
    return model

def model_train(self):
    self.model = self.RNN()

def model_test(self):
    batch_size = 128
    self.model.fit(self.X_train, self.Y_train, epochs=4, batch_size=batch_size, verbose=2,
                                callbacks=[EarlyStopping(monitor='val_loss', min_delta=0.0001,
                                                         patience=5, verbose=2, mode='auto')], validation_split=0.2)


if __name__ == "__main__":
    paths = 'PATHS TO ARTICLES'
    a = tensor_rnn([paths + '\\pos', paths + '\\neg'])
    a.model_train()
    a.model_test()
    a.model.save('RNNModelArticles.h5', include_optimizer=True)

类张量
定义初始化（self，corp路径，隐藏层=3，loadfile=True）：
self.h_层=隐藏的_层
self.num_words=[]
如果loadfile==False：
data\u set=pd.DataFrame（列=['Article'，'Polarity']）
craptopass=[]
对于os.listdir（公司路径[0]）中的文件：
以文本文件形式打开（公司路径[0]+'\\'+文件，'r'，errors='replace'）：
line=text_file.readline（）.replace（'|'，''）
text_file.close（）
如果len（行分割（“”））大于3：
line=''.join（[i if ord（i）<128 else''表示行中的i]）
craptopass.append（[line，1]）
good=data\u set.append（pd.DataFrame（craptopass，columns=['Article'，'Polarity']），ignore\u index=True）
data\u set=pd.DataFrame（列=['Article'，'Polarity']）
craptopass=[]
对于os.listdir（corp_路径[1]）中的文件：
以文本文件形式打开（公司路径[1]+'\\'+文件，'r'，errors='replace'）：
line=text_file.readline（）.replace（'|'，''）
text_file.close（）
如果len（行分割（“”））大于3：
line=''.join（[i if ord（i）<128 else''表示行中的i]）
craptopass.append（[line，-1]）
bad=data\u set.append（pd.DataFrame（craptopass，columns=['Article'，'Polarity']），ignore\u index=True）
对于处于良好状态的行['Article'].tolist（）：
计数器=len（line.split（））
self.num_words.append（计数器）
对于错误['Article']中的行。tolist（）：
计数器=len（line.split（））
self.num_words.append（计数器）
self.features=pd.concat（[good，bad]）。重置索引（drop=True）
#self.features=self.features.str.replace（'，'，''）
self.features.to_csv（'Headlines.csv'，sep='|'）
其他：
self.features=pd.read_csv（'Headlines.csv'，sep='|'）
self.features['totalwords']=self.features['Article'].str.count（''）+1
self.num_words.extend（self.features['totalwords'].tolist（））
self.features=shuffle（self.features）
self.max_len=len（max（self.features['Article'].tolist（））
tokenizer=self.tok=preprocessing.text.tokenizer（num\u words=len（self.num\u words），split=''）
self.tok.fit_on_文本（self.features['Article']值）
X=标记器。文本到序列（self.features['Article'].值）
self.X=预处理.sequence.pad_序列（X）
self.Y=pd.get_假人（self.features['Polarity']）。值
self.X\u列车，self.X\u测试，self.Y\u列车，self.Y\u测试=列车测试分割（self.X，self.Y，
测试尺寸=0.20，随机状态=36）
def RNN（自身）：
嵌入尺寸=128
lstm_out=128
模型=顺序（）
添加（嵌入（len（self.num\u words），嵌入尺寸，输入长度=self.X.shape[1]））
model.add（双向（CuDNNLSTM（lstm_out）））
模型。添加（辍学（0.2））
model.add（密集（2，activation='softmax'））
opt=Adam（lr=0.0001，衰减=1e-4）#1e-3
compile（loss='binary\u crossentropy'，optimizer=opt，metrics=['accurity']）
回归模型
def型动力传动系（自）：
self.model=self.RNN（）
def模型测试（自）：
批量大小=128
self.model.fit（self.X_train，self.Y_train，epochs=4，batch_size=batch_size，verbose=2，
回调=[EarlyStopping（monitor='val_loss'，min_delta=0.0001，
耐心=5，详细=2，模式='auto'）]，验证=0.2）
如果名称=“\uuuuu main\uuuuuuuu”：
路径='到项目的路径'
a=张量（[path+'\\pos'，path+'\\neg']）
a、 模型列车（）
a、 模型试验（）
a、 model.save（'RNNModelArticles.h5'，include\u optimizer=True）

您所需要做的就是预处理要提供给模型的新文本，就像预处理培训文本一样。之后，您应该有一个预测方法，该方法将以与模型在训练中输出预测相同的方式输出其预测。因此，在predict方法中，您应该编写如下内容：

def predict(self, sequence):
  presprocessed = preprocess(sequence)
  prediction = self.model.predict(preprocessed, batch_size=None, verbose=0, steps=None)

---

这是否为您澄清了问题？

嗨，Novak，我认为我们正在接近，对字符串输入进行预处理是有意义的，但现在的问题是，预期尺寸和字符串输入的尺寸不符合马赫数（请参见下文）。检查输入时出错：预期嵌入_输入具有形状（119），但得到了具有形状（4）的数组，所以您的问题是句子（或仅输入）的长度不相同？若这是一个问题，只需将放入模型中的所有内容填充到指定的长度，在本例中为119。对于填充，您可以使用一些中性词或类似的词（例如，

a

，因为形容词是中性的，因此不会影响情绪分析的结果）嗨，Novak，很抱歉更新太晚，我按照您的建议，我终于能够用我的模型进行预测了。谢谢你的帮助。