八种数值变量的特征工程技术：利用Sklearn、Numpy和Python将数值转化为预测模型的有效特征

import matplotlib.pyplot as plt  
 import seaborn as sns  
 from sklearn.datasets import load_wine  
 from sklearn.model_selection import train_test_split  
 from sklearn.preprocessing import StandardScaler  
 from sklearn.neighbors import KNeighborsClassifier  
 from sklearn.metrics import confusion_matrix  
 import numpy as np  
   
 X, y = load_wine(return_X_y=True)  
   
 # 将数据划分为训练集和测试集  
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42)  
   
 # 定义训练模型并获取混淆矩阵的函数  
 def get_confusion_matrix(X_train, X_test, y_train, y_test):  
     model = KNeighborsClassifier(n_neighbors=5)  
     model.fit(X_train, y_train)  
     y_pred = model.predict(X_test)  
     return confusion_matrix(y_test, y_pred)  
   
 # 获取未归一化的混淆矩阵  
 cm_without_norm = get_confusion_matrix(X_train, X_test, y_train, y_test)  
   
 # 归一化数据  
 scaler = StandardScaler()  
 X_train_scaled = scaler.fit_transform(X_train)  
 X_test_scaled = scaler.transform(X_test)  
   
 # 获取归一化后的混淆矩阵  
 cm_with_norm = get_confusion_matrix(X_train_scaled, X_test_scaled, y_train, y_test)  
   
 # 创建两个并列的子图  
 fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 8))  
   
 # 定义绘制热图的函数  
 def plot_heatmap(ax, cm, title):  
     sns.heatmap(cm, annot=True, fmt='d', cmap='viridis', ax=ax, cbar=False)  
     ax.set_title(title, fontsize=16, pad=20)  
     ax.set_xlabel(''Predicted', fontsize=12, labelpad=10)  
     ax.set_ylabel('Actual', fontsize=12, labelpad=10)  
   
 # 绘制热图  
 plot_heatmap(ax1, cm_without_norm, 'Confusion Matrix\nWithout Normalization')  
 plot_heatmap(ax2, cm_with_norm, 'Confusion Matrix\nWith Normalization')  
   
 # 添加共用的颜色条  
 cbar_ax = fig.add_axes([0.92, 0.15, 0.02, 0.7])  
 sm = plt.cm.ScalarMappable(cmap='viridis', norm=plt.Normalize(vmin=0, vmax=np.max([cm_without_norm, cm_with_norm])))  
 fig.colorbar(sm, cax=cbar_ax)  
   
 # 调整布局并显示图表  
 plt.tight_layout(rect=[0, 0, 0.9, 1])  
 plt.show()

from sklearn.preprocessing import PolynomialFeatures  
 import numpy as np  
   
 X = np.array([[1, 2], [3, 4]])  
 poly = PolynomialFeatures(degree=2, include_bias=False)  
 X_poly = poly.fit_transform(X)  
   
 print(X_poly)  
 # 输出: [[1. 2. 1. 2. 4.]  
 #       [3. 4. 9. 12. 16.]]  
   
 print(poly.get_feature_names(['x1', 'x2']))  
 # 输出: ['x1', 'x2', 'x1^2', 'x1 x2', 'x2^2']

import matplotlib.pyplot as plt  
   
 fig, ax = plt.subplots(figsize=(12, 4))  
 average_week_demand = df.groupby(["weekday", "hour"])["count"].mean()  
 average_week_demand.plot(ax=ax)  
 _ = ax.set(  
     title="Average hourly bike demand during the week",  
     xticks=[i * 24 for i in range(7)],  
     xticklabels=["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],  
     xlabel="Time of the week"
 )

import numpy as np  
 import pandas as pd  
   
 from sklearn.preprocessing import FunctionTransformer  
   
 import matplotlib.pyplot as plt  
 
 def sin_transformer(period):  
     return FunctionTransformer(lambda x: np.sin(x / period * 2 * np.pi))  
 
 def cos_transformer(period):  
     return FunctionTransformer(lambda x: np.cos(x / period * 2 * np.pi))  
   
 hour_df = pd.DataFrame(  
     np.arange(26).reshape(-1, 1),  
     columns=["hour"],  
 )  
 hour_df["hour_sin"] = sin_transformer(24).fit_transform(hour_df)["hour"]  
 hour_df["hour_cos"] = cos_transformer(24).fit_transform(hour_df)["hour"]  
 hour_df.plot(x="hour")  
 _ = plt.title("Trigonometric encoding of the 'hour' feature")

import matplotlib.pyplot as plt  
 import numpy as np  
 from sklearn.linear_model import LinearRegression  
 from sklearn.preprocessing import KBinsDiscretizer  
 from sklearn.tree import DecisionTreeRegressor  
   
 # 设置随机数生成器以确保可重复性  
 rnd = np.random.RandomState(42)  
   
 # 创建数据集  
 X = rnd.uniform(-3, 3, size=100)  # 在-3和3之间的100个点  
 y = np.sin(X) + rnd.normal(size=len(X)) / 3  # 正弦函数加噪声  
 X = X.reshape(-1, 1)  # 重塑为sklearn所需的正确格式  
   
 # 应用KBinsDiscretizer  
 discretizer = KBinsDiscretizer(n_bins=10, encode="onehot")  
 X_binned = discretizer.fit_transform(X)  
   
 # 准备可视化  
 fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True, figsize=(12, 5))  
 line = np.linspace(-3, 3, 1000).reshape(-1, 1)  # 用于绘图的点  
   
 # 训练和绘制模型的函数  
 def train_and_plot(X_train, X_plot, ax, title):  
     # 线性回归  
     linear_reg = LinearRegression().fit(X_train, y)  
     ax.plot(line, linear_reg.predict(X_plot), linewidth=2, color="green", label="Linear Regression")  
       
     # 决策树  
     tree_reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X_train, y)  
     ax.plot(line, tree_reg.predict(X_plot), linewidth=2, color="red", label="Decision Tree")  
       
     # 原始数据  
     ax.plot(X[:, 0], y, "o", c="k", alpha=0.5)  
     ax.legend(loc="best")  
     ax.set_xlabel("Input Feature")  
     ax.set_title(title)  
   
 # 绘制原始数据的图  
 train_and_plot(X, line, ax1, "Results Before Discretization")  
 ax1.set_ylabel("Regression Output")  
   
 # 绘制离散化数据的图  
 line_binned = discretizer.transform(line)  
 train_and_plot(X_binned, line_binned, ax2, "Results After Discretization")  
   
 plt.tight_layout()  
 plt.show()

import numpy as np  
 import pandas as pd  
 import matplotlib.pyplot as plt  
   
 # 创建一个具有正偏度值的示例数据集  
 np.random.seed(42)  
 data = {  
     'Income': np.random.exponential(scale=50000, size=1000)  # 指数分布以模拟偏度  
 }  
 df = pd.DataFrame(data)  
   
 # 创建一个具有两个并排子图的图形  
 fig, axes = plt.subplots(1, 2, figsize=(15, 5))  
   
 # 原始分布的图  
 axes[0].hist(df['Income'], bins=50, color='blue', alpha=0.7)  
 axes[0].set_title('Original Income Distribution')  
 axes[0].set_xlabel('Income')  
 axes[0].set_ylabel('Frequency')  
   
 # 应用对数变换  
 df['Log_Income'] = np.log1p(df['Income'])  # log1p相当于log(x + 1)  
   
 # 变换后分布的图  
 axes[1].hist(df['Log_Income'], bins=50, color='green', alpha=0.7)  
 axes[1].set_title('Log-transformed Income Distribution')  
 axes[1].set_xlabel('Log_Income')  
 axes[1].set_ylabel('Frequency')  
   
 # 显示图形  
 plt.tight_layout()  
 plt.show()

import numpy as np  
 import matplotlib.pyplot as plt  
 from sklearn.preprocessing import PowerTransformer  
   
 # 生成包含正值和负值的数据  
 np.random.seed(42)  
 data_positive = np.random.exponential(scale=2, size=1000)  # 正值  
 data_negative = -np.random.exponential(scale=0.5, size=200)  # 负值  
 data = np.concatenate([data_positive, data_negative])  # 合并正值和负值数据  
   
 # 创建两个PowerTransformer实例：一个用于Yeo-Johnson，一个用于Box-Cox进行比较  
 pt_yj = PowerTransformer(method='yeo-johnson', standardize=False)  # Yeo-Johnson变换  
 pt_bc = PowerTransformer(method='box-cox', standardize=False)  # Box-Cox变换  
   
 # 应用变换  
 data_yj = pt_yj.fit_transform(data.reshape(-1, 1))  # 应用Yeo-Johnson变换  
   
 # Box-Cox需要正数据，所以我们添加一个偏移量使所有值为正  
 data_offset = data - np.min(data) + 1e-6  # 偏移量以确保所有值为正  
 data_bc = pt_bc.fit_transform(data_offset.reshape(-1, 1))  # 应用Box-Cox变换  
   
 # 可视化结果  
 fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))  
   
 # 原始数据的直方图  
 ax1.hist(data, bins=50, edgecolor='black')  
 ax1.set_title("Original Data")  
 ax1.set_xlabel("Value")  
 ax1.set_ylabel("Frequency")  
   
 # Yeo-Johnson变换后数据的直方图  
 ax2.histax2.hist(data_yj, bins=50, edgecolor='black')  
 ax2.set_title("Yeo-Johnson")  
 ax2.set_xlabel("Value")  
   
 # Box-Cox变换后数据的直方图  
 ax3.hist(data_bc, bins=50, edgecolor='black')  
 ax3.set_title("Box-Cox")  
 ax3.set_xlabel("Value")  
   
 plt.tight_layout()  
 plt.show()

import numpy as np  
 from sklearn.preprocessing import QuantileTransformer  
 import matplotlib.pyplot as plt  
   
 # 创建一个具有偏斜分布的样本数据集  
 np.random.seed(0)  
 data = np.random.exponential(scale=2, size=(1000, 1))  # 指数分布  
   
 # 初始化QuantileTransformer  
 quantile_transformer = QuantileTransformer(n_quantiles=100, output_distribution='normal')  
   
 # 应用变换  
 data_transformed = quantile_transformer.fit_transform(data)  
   
 # 可视化原始和变换后的数据  
 plt.figure(figsize=(12, 6))  
   
 # 原始数据的直方图  
 plt.subplot(1, 2, 1)  
 plt.hist(data, bins=50, color='blue', edgecolor='black')  
 plt.title("Original Data (Exponential)")  
   
 # 变换后数据的直方图  
 plt.subplot(1, 2, 2)  
 plt.hist(data_transformed, bins=50, color='green', edgecolor='black')  
 plt.title("Transformed Data (Normal)")  
   
 plt.show()

import numpy as np  
 import matplotlib.pyplot as plt  
 from sklearn.datasets import fetch_lfw_people  
 from sklearn.decomposition import TruncatedSVD  
   
 # 加载Labeled Faces in the Wild数据集  
 lfw_people = fetch_lfw_people(min_faces_per_person=70, resize=0.4)  
 X = lfw_people.data  
 n_samples, h, w = lfw_people.images.shape  
   
 print(f"数据集维度：{X.shape}")  
   
 # 用于降维的组件数  
 n_components = 50  
   
 # 应用TruncatedSVD  
 svd = TruncatedSVD(n_components=n_components, random_state=42)  
 X_transformed = svd.fit_transform(X)  
   
 # 重构图像的函数  
 def reconstruct_image(svd, X_transformed):  
     return np.dot(X_transformed, svd.components_)  
   
 # 重构所有图像  
 X_reconstructed = reconstruct_image(svd, X_transformed)  
   
 # 显示原始和降维人脸的函数  
 def plot_transposed_original_and_reduced(X_original, X_reduced, n_faces=5):  
     fig, axes = plt.subplots(2, n_faces, figsize=(3*n_faces, 6))  
     random_indices = np.random.choice(X_original.shape[0], n_faces, replace=False)  
       
     for i, idx in enumerate(random_indices):  
         # 原始人脸  
         axes[0, i].imshow(X_original[idx].reshape(h, w), cmap='gray')  
         axes[0, i].set_title(f'Face {i+1}\nOriginal')  
         axes[0, i].axis('off')  
           
         # 降维人脸  
         axes[1, i].imshow(X_reduced[idx].reshape(h, w), cmap='gray')  
         axes[1, i].set_title(f'Reduced\n({n_components} comp.)')  
         axes[1, i].axis('off')  
       
     plt.tight_layout()  
     plt.show()  
   
 # 显示原始和降维人脸  
 plot_transposed_original_and_reduced(X, X_reconstructed)  
   
 # 计算并打印平均重构误差  
 mse = np.mean((X - X_reconstructed) ** 2)  
 print(f"\n平均重构误差 (MSE)：{mse:.4f}")  
   
 # 打印累积解释方差  
 explained_variance_ratio = svd.explained_variance_ratio_  
 cumulative_variance_ratio = np.cumsum(explained_variance_ratio)  
 print(f"\n{n_components} 个组件的累积解释方差：{cumulative_variance_ratio[-1]:.4f}")  
   
 # 显示前几个组件  
 n_components_show = min(10, n_components)  
 components = svd.components_[:n_components_show].reshape((n_components_show, h, w))  
 fig, axes = plt.subplots(2, 5, figsize=(15, 6))  
 for i, ax in enumerate(axes.flat):  
     if i < n_components_show:  
         ax.imshow(components[i], cmap='gray')  
         ax.set_title(f'Component {i+1}')  
     ax.axis('off')  
 plt.tight_layout()  
 plt.show()