双算法融合,预测精准度翻倍!机器学习+深度学习驱动冬小麦生长高度与产量智能预测系统

视频讲解:

https://www.bilibili.com/video/BV1bEktBAEVs/?spm_id_from=333.1387.homepage.video_card.click

页面展示:

引言

研究背景与意义:冬小麦产量预测对农业决策的重要性

现有技术局限性:传统方法在复杂环境下的不足

创新点:多算法融合提升预测精度

相关技术综述

机器学习方法:随机森林、支持向量机在农业预测中的应用

深度学习方法:LSTM、CNN处理时序与空间数据的优势

多算法融合策略:集成学习与模型堆叠的可行性分析

系统架构设计

数据采集层:卫星遥感、气象站与地面传感器的多源数据整合

特征工程模块:关键生长参数(NDVI、土壤湿度等)的提取与优化

算法融合层:基于加权投票或元学习的多模型协同预测机制

输出模块:可视化预测结果与不确定性评估

关键技术实现

数据预处理:缺失值填充与异常值检测的自动化流程

混合模型训练:

  • 随机森林处理结构化特征
  • LSTM捕获生长时序依赖关系
  • 注意力机制强化关键生长期特征
    超参数优化:贝叶斯搜索与交叉验证的结合
实验与验证

数据集描述:黄淮海平原冬小麦主产区的历史数据

评估指标:RMSE、MAE与R²的多维度对比

基线对比:单一模型与融合模型的性能差异分析

田间验证:实际产量与预测结果的误差分布

应用与展望

系统部署:轻量化模型在移动端的集成

扩展方向:

  • 结合无人机实时影像更新预测
  • 迁移学习适应不同小麦品种
    政策建议:智能预测系统在精准农业中的推广路径
结论

总结多算法融合系统的技术优势

强调跨学科合作对农业智能化的推动作用

代码:

复制代码
import pandas as pd
import numpy as np
import warnings
import time
from flask import Flask, render_template, request, redirect, url_for, send_file
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
import xgboost as xgb
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, GRU, Dense, Dropout, Attention, Layer, Input
from tensorflow.keras.models import Model
from tensorflow.keras.layers import MultiHeadAttention, LayerNormalization, GlobalAveragePooling1D

warnings.filterwarnings('ignore')
tf.random.set_seed(42)
np.random.seed(42)

# ================= Flask 初始化 =================
app = Flask(__name__)
app.config['SECRET_KEY'] = 'wheat_prediction_2026'

# ================= 全局变量 =================
global_vars = {
    'df': None, 'wheat_df': None, 'X': None, 'y': None,
    'X_train': None, 'X_test': None, 'y_train': None, 'y_test': None,
    'model': None, 'scaler': None, 'encoder': None, 'y_pred': None,
    'metrics': None, 'model_name': None, 'train_time': None,
    'preprocessor': None, 'model_trained': False
}


# ================= 数据加载 =================
def load_data():
    if global_vars['df'] is None:
        global_vars['df'] = pd.read_csv('wheat_growth_data.csv')
        global_vars['wheat_df'] = global_vars['df'][global_vars['df']['Crop Type'] == 'Wheat'].copy()
        X = global_vars['wheat_df'].drop(['Crop Type', 'Growth Height'], axis=1)
        y = global_vars['wheat_df']['Growth Height']
        global_vars['X'], global_vars['y'] = X, y


load_data()

# ================= 预处理 =================
categorical_features = ['Soil Type', 'Fertilizer Name']
numerical_features = ['Temparature', 'Humidity', 'Moisture', 'Nitrogen', 'Potassium', 'Phosphorous']
preprocessor = ColumnTransformer(
    transformers=[
        ('num', Pipeline([('imputer', SimpleImputer(strategy='median')), ('scaler', StandardScaler())]),
         numerical_features),
        ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_features)
    ])
global_vars['preprocessor'] = preprocessor


# ================= 注意力层 =================
class AttentionLayer(Layer):
    def __init__(self):
        super().__init__()

    def build(self, input_shape):
        self.W = self.add_weight(name='attention_weight', shape=(input_shape[-1], 1), initializer='normal',
                                 trainable=True)
        self.b = self.add_weight(name='attention_bias', shape=(input_shape[1], 1), initializer='zeros', trainable=True)

    def call(self, x):
        e = tf.nn.tanh(tf.matmul(x, self.W) + self.b)
        a = tf.nn.softmax(e, axis=1)
        output = x * a
        return tf.reduce_sum(output, axis=1)


# ================= 深度学习模型构建 =================
def build_model(algo, input_shape):
    if algo == 'lstm':
        model = Sequential([
            LSTM(64, return_sequences=True, input_shape=input_shape), Dropout(0.2),
            LSTM(32), Dropout(0.2), Dense(16, activation='relu'), Dense(1)])
    elif algo == 'gru':
        model = Sequential([
            GRU(64, return_sequences=True, input_shape=input_shape), Dropout(0.2),
            GRU(32), Dropout(0.2), Dense(16, activation='relu'), Dense(1)])
    elif algo == 'attention_lstm':
        inputs = Input(shape=input_shape)
        lstm_out = LSTM(64, return_sequences=True)(inputs)
        attn_out = AttentionLayer()(lstm_out)
        dense1 = Dense(32, activation='relu')(attn_out)
        dropout = Dropout(0.2)(dense1)
        output = Dense(1)(dropout)
        model = Model(inputs=inputs, outputs=output)
    elif algo == 'transformer':
        inputs = Input(shape=input_shape)
        attn = MultiHeadAttention(num_heads=2, key_dim=input_shape[-1])(inputs, inputs)
        norm = LayerNormalization(epsilon=1e-6)(attn + inputs)
        pool = GlobalAveragePooling1D()(norm)
        dense = Dense(32, activation='relu')(pool)
        output = Dense(1)(dense)
        model = Model(inputs=inputs, outputs=output)
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    return model


# ================= 路由 =================
@app.route('/')
def index():
    return render_template('index.html')


@app.route('/data')
def data_page():
    df = global_vars['wheat_df']
    data_table = df.head(10).to_html(classes='table table-striped table-hover', index=False, na_rep='-')
    desc_table = df[numerical_features + ['Growth Height']].describe().to_html(classes='table table-striped',
                                                                               float_format='%.2f')
    temp_data = df['Temparature'].tolist()[:200]
    hum_data = df['Humidity'].tolist()[:200]
    moist_data = df['Moisture'].tolist()[:200]
    n_data = df['Nitrogen'].tolist()[:200]
    height_data = df['Growth Height'].tolist()[:200]
    return render_template('data.html',
                           data_table=data_table, desc_table=desc_table, data_shape=df.shape, wheat_count=len(df),
                           temp_data=temp_data, hum_data=hum_data, moist_data=moist_data, n_data=n_data,
                           height_data=height_data)


@app.route('/feature')
def feature_page():
    df = global_vars['wheat_df']
    corr = df[numerical_features + ['Growth Height']].corr()
    corr_data = []
    features = corr.columns.tolist()
    for i in range(len(features)):
        for j in range(len(features)):
            corr_data.append([i, j, corr.iloc[i, j]])

    X_processed = preprocessor.fit_transform(global_vars['X'])
    rf = RandomForestRegressor(n_estimators=100, random_state=42)
    rf.fit(X_processed, global_vars['y'])
    importance = rf.feature_importances_.tolist()

    try:
        feature_names = preprocessor.get_feature_names_out().tolist()
    except:
        feature_names = numerical_features + ['Soil_Loam', 'Soil_Clay', 'Soil_Sandy', 'Fer_NPK', 'Fer_Urea', 'Fer_DAP']

    temp_height = [[df.iloc[i]['Temparature'], df.iloc[i]['Growth Height']] for i in range(200)]
    n_height = [[df.iloc[i]['Nitrogen'], df.iloc[i]['Growth Height']] for i in range(200)]
    hum_height = [[df.iloc[i]['Humidity'], df.iloc[i]['Growth Height']] for i in range(200)]

    return render_template('feature.html',
                           corr_data=corr_data, features=features, importance=importance, feature_names=feature_names,
                           temp_height=temp_height, n_height=n_height, hum_height=hum_height)


@app.route('/train', methods=['GET', 'POST'])
def train_page():
    if request.method == 'POST':
        algo = request.form['algorithm']
        test_size = float(request.form['test_size'])
        epochs = int(request.form['epochs'])
        batch_size = int(request.form['batch_size'])
        start_time = time.time()

        X = global_vars['X']
        y = global_vars['y']
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
        X_train_processed = preprocessor.fit_transform(X_train)
        X_test_processed = preprocessor.transform(X_test)

        model = None
        model_name = ''
        y_pred = None

        if algo == 'rf':
            model = RandomForestRegressor(n_estimators=100, max_depth=10, random_state=42)
            model.fit(X_train_processed, y_train)
            model_name = '随机森林回归 (RandomForest)'
        elif algo == 'xgboost':
            model = xgb.XGBRegressor(n_estimators=100, max_depth=6, learning_rate=0.1, random_state=42)
            model.fit(X_train_processed, y_train)
            model_name = 'XGBoost 回归'

        if algo in ['lstm', 'gru', 'attention_lstm', 'transformer']:
            X_train_reshaped = X_train_processed.reshape(X_train_processed.shape[0], 1, X_train_processed.shape[1])
            X_test_reshaped = X_test_processed.reshape(X_test_processed.shape[0], 1, X_test_processed.shape[1])
            model = build_model(algo, (1, X_train_processed.shape[1]))
            model.fit(X_train_reshaped, y_train, epochs=epochs, batch_size=batch_size, verbose=0)
            y_pred = model.predict(X_test_reshaped).flatten()
            if algo == 'lstm':
                model_name = '长短期记忆网络 (LSTM)'
            elif algo == 'gru':
                model_name = '门控循环单元 (GRU)'
            elif algo == 'attention_lstm':
                model_name = '注意力机制 LSTM'
            elif algo == 'transformer':
                model_name = 'Transformer 回归模型'
        else:
            y_pred = model.predict(X_test_processed)

        mse = mean_squared_error(y_test, y_pred)
        rmse = np.sqrt(mse)
        mae = mean_absolute_error(y_test, y_pred)
        r2 = r2_score(y_test, y_pred)

        global_vars['X_train'], global_vars['X_test'] = X_train, X_test
        global_vars['y_train'], global_vars['y_test'] = y_train, y_test
        global_vars['model'] = model
        global_vars['y_pred'] = y_pred
        global_vars['metrics'] = {'mse': mse, 'rmse': rmse, 'mae': mae, 'r2': r2}
        global_vars['model_name'] = model_name
        global_vars['train_time'] = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
        global_vars['model_trained'] = True

        return render_template('train.html',
                               training_msg=f'✅ {model_name} 训练完成!耗时:{time.time() - start_time:.2f}秒')
    return render_template('train.html')


@app.route('/result')
def result_page():
    if global_vars['model_trained']:
        return render_template('result.html',
                               model_name=global_vars['model_name'],
                               metrics=global_vars['metrics'],
                               test_count=len(global_vars['y_test']),
                               train_time=global_vars['train_time'],
                               y_test=global_vars['y_test'].tolist(),
                               y_pred=global_vars['y_pred'].tolist(),
                               errors=(global_vars['y_test'] - global_vars['y_pred']).tolist(),
                               residual=[[global_vars['y_pred'][i],
                                          (global_vars['y_test'].tolist()[i] - global_vars['y_pred'][i])] for i in
                                         range(len(global_vars['y_pred']))])
    return render_template('result.html')


@app.route('/predict', methods=['GET', 'POST'])
def predict_page():
    pred_result = None
    if request.method == 'POST' and global_vars['model_trained']:
        data = {
            'Temparature': float(request.form['temp']),
            'Humidity': float(request.form['hum']),
            'Moisture': float(request.form['moist']),
            'Nitrogen': float(request.form['n']),
            'Potassium': float(request.form['k']),
            'Phosphorous': float(request.form['p']),
            'Soil Type': request.form['soil'],
            'Fertilizer Name': request.form['fertilizer']
        }
        df_pred = pd.DataFrame([data])
        df_processed = preprocessor.transform(df_pred)
        if global_vars['model_name'] in ['LSTM', 'GRU', '注意力机制 LSTM', 'Transformer']:
            df_processed = df_processed.reshape(1, 1, -1)
        pred = global_vars['model'].predict(df_processed)[0]
        pred_result = round(float(pred), 2)
    return render_template('predict.html',
                           model_trained=global_vars['model_trained'],
                           pred_result=pred_result)


@app.route('/batch_predict')
def batch_predict():
    if global_vars['model_trained']:
        try:
            df_pred = pd.read_csv('wheat_pred_data.csv')
            df_processed = preprocessor.transform(df_pred)
            if global_vars['model_name'] in ['LSTM', 'GRU', '注意力机制 LSTM', 'Transformer']:
                df_processed = df_processed.reshape(df_processed.shape[0], 1, -1)
            df_pred['Predicted Growth Height'] = global_vars['model'].predict(df_processed).flatten()
            df_pred.to_csv('batch_pred_result.csv', index=False)
            return send_file('batch_pred_result.csv', as_attachment=True)
        except:
            return redirect(url_for('predict_page'))
    return redirect(url_for('train_page'))


@app.route('/export_pred')
def export_pred():
    df = global_vars['wheat_df'].copy()
    df['Predicted Growth Height'] = global_vars['model'].predict(preprocessor.transform(global_vars['X']))
    df.to_csv('wheat_growth_prediction.csv', index=False)
    return send_file('wheat_growth_prediction.csv', as_attachment=True)


@app.route('/conclusion')
def conclusion_page():
    return render_template('conclusion.html')


# ================= 启动 =================
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

完整代码数据:https://download.csdn.net/download/qq_38735017/92568950

相关推荐
chh56320 分钟前
从 BERT 到大模型:让模型从“会接龙”到“会回答
人工智能·深度学习·bert
TomEval38 分钟前
【测AI】第26篇:线上模型监控与告警体系 — 测试不是终点
人工智能·python·功能测试·ai
ZhengEnCi1 小时前
AI 总模仿代码库里的过时写法怎么办:先清坏样例,再用类型与测试让 AI 无法犯错
人工智能·ai编程
一只爱撸猫的程序猿2 小时前
五周、两个开源仓库、九次拦截之后:AI 时代程序员缺的到底是什么
人工智能·后端·开源
GitCode官方2 小时前
开源鸿蒙跨平台直播|AI 时代,用 cj-tauri 开发鸿蒙 PC 应用
人工智能·华为·harmonyos·atomgit
老金带你玩AI3 小时前
GPT-6.2更强更便宜了,为什么还有人骂?
人工智能
CyrusYiVPP3 小时前
实测 uv 0.13.7:同一套包,pip 装 94 秒,它只用 19 秒
人工智能·python
泯泷3 小时前
OpenClaw 退潮背后,是 AI 圈“技术自嗨”的终结
人工智能·chatgpt·llm
罗西的思考3 小时前
【轻量化复刻大模型 / KIMI K3】Muon 优化器及 训练系统
人工智能·算法·机器学习
屿华AI3 小时前
AUTOSAR 实战-诊断工具 | 用 Claude Code 开发诊断测试工具:AI 协作开发实践
人工智能·测试工具