{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f1e3f4b9-ad32-4ac3-b57e-eefb18f01560",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# ========== 1. 读取数据 ==========\n",
    "df = pd.read_csv(\"data/Camden_data.csv\")\n",
    "\n",
    "# ========== 2. 数据筛选 ==========\n",
    "filtered_df = df[\n",
    "    (df['property_type'].str.lower() == 'flat') &\n",
    "    (df['ward22nm'] == 'Bloomsbury') &\n",
    "    (df['built_form'].str.lower().str.contains('-terrace')) &\n",
    "    (df['wall_type'].str.lower() != 'other')\n",
    "].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9dcae145-b62a-4415-a591-1ecc9aa824aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         uprn      os_topo_toid    easting   northing postcode_locator  \\\n",
      "6413  5006230 1000000000000.000 530203.000 181732.000         WC1B 5BH   \n",
      "6414  5171576 1000000000000.000 530309.000 181747.000         WC1A 2NS   \n",
      "6417  5136568 1000000000000.000 530334.000 181768.000         WC1A 2QN   \n",
      "6418  5006231 1000000000000.000 530203.000 181732.000         WC1B 5BH   \n",
      "6423  5171575 1000000000000.000 530309.000 181747.000         WC1A 2NS   \n",
      "\n",
      "     administrative_area     oa21cd   lsoa21cd     lsoa21nm   lsoa11cd  ...  \\\n",
      "6413              Camden  E00004169  E01000855  Camden 028A  E01000855  ...   \n",
      "6414              Camden  E00004169  E01000855  Camden 028A  E01000855  ...   \n",
      "6417              Camden  E00004169  E01000855  Camden 028A  E01000855  ...   \n",
      "6418              Camden  E00004169  E01000855  Camden 028A  E01000855  ...   \n",
      "6423              Camden  E00004169  E01000855  Camden 028A  E01000855  ...   \n",
      "\n",
      "             roof_insulation roof_insulation_known    glazing_type  \\\n",
      "6413  another dwelling above                     1  single/partial   \n",
      "6414               insulated                     1       secondary   \n",
      "6417  another dwelling above                     1       secondary   \n",
      "6418  another dwelling above                     1  single/partial   \n",
      "6423  another dwelling above                     1       secondary   \n",
      "\n",
      "     glazing_type_known main_heat_type main_heat_type_known main_fuel_type  \\\n",
      "6413                  1         boiler                    1      mains gas   \n",
      "6414                  1         boiler                    1      mains gas   \n",
      "6417                  0         boiler                    0      mains gas   \n",
      "6418                  1         boiler                    1      mains gas   \n",
      "6423                  1         boiler                    1      mains gas   \n",
      "\n",
      "      main_fuel_type_known energy_consumption energy_consumption_known  \n",
      "6413                     1               7957                        1  \n",
      "6414                     1              11748                        1  \n",
      "6417                     0              10760                        0  \n",
      "6418                     1               5322                        1  \n",
      "6423                     1               8453                        1  \n",
      "\n",
      "[5 rows x 51 columns]\n"
     ]
    }
   ],
   "source": [
    "print(filtered_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "54f64227-8408-43a9-ae30-f41fe85b9487",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     construction_age_band wall_type wall_insulation               roof_type  \\\n",
      "6413              pre-1900     solid     uninsulated  another dwelling above   \n",
      "6414              pre-1900     solid     uninsulated                    flat   \n",
      "6417              pre-1900     solid     uninsulated  another dwelling above   \n",
      "6418             1900-1929     solid     uninsulated  another dwelling above   \n",
      "6423              pre-1900     solid     uninsulated  another dwelling above   \n",
      "\n",
      "             roof_insulation    glazing_type   built_form property_type  \\\n",
      "6413  another dwelling above  single/partial  mid-terrace          flat   \n",
      "6414               insulated       secondary  end-terrace          flat   \n",
      "6417  another dwelling above       secondary  end-terrace          flat   \n",
      "6418  another dwelling above  single/partial  mid-terrace          flat   \n",
      "6423  another dwelling above       secondary  end-terrace          flat   \n",
      "\n",
      "      total_floor_area  estimated_floor_count  ... epc_score  main_heat_type  \\\n",
      "6413                29                  4.000  ...        67          boiler   \n",
      "6414                34                  5.000  ...        54          boiler   \n",
      "6417                91                  4.000  ...        77          boiler   \n",
      "6418                61                  4.000  ...        76          boiler   \n",
      "6423                59                  5.000  ...        72          boiler   \n",
      "\n",
      "     main_fuel_type energy_consumption          tenure lookup_age_band  \\\n",
      "6413      mains gas               7957          social        pre-1920   \n",
      "6414      mains gas              11748  owner-occupied        pre-1920   \n",
      "6417      mains gas              10760  private-rented        pre-1920   \n",
      "6418      mains gas               5322  private-rented        pre-1920   \n",
      "6423      mains gas               8453  owner-occupied        pre-1920   \n",
      "\n",
      "     u_value_wall  u_value_roof  u_value_floor  u_value_glazing  \n",
      "6413        1.700         0.000          0.250            5.750  \n",
      "6414        1.700         0.280          0.250            2.820  \n",
      "6417        1.700         0.000          0.250            2.820  \n",
      "6418        1.700         0.000          0.250            5.750  \n",
      "6423        1.700         0.000          0.250            2.820  \n",
      "\n",
      "[5 rows x 21 columns]\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 4973 entries, 6413 to 115376\n",
      "Data columns (total 21 columns):\n",
      " #   Column                  Non-Null Count  Dtype  \n",
      "---  ------                  --------------  -----  \n",
      " 0   construction_age_band   4973 non-null   object \n",
      " 1   wall_type               4973 non-null   object \n",
      " 2   wall_insulation         4973 non-null   object \n",
      " 3   roof_type               4973 non-null   object \n",
      " 4   roof_insulation         4973 non-null   object \n",
      " 5   glazing_type            4973 non-null   object \n",
      " 6   built_form              4973 non-null   object \n",
      " 7   property_type           4973 non-null   object \n",
      " 8   total_floor_area        4973 non-null   int64  \n",
      " 9   estimated_floor_count   4751 non-null   float64\n",
      " 10  number_habitable_rooms  4973 non-null   object \n",
      " 11  epc_score               4973 non-null   int64  \n",
      " 12  main_heat_type          4973 non-null   object \n",
      " 13  main_fuel_type          4973 non-null   object \n",
      " 14  energy_consumption      4973 non-null   int64  \n",
      " 15  tenure                  4973 non-null   object \n",
      " 16  lookup_age_band         4973 non-null   object \n",
      " 17  u_value_wall            4973 non-null   float64\n",
      " 18  u_value_roof            4973 non-null   float64\n",
      " 19  u_value_floor           4973 non-null   float64\n",
      " 20  u_value_glazing         4973 non-null   float64\n",
      "dtypes: float64(5), int64(3), object(13)\n",
      "memory usage: 854.7+ KB\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# ===== 1. 精选字段 =====\n",
    "columns_to_keep = [\n",
    "    'construction_age_band', 'wall_type', 'wall_insulation', 'roof_type', 'roof_insulation',\n",
    "    'floor_type', 'glazing_type', 'built_form', 'property_type',\n",
    "    'total_floor_area', 'estimated_floor_count', 'number_habitable_rooms',\n",
    "    'epc_score', 'main_heat_type', 'main_fuel_type', 'energy_consumption', 'tenure'\n",
    "]\n",
    "columns_to_keep = [c for c in columns_to_keep if c in filtered_df.columns]\n",
    "filtered_df = filtered_df[columns_to_keep].copy()\n",
    "\n",
    "# ===== 2. 年代标准化完全覆盖8个类型 =====\n",
    "def standardize_age_band(age_band):\n",
    "    ab = str(age_band).strip().lower()\n",
    "    if ab in ['pre-1900', '1900-1929']:\n",
    "        return 'pre-1920'\n",
    "    elif ab == '1930-1949':\n",
    "        return '1930-1949'\n",
    "    elif ab == '1950-1966':\n",
    "        return '1950-1966'\n",
    "    elif ab == '1967-1982':\n",
    "        return '1967-1982'\n",
    "    elif ab == '1983-1995':\n",
    "        return '1983-1995'\n",
    "    elif ab == '1996-2011':\n",
    "        return '1996-2011'\n",
    "    elif ab == '2012-onwards':\n",
    "        return '2012-onwards'\n",
    "    else:\n",
    "        return np.nan\n",
    "\n",
    "filtered_df['lookup_age_band'] = filtered_df['construction_age_band'].apply(standardize_age_band)\n",
    "\n",
    "# ===== 3. 全查找相关字段小写去空格 =====\n",
    "for col in [\n",
    "    'wall_type', 'wall_insulation', 'roof_type', 'roof_insulation', 'floor_type', 'glazing_type'\n",
    "]:\n",
    "    if col in filtered_df.columns:\n",
    "        filtered_df[col] = filtered_df[col].astype(str).str.strip().str.lower()\n",
    "\n",
    "# ===== 4. 构建查找表（只保留墙和屋顶/窗体） =====\n",
    "age_band_list = ['pre-1920', '1930-1949', '1950-1966', '1967-1982', '1983-1995', '1996-2011', '2012-onwards']\n",
    "\n",
    "# -- 墙体\n",
    "wall_lookup = pd.DataFrame({\n",
    "    'lookup_age_band': age_band_list*4,\n",
    "    'wall_type': ['solid']*7 + ['solid']*7 + ['cavity']*7 + ['cavity']*7,\n",
    "    'wall_insulation': ['uninsulated']*7 + ['insulated']*7 + ['uninsulated']*7 + ['insulated']*7,\n",
    "    'u_value_wall': [\n",
    "        1.7,1.7,1.36,1.35,1.0,0.37,0.16,    # solid/unins\n",
    "        0.55,0.55,0.55,0.35,0.35,0.19,0.16, # solid/ins\n",
    "        1.5,1.5,1.0,1.0,0.7,0.28,0.16,      # cavity/unins\n",
    "        0.37,0.37,0.32,0.32,0.25,0.18,0.16  # cavity/ins\n",
    "    ]\n",
    "})\n",
    "\n",
    "# -- 屋顶\n",
    "roof_comb = []\n",
    "roof_uv = []\n",
    "for ab in age_band_list:\n",
    "    # pitched-unins+ins\n",
    "    roof_comb += [(ab, 'pitched', 'uninsulated'), (ab, 'pitched', 'insulated')]\n",
    "    roof_uv += [2.3, 0.25]\n",
    "    # flat-unins+ins\n",
    "    roof_comb += [(ab, 'flat', 'uninsulated'), (ab, 'flat', 'insulated')]\n",
    "    roof_uv += [2.3, 0.28]\n",
    "    # room in roof, 跟pitched一致\n",
    "    roof_comb += [(ab, 'room in roof', 'uninsulated'), (ab, 'room in roof', 'insulated')]\n",
    "    roof_uv += [2.3, 0.25]\n",
    "    # another dwelling above\n",
    "    roof_comb += [(ab, 'another dwelling above', 'another dwelling above')]\n",
    "    roof_uv += [0.0]\n",
    "roof_lookup = pd.DataFrame(roof_comb, columns=['lookup_age_band','roof_type','roof_insulation'])\n",
    "roof_lookup['u_value_roof'] = roof_uv\n",
    "\n",
    "# -- 窗\n",
    "glazing_lookup = pd.DataFrame({\n",
    "    'glazing_type': ['single/partial','double/triple','secondary'],\n",
    "    'u_value_glazing': [5.75,2.4,2.82]\n",
    "})\n",
    "\n",
    "# ===== 5. 查表函数（用字符串） =====\n",
    "def get_wall_u(row):\n",
    "    try:\n",
    "        match = wall_lookup[\n",
    "            (wall_lookup['lookup_age_band'] == row['lookup_age_band']) &\n",
    "            (wall_lookup['wall_type'] == row['wall_type']) &\n",
    "            (wall_lookup['wall_insulation'] == row['wall_insulation'])\n",
    "        ]\n",
    "        return match['u_value_wall'].iloc[0] if not match.empty else np.nan\n",
    "    except: return np.nan\n",
    "\n",
    "def get_roof_u(row):\n",
    "    try:\n",
    "        match = roof_lookup[\n",
    "            (roof_lookup['lookup_age_band'] == row['lookup_age_band']) &\n",
    "            (roof_lookup['roof_type'] == row['roof_type']) &\n",
    "            (roof_lookup['roof_insulation'] == row['roof_insulation'])\n",
    "        ]\n",
    "        return match['u_value_roof'].iloc[0] if not match.empty else np.nan\n",
    "    except: return np.nan\n",
    "\n",
    "def get_glazing_u(row):\n",
    "    try:\n",
    "        match = glazing_lookup[\n",
    "            (glazing_lookup['glazing_type'] == row['glazing_type'])\n",
    "        ]\n",
    "        return match['u_value_glazing'].iloc[0] if not match.empty else np.nan\n",
    "    except: return np.nan\n",
    "\n",
    "filtered_df['u_value_wall'] = filtered_df.apply(get_wall_u, axis=1)\n",
    "filtered_df['u_value_roof'] = filtered_df.apply(get_roof_u, axis=1)\n",
    "filtered_df['u_value_floor'] = 0.25  # 直接赋值为0.25，不做查表\n",
    "filtered_df['u_value_glazing'] = filtered_df.apply(get_glazing_u, axis=1)\n",
    "\n",
    "# ===== 7. 输出结果 =====\n",
    "filtered_df.to_csv('cleaned_flat_terraced_data_final.csv',index=False)\n",
    "print(filtered_df.head())\n",
    "print(filtered_df.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "798e9c2a-917b-4ee0-a00b-8687af0f67e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "core_cols = [\n",
    "    'construction_age_band', 'wall_type', 'wall_insulation', 'roof_type', 'roof_insulation',\n",
    "    'glazing_type', 'built_form',\n",
    "    'total_floor_area', 'estimated_floor_count', 'number_habitable_rooms',\n",
    "    'epc_score', 'main_heat_type', 'main_fuel_type', 'energy_consumption',\n",
    "    'lookup_age_band', 'u_value_wall', 'u_value_roof', 'u_value_floor', 'u_value_glazing'\n",
    "]\n",
    "filtered_df_clean = filtered_df[core_cols].dropna().reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9999978e-1cc2-4678-b113-ce7629c9c254",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import pandas as pd\n",
    "\n",
    "T_in = 20     # 室内\n",
    "T_out = 2     # 室外\n",
    "\n",
    "def get_roof_delta_T(row):\n",
    "    # 阁楼温度=室内与室外均值\n",
    "    T_attic = (T_in + T_out) / 2\n",
    "    if row['roof_type'] == 'flat':\n",
    "        # 顶层平屋顶/顶层直接对外\n",
    "        return T_in - T_out\n",
    "    elif row['roof_type'] == 'room_in_roof':\n",
    "        # 阁楼房间（住人）直接对外（可选略小，通常也用T_in - T_out） \n",
    "        return T_in - T_out\n",
    "    elif row['roof_type'] == 'pitched':\n",
    "        # 下方是阁楼（未住人），屋顶不直接对外\n",
    "        # 居住区与阁楼间，温差为室内-阁楼\n",
    "        return T_in - T_attic\n",
    "    elif row['roof_type'] == 'another_dwelling_above':\n",
    "        # 上面是别人家/住户，几乎不散热\n",
    "        return 0\n",
    "    else:\n",
    "        # 默认\n",
    "        return T_in - T_out\n",
    "\n",
    "def get_floor_delta_T(row):\n",
    "    # 阁楼温度=室内与室外均值\n",
    "    T_attic = (T_in + T_out) / 2\n",
    "    # 如果有floor_position之类字段，可根据实际情况细分\n",
    "    # 这里只做通用（你可以根据实际项目调整/完善下面判断！）\n",
    "    if 'floor_position' in row and row['floor_position'] == 'middle':\n",
    "        # 中间层，直接无热损\n",
    "        return 0\n",
    "    elif row['roof_type'] == 'pitched':\n",
    "        # 通常楼下是未开发loft，假设底层/普通楼层\n",
    "        return T_in - T_out\n",
    "    elif row['roof_type'] == 'room_in_roof':\n",
    "        # 阁楼：楼板下一层是阁楼\n",
    "        # 若阁楼为居住空间，对下不散热；如果room_in_roof直接跳出，用T_in-T_out\n",
    "        # 或近似用(室内-阁楼温度)\n",
    "        return T_in - T_attic\n",
    "    elif row['roof_type'] == 'another_dwelling_above':\n",
    "        # 多层公寓被其他住户覆盖，无热损\n",
    "        return 0\n",
    "    else:\n",
    "        return T_in - T_out\n",
    "\n",
    "def calc_areas(row):\n",
    "    tfa = row['total_floor_area']\n",
    "    # 1) pitched未开发阁楼\n",
    "    if row['roof_type'] == 'pitched':\n",
    "        roof_area = 0\n",
    "    # 2) 平屋顶\n",
    "    elif row['roof_type'] == 'flat':\n",
    "        roof_area = tfa\n",
    "    # 3) 阁楼居住\n",
    "    elif row['roof_type'] == 'room_in_roof':\n",
    "        roof_area = tfa / math.cos(math.radians(30))  # 如果你有斜面系数可以改\n",
    "    # 4) 楼上有别人家\n",
    "    elif row['roof_type'] == 'another_dwelling_above':\n",
    "        roof_area = 0\n",
    "    else:\n",
    "        roof_area = 0\n",
    "\n",
    "    wall_area = tfa * 2.1\n",
    "    floor_area = tfa\n",
    "    glazing_area = tfa * 0.18\n",
    "    return pd.Series([wall_area, roof_area, floor_area, glazing_area])\n",
    "\n",
    "filtered_df_clean[['wall_area', 'roof_area', 'floor_area', 'glazing_area']] = \\\n",
    "    filtered_df_clean.apply(calc_areas, axis=1)\n",
    "\n",
    "def calc_Q_total(row):\n",
    "    Q_wall = row['u_value_wall'] * row['wall_area'] * (T_in - T_out)\n",
    "    Q_floor = row['u_value_floor'] * row['floor_area'] * get_floor_delta_T(row)\n",
    "    Q_glazing = row['u_value_glazing'] * row['glazing_area'] * (T_in - T_out)\n",
    "    Q_roof = row['u_value_roof'] * row['roof_area'] * get_roof_delta_T(row)\n",
    "    return Q_wall + Q_floor + Q_glazing + Q_roof\n",
    "\n",
    "filtered_df_clean['Q_total'] = filtered_df_clean.apply(calc_Q_total, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "660e52ba-8303-4dfa-a681-aefcdaf0ff64",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 重新组织特征\n",
    "cat_cols = [\n",
    "    'built_form', 'wall_type', 'wall_insulation', 'roof_type', 'roof_insulation',\n",
    "    'glazing_type', 'main_heat_type', 'main_fuel_type', 'lookup_age_band'\n",
    "]  # 这些是类别特征，与你图1一致\n",
    "\n",
    "num_cols = [\n",
    "    'epc_score', 'estimated_floor_count', 'Q_total'\n",
    "]  # Q_total是物理灰盒，另外两个是你指定数值型非物理特征\n",
    "\n",
    "# 构建X, y\n",
    "X = pd.get_dummies(filtered_df_clean[cat_cols + num_cols], drop_first=True)\n",
    "y = filtered_df_clean['energy_consumption']\n",
    "\n",
    "# 缺失值用0填补（提前保证输入模型不会报错）\n",
    "X = X.fillna(0)\n",
    "y = y.fillna(0)\n",
    "\n",
    "\n",
    "# 切分训练/测试集\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=100, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "082b867d-b353-41f7-954c-12ef130e3c18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "corr_matrix = pd.DataFrame(X_train, columns=X.columns).corr()\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "plt.figure(figsize=(10,8))\n",
    "sns.heatmap(corr_matrix, annot=False, cmap='coolwarm', center=0)\n",
    "plt.title(\"Feature Correlation Matrix\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f11658f-35fe-4987-8909-87d1bbc6a9ed",
   "metadata": {},
   "source": [
    "# ML Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "abd63b57-b26e-476b-9052-719fe8cb39a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "/opt/conda/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "/opt/conda/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "/opt/conda/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              Model    R2     RMSE      MAE   MAPE  Acc(<10%)  Acc(<20%)\n",
      "4  GradientBoosting 0.942 2027.940  763.963  8.898     74.238     88.854\n",
      "0  LinearRegression 0.907 2554.912 1531.317 19.126     56.677     78.023\n",
      "1             Ridge 0.907 2558.234 1529.474 19.074     56.467     78.233\n",
      "2      DecisionTree 0.898 2688.565 1017.803 12.656     66.667     83.912\n",
      "3      RandomForest 0.891 2778.652 1167.927 14.802     61.304     78.128\n",
      "5        KNeighbors 0.849 3269.439 1475.462 18.316     60.778     73.922\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "/opt/conda/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "/tmp/ipykernel_62485/1618681004.py:51: FutureWarning: \n",
      "\n",
      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.\n",
      "\n",
      "  sns.barplot(x='R2', y='Model', data=results_df, palette='coolwarm')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# 机器学习模型对比\n",
    "from sklearn.linear_model import LinearRegression, Ridge\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
    "\n",
    "models = {\n",
    "    'LinearRegression': LinearRegression(),\n",
    "    'Ridge': Ridge(alpha=1.0),\n",
    "    'DecisionTree': DecisionTreeRegressor(random_state=100, max_depth=10),\n",
    "    'RandomForest': RandomForestRegressor(random_state=100, n_estimators=100, max_depth=7),\n",
    "    'GradientBoosting': GradientBoostingRegressor(random_state=100, n_estimators=100, max_depth=6),\n",
    "    'KNeighbors': KNeighborsRegressor(n_neighbors=5)\n",
    "}\n",
    "\n",
    "results = []\n",
    "for name, model in models.items():\n",
    "    model.fit(X_train, y_train)\n",
    "    y_pred = model.predict(X_test)\n",
    "    mae = mean_absolute_error(y_test, y_pred)\n",
    "    rmse = mean_squared_error(y_test, y_pred, squared=False)\n",
    "    r2 = r2_score(y_test, y_pred)\n",
    "    # 新增MAPE，防止分母为0通常加一点小量,或者直接用np.mean\n",
    "    mape = np.mean(np.abs((y_test - y_pred) / (y_test + 1e-8))) * 100\n",
    "    \n",
    "    # 统计在误差阈值10%、20%以内的“准确率”\n",
    "    abs_pct_error = np.abs((y_test - y_pred) / (y_test + 1e-8))\n",
    "    acc_10 = np.mean(abs_pct_error < 0.10) * 100   # 10%以内百分比\n",
    "    acc_20 = np.mean(abs_pct_error < 0.20) * 100   # 20%以内百分比\n",
    "\n",
    "    results.append({\n",
    "        'Model': name, \n",
    "        'R2': r2, \n",
    "        'RMSE': rmse, \n",
    "        'MAE': mae, \n",
    "        'MAPE': mape,\n",
    "        'Acc(<10%)': acc_10,   # 误差小于10%的样本占比\n",
    "        'Acc(<20%)': acc_20    # 误差小于20%的样本占比\n",
    "    })\n",
    "\n",
    "results_df = pd.DataFrame(results).sort_values(\"R2\", ascending=False)\n",
    "# 显示所有关键指标，保留3位小数，百分数列也美化\n",
    "with pd.option_context('display.float_format', '{:.3f}'.format):\n",
    "    print(results_df)\n",
    "    \n",
    "# 绘制R2对比条形图\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(8,3))\n",
    "sns.barplot(x='R2', y='Model', data=results_df, palette='coolwarm')\n",
    "plt.title(\"Model Performance Comparison (R² Score)\")\n",
    "plt.xlim(0, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38008fdc-99f0-428b-9b3b-ad639619937c",
   "metadata": {},
   "source": [
    "# Boost Model API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "78181835-8c25-43cc-8144-ec9d7d2fa927",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: scikit-learn==1.7.0 in /opt/conda/lib/python3.11/site-packages (1.7.0)\n",
      "Requirement already satisfied: numpy>=1.22.0 in /opt/conda/lib/python3.11/site-packages (from scikit-learn==1.7.0) (2.0.2)\n",
      "Requirement already satisfied: scipy>=1.8.0 in /opt/conda/lib/python3.11/site-packages (from scikit-learn==1.7.0) (1.13.1)\n",
      "Requirement already satisfied: joblib>=1.2.0 in /opt/conda/lib/python3.11/site-packages (from scikit-learn==1.7.0) (1.4.2)\n",
      "Requirement already satisfied: threadpoolctl>=3.1.0 in /opt/conda/lib/python3.11/site-packages (from scikit-learn==1.7.0) (3.5.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install scikit-learn==1.7.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b4e021ea-ff5d-4988-9c24-1530a23230ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['gb_features.joblib']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "import joblib\n",
    "\n",
    "# 训练模型\n",
    "gb = GradientBoostingRegressor(random_state=100, n_estimators=100, max_depth=5)\n",
    "gb.fit(X, y)\n",
    "\n",
    "# 保存模型和特征名\n",
    "joblib.dump(gb, 'gb_model.joblib')\n",
    "joblib.dump(X.columns.tolist(), 'gb_features.joblib')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0306057-8fcd-48f9-98ba-8a6c743d499f",
   "metadata": {},
   "source": [
    "## Vis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e36cf147-930d-43be-ad00-82e86a26b1f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Feature</th>\n",
       "      <th>Standardized Coefficient</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Calculated Heat Loss (Q_total)</td>\n",
       "      <td>8314.490</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Main Fuel Type Other</td>\n",
       "      <td>8312.884</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Main Fuel Type Mains Gas</td>\n",
       "      <td>6887.485</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Roof Type Room In Roof</td>\n",
       "      <td>5297.896</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Main Fuel Type No Heating System</td>\n",
       "      <td>5107.962</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Main Heat Type No Heating System</td>\n",
       "      <td>5107.962</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Wall (Uninsulated)</td>\n",
       "      <td>-4183.660</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Flat Roof</td>\n",
       "      <td>-4108.532</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Lookup Age Band 1996-2011</td>\n",
       "      <td>3573.880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>EPC Score</td>\n",
       "      <td>-3415.335</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                            Feature  Standardized Coefficient\n",
       "0    Calculated Heat Loss (Q_total)                  8314.490\n",
       "1              Main Fuel Type Other                  8312.884\n",
       "2          Main Fuel Type Mains Gas                  6887.485\n",
       "3            Roof Type Room In Roof                  5297.896\n",
       "4  Main Fuel Type No Heating System                  5107.962\n",
       "5  Main Heat Type No Heating System                  5107.962\n",
       "6                Wall (Uninsulated)                 -4183.660\n",
       "7                         Flat Roof                 -4108.532\n",
       "8         Lookup Age Band 1996-2011                  3573.880\n",
       "9                         EPC Score                 -3415.335"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_62485/2978900564.py:63: FutureWarning: \n",
      "\n",
      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
      "\n",
      "  ax = sns.barplot(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# 提取数值列和类别列\n",
    "# 推荐标准化数值列，再和类别列concat\n",
    "num_cols = ['epc_score', 'estimated_floor_count', 'Q_total']\n",
    "cat_cols = [c for c in X_train.columns if c not in num_cols]\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_num_train_scaled = scaler.fit_transform(X_train[num_cols])\n",
    "X_all_train_scaled = np.concatenate([X_num_train_scaled, X_train[cat_cols].values], axis=1)\n",
    "\n",
    "lr_scaled = LinearRegression()\n",
    "lr_scaled.fit(X_all_train_scaled, y_train)\n",
    "\n",
    "coefs = lr_scaled.coef_\n",
    "\n",
    "# 合成变量名（保证顺序对齐）\n",
    "all_feature_names = num_cols + cat_cols\n",
    "\n",
    "coef_df = pd.DataFrame({\n",
    "    'Feature': all_feature_names,\n",
    "    'Coefficient': coefs\n",
    "})\n",
    "\n",
    "# ==== 保留三位小数 ====\n",
    "coef_df['Coefficient'] = coef_df['Coefficient'].apply(lambda x: float(f\"{x:.3f}\"))\n",
    "\n",
    "# 变量名映射（易读友好名）\n",
    "readable_names = {\n",
    "    'roof_insulation_uninsulated': \"Roof (Uninsulated)\",\n",
    "    'roof_insulation_insulated': \"Roof (Insulated)\",\n",
    "    'roof_type_flat': \"Flat Roof\",\n",
    "    'roof_type_pitched': \"Pitched Roof\",\n",
    "    'wall_insulation_uninsulated': \"Wall (Uninsulated)\",\n",
    "    'main_fuel_type_no_heating_system': \"No Main Fuel\",\n",
    "    'main_heat_type_no_heating_system': \"No Heating System\",\n",
    "    'Q_total': \"Calculated Heat Loss (Q_total)\",\n",
    "    'epc_score': \"EPC Score\",\n",
    "    'main_fuel_type_mains_gas': \"Mains Gas\",\n",
    "    # ...其余变量继续补...\n",
    "}\n",
    "coef_df['Feature Readable'] = coef_df['Feature'].map(lambda x: readable_names.get(x, x.replace(\"_\", \" \").title()))\n",
    "\n",
    "# 按绝对值排序，取前10\n",
    "coef_top10 = coef_df.reindex(coef_df['Coefficient'].abs().sort_values(ascending=False).index).head(10).reset_index(drop=True)\n",
    "\n",
    "# ==== 表格显示三位小数，无科学计数 ====\n",
    "pd.set_option('display.float_format', '{:.3f}'.format)\n",
    "display(\n",
    "    coef_top10[['Feature Readable', 'Coefficient']].rename(\n",
    "        columns={'Feature Readable': 'Feature', 'Coefficient': 'Standardized Coefficient'}\n",
    "    )\n",
    ")\n",
    "\n",
    "# ==== 图形美化，三位小数，数字标注 ====\n",
    "plt.figure(figsize=(10,6))\n",
    "sns.set_style(\"whitegrid\")\n",
    "ax = sns.barplot(\n",
    "    data=coef_top10,\n",
    "    x='Feature Readable',\n",
    "    y='Coefficient',\n",
    "    palette=\"coolwarm\"\n",
    ")\n",
    "plt.xticks(rotation=30, ha='right', fontsize=12)\n",
    "plt.title(\"Top 10 Most Influential Features in Linear Regression (Standardized Coefficient)\", fontsize=15)\n",
    "plt.xlabel(\"Feature Name\", fontsize=12)\n",
    "plt.ylabel(\"Standardized Coefficient\", fontsize=12)\n",
    "for i, v in enumerate(coef_top10['Coefficient']):\n",
    "    ax.text(i, v + 0.02 * (1 if v > 0 else -1), f\"{v:.3f}\", color='black', ha='center', va='bottom' if v > 0 else 'top', fontsize=11)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f92c7c4a-e4cc-4748-b7b7-3b08be83e393",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e505b65-be2d-4da9-ab64-e0b02dd17dcb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e97f039-0682-4148-bf96-01b6ede8b2ff",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (base)",
   "language": "python",
   "name": "base"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}