前言
上一篇文章，讲解了《肥胖风险的多类别预测》机器学习方面的文章，主要是多分类算法的运用，本文是一个回归的算法，本期是2024年4月份的题目《Regression with an Abalone Dataset》即《鲍鱼年龄预测》，在此分享高手在这个比赛过程的代码。
由于内容比较多，分成两篇来完成，上篇着重 讲解数据探索（ EDA） 方面，下篇讲解 建模优化方面。
题目简介
先上一张鲍鱼的图。
这一段话写得非常棒，我就直接引用了。
🚀 在这个激动人心的探索中，我们深入了解鲍鱼生物学的迷人世界。我们的使命？利用先进的机器学习技术，根据鲍鱼的身体测量结果预测鲍鱼的年龄。
我们的数据集是从对这些海洋软体动物的细致研究和观察中收集的信息宝库。🐚 从外壳尺寸到身体质量，我们拥有解开鲍鱼年龄预测秘密所需的所有工具。
但为什么这个预测任务很重要？鲍鱼的年龄传统上是通过费力的方法来确定的，包括外壳切片和显微镜检查。
🕵️♂️ 通过利用现成的物理测量，我们旨在简化这一过程，并提供更快、更高效的替代方案。
当我们开始这段旅程时，我们将深入研究数据集，探索鲍鱼的不同特征与年龄之间的关系。通过分类和回归技术，我们将努力将均方根对数误差（RMSLE）降至最低，并提供准确的预测。📊💡
所以，准备好让自己沉浸在鲍鱼生物学和预测建模的世界中。用决心和创新，让我们一起揭开鲍鱼年龄预测的奥秘！🌊🔍✨
加载库
保证完整性，这部分也写上了。
# 加载库
import warnings as wrn
wrn.filterwarnings('ignore', category = DeprecationWarning)
wrn.filterwarnings('ignore', category = FutureWarning)
wrn.filterwarnings('ignore', category = UserWarning) import optuna
import xgboost as xgb
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import scipy.stats as stats
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import GroupKFold
from sklearn.metrics import accuracy_score, classification_report, mean_absolute_error
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import LinearSVC
from sklearn.preprocessing import RobustScaler
from sklearn.pipeline import make_pipeline
from sklearn.decomposition import PCA
from sklearn.model_selection import cross_val_score
from sklearn.metrics import make_scorer, accuracy_score, median_absolute_error
from imblearn.over_sampling import RandomOverSampler
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import mean_squared_error, r2_score
import lightgbm as lgb
import numpy as np
from scipy import stats
加载数据
# 加载所有数据
train_data = pd.read_csv("/kaggle/input/playground-series-s4e4/train.csv")
test_data = pd.read_csv("/kaggle/input/playground-series-s4e4/test.csv")
original_data = pd.read_csv('/kaggle/input/abalone-dataset/abalone.csv')
这里特别说明一下，这个
original_data是原始数据集，即来自于UCI。参考链接为：https://archive.ics.uci.edu/dataset/1/abalone
查看数据
y = train_data['Rings']
id_test = test_data['id']train_data = train_data.drop(['id'], axis = 1)
test_data = test_data.drop(['id'], axis = 1)train_data.columns = original_data.columns
test_data.columns = original_data.drop(['Rings'], axis=1).columns
train_data.head()
| Sex | Length | Diameter | Height | Whole weight | Shucked weight | Viscera weight | Shell weight | Rings | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | F | 0.550 | 0.430 | 0.150 | 0.7715 | 0.3285 | 0.1465 | 0.2400 | 11 |
| 1 | F | 0.630 | 0.490 | 0.145 | 1.1300 | 0.4580 | 0.2765 | 0.3200 | 11 |
| 2 | I | 0.160 | 0.110 | 0.025 | 0.0210 | 0.0055 | 0.0030 | 0.0050 | 6 |
| 3 | M | 0.595 | 0.475 | 0.150 | 0.9145 | 0.3755 | 0.2055 | 0.2500 | 10 |
| 4 | I | 0.555 | 0.425 | 0.130 | 0.7820 | 0.3695 | 0.1600 | 0.1975 | 9 |
训练集情况
# 查看数据结构num_train_rows, num_train_columns = train_data.shapenum_test_rows, num_test_columns = test_data.shapenum_original_rows, num_original_columns = original_data.shapeprint("Training Data:")
print(f"Number of Rows: {num_train_rows}")
print(f"Number of Columns: {num_train_columns}\n")print("Test Data:")
print(f"Number of Rows: {num_test_rows}")
print(f"Number of Columns: {num_test_columns}\n")print("Original Data:")
print(f"Number of Rows: {num_original_rows}")
print(f"Number of Columns: {num_original_columns}")
Training Data:
Number of Rows: 90615
Number of Columns: 9
Test Data:
Number of Rows: 60411
Number of Columns: 8
Original Data:
Number of Rows: 4177
Number of Columns: 9
# 查看重复缺失等情况missing_values_train = pd.DataFrame({'Feature': train_data.columns,'[TRAIN] No. of Missing Values': train_data.isnull().sum().values,'[TRAIN] % of Missing Values': ((train_data.isnull().sum().values)/len(train_data)*100)})missing_values_test = pd.DataFrame({'Feature': test_data.columns,'[TEST] No.of Missing Values': test_data.isnull().sum().values,'[TEST] % of Missing Values': ((test_data.isnull().sum().values)/len(test_data)*100)})missing_values_original = pd.DataFrame({'Feature': original_data.columns,'[ORIGINAL] No.of Missing Values': original_data.isnull().sum().values,'[ORIGINAL] % of Missing Values': ((original_data.isnull().sum().values)/len(original_data)*100)})unique_values = pd.DataFrame({'Feature': train_data.columns,'No. of Unique Values[FROM TRAIN]': train_data.nunique().values})feature_types = pd.DataFrame({'Feature': train_data.columns,'DataType': train_data.dtypes})merged_df = pd.merge(missing_values_train, missing_values_test, on='Feature', how='left')
merged_df = pd.merge(merged_df, missing_values_original, on='Feature', how='left')
merged_df = pd.merge(merged_df, unique_values, on='Feature', how='left')
merged_df = pd.merge(merged_df, feature_types, on='Feature', how='left')merged_df
| Feature | [TRAIN] No. of Missing Values | [TRAIN] % of Missing Values | [TEST] No.of Missing Values | [TEST] % of Missing Values | [ORIGINAL] No.of Missing Values | [ORIGINAL] % of Missing Values | No. of Unique Values[FROM TRAIN] | DataType | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | Sex | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 3 | object |
| 1 | Length | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 157 | float64 |
| 2 | Diameter | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 126 | float64 |
| 3 | Height | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 90 | float64 |
| 4 | Whole weight | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 3175 | float64 |
| 5 | Shucked weight | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 1799 | float64 |
| 6 | Viscera weight | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 979 | float64 |
| 7 | Shell weight | 0 | 0.0 | 0.0 | 0.0 | 0 | 0.0 | 1129 | float64 |
| 8 | Rings | 0 | 0.0 | NaN | NaN | 0 | 0.0 | 28 | int64 |
数据无重复、无缺失
train_data.describe().T
| count | mean | std | min | 25% | 50% | 75% | max | |
|---|---|---|---|---|---|---|---|---|
| Length | 90615.0 | 0.517098 | 0.118217 | 0.0750 | 0.4450 | 0.5450 | 0.6000 | 0.8150 |
| Diameter | 90615.0 | 0.401679 | 0.098026 | 0.0550 | 0.3450 | 0.4250 | 0.4700 | 0.6500 |
| Height | 90615.0 | 0.135464 | 0.038008 | 0.0000 | 0.1100 | 0.1400 | 0.1600 | 1.1300 |
| Whole weight | 90615.0 | 0.789035 | 0.457671 | 0.0020 | 0.4190 | 0.7995 | 1.0675 | 2.8255 |
| Shucked weight | 90615.0 | 0.340778 | 0.204428 | 0.0010 | 0.1775 | 0.3300 | 0.4630 | 1.4880 |
| Viscera weight | 90615.0 | 0.169422 | 0.100909 | 0.0005 | 0.0865 | 0.1660 | 0.2325 | 0.7600 |
| Shell weight | 90615.0 | 0.225898 | 0.130203 | 0.0015 | 0.1200 | 0.2250 | 0.3050 | 1.0050 |
| Rings | 90615.0 | 9.696794 | 3.176221 | 1.0000 | 8.0000 | 9.0000 | 11.0000 | 29.0000 |
数据集特征说明
| 列名 | 完整含义 | 详细说明 |
|---|---|---|
| ‘id’ | id | 鲍鱼的唯一号 |
| ‘Sex’ | 性别 | 指示鲍鱼性别的分类变量。可能的值为M（男性）、F（女性）和I（婴儿） |
| ‘Length’ | 长度 | 表示最长外壳测量值的连续变量，单位为毫米。 |
| ‘Diameter’ | 直径 | 表示外壳直径的连续变量，垂直于长度测量，单位为毫米。 |
| ‘Height’ | 高度 | 表示鲍鱼高度的连续变量，鲍鱼壳中有肉，单位为毫米。 |
| ‘Whole_weight’ | 整体重量 | 表示鲍鱼整体重量的连续变量，单位为克。 |
| ‘Shucked_weight’ | 去皮重量 | 表示肉（去皮后）重量的连续变量，单位为克。 |
| ‘Viscera_weight’ | 内脏重量 | 表示肠道重量（出血后）的连续变量，单位为克。 |
| ‘Shell_weight’ | 贝壳重量 | 表示贝壳重量（干燥后）的连续变量，单位为克。 |
| ‘Rings’ | 环 | 以年为单位表示鲍鱼年龄的整数变量。+1.5的值表示实际年龄（以年为单位）。 |
该数据集为大量鲍鱼标本提供了一套全面的物理测量数据。包括分类变量和连续变量在内的各种特征使该数据集非常适合各种预测建模任务，特别是基于这些容易获得的物理特征预测鲍鱼年龄。目标变量Rings表示鲍鱼壳中的环数，这是动物年龄的代表。预测鲍鱼的年龄是一项具有挑战性的任务，因为传统的环数方法既耗时又乏味。因此，该数据集提供了一个机会，可以探索使用可用的物理测量来估计鲍鱼年龄的替代、更有效的方法。
数据探索 （EDA）
numerical_variables = ['Length', 'Diameter', 'Height', 'Whole weight', 'Shucked weight', 'Viscera weight', 'Shell weight']
target_variable = 'Rings'
categorical_variables = ['Sex']
特征分为数值型和分类型，本题 数据结构相对比较简单
数值型特征分布图
# 分析数值型特征# Define a custom color palette
custom_palette = ['#28ae80', '#d3eb0c', '#ff9a0b'
]# Add 'Dataset' column to distinguish between train and test data
train_data['Dataset'] = 'Train'
test_data['Dataset'] = 'Test'
original_data['Dataset'] = 'Original'variables = [col for col in train_data.columns if col in numerical_variables]# Function to create and display a row of plots for a single variable
def create_variable_plots(variable):sns.set_style('whitegrid')fig, axes = plt.subplots(1, 2, figsize=(12, 4))# Box plotplt.subplot(1, 2, 1)if variable == 'Whole weight.1' or variable == 'Whole weight.2':sns.boxplot(data=pd.concat([train_data, test_data]), x=variable, y="Dataset", palette=custom_palette)else:sns.boxplot(data=pd.concat([train_data, test_data, original_data.dropna()]), x=variable, y="Dataset", palette=custom_palette)plt.xlabel(variable)plt.title(f"Box Plot for {variable}", fontweight='bold', fontfamily='serif')# Separate Histogramsplt.subplot(1, 2, 2)if variable =='Whole weight.1' or variable =='Whole weight.2':sns.histplot(data=train_data, x=variable, color=custom_palette[0], kde=True, bins=30, label="Train")sns.histplot(data=test_data, x=variable, color=custom_palette[1], kde=True, bins=30, label="Test")else:sns.histplot(data=train_data, x=variable, color=custom_palette[0], kde=True, bins=30, label="Train")sns.histplot(data=test_data, x=variable, color=custom_palette[1], kde=True, bins=30, label="Test")sns.histplot(data=original_data.dropna(), x=variable, color=custom_palette[2], kde=True, bins=30, label="Original")plt.xlabel(variable)plt.ylabel("Frequency")plt.title(f"Histogram for {variable} [TRAIN, TEST & ORIGINAL]", fontweight='bold', fontfamily='serif')plt.legend()# Adjust spacing between subplotsplt.tight_layout()# Show the plotsplt.show()# Perform univariate analysis for each variable
for variable in variables:create_variable_plots(variable)# Drop the 'Dataset' column after analysis
train_data.drop('Dataset', axis=1, inplace=True)
test_data.drop('Dataset', axis=1, inplace=True)
original_data.drop('Dataset', axis=1, inplace=True)
分类型特征分布图
# 分析分类型特征# Define a custom color palette for categorical features
categorical_palette = ['#33638d', '#28ae80', '#d3eb0c', '#ff9a0b']# List of categorical variables
categorical_variables = [col for col in categorical_variables]# Function to create and display a row of plots for a single categorical variable
def create_categorical_plots(variable):sns.set_style('whitegrid')fig, axes = plt.subplots(1, 2, figsize=(12, 4))# Pie Chartplt.subplot(1, 2, 1)train_data[variable].value_counts().plot.pie(autopct='%1.1f%%', colors=categorical_palette, wedgeprops=dict(width=0.3), startangle=140)plt.title(f"Pie Chart for {variable}", fontweight='bold', fontfamily='serif')# Bar Graphplt.subplot(1, 2, 2)sns.countplot(data=pd.concat([train_data, test_data, original_data.dropna()]), x=variable, palette=categorical_palette)plt.xlabel(variable)plt.ylabel("Count")plt.title(f"Bar Graph for {variable} [TRAIN, TEST & ORIGINAL]", fontweight='bold', fontfamily='serif')# Adjust spacing between subplotsplt.tight_layout()# Show the plotsplt.show()# Perform univariate analysis for each categorical variable
for variable in categorical_variables:create_categorical_plots(variable)
目标特征分布图
# 分析目标特征target_palette = ['#3b528b','#1fa088','#9ee742','#d6f015','#e0d20a','#ffaa08','#ff522f','#d7043d']fig, axes = plt.subplots(1, 2, figsize=(12, 4))# Box plot
plt.subplot(1, 2, 1)
sns.boxplot(data=train_data, x=target_variable, palette=target_palette)
plt.xlabel(variable)
plt.title(f"Box Plot for {target_variable} [TRAIN]", fontweight='bold', fontfamily='serif')# Separate Histograms
plt.subplot(1, 2, 2)
sns.histplot(data=train_data, x=target_variable, color=target_palette[1], kde=True, bins=30, label="Train")
plt.xlabel(variable)
plt.ylabel("Frequency")
plt.title(f"Histogram for {target_variable} [TRAIN]", fontweight='bold', fontfamily='serif')
plt.legend()# Adjust spacing between subplots
plt.tight_layout()# Show the plots
plt.show()
数据集“环”表示鲍鱼壳中的环的数量，这是动物年龄的代表。该变量的值范围从1到29，根据具体问题和建模方法，可以将其视为连续变量和分类变量。
- 连续变量法：
- 由于“环”变量代表鲍鱼的年龄，因此可以将其视为连续变量。
- 这意味着这项任务可以作为一个回归问题来处理，其中的目标是根据可用的物理测量来预测每只鲍鱼的确切环数（年龄）。
- 可以使用线性回归和决策树等建模技术来学习特征与连续“环”目标之间的关系。
- 分类变量法：
- 或者，“环”变量可以被视为一个分类变量，其中不同的值（1到29）代表不同的年龄组或类别。
- 在这种情况下，该任务可以被定义为一个分类问题，其中的目标是根据物理测量来预测每只鲍鱼的年龄组（类别）。
- 可以使用逻辑回归、决策树或随机森林等建模技术来学习特征和分类“环”目标之间的映射。
连续变量法或分类变量法之间的选择取决于问题的具体要求和模型的预期用途。如果目标是预测鲍鱼的确切年龄，那么连续变量法可能更适合。然而，如果重点是将鲍鱼分为不同的年龄组，那么分类变量方法可能更合适。
我将探索这两种方法，并比较它们的性能，以确定为给定问题建模“环”变量的最佳方式。
偏度条形图
# 测量和比较所有特征之间的偏度，并使用条形图进行比较skew_merged = pd.DataFrame(data = train_data[numerical_variables].skew(), columns = ['Skewness'])
skew_sorted = skew_merged.sort_values(ascending = False, by = 'Skewness')sns.barplot(x=skew_sorted.Skewness, y=skew_sorted.index, palette='viridis')
plt.title('Skewness in Explanatory Variables', fontweight='bold', fontfamily='serif')
plt.xlabel('Value')
plt.ylabel('Skewness')
plt.show()
相关性热力图
# 计算相关性的热力图
corr_train = train_data[numerical_variables].corr()
corr_test = test_data[numerical_variables].corr()# Create masks for the upper triangle
mask_train = np.triu(np.ones_like(corr_train, dtype=bool))
mask_test = np.triu(np.ones_like(corr_test, dtype=bool))# Set the text size and rotation
annot_kws = {"size": 8, "rotation": 45}# Generate heatmaps for train_data
plt.figure(figsize=(18, 7))
plt.subplot(1, 2, 1)
ax_train = sns.heatmap(corr_train, mask=mask_train, cmap='viridis', annot=True,square=True, linewidths=.5, xticklabels=1, yticklabels=1, annot_kws=annot_kws)
plt.title('Correlation Heatmap - Train Data', fontweight='bold', fontfamily='serif')# Generate heatmaps for test_data
plt.subplot(1, 2, 2)
ax_test = sns.heatmap(corr_test, mask=mask_test, cmap='viridis', annot=True,square=True, linewidths=.5, xticklabels=1, yticklabels=1, annot_kws=annot_kws)
plt.title('Correlation Heatmap - Test Data', fontweight='bold', fontfamily='serif')# Adjust layout
plt.tight_layout()# Show the plots
plt.show()
特征分布散点图
fig, axes = plt.subplots(2, 4, figsize=(16, 8))
axes = axes.flatten()for i, feature in enumerate(numerical_variables):axes[i].scatter(train_data[feature], train_data['Rings'], s=5)axes[i].set_xlabel(feature)axes[i].set_ylabel('Rings')axes[i].set_title(f'Rings vs {feature}')plt.tight_layout()
plt.show()
散点图显示，物理测量值（长度、直径、高度、重量）与代表鲍鱼年龄的环数之间存在正相关关系。这表明，更大、更重的鲍鱼往往更老。
为了量化关系的强度，让我们计算“环”和连续特征之间的Pearson相关系数：
相关系数
correlations = train_data[numerical_variables + ['Rings']].corr()
print(correlations['Rings'])
Length 0.623786
Diameter 0.636832
Height 0.665772
Whole weight 0.617274
Shucked weight 0.515067
Viscera weight 0.588954
Shell weight 0.694766
Rings 1.000000
Name: Rings, dtype: float64
相关系数表明，所有物理测量值与环的数量都具有中等强度的正相关性，其中壳体重量具有最高的相关性（0.694766）。
性别（雄性、雌性和幼年）对鲍鱼的年龄分布是否存在差异？
性别对年龄的影响
# Bar plot to show the distribution of Rings for each Sex category
plt.figure(figsize=(8, 6))
train_data.groupby('Sex')['Rings'].mean().plot(kind='bar')
plt.xlabel('Sex')
plt.ylabel('Mean Rings')
plt.title('Mean Rings by Sex')
plt.show()
条形图：按性别划分的平均环
条形图显示了每个性别类别的戒指平均数量。
我们可以看到，雌性鲍鱼的平均环数高于雄性和幼年鲍鱼。
# Bar plot to show the distribution of Rings for each Sex category
plt.figure(figsize=(8, 6))
train_data.groupby('Sex')['Rings'].mean().plot(kind='bar')
plt.xlabel('Sex')
plt.ylabel('Mean Rings')
plt.title('Mean Rings by Sex')
plt.show()
盒图：按性别划分的环分布
盒图提供了《指环王》在性别类别中分布的更详细比较。
该图显示，雌性鲍鱼的环的中位数和四分位间距（IQR）略高于雄性和幼年鲍鱼。
对于所有类别，似乎也存在一些具有非常高环值的异常值。
建模
准备数据
dd={"M":0,"F":1,"I":2}
train_data['Sex'] = train_data['Sex'].map(dd)
text_data['Sex'] = test_data['Sex'].map(dd)
X=train.drop(["Rings"],axis=1)
加载各类算法
from sklearn.linear_model import LogisticRegression,LinearRegression
from sklearn.svm import SVC
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.naive_bayes import GaussianNB, BernoulliNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.ensemble import RandomForestRegressor, ExtraTreesClassifier, GradientBoostingClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.ensemble import HistGradientBoostingClassifier
from xgboost import XGBRegressor
from lightgbm import LGBMRegressor
from catboost import CatBoostRegressor
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier# Set a seed for reproducibility
seed = 42# Initialize all the classification models in the requested format
log_reg = LogisticRegression(random_state=seed, max_iter=1000000)
svc = SVC(random_state=seed, probability=True)
lda = LinearDiscriminantAnalysis()
gnb = GaussianNB()
bnb = BernoulliNB()
knn = KNeighborsClassifier()
gauss = GaussianProcessClassifier(random_state=seed)
rf = RandomForestRegressor(random_state=seed)
et = ExtraTreesClassifier(random_state=seed)
xgb = XGBRegressor(random_state=seed)
lgb = LGBMRegressor(random_state=seed, verbosity=0)
dart = LGBMClassifier(random_state=seed, boosting_type='dart')
cb = CatBoostRegressor(random_state=seed, verbose=0)
gb = GradientBoostingClassifier(random_state=seed)
hgb = HistGradientBoostingClassifier(random_state=seed)
lr = LinearRegression()
rf_classifier = RandomForestClassifier(random_state=seed)
et_classifier = ExtraTreesClassifier(random_state=seed)
xgb_classifier = XGBClassifier(random_state=seed)
lgb_classifier = LGBMClassifier(random_state=seed, verbosity=0)
cb_classifier = CatBoostClassifier(random_state=seed, verbose=0)
选出合适算法
import warnings
# Ignore all warnings
warnings.filterwarnings("ignore")from sklearn.metrics import mean_squared_log_error
import numpy as npdef rmsle(y_true, y_pred):return np.sqrt(mean_squared_log_error(y_true, y_pred))# Fit the models and calculate RMSLE
models = [xgb, lgb, cb, rf]
rmsle_scores = []for model in models:X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.2,random_state=42)model.fit(X_train, y_train)y_pred = model.predict(X_test)score = rmsle(y_test, y_pred)rmsle_scores.append(score)# Create a DataFrame with the RMSLE scores
rmsle_df = pd.DataFrame(data=rmsle_scores, columns=['RMSLE'])
rmsle_df.index = ['xgb', 'lgb', 'cb', 'rf']
rmsle_df = rmsle_df.sort_values(by='RMSLE', ascending=False)# Create a bar graph using Seaborn
plt.figure(figsize=(12, 6))
barplot = sns.barplot(x='RMSLE', y=rmsle_df.index, data=rmsle_df, palette='viridis')# Add values on the bars with larger and bolder font
for index, value in enumerate(rmsle_df['RMSLE']):barplot.text(value + 0.001, index, str(round(value, 5)), ha='left', va='center', fontsize=12, fontweight='bold')plt.title("Models' RMSLE Scores", fontweight='bold', fontfamily='serif')
plt.xlabel('RMSLE')
plt.ylabel('Models')
plt.show()
小结
通上述EDA和Modeling 后，对数值结果有了一个初步的了解。不同的模型的结果情况有了一个最基础的 Baseline ，如何提高比赛成绩，将在下一篇做详细的说明。
