【人工智能项目】LSTM实现数据预测分类实验

最新推荐文章于 2025-11-10 18:11:29 发布
原创 最新推荐文章于 2025-11-10 18:11:29 发布 · 1.4w 阅读 · 260 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#人工智能 #lstm #分类

本文介绍了一项使用LSTM模型进行树种分类的实验。通过对采集到的数据进行预处理、特征提取及模型训练，实现了对不同树种的有效区分。实验采用的数据集包含多种树的数据，并且详细记录了从数据准备到模型训练的全过程。
部署运行你感兴趣的模型镜像

【人工智能项目】LSTM实现数据预测分类实验

本次主要对csv文件中采集到的数据来区分树的品种实验，通过不同列的数据，送入lstm模型中，得到预测结果。
在这里插入图片描述

导包

# 导包
import numpy as np
import pandas as pd
import glob
import os
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

train_path = "./"

print(os.listdir(train_path))

['.ipynb_checkpoints', 'code.ipynb', 'data.csv', 'lstm.h5', 'plant_totaldatat.xlsx']

读取数据

# 读取文件
data = pd.read_csv("data.csv")
data
Filename172.538173.141173.744174.348174.951175.554176.157176.76177.363...1165.8461166.3731166.91167.4271167.9541168.4811169.0081169.5351170.061Label
0芭蕉0001.ROH414.421417445.234558482.571625378.288757483.976776476.850617423.253845445.033813477.653564...487.088196513.986938532.956604545.502625504.853424568.687744547.811096584.947449564.7733761
1芭蕉0002.ROH469.523712450.353333447.543030457.880981467.616699456.375458483.575287447.543030415.224365...560.357178511.477722473.337708613.151001513.384766495.418793618.771606618.570923495.6195071
2芭蕉0003.ROH508.265930502.946411522.317505471.932556512.682129503.950104498.429840487.891144465.910461...597.694275552.126953540.885681661.327881553.030273540.183106650.889526659.521240550.2199711
3芭蕉0004.ROH490.801819514.789917529.945557463.501617527.536682525.027466489.898499514.288025503.247528...567.784424576.416138573.906921625.596680548.915161621.280823632.221008652.595825599.1997681
4芭蕉0005.ROH431.383697433.290680436.703217408.901154459.386505461.694977453.264008435.900269438.810974...535.867249499.232788503.849731569.691467518.704285512.381043577.921692573.605835520.8120121
..................................................................
2422樟树10096.ROH376.682861396.656189391.637787371.363342434.796234390.634094378.489502410.406677394.147003...478.155395441.520904413.317383508.265930447.844116424.558624497.927978522.618652449.9518747
2423樟树10097.ROH312.647797359.419495336.836578315.056641381.299835351.891876333.925903377.586182353.397400...434.495117420.242798342.758331476.047668397.258423369.054871446.639709460.390167384.9130867
2424樟树10098.ROH383.809052372.166290419.941681371.363342412.112946411.912201399.566894382.905731405.287903...438.208740460.089081427.469330478.556885463.300873468.620392485.181183525.328613500.0357367
2425樟树10099.ROH327.100861333.725159347.676392332.621124376.181030364.538300361.727966377.786926347.274902...417.934326411.410370377.184723433.190338413.919586395.752899432.989593445.636017425.5623177
2426樟树10100.ROH380.697601424.859741441.119446388.526367448.446320433.089966416.428803431.383697450.654449...500.838684497.526520458.182068537.673889493.210663465.709717551.625122561.059753480.2631537

2427 rows × 1757 columns

# 查看前5行数据
data.head()
Filename172.538173.141173.744174.348174.951175.554176.157176.76177.363...1165.8461166.3731166.91167.4271167.9541168.4811169.0081169.5351170.061Label
0芭蕉0001.ROH414.421417445.234558482.571625378.288757483.976776476.850617423.253845445.033813477.653564...487.088196513.986938532.956604545.502625504.853424568.687744547.811096584.947449564.7733761
1芭蕉0002.ROH469.523712450.353333447.543030457.880981467.616699456.375458483.575287447.543030415.224365...560.357178511.477722473.337708613.151001513.384766495.418793618.771606618.570923495.6195071
2芭蕉0003.ROH508.265930502.946411522.317505471.932556512.682129503.950104498.429840487.891144465.910461...597.694275552.126953540.885681661.327881553.030273540.183106650.889526659.521240550.2199711
3芭蕉0004.ROH490.801819514.789917529.945557463.501617527.536682525.027466489.898499514.288025503.247528...567.784424576.416138573.906921625.596680548.915161621.280823632.221008652.595825599.1997681
4芭蕉0005.ROH431.383697433.290680436.703217408.901154459.386505461.694977453.264008435.900269438.810974...535.867249499.232788503.849731569.691467518.704285512.381043577.921692573.605835520.8120121

5 rows × 1757 columns

数据分析

data.index

RangeIndex(start=0, stop=2427, step=1)

print(data.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2427 entries, 0 to 2426
Columns: 1757 entries, Filename to Label
dtypes: float64(1755), int64(1), object(1)
memory usage: 32.5+ MB
None

# 去除缺失数据
data.dropna(axis=0, how='any', inplace=True)

data
Filename172.538173.141173.744174.348174.951175.554176.157176.76177.363...1165.8461166.3731166.91167.4271167.9541168.4811169.0081169.5351170.061Label
0芭蕉0001.ROH414.421417445.234558482.571625378.288757483.976776476.850617423.253845445.033813477.653564...487.088196513.986938532.956604545.502625504.853424568.687744547.811096584.947449564.7733761
1芭蕉0002.ROH469.523712450.353333447.543030457.880981467.616699456.375458483.575287447.543030415.224365...560.357178511.477722473.337708613.151001513.384766495.418793618.771606618.570923495.6195071
2芭蕉0003.ROH508.265930502.946411522.317505471.932556512.682129503.950104498.429840487.891144465.910461...597.694275552.126953540.885681661.327881553.030273540.183106650.889526659.521240550.2199711
3芭蕉0004.ROH490.801819514.789917529.945557463.501617527.536682525.027466489.898499514.288025503.247528...567.784424576.416138573.906921625.596680548.915161621.280823632.221008652.595825599.1997681
4芭蕉0005.ROH431.383697433.290680436.703217408.901154459.386505461.694977453.264008435.900269438.810974...535.867249499.232788503.849731569.691467518.704285512.381043577.921692573.605835520.8120121
..................................................................
2422樟树10096.ROH376.682861396.656189391.637787371.363342434.796234390.634094378.489502410.406677394.147003...478.155395441.520904413.317383508.265930447.844116424.558624497.927978522.618652449.9518747
2423樟树10097.ROH312.647797359.419495336.836578315.056641381.299835351.891876333.925903377.586182353.397400...434.495117420.242798342.758331476.047668397.258423369.054871446.639709460.390167384.9130867
2424樟树10098.ROH383.809052372.166290419.941681371.363342412.112946411.912201399.566894382.905731405.287903...438.208740460.089081427.469330478.556885463.300873468.620392485.181183525.328613500.0357367
2425樟树10099.ROH327.100861333.725159347.676392332.621124376.181030364.538300361.727966377.786926347.274902...417.934326411.410370377.184723433.190338413.919586395.752899432.989593445.636017425.5623177
2426樟树10100.ROH380.697601424.859741441.119446388.526367448.446320433.089966416.428803431.383697450.654449...500.838684497.526520458.182068537.673889493.210663465.709717551.625122561.059753480.2631537

2427 rows × 1757 columns

# 删除第一列数据
data = data.drop(['Filename'], axis=1)

data
172.538173.141173.744174.348174.951175.554176.157176.76177.363177.966...1165.8461166.3731166.91167.4271167.9541168.4811169.0081169.5351170.061Label
0414.421417445.234558482.571625378.288757483.976776476.850617423.253845445.033813477.653564595.285400...487.088196513.986938532.956604545.502625504.853424568.687744547.811096584.947449564.7733761
1469.523712450.353333447.543030457.880981467.616699456.375458483.575287447.543030415.224365601.006409...560.357178511.477722473.337708613.151001513.384766495.418793618.771606618.570923495.6195071
2508.265930502.946411522.317505471.932556512.682129503.950104498.429840487.891144465.910461655.907959...597.694275552.126953540.885681661.327881553.030273540.183106650.889526659.521240550.2199711
3490.801819514.789917529.945557463.501617527.536682525.027466489.898499514.288025503.247528661.628967...567.784424576.416138573.906921625.596680548.915161621.280823632.221008652.595825599.1997681
4431.383697433.290680436.703217408.901154459.386505461.694977453.264008435.900269438.810974592.675842...535.867249499.232788503.849731569.691467518.704285512.381043577.921692573.605835520.8120121
..................................................................
2422376.682861396.656189391.637787371.363342434.796234390.634094378.489502410.406677394.147003510.775147...478.155395441.520904413.317383508.265930447.844116424.558624497.927978522.618652449.9518747
2423312.647797359.419495336.836578315.056641381.299835351.891876333.925903377.586182353.397400424.960113...434.495117420.242798342.758331476.047668397.258423369.054871446.639709460.390167384.9130867
2424383.809052372.166290419.941681371.363342412.112946411.912201399.566894382.905731405.287903531.149963...438.208740460.089081427.469330478.556885463.300873468.620392485.181183525.328613500.0357367
2425327.100861333.725159347.676392332.621124376.181030364.538300361.727966377.786926347.274902443.227173...417.934326411.410370377.184723433.190338413.919586395.752899432.989593445.636017425.5623177
2426380.697601424.859741441.119446388.526367448.446320433.089966416.428803431.383697450.654449533.458435...500.838684497.526520458.182068537.673889493.210663465.709717551.625122561.059753480.2631537

2427 rows × 1756 columns

# 样本分布
# 以图方式表示
sns.countplot(data["Label"])
plt.xlabel("Label")
plt.title("Number of  messages")

Text(0.5, 1.0, 'Number of  messages')

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FIhX7uBd-1635931670390)(output_11_1.png)]

# 重新排序
df = data.sample(frac=1).reset_index(drop=True)

df
172.538173.141173.744174.348174.951175.554176.157176.76177.363177.966...1165.8461166.3731166.91167.4271167.9541168.4811169.0081169.5351170.061Label
0429.978546448.345978447.342285430.380005473.839569442.323853457.178406452.862549429.175598582.739380...494.415100501.942718467.616699526.934509482.170136509.470367526.432617595.385803530.2466436
1281.834656293.979248335.431427288.057526310.238953317.365112305.822723321.179108327.502319398.462830...329.911163375.578827351.691132373.270355349.984863390.132263369.255615398.061371381.1994637
2440.316498426.164520453.665497430.480377450.052216461.594605456.174713440.517212444.130493607.429993...515.291748490.400360489.998871569.992554481.567932517.198731559.353516549.617737548.6140753
3285.247192309.737091289.362305302.008728340.750977327.000488323.688324345.769379316.963623418.034698...338.442474373.169983362.530914384.511627340.750977376.983978375.578827407.997833391.2362981
4458.081696475.345093447.743744437.606537476.950989457.278748469.523712437.305420436.803589594.683228...486.887451487.991516502.544952553.532104483.374573506.158203554.033997552.327698540.7853394
..................................................................
2422441.822022464.706024461.996063427.368958481.266815490.299988465.207855473.939911446.037476610.240295...523.421570524.927124519.406860577.720947499.232788537.473144581.434570584.646362551.6251222
2423290.767456264.270203298.395477291.670776303.915741331.416687325.394592316.762909328.204895404.384583...352.795166357.010651372.969238393.544769368.553040391.236298399.767639412.915894403.1801454
2424303.915741286.652344305.722382293.176300329.810791303.815369317.967316328.907471294.179993419.239105...344.866058354.802551357.512512400.972046342.557587383.006103390.634094388.024506372.6681521
2425428.473022434.394745487.991516408.098206464.003449489.396667456.174713431.684814458.583557590.066223...528.038513561.059753473.237335578.624268537.673889496.221741553.732849616.162048509.1692502
2426454.468445441.621277450.754822424.357910459.286133460.289825469.222595459.787964443.729004592.274353...494.916931484.779724499.533875555.840576474.441772526.231873546.707092568.988892528.2392584

2427 rows × 1756 columns

# 空值检查
df[df.isnull().values==True]
172.538173.141173.744174.348174.951175.554176.157176.76177.363177.966...1165.8461166.3731166.91167.4271167.9541168.4811169.0081169.5351170.061Label

0 rows × 1756 columns

# 得到x和y
x = df.iloc[:,:-1]
y = df.iloc[:,-1]

划分数据集

# 划分数据集
from sklearn.model_selection import train_test_split
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2)

# 数据归一化处理
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(x_train)

X_train = scaler.transform(x_train)
X_test = scaler.transform(x_test)

print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

(1941, 1755)
(1941,)
(486, 1755)
(486,)

# 对数据处理
from keras.utils import np_utils

X_train = X_train.reshape((-1,1,1755))
Y_train = np_utils.to_categorical(y_train)
X_test = X_test.reshape((-1,1,1755))
Y_test = np_utils.to_categorical(y_test)

print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
print(Y_test.shape)

(1941, 1, 1755)
(1941, 8)
(486, 1, 1755)
(486, 8)

模型

from keras import Sequential
from keras.layers import LSTM,Activation,Dense,Dropout,Input,Embedding,BatchNormalization,Add,concatenate,Flatten

model = Sequential()

model.add(LSTM(units=50,return_sequences=True,input_shape=(1,1755)))
model.add(Dropout(0.2))

model.add(LSTM(units=50,return_sequences=True))
model.add(Dropout(0.2))

model.add(LSTM(units=50,return_sequences=True))
model.add(Dropout(0.2))

# model.add(LSTM(units=50,return_sequences=True))
# model.add(Dropout(0.2))

model.add(LSTM(units=50))
model.add(Dropout(0.2))

# model.add(Dense(units=256))
# model.add(Dropout(0.2))
model.add(Dense(units=128))
model.add(Dropout(0.2))
model.add(Dense(units=64))
model.add(Dropout(0.2))
model.add(Dense(units=16))
model.add(Dropout(0.2))

model.add(Dense(units=8,activation="softmax"))

# Implement Learning rate decay
from keras.callbacks import EarlyStopping,ReduceLROnPlateau,ModelCheckpoint,LearningRateScheduler

checkpoint = ModelCheckpoint("lstm.h5",
                             monitor="val_loss",
                             mode="min",
                             save_best_only = True,
                             verbose=1)

earlystop = EarlyStopping(monitor = 'val_loss', 
                          min_delta = 0, 
                          patience = 5,
                          verbose = 1,
                          restore_best_weights = True)

reduce_lr = ReduceLROnPlateau(monitor = 'val_loss',
                              factor = 0.2,
                              patience = 3,
                              verbose = 1)
                              #min_delta = 0.00001)

callbacks = [earlystop, checkpoint, reduce_lr]

model.compile(optimizer="adam", loss='categorical_crossentropy', metrics=['accuracy'])

history_fit = model.fit(x=X_train, 
                        y=Y_train, 
                        batch_size=8, 
                        epochs=30, 
                        verbose=1, 
                        validation_data=(X_test, Y_test),
                        callbacks=callbacks)

Train on 1941 samples, validate on 486 samples
Epoch 1/30
1941/1941 [==============================] - 6s 3ms/step - loss: 1.0300 - accuracy: 0.6188 - val_loss: 0.5473 - val_accuracy: 0.8313

Epoch 00001: val_loss improved from inf to 0.54729, saving model to lstm.h5
Epoch 2/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.6064 - accuracy: 0.7836 - val_loss: 0.3829 - val_accuracy: 0.8374

Epoch 00002: val_loss improved from 0.54729 to 0.38287, saving model to lstm.h5
Epoch 3/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.4797 - accuracy: 0.8089 - val_loss: 0.3595 - val_accuracy: 0.8272

Epoch 00003: val_loss improved from 0.38287 to 0.35947, saving model to lstm.h5
Epoch 4/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.4672 - accuracy: 0.8083 - val_loss: 0.2970 - val_accuracy: 0.8354

Epoch 00004: val_loss improved from 0.35947 to 0.29702, saving model to lstm.h5
Epoch 5/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3946 - accuracy: 0.8557 - val_loss: 0.2658 - val_accuracy: 0.9033

Epoch 00005: val_loss improved from 0.29702 to 0.26579, saving model to lstm.h5
Epoch 6/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3519 - accuracy: 0.8712 - val_loss: 0.2217 - val_accuracy: 0.8909

Epoch 00006: val_loss improved from 0.26579 to 0.22171, saving model to lstm.h5
Epoch 7/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3287 - accuracy: 0.8743 - val_loss: 0.2439 - val_accuracy: 0.8683

Epoch 00007: val_loss did not improve from 0.22171
Epoch 8/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3400 - accuracy: 0.8635 - val_loss: 0.2036 - val_accuracy: 0.9259

Epoch 00008: val_loss improved from 0.22171 to 0.20360, saving model to lstm.h5
Epoch 9/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3541 - accuracy: 0.8666 - val_loss: 0.2087 - val_accuracy: 0.9321

Epoch 00009: val_loss did not improve from 0.20360
Epoch 10/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3227 - accuracy: 0.8691 - val_loss: 0.2141 - val_accuracy: 0.9362

Epoch 00010: val_loss did not improve from 0.20360
Epoch 11/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2842 - accuracy: 0.8851 - val_loss: 0.1821 - val_accuracy: 0.9506

Epoch 00011: val_loss improved from 0.20360 to 0.18205, saving model to lstm.h5
Epoch 12/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3343 - accuracy: 0.8712 - val_loss: 0.2297 - val_accuracy: 0.8951

Epoch 00012: val_loss did not improve from 0.18205
Epoch 13/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3082 - accuracy: 0.8800 - val_loss: 0.2213 - val_accuracy: 0.9321

Epoch 00013: val_loss did not improve from 0.18205
Epoch 14/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2550 - accuracy: 0.9052 - val_loss: 0.1765 - val_accuracy: 0.9444

Epoch 00014: val_loss improved from 0.18205 to 0.17651, saving model to lstm.h5
Epoch 15/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.3290 - accuracy: 0.8856 - val_loss: 0.2044 - val_accuracy: 0.9383

Epoch 00015: val_loss did not improve from 0.17651
Epoch 16/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2812 - accuracy: 0.9031 - val_loss: 0.1578 - val_accuracy: 0.9465

Epoch 00016: val_loss improved from 0.17651 to 0.15778, saving model to lstm.h5
Epoch 17/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2332 - accuracy: 0.9145 - val_loss: 0.1287 - val_accuracy: 0.9547

Epoch 00017: val_loss improved from 0.15778 to 0.12870, saving model to lstm.h5
Epoch 18/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2597 - accuracy: 0.9114 - val_loss: 0.1607 - val_accuracy: 0.9280

Epoch 00018: val_loss did not improve from 0.12870
Epoch 19/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2570 - accuracy: 0.9052 - val_loss: 0.1230 - val_accuracy: 0.9671

Epoch 00019: val_loss improved from 0.12870 to 0.12305, saving model to lstm.h5
Epoch 20/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2401 - accuracy: 0.9129 - val_loss: 0.1639 - val_accuracy: 0.9588

Epoch 00020: val_loss did not improve from 0.12305
Epoch 21/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2233 - accuracy: 0.9155 - val_loss: 0.1172 - val_accuracy: 0.9671

Epoch 00021: val_loss improved from 0.12305 to 0.11718, saving model to lstm.h5
Epoch 22/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2524 - accuracy: 0.9088 - val_loss: 0.1627 - val_accuracy: 0.9588

Epoch 00022: val_loss did not improve from 0.11718
Epoch 23/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2185 - accuracy: 0.9176 - val_loss: 0.1313 - val_accuracy: 0.9342

Epoch 00023: val_loss did not improve from 0.11718
Epoch 24/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.2344 - accuracy: 0.9160 - val_loss: 0.1223 - val_accuracy: 0.9527

Epoch 00024: val_loss did not improve from 0.11718

Epoch 00024: ReduceLROnPlateau reducing learning rate to 0.00020000000949949026.
Epoch 25/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.1890 - accuracy: 0.9274 - val_loss: 0.0862 - val_accuracy: 0.9691

Epoch 00025: val_loss improved from 0.11718 to 0.08617, saving model to lstm.h5
Epoch 26/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.1475 - accuracy: 0.9361 - val_loss: 0.0794 - val_accuracy: 0.9733

Epoch 00026: val_loss improved from 0.08617 to 0.07940, saving model to lstm.h5
Epoch 27/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.1507 - accuracy: 0.9392 - val_loss: 0.0673 - val_accuracy: 0.9774

Epoch 00027: val_loss improved from 0.07940 to 0.06732, saving model to lstm.h5
Epoch 28/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.1498 - accuracy: 0.9444 - val_loss: 0.0764 - val_accuracy: 0.9733

Epoch 00028: val_loss did not improve from 0.06732
Epoch 29/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.1513 - accuracy: 0.9423 - val_loss: 0.0733 - val_accuracy: 0.9774

Epoch 00029: val_loss did not improve from 0.06732
Epoch 30/30
1941/1941 [==============================] - 4s 2ms/step - loss: 0.1338 - accuracy: 0.9418 - val_loss: 0.0815 - val_accuracy: 0.9753

Epoch 00030: val_loss did not improve from 0.06732

Epoch 00030: ReduceLROnPlateau reducing learning rate to 4.0000001899898055e-05.

# 画曲线
def plot_performance(history=None,figure_directory=None,ylim_pad=[0,0]):
    xlabel="Epoch"
    legends=["Training","Validation"]
    
    plt.figure(figsize=(20,5))
    
    y1=history.history["accuracy"]
    y2=history.history["val_accuracy"]
    
    min_y=min(min(y1),min(y2))-ylim_pad[0]
    max_y=max(max(y1),max(y2))+ylim_pad[0]
    
    plt.subplot(121)
    
    plt.plot(y1)
    plt.plot(y2)
    
    plt.title("Model Accuracy\n",fontsize=17)
    plt.xlabel(xlabel,fontsize=15)
    plt.ylabel("Accuracy",fontsize=15)
    plt.ylim(min_y,max_y)
    plt.legend(legends,loc="upper left")
    plt.grid()
    
    y1=history.history["loss"]
    y2=history.history["val_loss"]
    
    min_y=min(min(y1),min(y2))-ylim_pad[1]
    max_y=max(max(y1),max(y2))+ylim_pad[1]
    
    plt.subplot(122)
    
    plt.plot(y1)
    plt.plot(y2)
    
    plt.title("Model Loss:\n",fontsize=17)
    plt.xlabel(xlabel,fontsize=15)
    plt.ylabel("Loss",fontsize=15)
    plt.ylim(min_y,max_y)
    plt.legend(legends,loc="upper left")
    plt.grid()
    plt.show()

# 可视化
plot_performance(history=history_fit)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4kudzXlk-1635931670393)(output_26_0.png)]

# 预测
predict_y = model.predict_classes(X_test)

predict_y

array([1, 6, 4, 3, 4, 1, 4, 6, 6, 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 5, 4, 5,
       7, 1, 4, 5, 3, 4, 1, 6, 4, 4, 5, 4, 1, 1, 7, 4, 1, 4, 6, 4, 4, 5,
       4, 7, 7, 6, 1, 1, 5, 6, 2, 1, 4, 4, 1, 4, 4, 4, 6, 5, 2, 6, 3, 1,
       2, 4, 2, 4, 1, 1, 1, 1, 1, 1, 6, 4, 1, 3, 5, 2, 4, 6, 3, 4, 4, 3,
       6, 5, 7, 1, 1, 2, 7, 4, 1, 6, 6, 2, 6, 1, 3, 4, 1, 1, 1, 4, 2, 1,
       3, 6, 2, 4, 4, 4, 3, 4, 1, 1, 6, 7, 6, 7, 2, 5, 1, 3, 4, 1, 3, 3,
       5, 4, 4, 7, 6, 2, 6, 4, 6, 6, 3, 5, 3, 5, 6, 3, 4, 1, 3, 6, 1, 4,
       6, 4, 6, 2, 2, 1, 7, 4, 6, 3, 6, 6, 5, 4, 4, 4, 4, 2, 4, 6, 1, 3,
       1, 6, 6, 4, 1, 1, 4, 1, 4, 4, 2, 3, 1, 6, 4, 4, 3, 6, 5, 3, 4, 6,
       1, 1, 3, 5, 4, 1, 6, 3, 4, 3, 1, 2, 1, 4, 6, 5, 3, 5, 4, 4, 4, 4,
       7, 3, 1, 4, 2, 4, 6, 7, 4, 1, 4, 3, 1, 4, 1, 5, 2, 5, 3, 4, 1, 2,
       4, 5, 1, 4, 4, 6, 3, 1, 4, 4, 5, 5, 6, 4, 3, 3, 1, 4, 5, 1, 1, 2,
       3, 1, 1, 6, 7, 6, 4, 6, 1, 3, 4, 1, 4, 2, 7, 4, 5, 1, 4, 2, 1, 7,
       3, 6, 4, 4, 1, 7, 1, 5, 4, 4, 1, 4, 4, 1, 1, 4, 1, 1, 3, 6, 3, 3,
       6, 5, 4, 3, 1, 2, 6, 6, 6, 4, 2, 2, 3, 1, 5, 1, 4, 1, 7, 3, 1, 1,
       3, 5, 6, 2, 4, 1, 1, 6, 1, 6, 6, 6, 7, 1, 5, 4, 2, 7, 1, 6, 3, 1,
       4, 5, 2, 1, 4, 5, 6, 3, 1, 5, 1, 6, 3, 1, 3, 6, 6, 5, 1, 6, 4, 1,
       7, 3, 4, 3, 7, 3, 6, 1, 5, 3, 4, 2, 4, 5, 4, 1, 1, 4, 6, 3, 6, 5,
       4, 6, 1, 6, 3, 1, 4, 4, 3, 1, 5, 6, 6, 3, 5, 3, 5, 2, 1, 3, 2, 4,
       1, 4, 1, 3, 7, 6, 3, 4, 4, 1, 4, 2, 1, 4, 4, 2, 1, 3, 1, 3, 4, 7,
       4, 4, 1, 1, 1, 1, 4, 4, 1, 4, 5, 6, 5, 3, 3, 1, 4, 3, 2, 2, 6, 4,
       4, 3, 2, 2, 1, 6, 3, 1, 3, 1, 6, 7, 4, 4, 4, 1, 1, 4, 3, 1, 4, 5,
       4, 3], dtype=int64)

from sklearn.metrics import accuracy_score,f1_score,confusion_matrix,classification_report

print(classification_report(y_test,predict_y))

              precision    recall  f1-score   support

           1       1.00      1.00      1.00       117
           2       0.97      1.00      0.99        36
           3       0.99      0.88      0.93        75
           4       0.92      0.99      0.95       117
           5       1.00      1.00      1.00        43
           6       1.00      0.99      0.99        73
           7       1.00      0.96      0.98        25

    accuracy                           0.98       486
   macro avg       0.98      0.97      0.98       486
weighted avg       0.98      0.98      0.98       486

小结

瓷们，点赞评论收藏走起来呀！！！在这里插入图片描述

您可能感兴趣的与本文相关的镜像

TensorFlow-v2.9

TensorFlow-v2.9

TensorFlow

TensorFlow 是由Google Brain 团队开发的开源机器学习框架,广泛应用于深度学习研究和生产环境。 它提供了一个灵活的平台,用于构建和训练各种机器学习模型

使用LSTM网络实现数据分类预测与仿真分析
DevPhantom的博客
08-06 492
在本文中，我们将使用Matlab实现基于LSTM网络的数据分类预测功能，并进行相应的仿真分析。首先，我们需要准备需要用到的数据集，本文使用UCI Machine Learning Repository提供的Iris数据集。我们需要将这些样本分为训练集和测试集，并对每个特征进行标准化处理，以确保各个特征对结果的影响相等。通过使用Matlab和deep learning toolbox，我们建立了一个包含LSTM层的神经网络模型，并使用Iris数据集进行训练和测试。使用LSTM网络实现数据分类预测与仿真分析。
【37】使用LSTM实现文本分类、图像分类、图像生成任务
Clichong
05-12 1万+
如有错误，恳请指出。 在上一篇文章中，使用了LSTM来预测时序信息，但是在自然语言处理领域中，LSTM可以用来进行文本预测，大体上的思路是将batch个文本，每个文本的seq个词汇编码为hidden dim长度的特征向量，所以最后的特征维度是[seq, batch, hidden dim]，就可以作为输入数据。提取LSTM最后的一个隐藏单元[batch, hidden dim]，再使用一个全连接层就可以实现分类。 而对于图像来说，其信息维度都很熟悉了，[batch, c, h, w]，那么其实也可以是将.
LSTM多类文本分类
04-12
LSTM多类文本分类，keras实现，Multi-Class Text Classification with LSTM，by SusaN Li。
PyTorch文本情感分析：LSTM实现IMDB影评分类
03-12
PyTorch文本情感分析：LSTM实现IMDB影评分类
LSTM模型做分类任务2（PyTorch实现）
最新发布
m0_59777389的博客
11-10 968
默认使用。
基于LSTM进行简单二分类
m0_67458511的博客
05-15 1664
self.rnn = nn.GRU（input_size = embedding维度,hidden_size=RNN维度。self.embedding = nn.Embedding(词库大小, 词向量维度, padding_idx=0)x = {token1:id1} --------- 用于将文本token进行数值转换，传给模型。id_y = {id1:y1} --------- 用于将模型传出的结果转换中午标签。y_id = {y1:id1} --------- 用于将标签转换数值 传给模型。
深度学习——LSTM解决分类问题
热门推荐
Elon15的博客
07-16 3万+
深度学习——LSTM解决分类问题
基于LSTM的中文文本多分类实战（详细注释）
李姆斯的博客
01-30 7105
使用深度学习中的LSTM（Long Short-Term Memory）长短期记忆网络，来尝试一下中文文本多分类,LSTM它是一种时间循环神经网络，适合于处理和预测时间序列中间隔和延迟相对较长的重要事件。 数据集 ChineseNlpCorpus的online_shopping_10_cats 10 个类别，共 6 万多条评论数据，正、负向评论各约 3 万条，包括书籍、平板、手机、水果、洗发水、热...
【LSTM分类】基于长短期记忆网络的数据分类预测附matlab代码
m0_57702748的博客
07-26 1831
基于长短期记忆网络（Long Short-Term Memory, LSTM）的数据分类预测是一种常见的序列数据分析方法。LSTM是一种特殊的循环神经网络（Recurrent Neural Network, RNN），具有记忆单元和门控机制，能够更好地处理序列数据中的长期依赖关系。下面是基于LSTM的数据分类预测的步骤：数据准备：首先，需要准备用于分类预测的训练数据集和测试数据集。序列数据应具有标签，以便进行监督学习。LSTM模型搭建：构建LSTM模型。
LSTM分类模型
huanxingchen1的博客
03-14 1万+
LSTM分类模型 本文主要固定一个文本分类的流程。分为三个部分： 数据处理。对分类文本数据集做简单的预处理。 模型数据准备。处理上一步的结果，得到模型的输入样本。 模型搭建和训练流程。 程序架构如下： 主要包括一个原始的分类文件(头条新闻)。 一个预处理脚本prepare_data.py 一个数据处理脚本data_loader.py 一个训练过程脚本trainer.py 一个模型文件lstm_model.py 分类流程 数据预处理 将原始的文本进行预处理，原始文件形式如下： 处理后文件如下，形式为
Python-利用LSTM进行多标签时间序列分类
08-11
利用LSTM进行多标签时间序列分类
人工智能+LSTM时间序列预测算法+完整代码+实验数据
10-18
人工智能与深度学习领域中的LSTM时间序列预测算法在处理和预测具有时间顺序性的数据方面显示出了巨大的潜力和应用前景。LSTM，全称为长短期记忆网络（Long Short-Term Memory），是循环神经网络（RNN）的一种特殊...
LSTM实现对股票数据进行预测（Keras实现）源代码及数据集
04-09
3、资源内容主要包括：股票数据（20支）.rar，LSTM实现对股票数据进行预测（Keras实现）源代码lstm_model.py（源码以600000.SH股票数据为基准进行分析，以2016年3月1日至2017年12月31日为回测期，进行收益率的预测...
【LSTM回归预测】基于贝叶斯优化长短记忆BO-LSTM实现数据回归预测附Matlab代码.rar
10-28
在当前人工智能和机器学习技术迅猛发展的背景下，对高效的数据处理和预测算法的需求日益增长。LSTM因其优秀的长序列数据处理能力，在自然语言处理、时间序列分析、金融市场预测等多个领域得到了广泛应用。贝叶斯优化...
实践：基于双向LSTM模型完成文本分类任务
m0_70026215的博客
12-27 3560
根据双向LSTM和单向LSTM的对比我们发现，正确率差距不大，但是速度缺相差较大,但理论上说双向LSTM具有比单向LSTM更多的参数，计算量更大，速度很慢，在这里却表现为速度大于单向，所以双向LSTM在有些时候是好于单向LSTM的，并且通过这次实验更能清晰的明白NLP的魅力。
基于长短期记忆网络(LSTM)的数据分类预测
yuchunyu12的博客
09-18 1626
基于长短期记忆网络（LSTM）的数据分类预测是一种常见的机器学习方法。LSTM是一种递归神经网络（RNN）的变体，被广泛用于处理序列数据。
LSTM分类-递归神经网络（Recurrent Neural Network）
落魄君子Blog
12-22 1544
源码LSTM分类（Long Short-Term Memory Classification）是一种基于**长短期记忆网络（Long Short-Term Memory, LSTM）**的分类方法。LSTM是一种特殊的递归神经网络（Recurrent Neural Network, RNN），设计用于处理和预测序列数据中的长期依赖关系。与传统的RNN相比，LSTM通过其独特的门控机制（输入门、遗忘门和输出门）有效地缓解了梯度消失和爆炸问题，能够记忆和遗忘信息，从而在处理长序列数据时表现出色。
实验七 循环神经网络（3）LSTM的记忆能力实验
weixin_51395608的博客
12-01 2267
无
lstm分类预测模型
02-27
### 使用PyTorch构建、训练和应用LSTM分类预测模型 #### 数据准备与预处理 在构建LSTM分类预测模型之前，数据的准备至关重要。通常情况下，输入的数据需要被转换成适合神经网络处理的形式。对于文本或时间序列数据而言，这意味着要将原始数据转化为张量形式，并进行必要的标准化操作[^1]。 ```python import torch from torch.utils.data import DataLoader, TensorDataset # 假设我们有一个简单的二元分类任务 X_train_tensor = torch.tensor(X_train, dtype=torch.float32) y_train_tensor = torch.tensor(y_train, dtype=torch.long) train_dataset = TensorDataset(X_train_tensor, y_train_tensor) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) ``` #### 定义LSTM模型结构 接下来就是定义具体的LSTM架构。这里展示了一个基础版本的单层LSTM用于分类的任务： ```python class LSTMClassifier(torch.nn.Module): def __init__(self, input_dim, hidden_dim, layer_dim, output_dim): super(LSTMClassifier, self).__init__() # 隐藏层数目 self.hidden_dim = hidden_dim # LSTM 层的数量 self.layer_dim = layer_dim # LSTM 的构造函数 self.lstm = torch.nn.LSTM(input_dim, hidden_dim, layer_dim, batch_first=True) # 全连接层 self.fc = torch.nn.Linear(hidden_dim, output_dim) def forward(self, x): h0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).requires_grad_() c0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).requires_grad_() out, (hn, cn) = self.lstm(x, (h0.detach(), c0.detach())) # 取最后一个时刻的状态作为全连接层的输入 out = self.fc(out[:, -1, :]) return out ``` #### 设置损失函数与优化器 选择合适的损失函数和优化算法是成功的关键之一。针对多类别分类问题，交叉熵损失是一个常见的选项；而对于梯度下降法的选择，则取决于具体需求和个人偏好[^4]。 ```python model = LSTMClassifier(input_dim=..., hidden_dim=..., layer_dim=..., output_dim=...) criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.01) ``` #### 开始训练过程 一旦所有的组件都准备好之后就可以进入实际的训练阶段了。下面给出了一段典型的训练循环代码片段： ```python for epoch in range(num_epochs): for i, (inputs, labels) in enumerate(train_loader): outputs = model(inputs) loss = criterion(outputs, labels) optimizer.zero_grad() # 清除之前的梯度 loss.backward() # 后向传播计算新的梯度 optimizer.step() # 更新权重参数 print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}') ``` #### 测试与评估 完成训练后还需要对测试集上的表现做出评价。这一步骤有助于确认所建立起来的模型是否具有良好的泛化能力。 ```python with torch.no_grad(): correct = 0 total = 0 for inputs, labels in test_loader: outputs = model(inputs) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Test Accuracy of the model on the {} test samples: {:.2%}'.format(total, correct / total)) ``` #### 模型保存与加载 最后，在满意于当前的结果时可以选择性地保存下整个模型以便日后重复利用或者部署到生产环境中去[^2]。 ```python torch.save(model.state_dict(), 'lstm_classifier.pth') loaded_model = LSTMClassifier(...) loaded_model.load_state_dict(torch.load('lstm_classifier.pth')) loaded_model.eval() ```
评论 23
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mind_programmonkey

你的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值