kaggle-abalone

1、分析数据和构建模型

# https://www.kaggle.com/code/ajeetsingh123/abalone-eda-regression-with-pipeline-ann

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import tensorflow as tf
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_log_error
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler, PolynomialFeatures
from keras.callbacks import EarlyStopping
from keras.layers import Dropout, Dense
from keras.losses import MeanSquaredLogarithmicError

train = pd.read_csv('D:\\python\\dataset\\Abalone\\playground-series-s4e4\\train.csv')

df = pd.DataFrame(train)

# pfr = ydata_profiling.ProfileReport(df)
# pfr.to_file("D:\\python\\dataset\\Abalone\\profile.html")
head = df.head()
print(head)
info = df.info()
print(info)
sum = df.isnull().sum()
print(sum)

df.drop('id', axis=1, inplace=True)
duplicateSum = df.duplicated().sum()
print(duplicateSum)

sexCounts = df['Sex'].value_counts()
print(sexCounts)

fig = plt.figure(figsize=(8, 6))
fig.add_axes([0.1, 0.1, 0.9, 0.9])
sns.barplot(data=df, x='Sex', y='Rings')
# plt.show()
sexRingsMean = df.groupby(['Sex']).mean()['Rings']
print(sexRingsMean)
# sns.pairplot(data=df, corner=True)
# plt.show()

corr = df.corr(numeric_only=True)
sns.heatmap(corr, annot=True, mask=np.triu(corr))
# plt.show()

corr = abs(corr['Rings']).sort_values(ascending=False)
print(corr)

numerical_features = ['Length', 'Diameter', 'Height', 'Whole weight', 'Whole weight.1',
                      'Whole weight.2', 'Shell weight', 'Rings']

plt, axes = plt.subplots(8, 2, figsize=(16, 32), gridspec_kw={'hspace': 2, 'wspace': 1})

for i, feature in enumerate(numerical_features):
    sns.histplot(data=df, x=feature, ax=axes[i, 0])
    sns.boxplot(data=df, x=feature, ax=axes[i, 1])
# plt.tight_layout()
# plt.show()
plt.savefig('D:\\python\\dataset\\Abalone\\plot.png')

X = df.drop('Rings', axis=1)
y = df['Rings']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True)

preprocessor = ColumnTransformer(
    [('onehotencoder', OneHotEncoder(sparse=False, drop='first'), ['Sex'])],
    remainder='passthrough'  # Pass through any columns not specified
)

models = {
    'Linear Regression': LinearRegression(),
    'KNeighborsRegressor': KNeighborsRegressor(),
    'Random Forest Regressor': RandomForestRegressor(),
    'GradientBoostingRegressor': GradientBoostingRegressor()

}

for name, model in models.items():
    # Combine the shared preprocessing pipeline with the model-specific pipeline

    pipeline = Pipeline([
        ('preprocessor', preprocessor),
        ('scaler', StandardScaler()),
        ('model', model)
    ])

    # Fit the pipeline
    pipeline.fit(X_train, y_train)

    y_pred = pipeline.predict(X_test)

    y_pred = np.maximum(y_pred, 0)  # to ensure that y_pred is non-negative value

    print(f"Model:", {name})
    rmsle = mean_squared_log_error(y_test, y_pred) ** 0.5
    print("RMSLE:", rmsle)
    print("----")

models_poly = {
    'Linear Regression': LinearRegression(),
    'KNeighborsRegressor': KNeighborsRegressor(),
    'Random Forest Regressor': RandomForestRegressor(),
    'GradientBoostingRegressor': GradientBoostingRegressor()

}

preprocessor_poly = ColumnTransformer(
    [('onehotencoder', OneHotEncoder(sparse=False, drop='first'), ['Sex']),
     ('poly', PolynomialFeatures(degree=2), ['Length', 'Diameter', 'Height', 'Whole weight', 'Whole weight.1',
                                             'Whole weight.2', 'Shell weight'])
     ],
    remainder='passthrough'
)

for name, model_poly in models_poly.items():
    # Combine the shared preprocessing pipeline with the model-specific pipeline

    pipeline = Pipeline([
        ('preprocessor', preprocessor_poly),
        ('scaler', StandardScaler()),
        ('model', model)
    ])

    # Fit the pipeline
    pipeline.fit(X_train, y_train)

    y_pred = pipeline.predict(X_test)

    y_pred = np.maximum(y_pred, 0)  # to ensure that ypred is non-negative value

    print(f"Model:", {name})
    rmsle = mean_squared_log_error(y_test, y_pred) ** 0.5
    print("RMSLE:", rmsle)
    print("------")

pipeline_ann = Pipeline([
    ('preprocessor', preprocessor),
    ('scaler', StandardScaler())
])
X_train_processed = pipeline_ann.fit_transform(X_train)
X_test_processed = pipeline_ann.transform(X_test)

model_nn = tf.keras.Sequential([
    Dense(128, activation='relu'),
    Dropout(0.3),
    Dense(64, activation='relu'),
    Dropout(0.2),
    Dense(32, activation='relu'),
    Dropout(0.2),
    Dense(1)
])

model_nn.compile(optimizer='adam', loss=MeanSquaredLogarithmicError(), metrics=['msle'])

es = EarlyStopping(monitor="val_loss", patience=15, mode='auto')
model_nn.fit(X_train_processed, y_train, epochs=50, validation_data=(X_test_processed, y_test), callbacks=[es])

model_nn.save('my_model')

2、使用模型预测和生成结果

# 加载整个模型
import numpy as np
import pandas as pd
from keras.models import load_model
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder

model_nn = load_model('my_model')
test = pd.read_csv('D:\\python\\dataset\\Abalone\\playground-series-s4e4\\test.csv')
id = test["id"]
test.drop('id', axis=1, inplace=True)
preprocessor = ColumnTransformer(
    [('onehotencoder', OneHotEncoder(sparse=False, drop='first'), ['Sex'])],
    remainder='passthrough'  # Pass through any columns not specified
)
pipeline_ann = Pipeline([
    ('preprocessor', preprocessor),
    ('scaler', StandardScaler())
])
test = pipeline_ann.fit_transform(test)
result_Y = model_nn.predict(test)
result = result_Y[:, 0]
df_preds = pd.DataFrame({'id': id, 'Rings': np.round(result_Y[:, 0]).astype(int)})

df_preds.to_csv('submission.csv', index=False)

ColumnTransformer 方法

transformers: 这是一个列表，包含多个转换器。每个转换器是一个三元素元组，分别代表转换器的名称、转换器实例和要应用转换的列的索引列表。例如，('cat', OneHotEncoder(), [0, 1]) 表示对一维数组或 DataFrame 的前两列应用 OneHotEncoder 转换。

remainder: 这个参数决定了未明确指定转换的列将如何处理。默认值是 'drop'，意味着这些列将被丢弃。如果设置为 'passthrough'，则这些列将保持原样，不会进行任何转换。

validate: 布尔类型，默认值为 True。如果设置为 False，则在调用 fit 方法时不会验证传入的数据是否符合预期。

n_jobs: 整数，表示并行运行的数量。如果设置为 -1，则使用所有处理器核心。

flatten: 布尔类型，默认值为 True。如果设置为 False，则输出将是一个嵌套结构，否则将被展平为一个二维数组。

ignore_failures: 布尔类型，默认值为 False。如果设置为 True，则在遇到无法转换的列时，不会抛出异常，而是忽略这些列。

order: 指定转换器应用的顺序。默认值是 None，意味着转换器将按照它们在 transformers 列表中的顺序应用。

error_score: 当转换失败时返回的分数。默认值是 nan，意味着转换失败的列将被填充为 NaN。

custom_transformers: 自定义转换器字典，键是转换器的名称，值是一个包含 transformer 和 columns 的元组。

PolynomialFeatures

PolynomialFeatures 是 scikit-learn 库中的一个转换器，它能够将原始特征进行多项式扩展，从而生成新的特征。这些新特征包括原特征的所有可能的单项式组合，以及原特征之间的交互项。例如，如果有两个特征 a 和 b，PolynomialFeatures 可以生成 (1, a, b, a^2, ab, b^2) 这样的特征集。

degree：控制多项式的最高次数，决定了生成的新特征的数量。
interaction_only：默认为 False，如果设置为 True，则不会生成特征自身的高次幂项，只生成特征间的交互项。
include_bias：默认为 True，如果设置为 False，则不会在生成的特征矩阵中包含常数项（即 1）。

Pipeline 方法参数解析

Pipeline 是 scikit-learn 库中的一个组件，它允许您创建一个序列化的机器学习工作流，其中包括一系列变换和一个最终的模型。这种结构非常有用，因为它可以让您轻松地组合多个步骤，并且可以很容易地进行交叉验证和参数调优。

参数说明
steps: 这是一个列表，包含了一系列的步骤，每个步骤都是一个元组，形式为 (step_name, transformer, parameters)。step_name 是步骤的名称，transformer 是实现了 fit 和 transform 方法的变换器实例，parameters 是传递给变换器的参数。

memory: 这是一个字符串或实现了 joblib.Memory 接口的对象，用于缓存管道中的变换器。默认值为 None，意味着不进行缓存。如果设置为字符串，它将指向缓存目录的路径。启用缓存可以在拟合过程中节省时间，尤其是当拟合步骤耗时较长时。

verbose: 这是一个布尔值，默认为 False。如果设置为 True，那么在每个步骤拟合完成后，将打印出所花费的时间。

named_steps: 这是一个类似于字典的对象，可以通过步骤名称来访问任何步骤的参数。这是一个只读属性，可以用来检查管道中的估计器。

pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('scaler', StandardScaler()),
    ('model', model)
])

'preprocessor': 这是第一个步骤的名称，preprocessor 是实现了 fit 和 transform 方法的变换器实例。
'scaler': 这是第二个步骤的名称，StandardScaler() 是一个标准缩放器实例，用于标准化数据。
'model': 这是最后一个步骤的名称，model 是一个实现了 fit 方法的模型实例，用于训练和预测。
这个管道首先应用 preprocessor 变换器，然后应用 StandardScaler 标准化器，最后应用 model 模型进行训练和预测。这样的结构使得数据预处理和模型训练可以无缝地结合在一起，简化了整个机器学习工作流程。