蒸汽预测赛题——模型验证

最新推荐文章于 2022-03-15 18:52:45 发布
最新推荐文章于 2022-03-15 18:52:45 发布
阅读量257 收藏 1
点赞数
分类专栏： 天池大赛 - 蒸汽预测赛题 面试 文章标签： python 机器学习 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30031221/article/details/110354391
版权

蒸汽预测赛题——模型验证

天池大赛比赛地址：链接

理论知识

  • 欠拟合 高偏差

    • 增加额外特征
    • 增加多项式特征
    • 降低惩罚

  • 过拟合 高方差

    • 收集更多数据
    • 使用更少的特征
    • 增加惩罚

  • 泛化：机器学习模型学习到的概念在处理未遇到过的样本时的表现

  • 正则化：防止过拟合

    • L1正则化 Lasso
      • 向量元素绝对值之和
      • 迫使那些弱的特征所对应的系数变成0，往往会使学到的模型很稀疏
    • L2正则化 Ridge 岭回归
      • 欧几里得范数 向量元素绝对值平方和再开方
      • 拟合的始终是条曲线

  • 回归模型的评估方法

    • 指标描述方法
      Mean Absolute Error(MAE)平均绝对值误差from sklearn.metrics import mean_absolue_error
      Mean Square Error(MSE)均方误差mean_square_error
      Root Mean Square Error(RMSE)均方根误差mean_square_error sort
      R-SquaredR平均值 = 1-(真实-预测的平方)/（真实-均值的平方)r2_score

  • 交叉验证

    • 简单交叉验证 通常划分30%的数据作为测试集

    • K折交叉验证 KFold

      • 原始数据划分K组 每个子集数据分别做一次验证集 剩余K-1次作为训练集 最后取平均

      • from sklearn.model_selection import KFold
kf = KFold(n_splits=10)
for train,test in kf.split(data):

    • 留一法交叉验证 LeaveOneOut

      • 训练集由除一个样本之外的其余样本组成，剩下一个样本组成验证集

      • from sklearn.model_selection import LeaveOneOut
loo = LeaveOneOut()

    • 留P法交叉验证 LeavePOut

      • 从完整的数据集中删除p个样本，产生训练集和验证集

      • from sklearn.model_selection import LeavePOut
lpo = LeavePOut(p=5)

    • 基于类标签，具有分层的交叉验证

      • 解决样本不平衡的问题
      • 确保相应的类别频率在每个训练和验证的折叠中保留
      • StratifiedKFold：K-Fold变种 返回的是index 返每个小集合中 各个类别的样例比例大致和完整数据中相同
      • StratifiedShuffleSplit：ShuffleSplit变种 返回的直接是值 划分中每个类的比例和完整中的相同

    • 用于分组数据的交叉验证

      • 留出一组特定的不属于测试集和训练集的数据
      • GroupKFold、LeaveOneOut、LeavePOut、GroupShuffleSplit

    • 时间序列分割 TimeSeriesSplit

      • 有关时间序列的样本，必须保证时间上的顺序性
      • 不能用未来的数据去检验现在的数据正确性

  • 模型调参

    • 整体模型的偏差和方差的大和谐
    • 过程影响类参数
      • 子模型数 n_estimators
      • 学习率 learning_rate
    • 子模型影响类参数
      • 最大数深度 max_depth
      • 分裂条件 criterion
    • bagging 降低方差
    • boosting 降低偏差
    • RandomForest
      • criterion、n_estimators、max_leaf_nodes、ma x_depth、min_samples_split、min_samples_leaf、min_weight_fraction_leaf
    • GradientTree
      • learning_rate、n_estimators、max_leaf_nodes、ma x_depth、min_samples_split、min_samples_leaf、min_weight_fraction_leaf、max_features、subsample
    • 网格搜索 穷举

1. 导包

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats

from sklearn.preprocessing import MinMaxScaler
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split

from sklearn.linear_model import SGDRegressor
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import SVR
import lightgbm as lgb

from sklearn.metrics import mean_squared_error

2. 加载数据

train_data_file = "../datasets/zhengqi_train.txt"
test_data_file = "../datasets/zhengqi_test.txt"

train_data = pd.read_csv(train_data_file, sep='\t', encoding='utf-8')
test_data = pd.read_csv(test_data_file, sep='\t', encoding='utf-8')

feature_columns = [col for col in train_data if col not in ['target']]

min_max_scaler = MinMaxScaler().fit(train_data[feature_columns])
train_data_scaler = min_max_scaler.transform(train_data[feature_columns])
test_data_scaler = min_max_scaler.transform(test_data[feature_columns])
train_data_scaler = pd.DataFrame(train_data_scaler,columns=feature_columns)
train_data_scaler['target'] = train_data['target']
test_data_scaler = pd.DataFrame(test_data_scaler,columns=feature_columns)

pca = PCA(n_components=16)
new_train_pca_16 = pca.fit_transform(train_data_scaler.iloc[:,:-1])
new_train_pca_16 = pd.DataFrame(new_train_pca_16)
new_train_pca_16['target'] = train_data_scaler['target']
new_test_pca_16 = pca.transform(test_data_scaler)
new_test_pca_16 = pd.DataFrame(new_test_pca_16)

train= new_train_pca_16.fillna(0)[new_test_pca_16.columns]
target = new_train_pca_16['target']

train_data,test_data,train_target,test_target = train_test_split(train,target,test_size=0.2,random_state=0)

3. 拟合数据

# 欠拟合 max_iter最大迭代次数 tol迭代到loss变化小于这个值时停止
clf = SGDRegressor(max_iter=500,tol=1e-2)
clf.fit(train_data,train_target)
print("SGDRegressor train MSE: ",mean_squared_error(train_target,clf.predict(train_data)))
print("SGDRegressor test MSE: ",mean_squared_error(test_target,clf.predict(test_data)))
# SGDRegressor train MSE:  0.1518963746787445
# SGDRegressor test MSE:  0.15617004077751775

# 过拟合
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(5)
train_data_poly = poly.fit_transform(train_data)
test_data_poly = poly.transform(test_data)
clf = SGDRegressor(max_iter=1000,tol=1e-3)
clf.fit(train_data_poly,train_target)
print("SGDRegressor train MSE: ",mean_squared_error(train_target,clf.predict(train_data_poly)))
print("SGDRegressor test MSE: ",mean_squared_error(test_target,clf.predict(test_data_poly)))
# SGDRegressor train MSE:  0.13239797454332378
# SGDRegressor test MSE:  0.14471496796078484

# 正常拟合
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(3)
train_data_poly = poly.fit_transform(train_data)
test_data_poly = poly.transform(test_data)
clf = SGDRegressor(max_iter=1000,tol=1e-3)
clf.fit(train_data_poly,train_target)
print("SGDRegressor train MSE: ",mean_squared_error(train_target,clf.predict(train_data_poly)))
print("SGDRegressor test MSE: ",mean_squared_error(test_target,clf.predict(test_data_poly)))
# SGDRegressor train MSE:  0.1339474648768595
# SGDRegressor test MSE:  0.14245462035372333

# 联合正则化
poly = PolynomialFeatures(3)
train_data_poly = poly.fit_transform(train_data)
test_data_poly = poly.transform(test_data)
#elasticNet 联合l1 和l2 范数加权正则化 l1_ratio 表示占多少
clf = SGDRegressor(max_iter=1000,tol=1e-3,penalty='elasticNet',l1_ratio=0.9,alpha=0.001)
clf.fit(train_data_poly,train_target)
print("SGDRegressor train MSE: ",mean_squared_erroror(train_target,clf.predict(train_data_poly)))
print("SGDRegressor test MSE: ",mean_squared_error(test_target,clf.predict(test_data_poly)))
# SGDRegressor train MSE:  0.1415386321846727
# SGDRegressor test MSE:  0.1480928293310648

4. 交叉验证 K折KFold、留一法LeaveOneOut、留P法LeavePOut

# from sklearn.model_selection import LeaveOneOut
# loo = LeaveOneOut()
# from sklearn.model_selection import LeavePOut
# lpo = LeavePOut(p=10)
from sklearn.model_selection import KFold
kf = KFold(n_splits=5)
for k,(train_index,test_index) in enumerate(kf.split(train)):
    train_data,test_data,train_target,test_target = train.values[train_index],train.values[test_index],\
    target.values[train_index],target.values[test_index]
    clf = SGDRegressor(max_iter=1000,tol=1e-3)
    clf.fit(train_data,train_target)
    print(k,"折 ","SGDRegressor train MSE: ",mean_squared_error(train_target,clf.predict(train_data)))
    print(k,"折 ","SGDRegressor test MSE: ",mean_squared_error(test_target,clf.predict(test_data)))
    
'''
注意KFold返回的是index
0 折  SGDRegressor train MSE:  0.15000344819294997
0 折  SGDRegressor test MSE:  0.10575417172621228
1 折  SGDRegressor train MSE:  0.13355864901674058
1 折  SGDRegressor test MSE:  0.18233565251295702
2 折  SGDRegressor train MSE:  0.1465085643709417
2 折  SGDRegressor test MSE:  0.13286058060702355
3 折  SGDRegressor train MSE:  0.14066988317392046
3 折  SGDRegressor test MSE:  0.1618205154729875
4 折  SGDRegressor train MSE:  0.13813813503634081
4 折  SGDRegressor test MSE:  0.16437792249692298
'''

5. 模型超参空间搜索 GridSearchCV

from sklearn.model_selection import GridSearchCV
randomForestRegressor = RandomForestRegressor()
# 构建字典 超参空间
parameters = {'n_estimators':[100,200],'max_depth':[5,10]}
clf = GridSearchCV(randomForestRegressor,param_grid=parameters,cv=3)
clf.fit(train_data,train_target)

print("SGDRegressor train MSE: ",mean_squared_error(train_target,clf.predict(train_data)))
print("SGDRegressor test MSE: ",mean_squared_error(test_target,clf.predict(test_data)))
# cv_results_中有训练时间和验证指标的信息
print(sorted(clf.cv_results_))
print(clf.best_params_)

'''
SGDRegressor train MSE:  0.03937490165306472
SGDRegressor test MSE:  0.15825533758727703
['mean_fit_time', 'mean_score_time', 'mean_test_score', 'param_max_depth', 'param_n_estimators', 'params', 'rank_test_score', 'split0_test_score', 'split1_test_score', 'split2_test_score', 'std_fit_time', 'std_score_time', 'std_test_score']
{'max_depth': 10, 'n_estimators': 200}
'''

 #随机参数优化
 train_data,test_data,train_target,test_target = train_test_split(train,target,test_size=0.2,random_state=0)

from sklearn.model_selection import RandomizedSearchCV
randomForestRegressor = RandomForestRegressor()
parameters = {'n_estimators':[50,100,150,200],'max_depth':[3,5,10,15]}
clf = RandomizedSearchCV(randomForestRegressor,param_distributions=parameters,cv=3)
clf.fit(train_data,train_target)
print("SGDRegressor train MSE: ",mean_squared_error(train_target,clf.predict(train_data)))
print("SGDRegressor test MSE: ",mean_squared_error(test_target,clf.predict(test_data)))
print(sorted(clf.cv_results_))
print(clf.best_params_)

'''
SGDRegressor train MSE:  0.022121433444846298
SGDRegressor test MSE:  0.15637853039323252
['mean_fit_time', 'mean_score_time', 'mean_test_score', 'param_max_depth', 'param_n_estimators', 'params', 'rank_test_score', 'split0_test_score', 'split1_test_score', 'split2_test_score', 'std_fit_time', 'std_score_time', 'std_test_score']
{'n_estimators': 200, 'max_depth': 15}
'''

6. LGB模型5折交叉验证

train_data_file = "../datasets/zhengqi_train.txt"
test_data_file = "../datasets/zhengqi_test.txt"

train_data2 = pd.read_csv(train_data_file, sep='\t', encoding='utf-8')
test_data2 = pd.read_csv(test_data_file, sep='\t', encoding='utf-8')

train_data2_d = train_data2[test_data2.columns].values
train_data2_t = train_data2['target'].values

from sklearn.model_selection import KFold
import lightgbm as lgb
import numpy as np

kf = KFold(n_splits=5,shuffle=True,random_state=2020)
MSE_DICT={'train_mse':[],'test_mse':[]}

for k,(train_index,test_index) in enumerate(kf.split(train_data2_d)):
    lgb_reg = lgb.LGBMRegressor(
        learning_rate=0.01,
        max_depth=-1,
        n_estimators=5000,
        boosting_type='gbdt',
        random_state=2020,
        objective='regression',
    )
    X_train_KFold,X_test_KFold = train_data2_d[train_index],train_data2_d[test_index]
    Y_train_KFold,Y_test_KFold = train_data2_t[train_index],train_data2_t[test_index]
    
    lgb_reg.fit(X=X_train_KFold,
                y=Y_train_KFold,
                eval_set=[(X_train_KFold,Y_train_KFold),(X_test_KFold,Y_test_KFold)],
                eval_names=['train','test'],
                early_stopping_rounds=100,
                eval_metric='MSE',
                verbose = 50
    )
    y_train_KFold_predict = lgb_reg.predict(X_train_KFold,num_iteration=lgb_reg.best_iteration_)
    y_test_KFold_predict = lgb_reg.predict(X_test_KFold,num_iteration=lgb_reg.best_iteration_)
    
    train_mse = mean_squared_error(y_train_KFold_predict, Y_train_KFold)
    test_mse = mean_squared_error(y_test_KFold_predict, Y_test_KFold)
    MSE_DICT['train_mse'].append(train_mse)
    MSE_DICT['test_mse'].append(test_mse)
    print('第{}折 训练和预测 训练MSE 预测MSE'.format(k + 1))
    print('------\n', '训练MSE\n', train_mse, '\n------')
    print('------\n', '预测MSE\n', test_mse, '\n------\n')

print('------\n', '训练MSE\n', MSE_DICT['train_mse'], '\n',np.mean(MSE_DICT['train_mse']), '\n------')
print('------\n', '预测MSE\n', MSE_DICT['test_mse'], '\n',np.mean(MSE_DICT['test_mse']), '\n------')

'''
Training until validation scores don't improve for 100 rounds
[50]	train's l2: 0.425465	test's l2: 0.496533
[100]	train's l2: 0.220271	test's l2: 0.283883
[150]	train's l2: 0.134273	test's l2: 0.19732
[200]	train's l2: 0.0949213	test's l2: 0.158257
[250]	train's l2: 0.0741039	test's l2: 0.13845
[300]	train's l2: 0.0617553	test's l2: 0.127983
[350]	train's l2: 0.052972	test's l2: 0.122248
[400]	train's l2: 0.0463628	test's l2: 0.118739
[450]	train's l2: 0.0408907	test's l2: 0.116877
[500]	train's l2: 0.036397	test's l2: 0.115797
[550]	train's l2: 0.0326647	test's l2: 0.115223
[600]	train's l2: 0.0293509	test's l2: 0.114269
[650]	train's l2: 0.0265367	test's l2: 0.113535
[700]	train's l2: 0.0241231	test's l2: 0.112868
[750]	train's l2: 0.0219745	test's l2: 0.112329
[800]	train's l2: 0.0200866	test's l2: 0.111965
[850]	train's l2: 0.0184577	test's l2: 0.111526
[900]	train's l2: 0.0169686	test's l2: 0.111169
[950]	train's l2: 0.0156194	test's l2: 0.110916
[1000]	train's l2: 0.014383	test's l2: 0.1108
[1050]	train's l2: 0.0132859	test's l2: 0.110887
[1100]	train's l2: 0.0122815	test's l2: 0.110883
Early stopping, best iteration is:
[1002]	train's l2: 0.0143354	test's l2: 0.110787
第1折 训练和预测 训练MSE 预测MSE
------
 训练MSE
 0.014335406865061465 
------
------
 预测MSE
 0.11078669083212028 
 
 ....
 
 训练MSE
 [0.014335406865061465, 0.00038001724874838936, 0.0066264997159705035, 0.002476702516409125, 0.006477785687227073] 
 0.006059282406683311 
------
------
 预测MSE
 [0.11078669083212028, 0.11085583591285612, 0.11445116914718123, 0.09379035773727774, 0.11315095015348814] 
 0.10860700075658469 
------
------
'''

7. 学习曲线 learning_curve

  • learning_curvce 可参考网址
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import ShuffleSplit
from sklearn.linear_model import SGDRegressor
from sklearn.model_selection import learning_curve
plt.rcParams.update({# Use mathtext, not LaTeX
                    'text.usetex': False,
                    # Use the Computer modern font
                    'font.family': 'serif',
                    'font.serif': 'cmr10',
                    'mathtext.fontset': 'cm',
})


def plot_learning_curve(estimator,title,X,y,ylim=None,cv=None,n_jobs=1,train_sizes=np.linspace(.1, 1.0, 7)):
    plt.figure(figsize=(9, 5), dpi=250)
    plt.figure()
    plt.title(title)
    if ylim is not None:
        plt.ylim(*ylim)
    plt.xlabel("Training examples")
    plt.ylabel("Score")
    
    train_sizes, train_scores, test_scores = learning_curve(
        estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
    
    train_scores_mean = np.mean(train_scores, axis=1)
    train_scores_std = np.std(train_scores, axis=1)
    test_scores_mean = np.mean(test_scores, axis=1)
    test_scores_std = np.std(test_scores, axis=1)
    plt.grid()

    plt.fill_between(train_sizes,
                     train_scores_mean - train_scores_std,
                     train_scores_mean + train_scores_std,
                     alpha=0.1,
                     color="r")
    plt.fill_between(train_sizes,
                     test_scores_mean - test_scores_std,
                     test_scores_mean + test_scores_std,
                     alpha=0.1,
                     color="g")
    plt.plot(train_sizes,
             train_scores_mean,
             'o-',
             color="r",
             label="Training score")
    plt.plot(train_sizes,
             test_scores_mean,
             'o-',
             color="g",
             label="Cross-validation score")

    plt.legend(loc="best")
    return plt

train_data_file = "../datasets/zhengqi_train.txt"
test_data_file = "../datasets/zhengqi_test.txt"

train_data2 = pd.read_csv(train_data_file, sep='\t', encoding='utf-8')
test_data2 = pd.read_csv(test_data_file, sep='\t', encoding='utf-8')

X = train_data2[test_data2.columns].values
Y = train_data2['target'].values

title = "LinearRegression"
cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=2020)
estimator = SGDRegressor()
plot_learning_curve(estimator, title, X, Y, ylim=(0.7, 1.01), cv=cv, n_jobs=-1)

在这里插入图片描述

8. 验证曲线 validation_curve

  • 可以用图的形式找最佳超参数
  • validation_curve 可参考网址
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import SGDRegressor
from sklearn.model_selection import validation_curve
plt.rcParams.update({# Use mathtext, not LaTeX
                     'text.usetex': False,
                     # Use the Computer modern font
                     'font.family': 'serif',
                     'font.serif': 'cmr10',
                      'mathtext.fontset': 'cm',
})

train_data_file = "../datasets/zhengqi_train.txt"
test_data_file = "../datasets/zhengqi_test.txt"

train_data2 = pd.read_csv(train_data_file, sep='\t', encoding='utf-8')
test_data2 = pd.read_csv(test_data_file, sep='\t', encoding='utf-8')

X = train_data2[test_data2.columns].values
Y = train_data2['target'].values

# 这里判断选多少惩罚系数合理 
param_range = [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001]
# validation_curve 可参考 https://blog.csdn.net/lvchunyang66/article/details/104411659
train_scores, test_scores = validation_curve(
             SGDRegressor(max_iter=1000,tol=1e-3,penalty='L1'),X,Y,
             param_name="alpha",
             param_range=param_range,
             cv=10,scoring='r2',n_jobs=1)

train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)

plt.figure(figsize=(9, 5), dpi=150)
plt.title("Validation Curve with SGDRegressor")
plt.xlabel("alpha")
plt.ylabel("Score")
plt.ylim(0.0, 1.1)

# 绘制轴半对数刻度曲线 semilogx
plt.semilogx(param_range, train_scores_mean, label="Training score", color="r")
plt.fill_between(param_range,
            train_scores_mean - train_scores_std,
            train_scores_mean + train_scores_std,
            alpha=0.2,
            color="r")
plt.semilogx(param_range,test_scores_mean,label="Cross-validation score",color="g")
plt.fill_between(param_range,
            test_scores_mean - test_scores_std,
            test_scores_mean + test_scores_std,
            alpha=0.2,
            color="g")

plt.legend(loc="best")
plt.show()

在这里插入图片描述

jialun0116
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
天池工业蒸汽量预测-模型验证
L1142456160的博客
10-18 770
本文改编自《阿里云天池大赛赛题解析-机器学习篇》工业蒸汽量预测的模型验证。进行了部分素材的替换和知识点的归纳总结。新增了周志华-《机器学习》中的模型评估，以及Datawhale8月集成学习中的偏差与方差的均衡。新增了Lasso和岭回归的调用方法
蒸汽预测赛题——模型训练
cjl的博客
11-20 276
蒸汽预测赛题——模型训练理论知识1. 导入相关库2. 导入数据3. 切分数据4. 多元线性回归 LinearRegression5. K近邻回归 KNeighborsRegressor6. 随机森林回归 RandomForestRegressor7. LGB模型回归 lightgbm 天池大赛比赛地址：链接 理论知识 回归用在目标数量连续时预测 线性回归模型 LinearRegression 假定因变量Y和自变量X呈线性相关 可以用Y=AX+b X是权重 from sklearn.metr
李航机器学习 | (3) 统计学习方法(第2版)笔记 --- 感知机习题与编程作业
sdu_hao的博客
11-06 2208
1. Minsky与Papert指出：感知机是线性模型，所以不能表示复杂的函数，如异或(XOR).验证感知机为什么不能表示异或。 首先写出异或函数对应的输入输出： y 1 1 -1 1 -1 +1 -1 1 +1 -1 -1 -1 我们可以可视化上述实例及其标签： import numpy as np...
1、sklearn中Polynomialfeatures的用法最直观说明
hushenming3的博客
05-29 4万+
使用sklearn.preprocessing.PolynomialFeatures来进行特征的构造。它是使用多项式的方法来进行的，如果有a，b两个特征，那么它的2次多项式为（1,a,b,a^2,ab, b^2），这个多项式的形式是使用poly的效果。PolynomialFeatures有三个参数degree：控制多项式的度interaction_only： 默认为False，如果指定为True，...
开源机器学习工具scikit-learn入门
xuanyuansen的专栏
01-14 5万+
开源机器学习工具scikit-learn入门。
阿里云天池大赛赛题解析中“工业蒸汽量预测”数据。
02-20
在此次“工业蒸汽量预测”赛题中，参赛者需要运用机器学习技术对工业生产的蒸汽使用量进行预测，这对于优化能源管理、提升生产效率具有重要意义。 1. **数据来源与版权**： 这份数据集源自阿里云天池大赛的“学习...
工业蒸汽预测——机器学习jupyter notebook笔记本
07-19
【标题】：“工业蒸汽预测——机器学习jupyter notebook笔记本” 在这个项目中，我们将探讨如何运用机器学习技术来预测工业蒸汽的生产过程。Jupyter Notebook是一个交互式计算环境，它允许我们编写、运行代码并直接...
赛题 工业蒸汽量预测.zip
01-17
经脱敏后的锅炉传感器采集的数据（采集频率是分钟级别），根据锅炉的工况，预测产生的蒸汽量(回归模型)。 **数据说明** 数据分成训练数据（train.txt）和测试数据（test.txt），其中字段”V0”-“V37”，这38个...
工业蒸汽预测-数据集
03-19
这样的数据集通常包含工厂的历史数据，用于训练机器学习模型以预测未来的蒸汽产量，帮助优化能源管理、降低成本并提高效率。 描述中的 "预测工业量" 提到的核心任务是预测，具体来说是预测工业蒸汽的产生量。提到的...
工业蒸汽量预测的模型融合
07-10
工业蒸汽量预测的模型融合
【生信】“随机森林”在生物信息学方面的应用
小哲的博客
12-07 3202
“随机森林”在生物信息学方面的应用 简介 随机森林是一种基于决策树的机器学习算法，可以用于样本分类或回归任务，属于非线性分类器。因此它可以挖掘变量之间复杂的非线性的相互依赖关系。通过随机森林分析，可以找出区分两组样本间差异的关键成分。 基础知识 1. 集成学习（ensemble learning） 通过建立多个模型组合来解决单一预测问题。工作原理是生成多个学习器模型，各自独立地学习和做出...
[机器学习与scikit-learn-21]：算法-逻辑回归-多项式非线性回归PolynomialFeatures与代码实现
文火冰糖（王文兵）的博客
03-15 2321
作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客 本文网址： 目录 第1章 scikit-learn对逻辑回归的支持 第2章 PolynomialFeatures类参数详解 2.1 PolynomialFeatures这个类有 3 个参数： 2.2 代码演示 第3章 回归代码实现案例 第1章 scikit-learn对逻辑回归的支持 scikit-learn只提供了对线性逻辑回归模型，对于非线性分布的样本，可以通过PolynomialFea..
sklearn.svm.SVC 参数说明
热门推荐
学习、思考、总结
08-27 11万+
经常用到sklearn中的SVC函数，这里把文档中的参数翻译了一些，以备不时之需。 本身这个函数也是基于libsvm实现的，所以在参数设置上有很多相似的地方。（PS: libsvm中的二次规划问题的解决算法是SMO）。 sklearn.svm.SVC(C=1.0, kernel='rbf', degree=3, gamma='auto', coef0=0.0, shrinking=True
算法：感知机及python实现
rosefun96的博客
03-15 8690
1.简介 感知机(perceptron)，一种构建超平面进行二分类的模型，也是神经网络和支持向量机的基础。构建误分类点到超平面的距离和的损失函数，通过随机梯度下降法进行优化，即可以得到感知机模型。 2.模型 感知机模型为一超平面： f(x)=sign(wx+b) f(x) = sign(wx + b) f(x)=sign(wx+b) 其中，x∈Rn,w∈Rn,b∈Rx\in R^n, w \in ...
编码格式处理、文件或dataFrame的操作
静心净气的博客
11-24 1万+
目录： 编码格式处理 普通的csv文件处理 dataFrame的读写函数 dataFrame处理单位：单元格（慢速、细致） dataFrame处理单位：整行、整列 dataFrame处理单位：整表 Series格式 一、编码格式处理 1、头文件写 #coding=utf-8，你才能写中文注释。 2、xls 等格式，虽然能用一下方式打开，但尽量转了csv再打开。 neg_da...
计算总分和平均分python_评估scikitlearn GridSearchCV中交叉验证分数的平均值和标准偏差...
weixin_39598069的博客
12-22 738
我正在使用python2.7和scikit来学习一些机器学习。我使用gridsearch来确定我的数据集和随机森林分类器的最佳超参数。我使用leave-one-out交叉验证和ROC曲线下的面积作为评估每一组超参数的指标。我的代码运行，但是我有点被clf.grid_分数_. 据我所知，每一组超参数都应该在所有的数据折叠中进行评估，以确定使用一个在所有其他折叠上训练过的模型对遗漏折叠的预测效果。这将...
原理+代码，总结了 11 种回归模型
Python数据之道
07-19 7139
导读：本文总结了一些常用的除线性回归模型之外的模型，其中包括一些单模型及集成学习器。保序回归、多项式回归、多输出回归、多输出K近邻回归、决策树回归、多输出决策树回归、AdaBoost回归...
利用keras来完成天池大赛蒸汽量预测
roymustang的博客
06-30 132
https://tianchi.aliyun.com/competition/entrance/231693/score蒸汽预测赛提地址 按流程下载 zhengqi_train.txt zhengqi_test.txt v1模型-0.8705 最简单的模型直接不做处理直接导入神经网络 打开提示 %config Completer.use_jedi=False 导入包 from tensorflow import keras import numpy as np import matplotlib.pypl
天池学习赛：工业蒸汽量预测5——特征优化
小屋
03-19 790
上一篇《天池学习赛：工业蒸汽量预测4——模型验证》 目录1 特征优化的方法1.1 合成特征1.2 特征变换1.3 用决策树创造新特征1.4 特征组合2 赛题特征优化代码 1 特征优化的方法 1.1 合成特征 从一个或者多个输入特征衍生来的特征（标准化和缩放法创建的特征不算），主要包含以下几个类型： （1）将一个特征与其本身或者其他特征相乘（特征组合） （2）两个特征相除 （3）对连续特征进行分箱，以分为多个去加分箱 1.2 特征变换 1 数值特征的变换和组合 常用的数值特征的变换和组合如下： （1）多项式特
天池赛事——工业蒸汽量预测.ipynb
最新发布
01-03
天池赛事——工业蒸汽量预测.ipynb是一个数据科学竞赛项目，旨在通过历史数据和机器学习算法预测工业生产中的蒸汽量，以帮助企业优化生产计划和资源配置，提高生产效率。 在这个竞赛项目中，参赛者需要首先对提供的历史蒸汽量数据进行分析和清洗，以消除异常值和缺失值，确保数据的准确性和完整性。接着，参赛者需要选择合适的特征工程方法，提取与蒸汽量相关的有效特征，以用于训练机器学习模型。 在建立机器学习模型时，参赛者可以尝试各种回归算法，如线性回归、决策树回归、随机森林回归等，通过训练数据拟合模型参数，并通过交叉验证等方法选择最优的模型。同时，还可以尝试一些深度学习模型，如神经网络，以处理复杂的非线性关系。 在模型训练完成后，参赛者需要使用测试数据对模型进行评估，评估指标通常包括均方根误差（RMSE）等，以衡量模型的预测精度。最终，参赛者需要提交他们的预测结果，竞赛主办方将根据预测精度等指标评选出最优秀的模型，并给予奖励。 通过参与天池赛事——工业蒸汽量预测.ipynb，参赛者不仅可以锻炼数据分析和建模能力，还有机会获得丰厚的奖金和与业内专家交流的机会，对于数据科学从业者来说具有很大的吸引力。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值