1
2
3
4

import pandas as pd
import numpy as np
from statsmodels.imputation.mice import MICEData
from sklearn.preprocessing import OrdinalEncoder

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 读取原始数据
raw_data = pd.read_csv('data_FIX.csv')
np.random.seed(2024)
# ===== 数据预处理阶段 =====
# 1. 保留所有原始字段
data = raw_data.copy()

# 2. 处理时间特征（不删除原列）
max_date = pd.to_datetime(data['last_review']).max()
data['last_review_days'] = (max_date - pd.to_datetime(data['last_review'])).dt.days
data['license'] = data['license'].fillna('UNLICENSED')
# 3. 编码分类变量（创建副本列进行编码）
geo_encoder = OrdinalEncoder()
room_type_encoder = OrdinalEncoder()

# 创建编码副本列
data[['ng_encoded', 'n_encoded']] = geo_encoder.fit_transform(data[['neighbourhood_group', 'neighbourhood']])
data['rt_encoded'] = room_type_encoder.fit_transform(data[['room_type']])

1
2
3
4

class statsmodels.imputation.mice.MICEData(data,
            perturbation_method='gaussian',
            k_pmm=20,
            history_callback=None)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# ===== 多重插补实现 =====
# 选择需要插补的数值列
impute_columns = ['price', 'minimum_nights', 'number_of_reviews', 
                 'reviews_per_month', 'calculated_host_listings_count',
                 'availability_365', 'number_of_reviews_ltm', 'last_review_days',
                 'ng_encoded', 'n_encoded', 'rt_encoded']

# 执行MICE插补
imp = MICEData(data[impute_columns], perturbation_method='gaussian', k_pmm=5)
for _ in range(5):
    imp.update_all()

# 合并插补结果
imputed_data = data.copy()
imputed_data[impute_columns] = imp.data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# ===== 后处理阶段 =====
# 1. 恢复分类变量
imputed_data[['neighbourhood_group', 'neighbourhood']] = geo_encoder.inverse_transform(
    imputed_data[['ng_encoded', 'n_encoded']])
imputed_data['room_type'] = room_type_encoder.inverse_transform(
    imputed_data[['rt_encoded']]).flatten()

# 2. 恢复last_review日期
imputed_data['last_review'] = np.where(
    imputed_data['last_review'].isna(),
    (max_date - pd.to_timedelta(imputed_data['last_review_days'], unit='D')).dt.strftime('%Y-%m-%d'),
    imputed_data['last_review']
)

# 3. 清理中间列
imputed_data = imputed_data.drop(['ng_encoded', 'n_encoded', 'rt_encoded', 'last_review_days'], axis=1)
#价格异常值处理
imputed_data = imputed_data[(imputed_data['price'] > 0) & (imputed_data['price'] < 10000)]
# 保存结果
imputed_data.to_csv('imputed_data_FIX_full.csv', index=False)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 绘制价格分布对比图
import matplotlib.pyplot as plt

plt.rcParams["font.sans-serif"] = ["SimHei"]  # 设置字体
plt.rcParams["axes.unicode_minus"] = False  # 正常显示负号
plt.figure(figsize=(12, 6))

# 原始数据分布
plt.subplot(1, 2, 1)
raw_data['price'].hist(bins=50, range=(0, 2500))  # 直接限定数据范围
plt.title(f'原始价格分布 (n={len(raw_data)})')
plt.xlabel('Price (USD)')
plt.ylabel('frequency')
plt.xlim(0, 2500)  # 双重保险设置显示范围[5,7](@ref)

# 插补后数据分布
plt.subplot(1, 2, 2)
imputed_data['price'].hist(bins=50, range=(0, 2500))
plt.title(f'插补后价格分布 (n={len(imputed_data)})')
plt.xlabel('Price (USD)')
plt.xlim(0, 2500)  # 同步设置显示范围

plt.tight_layout()  # 自动调整子图间距
plt.savefig('output_FIX.png', dpi=300, bbox_inches='tight')

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

# -*- coding: utf-8 -*-
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error
from sklearn.preprocessing import OneHotEncoder
import matplotlib.pyplot as plt
plt.rcParams["font.sans-serif"] = ["SimHei"]  # 设置字体
plt.rcParams["axes.unicode_minus"] = False  # 正常显示负号
# --------------------------
# 数据预处理与收益参数计算
# --------------------------
def preprocess_data(filepath):
    # 加载数据
    df = pd.read_csv(filepath)
    
    # 计算入住率 (Occupancy Rate = 1 - availability_365/365)
    df['occupancy_rate'] = 1 - df['availability_365'] / 365
    
    # 定义收益参数
    # 曼哈顿成本最高（参数最低），布鲁克林次之，其他区域更高
    revenue_param_map = {
        'Manhattan':0.374669,
        'Brooklyn': 0.510500,
        'Queens': 0.470317,
        'Bronx': 0.504385,
        'Staten Island': 0.500000
    }
    df['revenue_param'] = df['neighbourhood_group'].map(revenue_param_map)
    
    # 计算收益目标变量 (Revenue = Price * Occupancy Rate * Revenue Parameter)
    df['revenue'] = df['price'] * df['occupancy_rate'] * df['revenue_param']
    
    # 特征选择
    features = df[[
        'neighbourhood_group',  # 大区域分组
        'latitude',             # 纬度
        'longitude',            # 经度
        'room_type',            # 房源类型
        'minimum_nights',       # 最少入住天数
        'number_of_reviews',    # 累计评价数
        'reviews_per_month',    # 每月评价数（反映活跃度）
        'calculated_host_listings_count',  # 房东房源总数
        'availability_365',     # 可预订天数（用于计算入住率）
        'number_of_reviews_ltm',# 近12个月评价数
        'price'                 # 原始价格（作为可调节变量）
    ]]
    
    # 对分类变量进行独热编码
    encoder = OneHotEncoder(sparse_output=False, drop='first')
    encoded_cats = encoder.fit_transform(features[['neighbourhood_group', 'room_type']])
    encoded_df = pd.DataFrame(
        encoded_cats,
        columns=encoder.get_feature_names_out(['neighbourhood_group', 'room_type'])
    )
    
    # 合并数值型特征
    numerical_features = features[[
        'latitude', 'longitude', 'minimum_nights',
        'number_of_reviews', 'reviews_per_month',
        'calculated_host_listings_count', 'number_of_reviews_ltm',
        'price'
    ]]
    processed_features = pd.concat([encoded_df, numerical_features], axis=1)
    
    return df, processed_features, df['revenue']

# --------------------------
# 随机森林建模与评估
# --------------------------
def build_rf_model(features, target):
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(
        features, target, test_size=0.2, random_state=42
    )
    
    # 初始化随机森林模型
    model = RandomForestRegressor(
        n_estimators=200,
        max_depth=10,
        min_samples_leaf=5,
        random_state=42
    )
    model.fit(X_train, y_train)
    
    # 模型评估
    y_pred = model.predict(X_test)
    print(f"模型性能评估:")
    print(f"R² Score: {r2_score(y_test, y_pred):.3f}")
    print(f"RMSE: {np.sqrt(mean_squared_error(y_test, y_pred)):.1f}")
    
    # 可视化特征重要性
    feat_importance = pd.Series(model.feature_importances_, index=features.columns)
    feat_importance.nlargest(10).plot(kind='barh', title='特征重要性排名')
    plt.savefig('特征重要性排名.png', dpi=300, bbox_inches='tight')
    
    return model

# --------------------------
# 价格优化器
# --------------------------
def optimize_pricing(model, sample_features, original_price, price_range=0.5):
    """
    输入:
        - model: 训练好的随机森林模型
        - sample_features: 单个房源的特征数据（需包含除price外的所有特征）
        - original_price: 当前价格
        - price_range: 价格调整范围比例（默认±50%）
    输出:
        - optimal_price: 最大化收益的最优价格
        - max_revenue: 对应的预测收益
    """
    # 生成价格搜索空间（当前价格的50%~150%）
    price_min = original_price * (1 - price_range)
    price_max = original_price * (1 + price_range)
    prices = np.linspace(price_min, price_max, 100)
    
    # 复制特征并调整价格
    test_data = pd.DataFrame([sample_features] * len(prices))
    test_data['price'] = prices
    
    # 预测收益
    revenues = model.predict(test_data)
    
    # 找到最优价格
    optimal_idx = np.argmax(revenues)
    return prices[optimal_idx], revenues[optimal_idx]

# --------------------------
# 主程序
# --------------------------
if __name__ == "__main__":
    # 数据预处理
    df, features, target = preprocess_data("imputed_data_FIX_full.csv")  # 替换为实际文件路径
    
    # 训练模型
    rf_model = build_rf_model(features, target)
    
    # 示例：优化第100号房源价格
    sample_idx = 100
    sample_data = features.iloc[sample_idx]
    current_price = df.iloc[sample_idx]['price']
    
    optimal_price, max_revenue = optimize_pricing(
        model=rf_model,
        sample_features=sample_data,
        original_price=current_price
    )
    
    # 打印结果
    print("\n=== 价格优化结果 ===")
    print(f"当前价格: ${current_price:.0f}")
    print(f"最优价格: ${optimal_price:.0f}")
    print(f"预测收益提升: {((max_revenue - df.iloc[sample_idx]['revenue']) / df.iloc[sample_idx]['revenue']):.1%}")
    
    # 可视化价格-收益曲线
    price_range = 0.5
    prices = np.linspace(current_price * (1 - price_range), current_price * (1 + price_range), 100)
    test_data = pd.DataFrame([sample_data] * len(prices))
    test_data['price'] = prices

    plt.figure(figsize=(10, 6))
    plt.plot(prices, rf_model.predict(test_data))
    plt.axvline(optimal_price, color='red', linestyle='--')
    plt.xlabel("Price")
    plt.ylabel("Predicted Revenue")
    plt.title("价格与收益关系曲线")
    plt.savefig('价格与收益关系曲线.png', dpi=300, bbox_inches='tight')