{ "cells": [ { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original features: 70\n", "Missing values per column:\n", "Avg TiDB vCPU 0\n", "log(Avg_TiDB_vCPU_x_Read_KB) 0\n", "log(Avg_TiDB_vCPU_x_Write_KB) 0\n", "Avg_TiDB_vCPU_x_Write_KB 0\n", "sqrt(Avg_TiDB_vCPU_x_Write_RPC) 0\n", "log(Avg_TiDB_vCPU_x_Write_RPC) 0\n", "Avg_TiDB_vCPU_x_Write_RPC 0\n", "sqrt(Avg_TiDB_vCPU_x_Read_KB) 0\n", "Avg_TiDB_vCPU_x_Read_KB 0\n", "Read_RPC_x_Read_KB 0\n", "dtype: int64\n", "\n", "Target variable statistics:\n", "Min: 1589.75, Max: 448210.61, Mean: 53716.37, Std: 89327.92\n" ] } ], "source": [ "import pandas as pd\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "from sklearn.linear_model import Lasso, ElasticNet\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.feature_selection import SelectKBest, mutual_info_regression, RFE, RFECV\n", "from scipy import stats\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "# Load the data\n", "df = pd.read_pickle(\"../input/tidbcloud_dedicated_pricing_dataset.pkl\")\n", "\n", "feature_columns = [\n", " 'Avg TiDB vCPU', 'Avg TiKV vCPU', \n", " 'Avg TiDB CPU Util', 'Avg TiKV CPU Util',\n", " 'Avg Total vCPU', 'Avg Total CPU Util',\n", " 'Avg Read RCU', 'Read RCU%',\n", " 'Avg Write RCU', 'Write RCU %', \n", " 'Avg RCU/vCPU(PromQL)', 'Avg RCU/vCPU', \n", " 'Read QPS', 'Read RPC','Read RPC/Query', 'Read RPC RCU%', 'Read KB', 'Read Bytes RCU%', \n", " 'Write QPS', 'Write RPC', 'Write RPC/Query', 'Write RPC RCU%', 'Write KB', 'Write KB/RPC', 'Write Bytes RCU%'\n", "]\n", "\n", "selected_expert_features = [\n", " 'Avg TiDB vCPU', \n", " # 'Avg TiKV vCPU',\n", " 'Read RPC',\n", " 'Read KB',\n", " 'Write RPC',\n", " 'Write KB'\n", "]\n", "\n", "selected_expert_features_num = len(selected_expert_features)\n", "\n", "for i in range(selected_expert_features_num):\n", " feature_name = selected_expert_features[i]\n", " # replace “ ” with \"_\"\n", " normalized_feature_name = feature_name.replace(\" \", \"_\")\n", " df[normalized_feature_name] = df[feature_name]\n", " log_new_feature = f\"log({normalized_feature_name})\"\n", " df[log_new_feature] = np.log(df[selected_expert_features[i]])\n", " feature_columns.append(log_new_feature)\n", " power_new_feature = f\"power({normalized_feature_name})\"\n", " df[power_new_feature] = np.power(df[selected_expert_features[i]], 2)\n", " feature_columns.append(power_new_feature)\n", " sqrt_new_feature = f\"sqrt({normalized_feature_name})\"\n", " df[sqrt_new_feature] = np.sqrt(df[selected_expert_features[i]])\n", " feature_columns.append(sqrt_new_feature)\n", "\n", "for i in range(selected_expert_features_num):\n", " normalized_feature_name_i= selected_expert_features[i].replace(\" \", \"_\")\n", " for j in range(i+1, selected_expert_features_num):\n", " normalized_feature_name_j = selected_expert_features[j].replace(\" \", \"_\")\n", " newfeature_name = f\"{normalized_feature_name_i}_x_{normalized_feature_name_j}\"\n", " df[newfeature_name] = df[selected_expert_features[i]] * df[selected_expert_features[j]]\n", " feature_columns.append(newfeature_name)\n", " log_newfeature_name = f\"log({newfeature_name})\"\n", " df[log_newfeature_name] = np.log(df[newfeature_name])\n", " feature_columns.append(log_newfeature_name)\n", " sqrt_newfeature_name = f\"sqrt({newfeature_name})\"\n", " df[sqrt_newfeature_name] = np.sqrt(df[newfeature_name])\n", " feature_columns.append(sqrt_newfeature_name)\n", " \n", "\n", "\n", "df = df[(df['Dedicated Price Compute Only WO TiFlash'] >= 1500)]\n", "# Create feature matrix and handle missing values\n", "y = df['Dedicated Price Compute Only WO TiFlash']\n", "# y = (df['Dedicated Price Compute Only']) * 0.7\n", "# y = (df['Dedicated Price TiDB Compute Only'] + df['Dedicated Price TiKV Compute Only']) * 0.7\n", "\n", "X = df[feature_columns].copy()\n", "\n", "print(f\"Original features: {X.shape[1]}\")\n", "print(f\"Missing values per column:\")\n", "print(X.isnull().sum().sort_values(ascending=False).head(10))\n", "\n", "print(f\"\\nTarget variable statistics:\")\n", "print(f\"Min: {y.min():.2f}, Max: {y.max():.2f}, Mean: {y.mean():.2f}, Std: {y.std():.2f}\")\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dropping features: ['Avg TiDB vCPU'], since Avg TiKV vCPU is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg TiKV vCPU'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['Avg Total CPU Util'], since Avg TiKV CPU Util is the best correlated with the target\n", "Dropping features: ['Avg RCU/vCPU'], since Avg RCU/vCPU(PromQL) is the best correlated with the target\n", "Dropping features: ['Read RPC RCU%'], since Read Bytes RCU% is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg TiKV vCPU', 'log(Avg_TiDB_vCPU)', 'sqrt(Avg_TiDB_vCPU)'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['log(Read_RPC)'], since log(Avg_TiDB_vCPU) is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Read RPC', 'sqrt(Read_RPC)'], since sqrt(Avg_TiDB_vCPU) is the best correlated with the target\n", "Dropping features: ['Read KB'], since sqrt(Read_KB) is the best correlated with the target\n", "Dropping features: ['Avg Write RCU', 'Write RPC', 'Write KB'], since sqrt(Write_RPC) is the best correlated with the target\n", "Dropping features: ['log(Write_KB)'], since log(Write_RPC) is the best correlated with the target\n", "Dropping features: ['Write KB', 'sqrt(Write_KB)'], since sqrt(Write_RPC) is the best correlated with the target\n", "Dropping features: ['log(Read_RPC)', 'log(Avg_TiDB_vCPU_x_Read_RPC)'], since log(Avg_TiDB_vCPU) is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg Read RCU', 'Read RPC', 'power(Avg_TiDB_vCPU)', 'sqrt(Avg_TiDB_vCPU)', 'power(Read_RPC)', 'sqrt(Read_RPC)', 'Avg_TiDB_vCPU_x_Read_RPC', 'sqrt(Avg_TiDB_vCPU_x_Read_RPC)'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['power(Avg_TiDB_vCPU)', 'power(Read_KB)', 'Avg_TiDB_vCPU_x_Read_KB'], since Avg Read RCU is the best correlated with the target\n", "Dropping features: ['log(Read_KB)'], since log(Avg_TiDB_vCPU_x_Read_KB) is the best correlated with the target\n", "Dropping features: ['Read KB', 'Avg_TiDB_vCPU_x_Read_KB', 'sqrt(Avg_TiDB_vCPU_x_Read_KB)'], since Avg Read RCU is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg TiKV vCPU', 'Avg_TiDB_vCPU_x_Write_RPC'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['log(Read_RPC)', 'log(Write_RPC)', 'log(Write_KB)', 'log(Avg_TiDB_vCPU_x_Read_RPC)', 'log(Avg_TiDB_vCPU_x_Write_RPC)'], since log(Avg_TiDB_vCPU) is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg TiKV vCPU', 'Avg Write RCU', 'Write RPC', 'sqrt(Avg_TiDB_vCPU)', 'sqrt(Write_RPC)', 'Avg_TiDB_vCPU_x_Write_RPC', 'sqrt(Avg_TiDB_vCPU_x_Write_RPC)'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['Avg_TiDB_vCPU_x_Write_RPC', 'Avg_TiDB_vCPU_x_Write_KB'], since sqrt(Avg_TiDB_vCPU_x_Write_RPC) is the best correlated with the target\n", "Dropping features: ['log(Read_RPC)', 'log(Write_RPC)', 'log(Write_KB)', 'log(Avg_TiDB_vCPU_x_Read_RPC)', 'log(Avg_TiDB_vCPU_x_Write_RPC)', 'log(Avg_TiDB_vCPU_x_Write_KB)'], since log(Avg_TiDB_vCPU) is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg TiKV vCPU', 'Avg Write RCU', 'Write RPC', 'Write KB', 'sqrt(Avg_TiDB_vCPU)', 'sqrt(Write_RPC)', 'Avg_TiDB_vCPU_x_Write_RPC', 'sqrt(Avg_TiDB_vCPU_x_Write_RPC)', 'Avg_TiDB_vCPU_x_Write_KB', 'sqrt(Avg_TiDB_vCPU_x_Write_KB)'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['power(Avg_TiDB_vCPU)', 'power(Read_RPC)', 'Avg_TiDB_vCPU_x_Read_RPC', 'Avg_TiDB_vCPU_x_Read_KB', 'sqrt(Avg_TiDB_vCPU_x_Read_KB)', 'Read_RPC_x_Read_KB'], since Avg Read RCU is the best correlated with the target\n", "Dropping features: ['log(Read_KB)', 'log(Read_RPC_x_Read_KB)'], since log(Avg_TiDB_vCPU_x_Read_KB) is the best correlated with the target\n", "Dropping features: ['Avg Read RCU', 'Read KB', 'power(Avg_TiDB_vCPU)', 'Avg_TiDB_vCPU_x_Read_KB', 'sqrt(Avg_TiDB_vCPU_x_Read_KB)', 'Read_RPC_x_Read_KB', 'sqrt(Read_RPC_x_Read_KB)'], since sqrt(Avg_TiDB_vCPU_x_Read_RPC) is the best correlated with the target\n", "Dropping features: ['log(Read_RPC)', 'log(Write_RPC)', 'log(Write_KB)', 'log(Avg_TiDB_vCPU_x_Read_RPC)', 'log(Avg_TiDB_vCPU_x_Write_RPC)', 'log(Avg_TiDB_vCPU_x_Write_KB)', 'log(Read_RPC_x_Write_RPC)'], since log(Avg_TiDB_vCPU) is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg TiKV vCPU', 'Read RPC', 'sqrt(Avg_TiDB_vCPU)', 'sqrt(Read_RPC)', 'sqrt(Avg_TiDB_vCPU_x_Read_RPC)', 'sqrt(Avg_TiDB_vCPU_x_Write_RPC)', 'sqrt(Avg_TiDB_vCPU_x_Write_KB)', 'Read_RPC_x_Write_RPC', 'sqrt(Read_RPC_x_Write_RPC)'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['Avg Read RCU', 'power(Avg_TiDB_vCPU)', 'sqrt(Avg_TiDB_vCPU_x_Read_RPC)', 'Avg_TiDB_vCPU_x_Read_KB', 'sqrt(Avg_TiDB_vCPU_x_Read_KB)', 'Avg_TiDB_vCPU_x_Write_KB', 'Read_RPC_x_Read_KB', 'sqrt(Read_RPC_x_Read_KB)', 'Read_RPC_x_Write_RPC', 'Read_RPC_x_Write_KB'], since sqrt(Read_RPC_x_Write_RPC) is the best correlated with the target\n", "Dropping features: ['log(Read_RPC)', 'log(Write_RPC)', 'log(Write_KB)', 'log(Avg_TiDB_vCPU_x_Read_RPC)', 'log(Avg_TiDB_vCPU_x_Write_RPC)', 'log(Avg_TiDB_vCPU_x_Write_KB)', 'log(Read_RPC_x_Write_RPC)', 'log(Read_RPC_x_Write_KB)'], since log(Avg_TiDB_vCPU) is the best correlated with the target\n", "Dropping features: ['Avg TiDB vCPU', 'Avg TiKV vCPU', 'sqrt(Avg_TiDB_vCPU)', 'sqrt(Read_RPC)', 'sqrt(Avg_TiDB_vCPU_x_Read_RPC)', 'sqrt(Avg_TiDB_vCPU_x_Write_RPC)', 'sqrt(Avg_TiDB_vCPU_x_Write_KB)', 'sqrt(Read_RPC_x_Write_RPC)', 'Read_RPC_x_Write_KB', 'sqrt(Read_RPC_x_Write_KB)'], since Avg Total vCPU is the best correlated with the target\n", "Dropping features: ['Read KB', 'power(Read_KB)', 'Avg_TiDB_vCPU_x_Read_KB', 'Read_RPC_x_Write_KB', 'Read_KB_x_Write_RPC'], since sqrt(Avg_TiDB_vCPU_x_Read_KB) is the best correlated with the target\n", "Dropping features: ['log(Avg_TiDB_vCPU_x_Read_KB)', 'log(Avg_TiDB_vCPU_x_Write_KB)', 'log(Read_RPC_x_Read_KB)', 'log(Read_RPC_x_Write_KB)', 'log(Read_KB_x_Write_RPC)'], since log(Read_RPC_x_Write_RPC) is the best correlated with the target\n", "Dropping features: ['Avg Read RCU', 'Read KB', 'sqrt(Avg_TiDB_vCPU_x_Read_KB)', 'Avg_TiDB_vCPU_x_Write_KB', 'sqrt(Read_RPC_x_Read_KB)', 'Read_RPC_x_Write_KB', 'Read_KB_x_Write_RPC', 'sqrt(Read_KB_x_Write_RPC)'], since sqrt(Read_RPC_x_Write_KB) is the best correlated with the target\n", "Dropping features: ['log(Avg_TiDB_vCPU_x_Read_KB)', 'log(Read_RPC_x_Read_KB)', 'log(Read_KB_x_Write_RPC)', 'log(Read_KB_x_Write_KB)'], since log(Read_RPC_x_Write_KB) is the best correlated with the target\n", "Dropping features: ['Read KB', 'power(Read_KB)', 'Read_KB_x_Write_RPC', 'sqrt(Read_KB_x_Write_RPC)', 'Read_KB_x_Write_KB', 'sqrt(Read_KB_x_Write_KB)'], since sqrt(Avg_TiDB_vCPU_x_Read_KB) is the best correlated with the target\n", "Dropping features: ['log(Write_RPC)', 'log(Write_KB)', 'log(Avg_TiDB_vCPU_x_Write_KB)', 'log(Read_RPC_x_Write_RPC)', 'log(Read_RPC_x_Write_KB)', 'log(Write_RPC_x_Write_KB)'], since log(Avg_TiDB_vCPU_x_Write_RPC) is the best correlated with the target\n", "Dropping features: ['Avg Write RCU', 'Write RPC', 'Write KB', 'power(Write_RPC)', 'sqrt(Write_RPC)', 'power(Write_KB)', 'sqrt(Write_KB)', 'sqrt(Avg_TiDB_vCPU_x_Write_KB)', 'Write_RPC_x_Write_KB', 'sqrt(Write_RPC_x_Write_KB)'], since sqrt(Avg_TiDB_vCPU_x_Write_RPC) is the best correlated with the target\n", "Number of features before removing redundancy: 70\n", "Number of features removed due to high correlation: 55\n", "Features removed: ['log(Write_RPC_x_Write_KB)', 'sqrt(Avg_TiDB_vCPU_x_Read_RPC)', 'log(Avg_TiDB_vCPU_x_Read_KB)', 'sqrt(Read_RPC_x_Write_RPC)', 'Avg Write RCU', 'Avg TiDB vCPU', 'log(Avg_TiDB_vCPU)', 'Read RPC', 'log(Read_RPC_x_Read_KB)', 'Avg_TiDB_vCPU_x_Write_KB', 'log(Avg_TiDB_vCPU_x_Write_KB)', 'log(Write_RPC)', 'Read_RPC_x_Write_RPC', 'Write KB', 'sqrt(Read_RPC)', 'log(Read_KB_x_Write_KB)', 'sqrt(Avg_TiDB_vCPU_x_Read_KB)', 'sqrt(Read_RPC_x_Read_KB)', 'sqrt(Write_RPC)', 'Read_RPC_x_Read_KB', 'sqrt(Read_RPC_x_Write_KB)', 'Read RPC RCU%', 'Avg_TiDB_vCPU_x_Read_RPC', 'log(Read_KB)', 'Avg Total CPU Util', 'Avg Read RCU', 'Avg_TiDB_vCPU_x_Read_KB', 'sqrt(Avg_TiDB_vCPU_x_Write_KB)', 'power(Avg_TiDB_vCPU)', 'sqrt(Avg_TiDB_vCPU)', 'power(Read_RPC)', 'log(Read_RPC_x_Write_KB)', 'Read_KB_x_Write_RPC', 'log(Read_RPC)', 'log(Avg_TiDB_vCPU_x_Write_RPC)', 'power(Read_KB)', 'Avg RCU/vCPU', 'sqrt(Read_KB_x_Write_RPC)', 'Avg_TiDB_vCPU_x_Write_RPC', 'Avg TiKV vCPU', 'Write RPC', 'sqrt(Read_KB_x_Write_KB)', 'log(Avg_TiDB_vCPU_x_Read_RPC)', 'sqrt(Write_KB)', 'power(Write_RPC)', 'log(Read_RPC_x_Write_RPC)', 'Read_KB_x_Write_KB', 'power(Write_KB)', 'Read_RPC_x_Write_KB', 'log(Write_KB)', 'sqrt(Avg_TiDB_vCPU_x_Write_RPC)', 'log(Read_KB_x_Write_RPC)', 'Write_RPC_x_Write_KB', 'sqrt(Write_RPC_x_Write_KB)', 'Read KB']\n", "LassoCV found the optimal alpha: 7881.69606\n", "Using a manually adjusted, smaller alpha: 788.16961\n", "Number of features selected with manual alpha: 11\n", "\n", "=== Final Recommended Feature Set ===\n", "['Write RPC', 'Write RCU %', 'Read Bytes RCU%', 'Write KB', 'Read QPS', 'Write RPC RCU%', 'Read RCU%', 'Avg Total vCPU', 'Avg TiDB CPU Util', 'Avg TiKV CPU Util', 'Avg TiDB vCPU', 'Write KB/RPC', 'Avg RCU/vCPU(PromQL)', 'Read RPC', 'sqrt(Read_KB)', 'Read KB']\n" ] } ], "source": [ "# =============================================================================\n", "# Feature Selection Functions\n", "# =============================================================================\n", "from sklearn.linear_model import LassoCV\n", "from sklearn.model_selection import train_test_split\n", "\n", "def select_by_correlation(X_train_df, y_train_series, threshold=0.1):\n", " \"\"\"\n", " Step 1: Select initial candidate features by their correlation \n", " with the target variable. (Reusing your function)\n", " \"\"\"\n", " correlations = []\n", " for col in X_train_df.columns:\n", " # Ensure we are working with numeric types and handle potential NaNs\n", " if pd.api.types.is_numeric_dtype(X_train_df[col]):\n", " corr = abs(np.corrcoef(X_train_df[col].fillna(0), y_train_series.fillna(0))[0, 1])\n", " correlations.append((col, corr))\n", " \n", " correlations.sort(key=lambda x: x[1], reverse=True)\n", " selected_features = [name for name, corr in correlations if corr > threshold]\n", " \n", " return selected_features\n", "\n", "def remove_highly_correlated_features(X_train_df, y_train_series, features_to_check, threshold=0.9):\n", " \"\"\"\n", " Step 2: From a list of candidate features, remove features that are highly\n", " correlated with each other to avoid multicollinearity.\n", " \"\"\"\n", " X_subset = X_train_df[features_to_check]\n", " corr_matrix = X_subset.corr().abs()\n", " upper_triangle = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))\n", " \n", " features_to_drop = set()\n", " for column in upper_triangle.columns:\n", " high_corr_group = upper_triangle.index[upper_triangle[column] > threshold].tolist()\n", " if high_corr_group:\n", " # For each group of highly correlated features, find their individual correlation with the target\n", " all_correlated_features = high_corr_group + [column]\n", " target_correlations = {\n", " feat: abs(np.corrcoef(X_train_df[feat], y_train_series)[0, 1])\n", " for feat in all_correlated_features\n", " }\n", "\n", "\n", " # Find the feature with the highest correlation to the target\n", " best_feature = max(target_correlations, key=target_correlations.get)\n", " if best_feature in selected_expert_features:\n", " continue\n", " \n", " # Add all other features in the group to the drop set\n", " drop_features = []\n", " for feat in all_correlated_features:\n", " if feat != best_feature:\n", " drop_features.append(feat)\n", "\n", " print(f\"Dropping features: {drop_features}, since {best_feature} is the best correlated with the target\")\n", " \n", " features_to_drop.update(drop_features)\n", "\n", " final_features = [feat for feat in features_to_check if feat not in features_to_drop]\n", " \n", " print(f\"Number of features before removing redundancy: {len(features_to_check)}\")\n", " print(f\"Number of features removed due to high correlation: {len(features_to_drop)}\")\n", " print(f\"Features removed: {list(features_to_drop)}\")\n", " \n", " return final_features\n", "\n", "def select_features_with_lasso_manually(X_train_df, y_train_series, features_to_use, alpha_multiplier=0.1):\n", " \"\"\"\n", " Step 3 (Alternative): Use Lasso with a manually adjusted alpha\n", " to select more features.\n", " \"\"\"\n", " X_subset = X_train_df[features_to_use]\n", " \n", " # Scale data before applying Lasso\n", " scaler = StandardScaler()\n", " X_scaled = scaler.fit_transform(X_subset)\n", " \n", " # First, run LassoCV to find the optimal alpha as a reference\n", " lasso_cv = LassoCV(cv=5, random_state=42, max_iter=3000)\n", " lasso_cv.fit(X_scaled, y_train_series)\n", " optimal_alpha = lasso_cv.alpha_\n", " print(f\"LassoCV found the optimal alpha: {optimal_alpha:.5f}\")\n", "\n", " # Now, set a smaller alpha manually to relax the selection criteria\n", " manual_alpha = optimal_alpha * alpha_multiplier # e.g., 10% of the optimal alpha\n", " print(f\"Using a manually adjusted, smaller alpha: {manual_alpha:.5f}\")\n", "\n", " # Train a new Lasso model with the manual alpha\n", " lasso_manual = Lasso(alpha=manual_alpha, random_state=42, max_iter=3000)\n", " lasso_manual.fit(X_scaled, y_train_series)\n", " \n", " # Get the selected features\n", " final_selected_features = [\n", " feature for feature, coef in zip(features_to_use, lasso_manual.coef_) if abs(coef) > 1e-6\n", " ]\n", " \n", " print(f\"Number of features selected with manual alpha: {len(final_selected_features)}\")\n", " \n", " return final_selected_features\n", "\n", "uncorrelated_features = remove_highly_correlated_features(\n", " X, y, feature_columns, threshold=0.90\n", ")\n", "selected_feature_columns = select_features_with_lasso_manually(X, y, uncorrelated_features)\n", "# selected_feature_columns = feature_columns\n", "# print(selected_feature_columns)\n", "selected_feature_columns = list(set(selected_feature_columns + selected_expert_features))\n", "print(\"\\n=== Final Recommended Feature Set ===\")\n", "print(selected_feature_columns)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--- Value counts of the binned target variable ---\n", "Dedicated Price Compute Only WO TiFlash\n", "6 12\n", "3 12\n", "0 12\n", "5 11\n", "4 11\n", "1 11\n", "2 11\n", "Name: count, dtype: int64\n", "---------------------------------------------\n", "Training set size: 72\n", "Test set size: 8\n", "\n", "--- Statistical summary of y in different sets ---\n", "Original y distribution:\n", " count 80.000000\n", "mean 53716.370375\n", "std 89327.923123\n", "min 1589.750000\n", "25% 4287.372500\n", "50% 9922.745000\n", "75% 51285.907500\n", "max 448210.610000\n", "Name: Dedicated Price Compute Only WO TiFlash, dtype: float64\n", "\n", "y_train distribution:\n", " count 72.000000\n", "mean 51534.906111\n", "std 88101.080321\n", "min 1589.750000\n", "25% 4287.372500\n", "50% 9571.675000\n", "75% 48720.485000\n", "max 448210.610000\n", "Name: Dedicated Price Compute Only WO TiFlash, dtype: float64\n", "\n", "y_test distribution:\n", " count 8.000000\n", "mean 73349.548750\n", "std 104104.754133\n", "min 1589.760000\n", "25% 5855.420000\n", "50% 12353.635000\n", "75% 112491.180000\n", "max 252172.460000\n", "Name: Dedicated Price Compute Only WO TiFlash, dtype: float64\n", "---------------------------------------------\n" ] } ], "source": [ "X = df[selected_feature_columns].copy()\n", "\n", "import pandas as pd\n", "import numpy as np\n", "from sklearn.model_selection import train_test_split\n", "\n", "num_bins = int(np.floor(1+np.log2(len(y))))\n", "\n", "try:\n", " y_binned = pd.qcut(y, q=num_bins, labels=False, duplicates='drop')\n", "except ValueError as e:\n", " # If qcut fails (e.g., too few data points or strange distribution),\n", " # you can fall back to cut, which divides by value range.\n", " print(f\"qcut failed: {e}. Trying pd.cut instead.\")\n", " y_binned = pd.cut(y, bins=num_bins, labels=False, include_lowest=True)\n", "\n", "# Check the distribution of the newly created bins\n", "print(\"--- Value counts of the binned target variable ---\")\n", "print(y_binned.value_counts())\n", "print(\"-\" * 45)\n", "\n", "\n", "# 2. Now, use this binned series for the 'stratify' parameter.\n", "# This ensures the distribution of y's values (low, medium, high, etc.)\n", "# is similar in both the training and testing sets.\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " X, y,\n", " test_size=0.1,\n", " random_state=42,\n", " stratify=y_binned # Use the binned categories for stratification\n", ")\n", "\n", "# 3. Verify the result\n", "print(f\"Training set size: {len(X_train)}\")\n", "print(f\"Test set size: {len(X_test)}\\n\")\n", "\n", "print(\"--- Statistical summary of y in different sets ---\")\n", "print(\"Original y distribution:\\n\", y.describe())\n", "print(\"\\ny_train distribution:\\n\", y_train.describe())\n", "print(\"\\ny_test distribution:\\n\", y_test.describe())\n", "print(\"-\" * 45)\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Z-score outliers in target: 1\n", "IQR outliers in target: 14\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def detect_outliers_zscore(data, threshold=3):\n", " z_scores = np.abs(stats.zscore(data))\n", " return z_scores > threshold\n", "\n", "def detect_outliers_iqr(data, factor=1.5):\n", " Q1 = np.percentile(data, 25)\n", " Q3 = np.percentile(data, 75)\n", " IQR = Q3 - Q1\n", " lower_bound = Q1 - factor * IQR\n", " upper_bound = Q3 + factor * IQR\n", " return (data < lower_bound) | (data > upper_bound)\n", "\n", "\n", "outliers_zscore = detect_outliers_zscore(y)\n", "outliers_iqr = detect_outliers_iqr(y)\n", "\n", "print(f\"Z-score outliers in target: {outliers_zscore.sum()}\")\n", "print(f\"IQR outliers in target: {outliers_iqr.sum()}\")\n", "\n", "\n", "plt.figure(figsize=(15, 5))\n", "\n", "plt.subplot(1, 3, 1)\n", "plt.hist(y, bins=20, alpha=0.7, edgecolor='black')\n", "plt.title('Target Variable Distribution')\n", "plt.xlabel('Target Cost')\n", "plt.ylabel('Frequency')\n", "\n", "plt.subplot(1, 3, 2)\n", "plt.boxplot(y)\n", "plt.title('Target Variable Boxplot')\n", "plt.ylabel('Target Cost')\n", "\n", "plt.subplot(1, 3, 3)\n", "plt.scatter(range(len(y)), y, alpha=0.7)\n", "plt.scatter(np.where(outliers_iqr)[0], y[outliers_iqr], color='red', s=50, label='IQR Outliers')\n", "plt.title('Target Values with Outliers')\n", "plt.xlabel('Sample Index')\n", "plt.ylabel('Target Cost')\n", "plt.legend()\n", "\n", "plt.tight_layout()\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=== Top 15 Features by Correlation with Target ===\n", " Feature Abs_Correlation\n", "7 Avg Total vCPU 0.887900\n", "10 Avg TiDB vCPU 0.864873\n", "13 Read RPC 0.783797\n", "0 Write RPC 0.720459\n", "3 Write KB 0.680042\n", "14 sqrt(Read_KB) 0.624446\n", "15 Read KB 0.598808\n", "4 Read QPS 0.554943\n", "1 Write RCU % 0.332546\n", "6 Read RCU% 0.286429\n", "11 Write KB/RPC 0.214784\n", "9 Avg TiKV CPU Util 0.164241\n", "2 Read Bytes RCU% 0.097053\n", "5 Write RPC RCU% 0.088498\n", "8 Avg TiDB CPU Util 0.081255\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "=== High Correlation Pairs (>0.9) ===\n", "Write RPC - Write KB: 0.922\n", "Avg Total vCPU - Avg TiDB vCPU: 0.970\n", "Avg TiDB vCPU - Read RPC: 0.937\n", "sqrt(Read_KB) - Read KB: 0.923\n", "\n", "Found 4 highly correlated feature pairs.\n" ] } ], "source": [ "\n", "scaler = StandardScaler()\n", "X_scaled = scaler.fit_transform(X)\n", "X_scaled_df = pd.DataFrame(X_scaled, columns=selected_feature_columns)\n", "\n", "\n", "correlations = []\n", "for col in selected_feature_columns:\n", " corr = np.corrcoef(X[col], y)[0, 1]\n", " correlations.append(abs(corr))\n", "\n", "correlation_df = pd.DataFrame({\n", " 'Feature': selected_feature_columns,\n", " 'Abs_Correlation': correlations\n", "}).sort_values('Abs_Correlation', ascending=False)\n", "\n", "print(\"=== Top 15 Features by Correlation with Target ===\")\n", "print(correlation_df.head(15))\n", "\n", "\n", "top_features = correlation_df.head(20)['Feature'].tolist()\n", "corr_matrix = X[top_features].corr()\n", "\n", "plt.figure(figsize=(16, 12))\n", "mask = np.triu(np.ones_like(corr_matrix, dtype=bool))\n", "sns.heatmap(corr_matrix, mask=mask, annot=True, cmap='coolwarm', center=0,\n", " square=True, linewidths=0.5, cbar_kws={\"shrink\": .5}, fmt='.2f')\n", "plt.title('Feature Correlation Matrix (Top 20 Features)')\n", "plt.xticks(rotation=45, ha='right')\n", "plt.yticks(rotation=0)\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "\n", "def find_high_corr_pairs(corr_matrix, threshold=0.9):\n", " high_corr_pairs = []\n", " for i in range(len(corr_matrix.columns)):\n", " for j in range(i+1, len(corr_matrix.columns)):\n", " if abs(corr_matrix.iloc[i, j]) > threshold:\n", " high_corr_pairs.append((\n", " corr_matrix.columns[i], \n", " corr_matrix.columns[j], \n", " corr_matrix.iloc[i, j]\n", " ))\n", " return high_corr_pairs\n", "\n", "high_corr_pairs = find_high_corr_pairs(X.corr(), threshold=0.9)\n", "print(f\"\\n=== High Correlation Pairs (>0.9) ===\")\n", "for feat1, feat2, corr in high_corr_pairs:\n", " print(f\"{feat1} - {feat2}: {corr:.3f}\")\n", "\n", "print(f\"\\nFound {len(high_corr_pairs)} highly correlated feature pairs.\")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training set: 72 samples\n", "Test set: 8 samples\n", "\n", "=== Correlation-based Selection ===\n", "Selected 13 features with correlation > 0.1\n", "Top 10 selected features: ['Avg Total vCPU', 'Avg TiDB vCPU', 'Read RPC', 'Write RPC', 'Write KB', 'sqrt(Read_KB)', 'Read KB', 'Read QPS', 'Write RCU %', 'Read RCU%']\n", "\n", "=== SelectKBest (F-test) ===\n", "Selected 8 features\n", "Selected features: ['Write RPC', 'Write KB', 'Read QPS', 'Avg Total vCPU', 'Avg TiDB vCPU', 'Read RPC', 'sqrt(Read_KB)', 'Read KB']\n", "\n", "=== Recursive Feature Elimination ===\n", "Selected 9 features\n", "Selected features: ['Write RPC', 'Write RCU %', 'Write KB', 'Avg Total vCPU', 'Avg TiDB CPU Util', 'Avg TiDB vCPU', 'Avg RCU/vCPU(PromQL)', 'Read RPC', 'sqrt(Read_KB)']\n", "\n", "=== Expert Columns ===\n", "Selected 5 features\n", "Selected features: ['Avg TiDB vCPU', 'Read RPC', 'Read KB', 'Write RPC', 'Write KB']\n" ] } ], "source": [ "# =============================================================================\n", "# Multiple Feature Selection Methods\n", "# =============================================================================\n", "\n", "scaler = StandardScaler()\n", "X_train_scaled = scaler.fit_transform(X_train)\n", "X_test_scaled = scaler.transform(X_test)\n", "\n", "\n", "print(f\"Training set: {X_train.shape[0]} samples\")\n", "print(f\"Test set: {X_test.shape[0]} samples\")\n", "\n", "# method 1: select features by correlation with target variable\n", "def select_by_correlation(X_train, y_train, threshold=0.1):\n", " \"\"\"select features by correlation with target variable\"\"\"\n", " correlations = []\n", " for i, col in enumerate(X_train.columns):\n", " corr = abs(np.corrcoef(X_train[col], y_train)[0, 1])\n", " correlations.append((i, col, corr))\n", " \n", " # sort by correlation and select features with correlation > threshold\n", " correlations.sort(key=lambda x: x[2], reverse=True)\n", " selected_indices = [idx for idx, _, corr in correlations if corr > threshold]\n", " selected_features = [name for _, name, corr in correlations if corr > threshold]\n", " \n", " return selected_indices, selected_features\n", "\n", "corr_indices, corr_features = select_by_correlation(X_train, y_train, threshold=0.1)\n", "print(f\"\\n=== Correlation-based Selection ===\")\n", "print(f\"Selected {len(corr_features)} features with correlation > 0.1\")\n", "print(\"Top 10 selected features:\", corr_features[:10])\n", "X_train_corr_unscaled = X_train[corr_features]\n", "X_test_corr_unscaled = X_test[corr_features]\n", "scaler_corr = StandardScaler()\n", "X_train_corr_scaled = scaler_corr.fit_transform(X_train_corr_unscaled)\n", "X_test_corr_scaled = scaler_corr.transform(X_test_corr_unscaled)\n", "\n", "# method 2: SelectKBest (Mutual Information)\n", "def optimized_mutual_info(X, y):\n", " return mutual_info_regression(X, y, discrete_features=False, n_neighbors=3, random_state=42)\n", "\n", "k_best = SelectKBest(score_func=optimized_mutual_info, k=8)\n", "X_train_kbest_scaled = k_best.fit_transform(X_train_scaled, y_train)\n", "X_test_kbest_scaled = k_best.transform(X_test_scaled)\n", "selected_features_kbest = [selected_feature_columns[i] for i in k_best.get_support(indices=True)]\n", "X_train_kbest_unscaled = X_train[selected_features_kbest]\n", "X_test_kbest_unscaled = X_test[selected_features_kbest]\n", "\n", "print(f\"\\n=== SelectKBest (F-test) ===\")\n", "print(f\"Selected {len(selected_features_kbest)} features\")\n", "print(\"Selected features:\", selected_features_kbest)\n", "\n", "# method 3: Recursive Feature Elimination (RFE)\n", "estimator = ElasticNet(alpha=0.5, l1_ratio=0.5, max_iter=2000, random_state=42)\n", "rfecv = RFECV(estimator=estimator, step=1, cv=5, scoring='neg_mean_squared_error', min_features_to_select=5)\n", "X_train_rfecv_scaled = rfecv.fit_transform(X_train_scaled, y_train)\n", "X_test_rfecv_scaled = rfecv.transform(X_test_scaled)\n", "selected_features_rfecv = [selected_feature_columns[i] for i in rfecv.get_support(indices=True)]\n", "X_train_rfecv_unscaled = X_train[selected_features_rfecv]\n", "X_test_rfecv_unscaled = X_test[selected_features_rfecv]\n", "\n", "print(f\"\\n=== Recursive Feature Elimination ===\")\n", "print(f\"Selected {len(selected_features_rfecv)} features\")\n", "print(\"Selected features:\", selected_features_rfecv)\n", "\n", "# method 4: expert selected features\n", "X_train_expert_unscaled = X_train[selected_expert_features]\n", "X_test_expert_unscaled = X_test[selected_expert_features]\n", "scaler_expert = StandardScaler()\n", "X_train_expert_scaled = scaler_expert.fit_transform(X_train_expert_unscaled)\n", "X_test_expert_scaled = scaler_expert.transform(X_test_expert_unscaled)\n", "\n", "\n", "print(f\"\\n=== Expert Columns ===\")\n", "print(f\"Selected {len(selected_expert_features)} features\")\n", "print(\"Selected features:\", selected_expert_features)\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing: Linear (Expert, Unscaled)...\n", "✗ FAILED: Linear (Expert, Unscaled) with error: 0\n", "Processing: RandomForest (Expert, Unscaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: RandomForest (Expert, Unscaled) with error: 0\n", "Processing: GradientBoosting (GridSearchCV) (Expert, Unscaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: GradientBoosting (GridSearchCV) (Expert, Unscaled) with error: 0\n", "Processing: RidgeCV (Expert, Scaled)...\n", "✗ FAILED: RidgeCV (Expert, Scaled) with error: 0\n", "Processing: LassoCV (Expert, Scaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: LassoCV (Expert, Scaled) with error: 0\n", "Processing: ElasticNetCV (Expert, Scaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: ElasticNetCV (Expert, Scaled) with error: 0\n", "Processing: BayesianRidge (Expert, Scaled)...\n", "✗ FAILED: BayesianRidge (Expert, Scaled) with error: 0\n", "Processing: Huber (Expert, Scaled)...\n", "✗ FAILED: Huber (Expert, Scaled) with error: 0\n", "Processing: SVR (GridSearchCV) (Expert, Scaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: SVR (GridSearchCV) (Expert, Scaled) with error: 0\n", "Processing: Linear (KBest, Unscaled)...\n", "✗ FAILED: Linear (KBest, Unscaled) with error: 0\n", "Processing: RandomForest (KBest, Unscaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: RandomForest (KBest, Unscaled) with error: 0\n", "Processing: GradientBoosting (GridSearchCV) (KBest, Unscaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: GradientBoosting (GridSearchCV) (KBest, Unscaled) with error: 0\n", "Processing: RidgeCV (KBest, Scaled)...\n", "✗ FAILED: RidgeCV (KBest, Scaled) with error: 0\n", "Processing: LassoCV (KBest, Scaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "✗ FAILED: LassoCV (KBest, Scaled) with error: 0\n", "Processing: BayesianRidge (KBest, Scaled)...\n", "✗ FAILED: BayesianRidge (KBest, Scaled) with error: 0\n", "Processing: SVR (GridSearchCV) (KBest, Scaled)...\n", "✗ FAILED: SVR (GridSearchCV) (KBest, Scaled) with error: 0\n", "Processing: Linear (RFECV, Unscaled)...\n", "✗ FAILED: Linear (RFECV, Unscaled) with error: 0\n", "Processing: RandomForest (RFECV, Unscaled)...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n", "Traceback (most recent call last):\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3805, in get_loc\n", " return self._engine.get_loc(casted_key)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"index.pyx\", line 167, in pandas._libs.index.IndexEngine.get_loc\n", " File \"index.pyx\", line 196, in pandas._libs.index.IndexEngine.get_loc\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2606, in pandas._libs.hashtable.Int64HashTable.get_item\n", " File \"pandas/_libs/hashtable_class_helper.pxi\", line 2630, in pandas._libs.hashtable.Int64HashTable.get_item\n", "KeyError: 0\n", "\n", "The above exception was the direct cause of the following exception:\n", "\n", "Traceback (most recent call last):\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 344, in \n", " result = train_and_evaluate_model(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 223, in train_and_evaluate_model\n", " return train_and_evaluate_model_normal(model_tuple)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/var/folders/rq/cwcg5_z51gg75bk0ql7lhfh00000gn/T/ipykernel_35635/3513226097.py\", line 74, in train_and_evaluate_model_normal\n", " y_true_fold = y_train[val_idx][0]\n", " ~~~~~~~~~~~~~~~~^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1112, in __getitem__\n", " return self._get_value(key)\n", " ^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/series.py\", line 1228, in _get_value\n", " loc = self.index.get_loc(label)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", " File \"/Users/ian/miniconda3/envs/corpus/lib/python3.11/site-packages/pandas/core/indexes/base.py\", line 3812, in get_loc\n", " raise KeyError(key) from err\n", "KeyError: 0\n" ] }, { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[13], line 344\u001b[0m\n\u001b[1;32m 342\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m model_tuple \u001b[38;5;129;01min\u001b[39;00m models_data:\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 344\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mtrain_and_evaluate_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_tuple\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 345\u001b[0m results\u001b[38;5;241m.\u001b[39mappend(result)\n\u001b[1;32m 346\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", "Cell \u001b[0;32mIn[13], line 223\u001b[0m, in \u001b[0;36mtrain_and_evaluate_model\u001b[0;34m(model_tuple)\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mtrain_and_evaluate_model\u001b[39m(model_tuple):\n\u001b[1;32m 222\u001b[0m \u001b[38;5;66;03m# return train_and_evaluate_model_log(model_tuple)\u001b[39;00m\n\u001b[0;32m--> 223\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtrain_and_evaluate_model_normal\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_tuple\u001b[49m\u001b[43m)\u001b[49m\n", "Cell \u001b[0;32mIn[13], line 69\u001b[0m, in \u001b[0;36mtrain_and_evaluate_model_normal\u001b[0;34m(model_tuple)\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[38;5;66;03m# --- Cross-Validation (Old method, incorrect for log-transform) ---\u001b[39;00m\n\u001b[1;32m 65\u001b[0m \u001b[38;5;66;03m# The old way is commented out because it calculates scores on the wrong\u001b[39;00m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;66;03m# scale (either log-scale y or fitting on original y), making the\u001b[39;00m\n\u001b[1;32m 67\u001b[0m \u001b[38;5;66;03m# CV score not comparable to the Test/Train R2.\u001b[39;00m\n\u001b[1;32m 68\u001b[0m loocv \u001b[38;5;241m=\u001b[39m LeaveOneOut()\n\u001b[0;32m---> 69\u001b[0m y_pred \u001b[38;5;241m=\u001b[39m \u001b[43mcross_val_predict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbest_estimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mloocv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 70\u001b[0m r2_scores \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 71\u001b[0m y_mean \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mmean(y_train)\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/utils/_param_validation.py:213\u001b[0m, in \u001b[0;36mvalidate_params..decorator..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 207\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[1;32m 209\u001b[0m skip_parameter_validation\u001b[38;5;241m=\u001b[39m(\n\u001b[1;32m 210\u001b[0m prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[1;32m 211\u001b[0m )\n\u001b[1;32m 212\u001b[0m ):\n\u001b[0;32m--> 213\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 214\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m InvalidParameterError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 215\u001b[0m \u001b[38;5;66;03m# When the function is just a wrapper around an estimator, we allow\u001b[39;00m\n\u001b[1;32m 216\u001b[0m \u001b[38;5;66;03m# the function to delegate validation to the estimator, but we replace\u001b[39;00m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;66;03m# the name of the estimator by the name of the function in the error\u001b[39;00m\n\u001b[1;32m 218\u001b[0m \u001b[38;5;66;03m# message to avoid confusion.\u001b[39;00m\n\u001b[1;32m 219\u001b[0m msg \u001b[38;5;241m=\u001b[39m re\u001b[38;5;241m.\u001b[39msub(\n\u001b[1;32m 220\u001b[0m \u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparameter of \u001b[39m\u001b[38;5;124m\\\u001b[39m\u001b[38;5;124mw+ must be\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 221\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparameter of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must be\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 222\u001b[0m \u001b[38;5;28mstr\u001b[39m(e),\n\u001b[1;32m 223\u001b[0m )\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/model_selection/_validation.py:1293\u001b[0m, in \u001b[0;36mcross_val_predict\u001b[0;34m(estimator, X, y, groups, cv, n_jobs, verbose, fit_params, params, pre_dispatch, method)\u001b[0m\n\u001b[1;32m 1290\u001b[0m \u001b[38;5;66;03m# We clone the estimator to make sure that all the folds are\u001b[39;00m\n\u001b[1;32m 1291\u001b[0m \u001b[38;5;66;03m# independent, and that it is pickle-able.\u001b[39;00m\n\u001b[1;32m 1292\u001b[0m parallel \u001b[38;5;241m=\u001b[39m Parallel(n_jobs\u001b[38;5;241m=\u001b[39mn_jobs, verbose\u001b[38;5;241m=\u001b[39mverbose, pre_dispatch\u001b[38;5;241m=\u001b[39mpre_dispatch)\n\u001b[0;32m-> 1293\u001b[0m predictions \u001b[38;5;241m=\u001b[39m \u001b[43mparallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1294\u001b[0m \u001b[43m \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_fit_and_predict\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1295\u001b[0m \u001b[43m \u001b[49m\u001b[43mclone\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1296\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1297\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1298\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1299\u001b[0m \u001b[43m \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1300\u001b[0m \u001b[43m \u001b[49m\u001b[43mrouted_params\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1301\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1302\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1303\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43msplits\u001b[49m\n\u001b[1;32m 1304\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1306\u001b[0m inv_test_indices \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mempty(\u001b[38;5;28mlen\u001b[39m(test_indices), dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mint\u001b[39m)\n\u001b[1;32m 1307\u001b[0m inv_test_indices[test_indices] \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;28mlen\u001b[39m(test_indices))\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/utils/parallel.py:67\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 62\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m 63\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 64\u001b[0m (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m 66\u001b[0m )\n\u001b[0;32m---> 67\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/joblib/parallel.py:1863\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1861\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m 1862\u001b[0m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 1863\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(output)\n\u001b[1;32m 1865\u001b[0m \u001b[38;5;66;03m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[38;5;66;03m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m 1867\u001b[0m \u001b[38;5;66;03m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m 1868\u001b[0m \u001b[38;5;66;03m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m 1869\u001b[0m \u001b[38;5;66;03m# callback.\u001b[39;00m\n\u001b[1;32m 1870\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/joblib/parallel.py:1792\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1790\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_batches \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 1791\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m-> 1792\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1793\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_completed_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 1794\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_progress()\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/utils/parallel.py:129\u001b[0m, in \u001b[0;36m_FuncWrapper.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 127\u001b[0m config \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 128\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mconfig):\n\u001b[0;32m--> 129\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/model_selection/_validation.py:1378\u001b[0m, in \u001b[0;36m_fit_and_predict\u001b[0;34m(estimator, X, y, train, test, fit_params, method)\u001b[0m\n\u001b[1;32m 1376\u001b[0m estimator\u001b[38;5;241m.\u001b[39mfit(X_train, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mfit_params)\n\u001b[1;32m 1377\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1378\u001b[0m \u001b[43mestimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mfit_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1379\u001b[0m func \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(estimator, method)\n\u001b[1;32m 1380\u001b[0m predictions \u001b[38;5;241m=\u001b[39m func(X_test)\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/base.py:1474\u001b[0m, in \u001b[0;36m_fit_context..decorator..wrapper\u001b[0;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1467\u001b[0m estimator\u001b[38;5;241m.\u001b[39m_validate_params()\n\u001b[1;32m 1469\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[1;32m 1470\u001b[0m skip_parameter_validation\u001b[38;5;241m=\u001b[39m(\n\u001b[1;32m 1471\u001b[0m prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[1;32m 1472\u001b[0m )\n\u001b[1;32m 1473\u001b[0m ):\n\u001b[0;32m-> 1474\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfit_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/ensemble/_forest.py:489\u001b[0m, in \u001b[0;36mBaseForest.fit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m 478\u001b[0m trees \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 479\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_estimator(append\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, random_state\u001b[38;5;241m=\u001b[39mrandom_state)\n\u001b[1;32m 480\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_more_estimators)\n\u001b[1;32m 481\u001b[0m ]\n\u001b[1;32m 483\u001b[0m \u001b[38;5;66;03m# Parallel loop: we prefer the threading backend as the Cython code\u001b[39;00m\n\u001b[1;32m 484\u001b[0m \u001b[38;5;66;03m# for fitting the trees is internally releasing the Python GIL\u001b[39;00m\n\u001b[1;32m 485\u001b[0m \u001b[38;5;66;03m# making threading more efficient than multiprocessing in\u001b[39;00m\n\u001b[1;32m 486\u001b[0m \u001b[38;5;66;03m# that case. However, for joblib 0.12+ we respect any\u001b[39;00m\n\u001b[1;32m 487\u001b[0m \u001b[38;5;66;03m# parallel_backend contexts set at a higher level,\u001b[39;00m\n\u001b[1;32m 488\u001b[0m \u001b[38;5;66;03m# since correctness does not rely on using threads.\u001b[39;00m\n\u001b[0;32m--> 489\u001b[0m trees \u001b[38;5;241m=\u001b[39m \u001b[43mParallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 490\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 491\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 492\u001b[0m \u001b[43m \u001b[49m\u001b[43mprefer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mthreads\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 493\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 494\u001b[0m \u001b[43m \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_parallel_build_trees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 495\u001b[0m \u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 496\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 497\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 498\u001b[0m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 499\u001b[0m \u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 500\u001b[0m \u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 501\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 502\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 503\u001b[0m \u001b[43m \u001b[49m\u001b[43mclass_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclass_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 504\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_samples_bootstrap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 505\u001b[0m \u001b[43m \u001b[49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmissing_values_in_feature_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 506\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 507\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrees\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 508\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 510\u001b[0m \u001b[38;5;66;03m# Collect newly grown trees\u001b[39;00m\n\u001b[1;32m 511\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimators_\u001b[38;5;241m.\u001b[39mextend(trees)\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/utils/parallel.py:67\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 62\u001b[0m config \u001b[38;5;241m=\u001b[39m get_config()\n\u001b[1;32m 63\u001b[0m iterable_with_config \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 64\u001b[0m (_with_config(delayed_func, config), args, kwargs)\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[1;32m 66\u001b[0m )\n\u001b[0;32m---> 67\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/joblib/parallel.py:1863\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1861\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m 1862\u001b[0m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[0;32m-> 1863\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturn_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(output)\n\u001b[1;32m 1865\u001b[0m \u001b[38;5;66;03m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m 1866\u001b[0m \u001b[38;5;66;03m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m 1867\u001b[0m \u001b[38;5;66;03m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m 1868\u001b[0m \u001b[38;5;66;03m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m 1869\u001b[0m \u001b[38;5;66;03m# callback.\u001b[39;00m\n\u001b[1;32m 1870\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/joblib/parallel.py:1792\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1790\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_batches \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 1791\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_dispatched_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m-> 1792\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1793\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_completed_tasks \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 1794\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_progress()\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/utils/parallel.py:129\u001b[0m, in \u001b[0;36m_FuncWrapper.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 127\u001b[0m config \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 128\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mconfig):\n\u001b[0;32m--> 129\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/ensemble/_forest.py:179\u001b[0m, in \u001b[0;36m_parallel_build_trees\u001b[0;34m(tree, bootstrap, X, y, sample_weight, tree_idx, n_trees, verbose, class_weight, n_samples_bootstrap, missing_values_in_feature_mask)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 177\u001b[0m curr_sample_weight \u001b[38;5;241m=\u001b[39m sample_weight\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[0;32m--> 179\u001b[0m indices \u001b[38;5;241m=\u001b[39m \u001b[43m_generate_sample_indices\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[43mtree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom_state\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_samples\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_samples_bootstrap\u001b[49m\n\u001b[1;32m 181\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 182\u001b[0m sample_counts \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mbincount(indices, minlength\u001b[38;5;241m=\u001b[39mn_samples)\n\u001b[1;32m 183\u001b[0m curr_sample_weight \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m sample_counts\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/ensemble/_forest.py:132\u001b[0m, in \u001b[0;36m_generate_sample_indices\u001b[0;34m(random_state, n_samples, n_samples_bootstrap)\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m_generate_sample_indices\u001b[39m(random_state, n_samples, n_samples_bootstrap):\n\u001b[1;32m 129\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 130\u001b[0m \u001b[38;5;124;03m Private function used to _parallel_build_trees function.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 132\u001b[0m random_instance \u001b[38;5;241m=\u001b[39m \u001b[43mcheck_random_state\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrandom_state\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 133\u001b[0m sample_indices \u001b[38;5;241m=\u001b[39m random_instance\u001b[38;5;241m.\u001b[39mrandint(\n\u001b[1;32m 134\u001b[0m \u001b[38;5;241m0\u001b[39m, n_samples, n_samples_bootstrap, dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mint32\n\u001b[1;32m 135\u001b[0m )\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m sample_indices\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/site-packages/sklearn/utils/validation.py:1397\u001b[0m, in \u001b[0;36mcheck_random_state\u001b[0;34m(seed)\u001b[0m\n\u001b[1;32m 1395\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mmtrand\u001b[38;5;241m.\u001b[39m_rand\n\u001b[1;32m 1396\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(seed, numbers\u001b[38;5;241m.\u001b[39mIntegral):\n\u001b[0;32m-> 1397\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mRandomState\u001b[49m\u001b[43m(\u001b[49m\u001b[43mseed\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1398\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(seed, np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mRandomState):\n\u001b[1;32m 1399\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m seed\n", "File \u001b[0;32mnumpy/random/mtrand.pyx:184\u001b[0m, in \u001b[0;36mnumpy.random.mtrand.RandomState.__init__\u001b[0;34m()\u001b[0m\n", "File \u001b[0;32m_mt19937.pyx:132\u001b[0m, in \u001b[0;36mnumpy.random._mt19937.MT19937.__init__\u001b[0;34m()\u001b[0m\n", "File \u001b[0;32m~/miniconda3/envs/corpus/lib/python3.11/contextlib.py:81\u001b[0m, in \u001b[0;36mContextDecorator.__call__..inner\u001b[0;34m(*args, **kwds)\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(func)\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21minner\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[1;32m 80\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_recreate_cm():\n\u001b[0;32m---> 81\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "# =============================================================================\n", "#\n", "# FINAL SCRIPT FOR MODEL TRAINING AND COMPARISON ON A SMALL DATASET\n", "#\n", "# =============================================================================\n", "\n", "import pandas as pd\n", "import numpy as np\n", "from sklearn.model_selection import KFold, cross_val_score, GridSearchCV\n", "from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error\n", "\n", "# Import all models\n", "from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet, RidgeCV, LassoCV, ElasticNetCV, BayesianRidge, HuberRegressor\n", "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n", "from sklearn.svm import SVR\n", "from sklearn.base import clone\n", "from sklearn.model_selection import LeaveOneOut\n", "\n", "# Assuming all your dataframes (X_train_expert_unscaled, y_train, etc.) are pre-loaded\n", "# and all feature lists (selected_expert_features, etc.) are defined.\n", "\n", "\n", "# =============================================================================\n", "# 1. ROBUST MODEL EVALUATION FUNCTION\n", "# =============================================================================\n", "\n", "def train_and_evaluate_model_normal(model_tuple):\n", " \"\"\"\n", " Fits, evaluates, and cross-validates a model, correctly handling log-transformation.\n", " Handles standard estimators and GridSearchCV objects.\n", " \"\"\"\n", " model, X_train, X_test, y_train, y_test, model_name, features = model_tuple\n", " \n", " print(f\"Processing: {model_name}...\")\n", "\n", " # --- Fit the main model using log-transformed target ---\n", " # y_train_log = np.log1p(y_train)\n", " model.fit(X_train, y_train)\n", "\n", " # --- Identify the best estimator from the fitted model ---\n", " if isinstance(model, GridSearchCV):\n", " best_estimator = model.best_estimator_\n", " best_params = model.best_params_\n", " else:\n", " best_estimator = model\n", " if hasattr(best_estimator, 'alpha_'):\n", " best_params = {'alpha': best_estimator.alpha_}\n", " elif hasattr(best_estimator, 'l1_ratio_'):\n", " best_params = {'alpha': best_estimator.alpha_, 'l1_ratio': best_estimator.l1_ratio_}\n", " else:\n", " best_params = 'N/A'\n", "\n", " # --- Predictions ---\n", " y_train_pred = best_estimator.predict(X_train)\n", " y_test_pred = best_estimator.predict(X_test)\n", "\n", " # --- Calculate Metrics ---\n", " # Metrics are calculated on the original scale\n", " train_r2 = r2_score(y_train, y_train_pred)\n", " test_r2 = r2_score(y_test, y_test_pred)\n", " train_rmse = np.sqrt(mean_squared_error(y_train, y_train_pred)) # Added train RMSE for completeness\n", " test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred))\n", "\n", " # --- Cross-Validation (Old method, incorrect for log-transform) ---\n", " # The old way is commented out because it calculates scores on the wrong\n", " # scale (either log-scale y or fitting on original y), making the\n", " # CV score not comparable to the Test/Train R2.\n", " loocv = LeaveOneOut()\n", " cv_scores = cross_val_score(best_estimator, X_train, y_train, cv=loocv, scoring='neg_mean_squared_error')\n", " cv_mean = cv_scores.mean()\n", " cv_std = cv_scores.std()\n", " \n", " # --- Overfitting Check ---\n", " # Now this comparison is meaningful as both R2 scores are on the same scale\n", " overfitting = np.sqrt(-cv_scores.mean()) - np.sqrt(mean_squared_error(y_train, y_train_pred)) # Positive value indicates overfitting\n", "\n", " return {\n", " 'Model': model_name,\n", " 'Train_R2': train_r2,\n", " 'Test_R2': test_r2,\n", " 'CV_R2_Mean': cv_mean,\n", " 'CV_R2_Std': cv_std,\n", " 'Overfitting': overfitting,\n", " 'Test_RMSE': test_rmse,\n", " 'Best_Params': str(best_params),\n", " 'Features': features,\n", " 'Predictions_Test': y_test_pred,\n", " 'Predictions_Train': y_train_pred,\n", " }\n", "\n", "def train_and_evaluate_model_log(model_tuple):\n", " \"\"\"\n", " Fits, evaluates, and cross-validates a model, correctly handling log-transformation.\n", " Handles standard estimators and GridSearchCV objects.\n", " \"\"\"\n", " model, X_train, X_test, y_train, y_test, model_name, features = model_tuple\n", " \n", " print(f\"Processing: {model_name}...\")\n", "\n", " # --- Fit the main model using log-transformed target ---\n", " y_train_log = np.log1p(y_train)\n", " model.fit(X_train, y_train_log)\n", "\n", " # --- Identify the best estimator from the fitted model ---\n", " if isinstance(model, GridSearchCV):\n", " best_estimator = model.best_estimator_\n", " best_params = model.best_params_\n", " else:\n", " best_estimator = model\n", " if hasattr(best_estimator, 'alpha_'):\n", " best_params = {'alpha': best_estimator.alpha_}\n", " elif hasattr(best_estimator, 'l1_ratio_'):\n", " best_params = {'alpha': best_estimator.alpha_, 'l1_ratio': best_estimator.l1_ratio_}\n", " else:\n", " best_params = 'N/A'\n", "\n", " # --- Predictions ---\n", " # Predict on log scale and transform back to original scale\n", " y_train_pred_log = best_estimator.predict(X_train)\n", " y_train_pred = np.expm1(y_train_pred_log)\n", " \n", " y_test_pred_log = best_estimator.predict(X_test)\n", " y_test_pred = np.expm1(y_test_pred_log)\n", "\n", " # --- Calculate Metrics ---\n", " # Metrics are calculated on the original scale\n", " train_r2 = r2_score(y_train, y_train_pred)\n", " test_r2 = r2_score(y_test, y_test_pred)\n", " train_rmse = np.sqrt(mean_squared_error(y_train, y_train_pred)) # Added train RMSE for completeness\n", " test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred))\n", "\n", " # --- Cross-Validation (Old method, incorrect for log-transform) ---\n", " # The old way is commented out because it calculates scores on the wrong\n", " # scale (either log-scale y or fitting on original y), making the\n", " # CV score not comparable to the Test/Train R2.\n", " \"\"\"\n", " cv = KFold(n_splits=5, shuffle=True, random_state=42)\n", " cv_scores = cross_val_score(best_estimator, X_train, y_train, cv=cv, scoring='r2') # This is problematic\n", " cv_mean = cv_scores.mean()\n", " cv_std = cv_scores.std()\n", " \"\"\"\n", "\n", " # --- Cross-Validation (New method: Manual loop for correct evaluation) ---\n", " # This loop ensures that for each fold, we train on log-y, predict,\n", " # transform back, and then score, so all metrics are on the same original scale.\n", " cv = KFold(n_splits=5, shuffle=True, random_state=42)\n", " cv_scores_on_orig_scale = []\n", " \n", " for train_idx, val_idx in cv.split(X_train):\n", " # 1. Create data for the current fold\n", " if isinstance(X_train, (pd.DataFrame, pd.Series)):\n", " # Use .iloc for pandas objects for safe positional indexing\n", " X_train_fold, X_val_fold = X_train.iloc[train_idx], X_train.iloc[val_idx]\n", " else:\n", " # Use standard bracket indexing for numpy arrays\n", " X_train_fold, X_val_fold = X_train[train_idx], X_train[val_idx]\n", " \n", " # Because y_train was converted to a numpy array at the start, this is ALWAYS safe.\n", " if isinstance(y_train, (pd.DataFrame, pd.Series)):\n", " y_train_fold, y_val_fold_orig = y_train.iloc[train_idx], y_train.iloc[val_idx]\n", " else:\n", " y_train_fold, y_val_fold_orig = y_train[train_idx], y_train[val_idx]\n", "\n", " # 2. Log-transform the target for training this fold\n", " y_train_fold_log = np.log1p(y_train_fold)\n", "\n", " # 3. Fit a clone of the best estimator on the fold's training data\n", " fold_model = clone(best_estimator)\n", " fold_model.fit(X_train_fold, y_train_fold_log)\n", "\n", " # 4. Predict on the validation set and transform back to the original scale\n", " y_val_pred_log = fold_model.predict(X_val_fold)\n", " y_val_pred_orig = np.expm1(y_val_pred_log)\n", "\n", " # 5. Calculate the score on the original scale and store it\n", " fold_score = r2_score(y_val_fold_orig, y_val_pred_orig)\n", " cv_scores_on_orig_scale.append(fold_score)\n", "\n", " cv_scores = np.array(cv_scores_on_orig_scale)\n", " cv_mean = cv_scores.mean()\n", " cv_std = cv_scores.std()\n", "\n", " \n", " # --- Overfitting Check ---\n", " # Now this comparison is meaningful as both R2 scores are on the same scale\n", " overfitting = train_r2 - cv_mean\n", "\n", " return {\n", " 'Model': model_name,\n", " 'Train_R2': train_r2,\n", " 'Test_R2': test_r2,\n", " 'CV_R2_Mean': cv_mean,\n", " 'CV_R2_Std': cv_std,\n", " 'Overfitting': overfitting,\n", " 'Test_RMSE': test_rmse,\n", " 'Best_Params': str(best_params),\n", " 'Features': features,\n", " 'Predictions_Test': y_test_pred,\n", " 'Predictions_Train': y_train_pred,\n", " }\n", "\n", "def train_and_evaluate_model(model_tuple):\n", " # return train_and_evaluate_model_log(model_tuple)\n", " return train_and_evaluate_model_normal(model_tuple)\n", "\n", "# =============================================================================\n", "# 2. HYPERPARAMETER DEFINITIONS FOR AUTO-TUNING\n", "# =============================================================================\n", "\n", "# Define a wider search range for regularization strength (alpha)\n", "# Suitable for small datasets where stronger regularization might be needed.\n", "alphas_cv = [0.05, 0.1, 0.5, 1.0, 5.0, 10.0, 50.0, 100.0]\n", "\n", "# Define l1_ratio search range for ElasticNet\n", "l1_ratios_cv = [0.1, 0.5, 0.9, 0.99]\n", "\n", "# Define strict parameters for RandomForest to prevent overfitting\n", "rf_params = {\n", " 'n_estimators': 100,\n", " 'max_depth': 3,\n", " 'min_samples_leaf': 15, # Crucial for small datasets\n", " 'max_features': 'sqrt', # Increases tree diversity\n", " 'random_state': 42\n", "}\n", "\n", "# Define parameter grid for SVR to be used with GridSearchCV\n", "svr_params = [\n", " {\n", " 'kernel': ['linear'],\n", " 'C': [0.1, 1, 10], # Small C = strong regularization\n", " 'epsilon': [0.1, 0.5]\n", " },\n", " {\n", " 'kernel': ['rbf'],\n", " 'C': [1, 10, 100],\n", " 'gamma': ['scale', 'auto'],\n", " 'epsilon': [0.1, 0.5]\n", " }\n", "]\n", "\n", "# START: ADDITION FOR GRADIENT BOOSTING\n", "# Define a conservative parameter grid for GradientBoostingRegressor for GridSearchCV\n", "# This helps to control complexity and prevent overfitting.\n", "gbr_params_strict = {\n", " 'n_estimators': [100, 150, 200], # 树的数量可以适当增加，因为学习率降低了\n", " 'learning_rate': [0.01, 0.005], # 使用更小的学习率\n", " 'max_depth': [2, 3], # 强制使用更浅的树，这是最有效的正则化手段之一\n", " 'min_samples_leaf': [10, 15, 20], # 要求每个叶节点有更多的样本，防止模型关注噪声\n", " 'subsample': [0.7, 0.8], # 每次迭代只使用一部分数据，增加随机性\n", " 'max_features': ['sqrt', 'log2'],\n", " 'random_state': [42]\n", "}\n", "\n", "# END: ADDITION FOR GRADIENT BOOSTING\n", "\n", "\n", "# =============================================================================\n", "# 3. COMPREHENSIVE LIST OF MODELS FOR TESTING\n", "# =============================================================================\n", "\n", "# This list systematically combines each feature set with a suite of models\n", "# optimized for small datasets.\n", "\n", "models_data = [\n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " # Feature Set 1: Expert Features\n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " # --- Baselines and Tree Models ---\n", " (LinearRegression(), X_train_expert_unscaled, X_test_expert_unscaled, y_train, y_test, \"Linear (Expert, Unscaled)\", selected_expert_features),\n", " (RandomForestRegressor(**rf_params), X_train_expert_unscaled, X_test_expert_unscaled, y_train, y_test, \"RandomForest (Expert, Unscaled)\", selected_expert_features),\n", " (GridSearchCV(GradientBoostingRegressor(), gbr_params_strict, cv=5), X_train_expert_unscaled, X_test_expert_unscaled, y_train, y_test, \"GradientBoosting (GridSearchCV) (Expert, Unscaled)\", selected_expert_features),\n", "\n", " \n", " # --- Auto-tuned Regularized Linear Models ---\n", " (RidgeCV(alphas=alphas_cv), X_train_expert_scaled, X_test_expert_scaled, y_train, y_test, \"RidgeCV (Expert, Scaled)\", selected_expert_features),\n", " (LassoCV(alphas=alphas_cv, max_iter=5000, random_state=42), X_train_expert_scaled, X_test_expert_scaled, y_train, y_test, \"LassoCV (Expert, Scaled)\", selected_expert_features),\n", " (ElasticNetCV(alphas=alphas_cv, l1_ratio=l1_ratios_cv, max_iter=5000, random_state=42), X_train_expert_scaled, X_test_expert_scaled, y_train, y_test, \"ElasticNetCV (Expert, Scaled)\", selected_expert_features),\n", "\n", " # --- Robust and Bayesian Models (Recommended for Small Data) ---\n", " (BayesianRidge(), X_train_expert_scaled, X_test_expert_scaled, y_train, y_test, \"BayesianRidge (Expert, Scaled)\", selected_expert_features),\n", " (HuberRegressor(), X_train_expert_scaled, X_test_expert_scaled, y_train, y_test, \"Huber (Expert, Scaled)\", selected_expert_features),\n", " (GridSearchCV(SVR(), svr_params, cv=5), X_train_expert_scaled, X_test_expert_scaled, y_train, y_test, \"SVR (GridSearchCV) (Expert, Scaled)\", selected_expert_features),\n", "\n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " # Feature Set 2: SelectKBest Features\n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " (LinearRegression(), X_train_kbest_unscaled, X_test_kbest_unscaled, y_train, y_test, \"Linear (KBest, Unscaled)\", selected_features_kbest),\n", " (RandomForestRegressor(**rf_params), X_train_kbest_unscaled, X_test_kbest_unscaled, y_train, y_test, \"RandomForest (KBest, Unscaled)\", selected_features_kbest),\n", " (GridSearchCV(GradientBoostingRegressor(), gbr_params_strict, cv=5), X_train_kbest_unscaled, X_test_kbest_unscaled, y_train, y_test, \"GradientBoosting (GridSearchCV) (KBest, Unscaled)\", selected_features_kbest),\n", " (RidgeCV(alphas=alphas_cv), X_train_kbest_scaled, X_test_kbest_scaled, y_train, y_test, \"RidgeCV (KBest, Scaled)\", selected_features_kbest),\n", " (LassoCV(alphas=alphas_cv, max_iter=5000, random_state=42), X_train_kbest_scaled, X_test_kbest_scaled, y_train, y_test, \"LassoCV (KBest, Scaled)\", selected_features_kbest),\n", " (BayesianRidge(), X_train_kbest_scaled, X_test_kbest_scaled, y_train, y_test, \"BayesianRidge (KBest, Scaled)\", selected_features_kbest),\n", " (GridSearchCV(SVR(), svr_params, cv=5), X_train_kbest_scaled, X_test_kbest_scaled, y_train, y_test, \"SVR (GridSearchCV) (KBest, Scaled)\", selected_features_kbest),\n", "\n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " # Feature Set 3: RFE (Recursive Feature Elimination) Features\n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " (LinearRegression(), X_train_rfecv_unscaled, X_test_rfecv_unscaled, y_train, y_test, \"Linear (RFECV, Unscaled)\", selected_features_rfecv),\n", " (RandomForestRegressor(**rf_params), X_train_rfecv_unscaled, X_test_rfecv_unscaled, y_train, y_test, \"RandomForest (RFECV, Unscaled)\", selected_features_rfecv),\n", " (GridSearchCV(GradientBoostingRegressor(), gbr_params_strict, cv=5), X_train_rfecv_unscaled, X_test_rfecv_unscaled, y_train, y_test, \"GradientBoosting (GridSearchCV) (RFECV, Unscaled)\", selected_features_rfecv),\n", " (RidgeCV(alphas=alphas_cv), X_train_rfecv_scaled, X_test_rfecv_scaled, y_train, y_test, \"RidgeCV (RFECV, Scaled)\", selected_features_rfecv),\n", " (LassoCV(alphas=alphas_cv, max_iter=5000, random_state=42), X_train_rfecv_scaled, X_test_rfecv_scaled, y_train, y_test, \"LassoCV (RFECV, Scaled)\", selected_features_rfecv),\n", " (BayesianRidge(), X_train_rfecv_scaled, X_test_rfecv_scaled, y_train, y_test, \"BayesianRidge (RFECV, Scaled)\", selected_features_rfecv),\n", " (GridSearchCV(SVR(), svr_params, cv=5), X_train_rfecv_scaled, X_test_rfecv_scaled, y_train, y_test, \"SVR (GridSearchCV) (RFECV, Scaled)\", selected_features_rfecv),\n", " \n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " # Feature Set 4: Correlation Features\n", " # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", " (LinearRegression(), X_train_corr_unscaled, X_test_corr_unscaled, y_train, y_test, \"Linear (Corr, Unscaled)\", corr_features),\n", " (RandomForestRegressor(**rf_params), X_train_corr_unscaled, X_test_corr_unscaled, y_train, y_test, \"RandomForest (Corr, Unscaled)\", corr_features),\n", " (GridSearchCV(GradientBoostingRegressor(), gbr_params_strict, cv=5), X_train_corr_unscaled, X_test_corr_unscaled, y_train, y_test, \"GradientBoosting (GridSearchCV) (Corr, Unscaled)\", corr_features),\n", " (RidgeCV(alphas=alphas_cv), X_train_corr_scaled, X_test_corr_scaled, y_train, y_test, \"RidgeCV (Corr, Scaled)\", corr_features),\n", " (LassoCV(alphas=alphas_cv, max_iter=5000, random_state=42), X_train_corr_scaled, X_test_corr_scaled, y_train, y_test, \"LassoCV (Corr, Scaled)\", corr_features),\n", " (BayesianRidge(), X_train_corr_scaled, X_test_corr_scaled, y_train, y_test, \"BayesianRidge (Corr, Scaled)\", corr_features),\n", " (GridSearchCV(SVR(), svr_params, cv=5), X_train_corr_scaled, X_test_corr_scaled, y_train, y_test, \"SVR (GridSearchCV) (Corr, Scaled)\", corr_features),\n", "]\n", "\n", "# =============================================================================\n", "# 4. EXECUTE TRAINING AND EVALUATION\n", "# =============================================================================\n", "\n", "results = []\n", "for model_tuple in models_data:\n", " try:\n", " result = train_and_evaluate_model(model_tuple)\n", " results.append(result)\n", " except Exception as e:\n", " model_name = model_tuple[5]\n", " print(f\"✗ FAILED: {model_name} with error: {e}\")\n", " # print stack trace\n", " import traceback\n", " traceback.print_exc()\n", "\n", "# Create a DataFrame from the results\n", "results_df = pd.DataFrame(results)\n", "\n", "\n", "# =============================================================================\n", "# 5. ANALYZE RESULTS AND RANK MODELS\n", "# =============================================================================\n", "\n", "if not results_df.empty:\n", " print(\"\\n\" + \"=\"*80)\n", " print(\"MODEL PERFORMANCE ANALYSIS\")\n", " print(\"=\"*80)\n", "\n", " # --- Calculate a Composite Score for Ranking ---\n", " # This score prioritizes high, stable performance (CV_R2_Mean)\n", " # and penalizes models that are overfitted.\n", " # We use .clip(0) so we don't 'reward' underfitting models.\n", " results_df['Composite_Score'] = results_df['CV_R2_Mean'] - results_df['Overfitting'].clip(0)\n", "\n", " # Sort models by the composite score\n", " results_df_sorted = results_df.sort_values(by='Composite_Score', ascending=False)\n", " \n", " # Define columns to display for a clean report\n", " display_cols = [\n", " 'Model',\n", " 'Test_R2',\n", " 'CV_R2_Mean',\n", " 'CV_R2_Std',\n", " 'Overfitting',\n", " 'Test_RMSE',\n", " 'Composite_Score',\n", " 'Best_Params'\n", " ]\n", "\n", " print(\"\\nTop Models Ranked by Composite Score (CV R² - Overfitting):\")\n", " # Display the sorted results. Using display() is nicer in notebooks.\n", " # In a standard script, you might just print it.\n", " try:\n", " from IPython.display import display\n", " display(results_df_sorted[display_cols])\n", " except ImportError:\n", " print(results_df_sorted[display_cols].to_string())\n", "\n", "else:\n", " print(\"\\nNo models were successfully evaluated.\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib.ticker as mticker\n", "\n", "for selected_model_index in range(29):\n", " for index, row in results_df_sorted.iterrows():\n", " if index == selected_model_index:\n", " best_model_name = row['Model']\n", " best_result = row\n", " break\n", "\n", " print(f\"\\nSELECTED MODEL({selected_model_index}): {best_model_name}\")\n", " print(f\" Test R²: {best_result['Test_R2']:.4f}\")\n", " print(f\" Test RMSE: {best_result['Test_RMSE']:.2f}\")\n", " print(f\" Overfitting: {best_result['Overfitting']:.4f}\")\n", " print(f\" CV R² Mean: {best_result['CV_R2_Mean']:.4f} ± {best_result['CV_R2_Std']:.4f}\")\n", "\n", " # Create a single figure to hold both subplots\n", " plt.figure(figsize=(16, 7)) # Increased figure size for better readability\n", "\n", " # --------------------------------------------------\n", " # Plot 1: Left side (Predicted vs Actual)\n", " # --------------------------------------------------\n", " plt.subplot(1, 2, 1)\n", " plt.scatter(y_test, best_result['Predictions_Test'], alpha=0.7, s=50)\n", " plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2, label='Perfect Prediction (y=x)')\n", " plt.xlabel('Actual Cost')\n", " plt.ylabel('Predicted Cost')\n", " plt.title(f'{best_model_name}\\nTest R² = {best_result[\"Test_R2\"]:.4f}')\n", " plt.grid(True, alpha=0.3)\n", " plt.legend()\n", " plt.axis('equal') # Make axes equal to ensure the 45-degree line looks correct\n", "\n", " # --------------------------------------------------\n", " # Plot 2: Right side (Price Ratio Plot)\n", " # --------------------------------------------------\n", " plt.subplot(1, 2, 2)\n", " y_pred = best_result['Predictions_Test']\n", " # Ensure y_test is a numpy array for calculation to avoid index issues\n", " y_test_vals = y_test.values if hasattr(y_test, 'values') else y_test\n", " # Use your custom formula for the price ratio\n", " price_ratio = ((y_pred * 0.7) / y_test_vals) * 100\n", "\n", " plt.scatter(y_test_vals, price_ratio, alpha=0.7, s=50)\n", "\n", " # Set Y-axis to log scale to see all points\n", " plt.yscale('log')\n", "\n", " # Add the 70% reference line\n", " plt.axhline(y=70, color='g', linestyle='--', label='70% Ratio Line')\n", " plt.axhline(y=60, color='g', linestyle='--', label='60% Ratio Line')\n", " plt.axhline(y=50, color='r', linestyle='--', label='50% Ratio Line')\n", " plt.axhline(y=80, color='r', linestyle='--', label='80% Ratio Line')\n", " plt.legend()\n", "\n", " # Set English labels and title\n", " plt.xlabel('Actual Cost')\n", " plt.ylabel('Price Ratio (Log Scale) %')\n", " plt.title(f'{best_model_name}\\n(Predicted Price * 0.7) vs Actual Price Ratio')\n", " plt.grid(True, which=\"both\", ls=\"--\", alpha=0.3)\n", "\n", " ax = plt.gca()\n", " # Define the ticks you want to see. Adding a few extra for context.\n", " ticks_to_show = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 130,150, 170, 190, 200, 300, 400, 500]\n", " ax.set_yticks(ticks_to_show)\n", " # Format the Y-axis to show '%' symbols for the ticks we just set\n", " ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=100.0))\n", "\n", "\n", " # Adjust layout for the entire figure and show\n", " plt.tight_layout(pad=2.0)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "\n", "import matplotlib.ticker as mticker\n", "\n", "\n", "for index, row in results_df_sorted.iterrows():\n", " if index == 7:\n", " best_model_name = row['Model']\n", " best_result = row\n", " break\n", "\n", "\n", "price_ratio = ((best_result['Predictions_Test'] * 0.7) / y_test) * 100\n", "best_result['Price_Ratio_%'] = price_ratio\n", "\n", "\n", "LOWER_BOUND = 50\n", "UPPER_BOUND = 80\n", "best_result['Status'] = np.where(\n", " (best_result['Price_Ratio_%'] >= LOWER_BOUND) & (best_result['Price_Ratio_%'] <= UPPER_BOUND),\n", " 'In-Range',\n", " 'Ou-Range'\n", ")\n", "\n", "test_data_indexes = []\n", "price_ratio_values = []\n", "for index, row in best_result['Price_Ratio_%'].items():\n", " test_data_indexes.append(index)\n", " price_ratio_values.append(row)\n", "\n", "\n", "print(\"-\"*100)\n", "\n", "for i in range(len(best_result['Predictions_Test'])):\n", " print(test_data_indexes[i], best_result['Status'][i], round(price_ratio_values[i], 2), round(best_result['Predictions_Test'][i], 2), round(y_test.iloc[i], 2))\n", "\n", "print(test_data_indexes)\n", "print(price_ratio_values)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " chosen_model_tuple = next(m for m in models_data if m[5] == best_model_name)\n", "except StopIteration:\n", " print(f\"error: model '{best_model_name}' not in models_data\")\n", " exit()\n", " \n", "model_obj, X_train_data, _, y_train_data, _, _, feature_list = chosen_model_tuple\n", "\n", "\n", "print(f\"\\nextracting formula for model '{best_model_name}'...\")\n", "model_obj.fit(X_train_data, y_train_data)\n", "\n", "if isinstance(model_obj, GridSearchCV):\n", " final_estimator = model_obj.best_estimator_\n", "else:\n", " final_estimator = model_obj\n", "\n", "scaled_coefficients = final_estimator.coef_\n", "scaled_intercept = final_estimator.intercept_\n", "\n", "\n", "if \"Expert\" in best_model_name:\n", " scaler = scaler_expert\n", "elif \"KBest\" in best_model_name:\n", " scaler_kbest = StandardScaler().fit(X_train_kbest_unscaled)\n", " scaler = scaler_kbest\n", "elif \"RFECV\" in best_model_name:\n", " scaler_rfecv = StandardScaler().fit(X_train_rfecv_unscaled)\n", " scaler = scaler_rfecv\n", "elif \"Corr\" in best_model_name:\n", " scaler = scaler_corr\n", "else:\n", " raise ValueError(\"cannot determine the corresponding scaler for the selected model\")\n", "\n", "# Extract the mean and standard deviation for each feature from the scaler\n", "feature_means = scaler.mean_\n", "feature_stds = scaler.scale_\n", "\n", "# Convert scaled parameters to original, unscaled parameters ---\n", "\n", "# 2Calculate the coefficients for the ORIGINAL (unscaled) features\n", "# Formula: Original_Coef = Scaled_Coef / Std_Dev\n", "original_coefficients = scaled_coefficients / feature_stds\n", "\n", "# 3. Calculate the new intercept for the ORIGINAL (unscaled) formula\n", "# Formula: Original_Intercept = Scaled_Intercept - sum(Original_Coef * Mean)\n", "original_intercept = scaled_intercept - np.sum(original_coefficients * feature_means)\n", "\n", "# --- Display the new, simplified pricing formula and its parameters ---\n", "\n", "print(\"\\n\" + \"=\"*80)\n", "print(f\"Simplified Pricing Formula (based on model: {best_model_name})\")\n", "print(\"=\"*80)\n", "print(\"This formula works directly with the original feature values (e.g., sq. ft., year).\")\n", "\n", "# --- Generate the simplified formula in a human-readable format ---\n", "print(\"\\n**Final Pricing Formula (Interpretable Format):**\")\n", "print(f\"Base Price = ${original_intercept:,.2f}\")\n", "for i, feature_name in enumerate(feature_list):\n", " coef = original_coefficients[i]\n", " sign = \"+\" if coef >= 0 else \"-\"\n", " # We use .4f for precision, but you could use .2f for a cleaner look\n", " print(f\" {sign} (${abs(coef):.4f} * \\\"{feature_name}\\\")\")\n", "\n", "# --- Generate the simplified formula in LaTeX format ---\n", "formula_latex_simple = f\"$$ Price = {original_intercept:.4f} \\\\\\\\\"\n", "for i, feature_name in enumerate(feature_list):\n", " coef = original_coefficients[i]\n", " sign = \"+\" if coef >= 0 else \"-\"\n", " # Using \\\\text{{...}} for feature names is good practice in LaTeX\n", " formula_latex_simple += f\"& {sign} {abs(coef):.4f} \\\\times \\\\text{{{feature_name}}} \\\\\\\\\"\n", "\n", "formula_latex_simple = formula_latex_simple.rstrip('\\\\\\\\') + \"$$\"\n", "\n", "print(\"\\n**Final Pricing Formula (LaTeX Format):**\")\n", "print(\"Copy the code below to a markdown editor that supports LaTeX to see the formatted formula.\")\n", "print(formula_latex_simple)\n", "\n", "\n", "# --- Display the model parameter interpretation in original units ---\n", "print(\"\\n**Model Parameter Interpretation:**\")\n", "# Note: Feature importance is best judged by the SCALED coefficients,\n", "# as they are unit-agnostic. We include them here for ranking.\n", "coef_df_simple = pd.DataFrame({\n", " 'Feature': feature_list,\n", " 'Original Coefficient ($ per unit)': original_coefficients,\n", " 'Impact (from Scaled Coef)': abs(scaled_coefficients)\n", "})\n", "\n", "# Sort by the absolute value of the SCALED coefficient to find the most impactful features\n", "coef_df_sorted = coef_df_simple.sort_values(by='Impact (from Scaled Coef)', ascending=False).drop(columns=['Impact (from Scaled Coef)'])\n", "\n", "print(f\"Base Price (Intercept): ${original_intercept:,.2f}\")\n", "print(\"Feature Coefficients (sorted by impact):\")\n", "print(coef_df_sorted.to_string())\n", "\n", "print(\"\\nInterpretation:\")\n", "print(\"The 'Original Coefficient' shows how much the final price changes (in dollars)\")\n", "print(\"for every one-unit increase in that feature (e.g., for one extra sq. ft. of GrLivArea).\")\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(f\"\\nextracting formula for model '{best_model_name}'...\")\n", "\n", "try:\n", " chosen_model_tuple = next(m for m in models_data if m[5] == best_model_name)\n", "except StopIteration:\n", " print(f\"error: model '{best_model_name}' not in models_data\")\n", " exit()\n", " \n", "model_obj, X_train_data, _, y_train_data, _, _, feature_list = chosen_model_tuple\n", "\n", "original_coefficients = model_obj.coef_\n", "original_intercept = model_obj.intercept_\n", "\n", "print(\"\\nFinal Pricing Formula:\")\n", "print(f\"Base Price = {original_intercept:.2f}\")\n", "for i, feature_name in enumerate(feature_list):\n", " coef = original_coefficients[i]\n", " sign = \"+\" if coef >= 0 else \"-\"\n", " print(f\" {sign} ({abs(coef):.4f} * \\\"{feature_name}\\\")\")\n" ] } ], "metadata": { "kernelspec": { "display_name": "corpus", "language": "python", "name": "python3" }, "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.11" } }, "nbformat": 4, "nbformat_minor": 2 }