LSTM 学生成绩预测系统的实现与界面整理

核心实现

这部分的关键点是把学习过程整理成时间序列，再交给 LSTM 去学习。LSTM 是 RNN 的一种变体，适合处理有前后关联的数据，像学习习惯这种慢慢累积的特征，比普通的静态分类模型更顺手。

视图层里把数据清洗、编码、归一化、训练、预测和结果落库都串在了一起。接口逻辑如下。

#coding:utf-8
import os
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from django.http import JsonResponse
from sklearn.preprocessing import MinMaxScaler, LabelEncoder
from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout
import matplotlib.pyplot as plt
import pymysql

# 获取当前文件路径的根目录
parent_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
dbtype, host, port, user, passwd, dbName, charset, hasHadoop = config_read(os.path.join(parent_directory, "config.ini"))

# MySQL 连接配置
mysql_config = {
    'host': host,
    'user': user,
    'password': passwd,
    'database': dbName,
    'port': port
}

def auto_figsize(x_data, base_width=8, base_height=6, width_per_point=0.2):
    """根据数据点数量自动调整画布宽度"""
    num_points = len(x_data)
    dynamic_width = base_width + width_per_point * num_points
    return (dynamic_width, base_height)

def create_dataset(data, time_step=1):
    """定义函数创建时间序列数据集"""
    X, Y = [], []
    for i in range(len(data) - time_step - 1):
        a = data[i:(i + time_step), :]
        X.append(a)
        Y.append(data[i + time_step, :])
    return np.array(X), np.array(Y)

def learningdataforecast_forecast(request):
    if request.method in ["POST", "GET"]:
        msg = {'code': normal_code, "msg": mes.normal_code}
        # 1. 获取数据集
        connection = pymysql.connect(**mysql_config)
        query = "SELECT date, student, subject, regulargrade, midtermresults, learningattitude, finalgrade FROM learningdata ORDER BY date ASC"
        
        # 2. 处理缺失值与日期格式
        data = pd.read_sql(query, connection).dropna()
        date_format = data['date'].iloc[0]
        if isinstance(date_format, (datetime.date, datetime.datetime)):
            pass
        elif "年" in date_format and "月" in date_format and "日" in date_format:
            date_format = '%Y年%m月%d日'
        elif "年" in date_format and "月" in date_format:
            date_format = '%Y年%m月'
        elif "年" in date_format:
            date_format = '%Y年'
        else:
            if date_format == "" or date_format is None:
                data['date'] = pd.to_datetime(data['date'])
            else:
                data['date'] = pd.to_datetime(data['date'], format=date_format)
        
        data.set_index('date', inplace=True)
        
        # 编码处理类别特征
        student_encoder = LabelEncoder()
        data['student'] = student_encoder.fit_transform(data['student'])
        subject_encoder = LabelEncoder()
        data['subject'] = subject_encoder.fit_transform(data['subject'])
        learningattitude_encoder = LabelEncoder()
        data['learningattitude'] = learningattitude_encoder.fit_transform(data['learningattitude'])
        
        # 只选择需要的列
        data = data[['student', 'subject', 'regulargrade', 'midtermresults', 'learningattitude', 'finalgrade']]
        
        # 归一化处理（为了 LSTM 的训练）
        scaler = MinMaxScaler(feature_range=(0, 1))
        scaled_data = scaler.fit_transform(data)
        
        # 设置时间步长
        time_step = int(len(data)/10)
        if time_step > 30: time_step = 30
        if time_step <= 0: time_step = 1
        
        X, y = create_dataset(scaled_data, time_step)
        
        # 划分训练集和测试集
        train_size = int(len(X) * 0.8)
        X_train, X_test = X[:train_size], X[train_size:]
        y_train, y_test = y[:train_size], y[train_size:]
        
        print(f'X_train shape: {X_train.shape}, y_train shape: {y_train.shape}')
        
        # 创建 LSTM 模型
        model = Sequential()
        model.add(LSTM(50, return_sequences=True, input_shape=(X_train.shape[1], X_train.shape[2])))
        model.add(Dropout(0.2))  # 防止过拟合
        model.add(LSTM(50, return_sequences=False))
        model.add(Dropout(0.2))
        model.add(Dense(len(data.columns), activation='relu'))
        
        # 编译模型
        model.compile(optimizer='adam', loss='mean_squared_error')
        
        # 训练模型
        model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1)
        
        # 进行预测
        train_predict = model.predict(X_train)
        test_predict = model.predict(X_test)
        
        # 将预测结果反归一化
        train_predict = scaler.inverse_transform(train_predict)
        test_predict = scaler.inverse_transform(test_predict)
        
        # 绘制预测结果
        plt.rcParams['font.sans-serif'] = ['SimHei']
        plt.rcParams['axes.unicode_minus'] = False
        
        # 此处省略部分绘图代码以保持篇幅，实际逻辑包含多个子图生成
        # ... (保存 student_prediction.png, subject_prediction.png 等)
        
        # 准备未来 3 个月的输入数据
        last_data_days = scaled_data[-time_step:]
        future_predictions = []
        for _ in range(3):
            last_data_days = last_data_days.reshape((1, time_step, len(data.columns)))
            prediction = model.predict(last_data_days)
            future_predictions.append(prediction[0])
            last_data_days = np.append(last_data_days[:, 1:, :], [prediction], axis=1)
        
        future_predictions = scaler.inverse_transform(future_predictions)
        
        # 生成 DataFrame 并写入数据库
        last_date = data.index[-1]
        future_dates = [last_date + timedelta(days=31*i) for i in range(1, 3+1)]
        df = pd.DataFrame(columns=['date', 'student', 'subject', 'regulargrade', 'midtermresults', 'learningattitude', 'finalgrade'])
        df['date'] = [str(date.year)+"-"+str(date.month) for date in future_dates]
        df['student'] = future_predictions[:, 1-1]
        df['subject'] = future_predictions[:, 2-1]
        df['regulargrade'] = future_predictions[:, 3-1]
        df['midtermresults'] = future_predictions[:, 4-1]
        df['learningattitude'] = future_predictions[:, 5-1]
        df['finalgrade'] = future_predictions[:, 6-1]
        
        # 解码回原始标签
        df['student'] = student_encoder.inverse_transform(df['student'].astype(int))
        df['subject'] = subject_encoder.inverse_transform(df['subject'].astype(int))
        df['learningattitude'] = learningattitude_encoder.inverse_transform(df['learningattitude'].astype(int))
        
        # 插入数据库
        connection_string = f"mysql+pymysql://{mysql_config['user']}:{mysql_config['password']}@{mysql_config['host']}:{mysql_config['port']}/{mysql_config['database']}"
        engine = create_engine(connection_string)
        try:
            df.to_sql('learningdataforecast', con=engine, if_exists='append', index=False)
            print("数据更新成功！")
        except Exception as e:
            print(f"发生错误：{e}")
        finally:
            engine.dispose()
            
        return JsonResponse(msg, encoder=CustomJsonEncoder)

这段代码里最实用的部分其实不是 LSTM 本身，而是前面的数据整理。日期格式不统一、类别字段要编码、数值要归一化，这些都处理不好，模型再复杂也跑不稳。后面做未来 3 个月预测时，采用的是递推方式，思路直接，但误差会逐步累积，这个代价在时序预测里绕不过去。

小结

这套系统把学习数据分析和成绩预测做成了一个能落地的 Web 应用：前端负责展示，Django 负责业务流程，LSTM 负责时间序列预测，MySQL 负责数据沉淀。它适合做教学辅助和趋势观察，但结果更像参考值，不该被当成绝对结论。对学校场景来说，这种系统的价值在于帮教师更快看见问题，而不是替教师做判断。