lstm进行分类，第一个epoch loss就为nan

Question

利用lstm对眼动数据进行分类，但是loss从第一个epoch就一直是nan我不明白是为什么，数据里面没有空的数据

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.feature_selection import RFE
from sklearn.metrics import roc_auc_score, accuracy_score, f1_score, precision_score
from sklearn.metrics import confusion_matrix, classification_report
import tensorflow as tf
from keras.layers import LSTM, Dense, Dropout
from keras.models import Sequential
import keras
import os
current_folder_path = os.getcwd()  

# 读取数据
data = pd.read_csv('./data.csv')
n = 5  # 这是你想要选择的后续进行分类的特征个数，或者RF-RFE选出来的特征数

# 分离特征和标签
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
print(0000)
# 特征归一化
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# 特征选择
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rfe = RFE(estimator=rf, n_features_to_select=n, step=1)
rfe.fit(X_scaled, y)
print(1111222333)
# 输出特征排名柱状图
feature_ranking = pd.Series(rfe.ranking_, index=X.columns)
ax = feature_ranking.plot(kind='bar')
ax.set_xticklabels(ax.get_xticklabels(), rotation=20)  # 旋转x轴刻度标签
# plt.xlabel('Features')
# plt.ylabel('Rank')
# plt.title('Feature Ranking')
# plt.show()

# 选取选定特征
X_selected = X_scaled[:, rfe.support_]

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.2, random_state=42)
print(X_train.shape," ",y_train.shape)
# 参数选择
# 创建神经网络模型  
clf = Sequential()  
clf.add(LSTM(50, activation='relu', input_shape=(X_train.shape[1], 1), return_sequences=True))  # 输入层，28*28=784个特征，50个LSTM单元
clf.add(Dropout(0.2))
clf.add(LSTM(units=50, return_sequences=True))
clf.add(Dropout(0.2))
clf.add(LSTM(50))

clf.add(Dense(8))
clf.add(Dropout(0.2))

clf.add(Dense(4, activation='softmax'))  # 输出层，4个类别，使用softmax激活函数
# 编译模型，设置损失函数、优化器和评估指标
clf.compile(loss='sparse_categorical_crossentropy', optimizer=keras.optimizers.Adam(lr=0.1, decay=0.5, clipnorm=1), metrics=['accuracy'])
# 训练模型，设置训练轮数为10轮，批处理大小为32  
#clf.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val))  
clf.fit(X_train, y_train, epochs=10, batch_size=32, verbose=1)
print(4444444444)
# 在测试集上进行预测，并计算准确率  

# 在训练集上进行预测
y_train_pred = clf.predict(X_train)
print(y_train_pred)
# 在测试集上进行预测
y_test_pred = clf.predict(X_test)

# 输出评价指标
train_accuracy = accuracy_score(y_train, y_train_pred)
train_f1_micro = f1_score(y_train, y_train_pred, average='micro')
train_f1_macro = f1_score(y_train, y_train_pred, average='macro')
train_precision = precision_score(y_train, y_train_pred, average='macro')
test_precision = precision_score(y_test, y_test_pred, average='macro')
test_accuracy = accuracy_score(y_test, y_test_pred)
test_f1_micro = f1_score(y_test, y_test_pred, average='micro')
test_f1_macro = f1_score(y_test, y_test_pred, average='macro')

# Print evaluation metrics
print("Train Accuracy:", train_accuracy)
print("Train Precision:", train_precision)
print("Train F1 Score (micro):", train_f1_micro)
print("Train F1 Score (macro):", train_f1_macro)
print("Test Accuracy:", test_accuracy)
print("Test Precision:", test_precision)
print("Test F1 Score (micro):", test_f1_micro)
print("Test F1 Score (macro):", test_f1_macro)
# 计算混淆矩阵
cm = confusion_matrix(y_train, y_train_pred)
print("Confusion Matrix:")
print(cm)

# 绘制混淆矩阵
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
plt.colorbar()
classes = np.unique(y)
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes)
plt.yticks(tick_marks, classes)
plt.xlabel('Predicted Label')
plt.ylabel('True Label')
plt.title('Confusion Matrix')
plt.show()
#测试集混淆矩阵
cm = confusion_matrix(y_train, y_train_pred)
print("Confusion Matrix:")
print(cm)

# 绘制混淆矩阵
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
plt.colorbar()
classes = np.unique(y)
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes)
plt.yticks(tick_marks, classes)
plt.xlabel('Predicted Label')
plt.ylabel('True Label')
plt.title('Confusion Matrix')
plt.show()

# 输出分类报告
print("Classification Report:")
print(classification_report(y_train, y_train_pred))
print("Classification Report:")
print(classification_report(y_test, y_test_pred))

Answer 1

该回答引用自GPT-3.5,由博主GISer Liu编写：

首先，出现 NaN 损失的问题通常是由于模型训练过程中的数值不稳定性导致的。在你的代码中，我注意到几个潜在的问题：

1. 学习率设置过高 ：在使用 Adam 优化器时，学习率设置为 0.1 很可能过高，特别是结合了衰减参数。这可能导致参数更新过大，使得模型无法收敛。
2. 数据预处理不足 ：在 LSTM 模型中，输入数据的规范化非常重要。你在 MinMaxScaler 中对数据进行了归一化，但 LSTM 模型需要的是 3D 的输入形式 (samples, timesteps, features)，你可能需要进一步调整数据的形状以适应 LSTM 模型的输入要求。
3. Dropout 使用不当 ：过多的 Dropout 层可能会导致信息丢失过多，影响模型的性能。
   解决方案：

• 降低学习率 ：尝试将学习率设置为一个较小的值，比如 0.001 或更小，观察模型的训练情况。
• 调整数据形状 ：将输入数据的形状调整为 3D，可以通过 reshape 函数实现。例如，X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)。
• 减少 Dropout 层 ：尝试减少 Dropout 层的使用，或者逐渐增加 Dropout 的比例，以观察模型的训练效果。
  我会给你提供一个修改后的代码框架作为参考：
  python
  Copy code

  # 调整学习率
  optimizer = keras.optimizers.Adam(lr=0.001, decay=0.0, clipnorm=1)
  # 调整数据形状
  X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
  X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
  # 减少 Dropout 层
  clf = Sequential()
  clf.add(LSTM(50, activation='relu', input_shape=(X_train.shape[1], 1), return_sequences=True))
  clf.add(Dropout(0.2))
  clf.add(LSTM(units=50, return_sequences=True))
  clf.add(Dropout(0.2))
  clf.add(LSTM(50))
  clf.add(Dense(8))
  clf.add(Dropout(0.2))
  clf.add(Dense(4, activation='softmax'))
  # 编译模型
  clf.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
  # 训练模型
  clf.fit(X_train, y_train, epochs=10, batch_size=32, verbose=1)
  

  这些调整应该能够帮助你解决 NaN 损失的问题。如果问题仍然存在，请尝试进一步调整超参数或模型架构。

如果该回答解决了您的问题，请采纳！如果没有，请私信联系或评论您的疑惑