基于 LSTM 与 Django 的学生学习数据分析系统实战

数据预处理与模型构建

在获取原始数据后，我们需要进行清洗和归一化处理。LSTM 对时间步长敏感，因此设置合适的时间窗口至关重要。下面这段代码展示了如何连接数据库、处理缺失值以及构建 LSTM 模型的核心流程。

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

# 获取配置信息
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_config = {
    'host': host,
    'user': user,
    'password': passwd,
    'database': dbName,
    'port': port
}

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月'
        else:
            date_format='%Y-%m-%d'
            
        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 字段为例生成可视化图片
        plt.figure(figsize=(12, 6), dpi=80)
        plt.plot(data.index[:len(train_predict)], train_predict[:, 1-1], label='训练 student 预测', color='blue')
        plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 1-1], label='测试 student 预测', color='red')
        plt.plot(data.index, data['student'], label='实际 student', color='green')
        plt.title('student 预测')
        plt.xlabel('Date')
        plt.ylabel('student')
        plt.legend()
        directory = os.path.join(parent_directory, "templates", "upload", "learningdataforecast", "student_prediction.png")
        os.makedirs(os.path.dirname(directory), exist_ok=True)
        plt.savefig(directory)
        plt.clf()
        plt.close()
        
        # ... (此处省略其他字段的绘图代码，逻辑类似)
        
        # 准备未来 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)

后端接口说明

除了核心的预测逻辑外，系统还包含标准的用户认证、权限管理及数据 CRUD 接口。这些模块保证了系统的安全性与可维护性，例如登录验证、密码重置及批量导入 Excel 等功能均在此框架下实现。

系统测试与结论

软件测试环节重点验证了用户端与管理端的交互逻辑。通过覆盖所有功能点的用例分析，确保系统在数据监控、权限分配及预测准确性上达到预期目标。

从系统构建来看，借助 Python 语言的灵活性与丰富库资源，结合 Django 框架高效搭建 Web 架构，利用 MySQL 数据库实现数据的有序存储与管理。LSTM 算法在挖掘学生学习时间序列数据规律、预测期末成绩等方面发挥关键作用，Echarts 则让数据以直观可视化形式呈现。这些技术的有机融合，赋予了系统强大的功能，能有效帮助教师更精准地了解学生的学习状态，从而制定更具针对性的教学方案，提高教学质量。