{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.17","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[],"dockerImageVersionId":31042,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport lightgbm as lgb\nfrom sklearn.model_selection import TimeSeriesSplit\nfrom sklearn.decomposition import PCA\n# from scipy.stats import skew # Yeh import abhi use nahi ho raha, agar zaroorat na ho toh hata sakte hain\nfrom catboost import CatBoostRegressor\nimport gc\n\n# --- Configuration ---\nTRAIN_FILE = '/kaggle/input/drw-crypto-market-prediction/train.parquet'\nTEST_FILE = '/kaggle/input/drw-crypto-market-prediction/test.parquet'\nSAMPLE_SUBMISSION_FILE = '/kaggle/input/drw-crypto-market-prediction/sample_submission.csv'\nSUBMISSION_FILE = '/kaggle/working/submission.csv'\nN_SPLITS = 5\n\n# --- LightGBM Parameters ---\nlgb_params = {\n    'objective': 'regression_l1',\n    'metric': 'mae',\n    'n_estimators': 1500, # Aapka current value\n    'learning_rate': 0.015,\n    'feature_fraction': 0.7,\n    'bagging_fraction': 0.7,\n    'bagging_freq': 1,\n    'lambda_l1': 0.1,\n    'lambda_l2': 0.1,\n    'num_leaves': 31,\n    'verbose': -1,\n    'n_jobs': -1,\n    'seed': 42,\n    'boosting_type': 'gbdt',\n}\n\n# --- CatBoost Parameters ---\ncat_params = {\n    'iterations': 800,\n    'learning_rate': 0.015,\n    'depth': 6,\n    'loss_function': 'MAE',\n    'random_seed': 42,\n    'verbose': 100, # Show progress every 100 iterations\n    # early_stopping_rounds will be used in fit method\n}\n\n# --- Utility Functions (Improved Pearson Correlation) ---\ndef pearson_correlation(y_true, y_pred):\n    y_true = np.asarray(y_true) # Ensure numpy array\n    y_pred = np.asarray(y_pred)\n    \n    # Remove NaNs if any, or fill them if appropriate for your strategy\n    # For safety, let's remove rows with NaNs in either for correlation calculation\n    valid_indices = ~np.isnan(y_true) & ~np.isnan(y_pred)\n    y_true_valid = y_true[valid_indices]\n    y_pred_valid = y_pred[valid_indices]\n\n    if len(y_true_valid) < 2 or len(y_pred_valid) < 2: # Need at least 2 points\n        return 0.0\n    if np.std(y_true_valid) == 0 or np.std(y_pred_valid) == 0: # Avoid division by zero if constant\n        return 0.0\n    return np.corrcoef(y_true_valid, y_pred_valid)[0, 1]\n\n# --- 1. Load Data ---\nprint(\"Loading data...\")\ntry:\n    train_df_orig = pd.read_parquet(TRAIN_FILE)\n    test_df_orig = pd.read_parquet(TEST_FILE)\n    sample_submission = pd.read_csv(SAMPLE_SUBMISSION_FILE)\nexcept FileNotFoundError:\n    print(f\"Error: Files not found. Check paths.\")\n    exit()\nexcept Exception as e:\n    print(f\"Error loading data: {e}\")\n    exit()\n\n# --- Timestamp Conversion and Filtering ---\ndef convert_and_filter_train_data(df_orig):\n    df = df_orig.copy()\n    if 'timestamp' in df.columns:\n        try:\n            if df['timestamp'].dtype in ['int64', 'float64']:\n                df['timestamp'] = pd.to_datetime(df['timestamp'], unit='s')\n            elif df['timestamp'].dtype == 'object':\n                 df['timestamp'] = pd.to_datetime(df['timestamp'])\n\n            if pd.api.types.is_datetime64_any_dtype(df['timestamp']):\n                print(\"Min train timestamp:\", df['timestamp'].min())\n                print(\"Max train timestamp:\", df['timestamp'].max())\n                filtered_df = df[df['timestamp'] >= '2024-01-01']\n                if filtered_df.empty:\n                    print(\"Warning: No data after '2024-01-01'. Trying '2023-12-01'.\")\n                    filtered_df = df[df['timestamp'] >= '2023-12-01']\n                    if filtered_df.empty:\n                        print(\"Warning: Still no data after '2023-12-01'. Using all training data.\")\n                        return df # Return full df if no data after filters\n                    return filtered_df\n                return filtered_df\n            else:\n                print(\"Timestamp not converted to datetime. Using all training data.\")\n                return df\n        except Exception as e:\n            print(f\"Error during timestamp conversion/filtering: {e}. Using all training data.\")\n            return df\n    else:\n        print(\"Error: 'timestamp' column not found in train_df for filtering. Using all training data.\")\n        return df\n\ntrain_df = convert_and_filter_train_data(train_df_orig)\ntest_df = test_df_orig.copy() # Test data is used as is, timestamp masked\n\nprint(f\"Using Train shape: {train_df.shape}, Test shape: {test_df.shape}\")\ngc.collect()\n\n# --- 2. Feature Engineering ---\nprint(\"Starting feature engineering...\")\n# Identify proprietary features from the potentially filtered train_df's columns\n# This ensures we only consider X features actually present in the data we're using\nproprietary_features_list = [col for col in train_df.columns if col.startswith('X') or col.startswith('x')]\nif not proprietary_features_list:\n    print(\"Warning: No proprietary features found in the current train_df. Using only public features.\")\nelse:\n    print(f\"Found {len(proprietary_features_list)} proprietary features in current train_df.\")\n\n# Calculate medians for X features from the CURRENT (potentially filtered) training data\ntrain_medians_for_X = {col: train_df[col].median() for col in proprietary_features_list if train_df[col].isnull().any()}\n\n\ndef feature_engineer(df, medians_dict_for_X_fill, current_prop_features_list):\n    df_fe = df.copy()\n    # Imbalance features\n    df_fe['bid_ask_qty_imbalance'] = (df_fe['bid_qty'] - df_fe['ask_qty']) / (df_fe['bid_qty'] + df_fe['ask_qty'] + 1e-9)\n    df_fe['buy_sell_qty_imbalance'] = (df_fe['buy_qty'] - df_fe['sell_qty']) / (df_fe['buy_qty'] + df_fe['sell_qty'] + 1e-9)\n    df_fe['bid_ask_ratio'] = df_fe['bid_qty'] / (df_fe['ask_qty'] + 1e-9)\n    df_fe['buy_sell_ratio'] = df_fe['buy_qty'] / (df_fe['sell_qty'] + 1e-9)\n\n\n    # Lags for key public features\n    lags = [1, 2, 3, 5, 10] # Your current lags\n    features_to_lag = ['volume', 'bid_qty', 'ask_qty', 'buy_qty', 'sell_qty', 'bid_ask_qty_imbalance', 'buy_sell_qty_imbalance']\n    for feature in features_to_lag:\n        if feature in df_fe.columns:\n            for lag in lags:\n                df_fe[f'{feature}_lag_{lag}'] = df_fe[feature].shift(lag)\n\n    # Rolling window features for key public features\n    windows = [5, 10, 30] # Your current windows\n    features_for_rolling = ['volume', 'bid_ask_qty_imbalance', 'buy_sell_qty_imbalance']\n    for feature in features_for_rolling:\n        if feature in df_fe.columns:\n            for window in windows:\n                df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n                df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n\n    # *** NEW: Difference features for key public features ***\n    diff_periods = [1, 2, 3, 5, 10]\n    features_to_diff = ['volume', 'bid_qty', 'ask_qty', 'buy_qty', 'sell_qty', 'bid_ask_qty_imbalance']\n    for feature in features_to_diff:\n        if feature in df_fe.columns:\n            for period in diff_periods:\n                df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n\n    # Rolling/Diffs for a subset of proprietary features\n    # current_prop_features_list ensures we only operate on features present in df\n    prop_features_subset_fe = [pf for pf in current_prop_features_list if pf in df_fe.columns][:15]\n    if prop_features_subset_fe:\n        for feature in prop_features_subset_fe:\n            for window in [5, 10]:\n                df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n                df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n            # *** NEW: Difference for proprietary features subset ***\n            for period in [1, 3]:\n                 df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n\n    # Interaction features (Original X_ * X_)\n    available_x_features_for_interaction = [pf for pf in current_prop_features_list if pf in df_fe.columns][:8]\n    if len(available_x_features_for_interaction) > 1: # Need at least 2 for product\n        for i, col_i in enumerate(available_x_features_for_interaction):\n            for col_j in available_x_features_for_interaction[i + 1:]:\n                df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n    \n    # *** NEW: Interaction features (Public * X_) ***\n    public_interaction_candidates = ['volume', 'bid_ask_qty_imbalance']\n    if available_x_features_for_interaction and public_interaction_candidates:\n        for p_feat in public_interaction_candidates:\n            if p_feat in df_fe.columns:\n                for x_feat in available_x_features_for_interaction[:5]: # Interact with first 5 of available X\n                    df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n\n\n    # Fill NaNs from original proprietary features using pre-calculated medians\n    for col in current_prop_features_list: # Iterate over known prop features\n        if col in df_fe.columns and df_fe[col].isnull().any(): # Check if it's in current df_fe\n            df_fe[col].fillna(medians_dict_for_X_fill.get(col, 0), inplace=True)\n\n    # *** IMPROVED NaN handling for Lags/Rolling/Diffs ***\n    df_fe.fillna(method='bfill', inplace=True) # Backfill first\n    df_fe.fillna(method='ffill', inplace=True) # Then forward fill\n    df_fe.fillna(0, inplace=True) # Fill any remaining NaNs with 0\n\n    df_fe.replace([np.inf, -np.inf], 0, inplace=True) # Clean infinites\n    return df_fe\n\ntrain_df_fe = feature_engineer(train_df, train_medians_for_X, proprietary_features_list)\ntest_df_fe = feature_engineer(test_df, train_medians_for_X, proprietary_features_list) # Pass train_medians for test\ngc.collect()\n\n\n# --- Define Features and Target ---\n# Use label from train_df as its index aligns with the original filtering\n# train_df_fe is used for features 'X'\ny = train_df['label'].loc[train_df_fe.index] # Ensure y aligns with train_df_fe index\n\nfeatures_cols = [col for col in train_df_fe.columns if col not in ['timestamp', 'label']]\nX = train_df_fe[features_cols]\n\n# Align test set features\nX_test = test_df_fe.copy()\nfor feature_col in X.columns:\n    if feature_col not in X_test.columns:\n        X_test[feature_col] = 0\nX_test = X_test[X.columns] # Ensure same column order and selection\n\nprint(f\"Number of features before PCA/Selection: {len(X.columns)}\")\n\n\n# --- PCA and Feature Selection ---\nprint(\"Applying PCA...\")\n# Proprietary features that are actually in the current X dataframe for PCA\nprop_features_for_pca = [pf for pf in proprietary_features_list if pf in X.columns]\nprint(f\"Proprietary features available in X for PCA: {len(prop_features_for_pca)}\")\n\nX_pca_applied_flag = False\nif prop_features_for_pca and len(prop_features_for_pca) >= 30 : # PCA needs n_features >= n_components\n    pca = PCA(n_components=30, random_state=42)\n    \n    # Fit PCA on training data part\n    X_pca_train_components = pca.fit_transform(X[prop_features_for_pca])\n    X_pca_train_df = pd.DataFrame(X_pca_train_components, columns=[f'PCA_{i}' for i in range(pca.n_components_)], index=X.index)\n    \n    # Transform test data\n    X_pca_test_components = pca.transform(X_test[prop_features_for_pca])\n    X_pca_test_df = pd.DataFrame(X_pca_test_components, columns=[f'PCA_{i}' for i in range(pca.n_components_)], index=X_test.index)\n\n    # Initial model fit for identifying top original proprietary features to keep\n    # This fit still has leakage potential if using full X,y.\n    temp_model_for_importance = lgb.LGBMRegressor(**lgb_params)\n    temp_model_for_importance.fit(X[prop_features_for_pca], y) # Fit only on prop features for this selection\n    importances_prop_orig = pd.Series(temp_model_for_importance.feature_importances_, index=prop_features_for_pca)\n    top_orig_prop_features_to_keep = importances_prop_orig.nlargest(20).index.tolist()\n    \n    # Drop all original proprietary features (that were used in PCA), then add PCA comps and selected top original ones\n    X = X.drop(columns=prop_features_for_pca, errors='ignore')\n    X_test = X_test.drop(columns=prop_features_for_pca, errors='ignore')\n\n    X = pd.concat([X, X_pca_train_df, train_df_fe[top_orig_prop_features_to_keep].loc[X.index] ], axis=1)\n    X_test = pd.concat([X_test, X_pca_test_df, test_df_fe[top_orig_prop_features_to_keep].loc[X_test.index]], axis=1)\n    \n    X_test = X_test.reindex(columns=X.columns, fill_value=0) # Align columns\n    print(\"PCA applied and top original proprietary features retained alongside PCA components.\")\n    X_pca_applied_flag = True\nelse:\n    print(\"Skipping PCA: Not enough proprietary features for specified n_components or none found in X.\")\ngc.collect()\n\n\n# --- Feature selection based on importance (post-PCA if applied) ---\nprint(\"Starting final feature selection...\")\nfs_model = lgb.LGBMRegressor(**lgb_params)\nfs_model.fit(X, y)\nimportances_final = pd.Series(fs_model.feature_importances_, index=X.columns)\n\nquantile_fs = 0.15\nselected_features_final = importances_final[importances_final > importances_final.quantile(quantile_fs)].index.tolist()\n\nif not selected_features_final:\n    print(f\"Quantile {quantile_fs} resulted in 0 features. Using non-zero importance features.\")\n    selected_features_final = importances_final[importances_final > 0].index.tolist()\n    if not selected_features_final:\n        print(\"All feature importances are 0 after FS model. Keeping all current features.\")\n        selected_features_final = X.columns.tolist()\n\nX = X[selected_features_final]\nX_test = X_test[selected_features_final]\nprint(f\"Number of features after final selection: {len(selected_features_final)}\")\ngc.collect()\n\n\n# --- 3. Model Training (Cross-Validation) ---\nprint(\"Starting model training with TimeSeriesSplit CV...\")\ntms = TimeSeriesSplit(n_splits=N_SPLITS)\n\n# For LightGBM\noof_predictions_lgbm = np.zeros(len(X)) # OOF preds should match length of X used in CV\ntest_predictions_lgbm = np.zeros(len(X_test)) # Test preds match length of X_test\nlgbm_models = []\n\nprint(\"\\n--- Training LightGBM ---\")\nfor fold, (train_index, val_index) in enumerate(tms.split(X)):\n    print(f\"\\n----- LGBM Fold {fold+1}/{N_SPLITS} -----\")\n    X_train, X_val = X.iloc[train_index], X.iloc[val_index]\n    y_train, y_val = y.iloc[train_index], y.iloc[val_index]\n\n    model_lgb = lgb.LGBMRegressor(**lgb_params)\n    model_lgb.fit(X_train, y_train,\n                  eval_set=[(X_val, y_val)],\n                  eval_metric=lambda y_true, y_pred: [('pearson_corr', pearson_correlation(y_true, y_pred), True)],\n                  callbacks=[lgb.early_stopping(100, verbose=50, min_delta=0.00001)]) # Added min_delta\n    \n    val_preds = model_lgb.predict(X_val)\n    # Store OOF preds at correct indices if X's index is not simple range 0..N-1\n    # For TimeSeriesSplit, val_index directly maps to iloc positions of original X\n    oof_predictions_lgbm[val_index] = val_preds\n    test_predictions_lgbm += model_lgb.predict(X_test) / N_SPLITS\n    lgbm_models.append(model_lgb)\n    \n    fold_pearson = pearson_correlation(y_val, val_preds)\n    print(f\"LGBM Fold {fold+1} Pearson Correlation: {fold_pearson:.4f}\")\ngc.collect()\n\n# Calculate overall OOF Pearson for LGBM\n# Identify indices covered by CV validation folds\nall_val_indices = np.concatenate([val_idx for _, val_idx in tms.split(X)])\nunique_val_indices = np.unique(all_val_indices) # Get unique indices that were in any val_set\n\ny_true_for_oof_lgbm = y.iloc[unique_val_indices]\noof_preds_actual_lgbm = oof_predictions_lgbm[unique_val_indices]\n\nif len(y_true_for_oof_lgbm) == len(oof_preds_actual_lgbm) and len(oof_preds_actual_lgbm) > 0:\n    overall_oof_pearson_lgbm = pearson_correlation(y_true_for_oof_lgbm, oof_preds_actual_lgbm)\n    print(f\"\\nOverall LGBM OOF Pearson Correlation: {overall_oof_pearson_lgbm:.4f}\")\nelse:\n    print(\"Could not calculate OOF Pearson for LGBM due to length/index mismatch or no OOF predictions.\")\n\n\n# For CatBoost\noof_predictions_cat = np.zeros(len(X))\ntest_predictions_cat = np.zeros(len(X_test))\ncat_models = []\n\nprint(\"\\n--- Training CatBoost ---\")\nfor fold, (train_index, val_index) in enumerate(tms.split(X)):\n    print(f\"\\n----- CatBoost Fold {fold+1}/{N_SPLITS} -----\")\n    X_train, X_val = X.iloc[train_index], X.iloc[val_index]\n    y_train, y_val = y.iloc[train_index], y.iloc[val_index]\n\n    model_cat = CatBoostRegressor(**cat_params)\n    model_cat.fit(X_train, y_train,\n                  eval_set=[(X_val, y_val)],\n                  early_stopping_rounds=100, # Correct way for CatBoost\n                  verbose=cat_params.get('verbose', 0) # Use verbose from params\n                  )\n    \n    val_preds_cat = model_cat.predict(X_val)\n    oof_predictions_cat[val_index] = val_preds_cat\n    test_predictions_cat += model_cat.predict(X_test) / N_SPLITS\n    cat_models.append(model_cat)\n\n    fold_pearson_cat = pearson_correlation(y_val, val_preds_cat)\n    print(f\"CatBoost Fold {fold+1} Pearson Correlation: {fold_pearson_cat:.4f}\")\ngc.collect()\n\ny_true_for_oof_cat = y.iloc[unique_val_indices] # Same true labels for OOF\noof_preds_actual_cat = oof_predictions_cat[unique_val_indices]\nif len(y_true_for_oof_cat) == len(oof_preds_actual_cat) and len(oof_preds_actual_cat) > 0:\n    overall_oof_pearson_cat = pearson_correlation(y_true_for_oof_cat, oof_preds_actual_cat)\n    print(f\"\\nOverall CatBoost OOF Pearson Correlation: {overall_oof_pearson_cat:.4f}\")\nelse:\n    print(\"Could not calculate OOF Pearson for CatBoost due to length/index mismatch or no OOF predictions.\")\n\n\n# --- 4. Ensemble Predictions ---\nw_lgbm = 0.7 # Aapka current weight\nw_cat = 0.3  # Aapka current weight\nprint(f\"\\nEnsembling with weights: LGBM={w_lgbm}, CatBoost={w_cat}\")\nfinal_test_predictions = w_lgbm * test_predictions_lgbm + w_cat * test_predictions_cat\n\n\n# --- 5. Create Submission File ---\nprint(\"\\nCreating submission file...\")\n# Ensure final_test_predictions length matches sample_submission 'ID' length\nif len(final_test_predictions) != len(sample_submission):\n    print(f\"Error: Length of predictions ({len(final_test_predictions)}) does not match sample submission ({len(sample_submission)}). Padding/truncating (not ideal).\")\n    # This is a fallback, ideally lengths should match due to X_test processing\n    if len(final_test_predictions) > len(sample_submission):\n        final_test_predictions = final_test_predictions[:len(sample_submission)]\n    else:\n        final_test_predictions = np.pad(final_test_predictions, (0, len(sample_submission) - len(final_test_predictions)), 'constant')\n\n\nsubmission_df = pd.DataFrame({'ID': sample_submission['ID'], 'prediction': final_test_predictions})\nsubmission_df.to_csv(SUBMISSION_FILE, index=False)\nprint(f\"Submission file '{SUBMISSION_FILE}' created successfully.\")\n\n# --- 6. Cleanup ---\ndel train_df_orig, test_df_orig, train_df, test_df, train_df_fe, test_df_fe\ndel X, y, X_test, X_train, X_val, y_train, y_val\ndel lgbm_models, cat_models, temp_model_for_importance, fs_model\nif X_pca_applied_flag: # Only delete if PCA was applied\n    del X_pca_train_df, X_pca_test_df, pca\ngc.collect()\n\nprint(\"\\nScript finished.\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-02T12:12:32.415302Z","iopub.execute_input":"2025-06-02T12:12:32.415664Z","iopub.status.idle":"2025-06-02T12:18:09.760805Z","shell.execute_reply.started":"2025-06-02T12:12:32.415626Z","shell.execute_reply":"2025-06-02T12:18:09.757163Z"}},"outputs":[{"name":"stdout","text":"Loading data...\nError: 'timestamp' column not found in train_df for filtering. Using all training data.\nUsing Train shape: (525887, 896), Test shape: (538150, 896)\nStarting feature engineering...\nFound 890 proprietary features in current train_df.\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:196: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n  df_fe.fillna(method='bfill', inplace=True) # Backfill first\n/tmp/ipykernel_177/4157289091.py:197: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n  df_fe.fillna(method='ffill', inplace=True) # Then forward fill\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:168: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_mean_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).mean()\n/tmp/ipykernel_177/4157289091.py:169: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_roll_std_{window}'] = df_fe[feature].rolling(window=window, min_periods=1).std()\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:172: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{feature}_diff_{period}'] = df_fe[feature].diff(period)\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:179: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{col_i}_{col_j}_product'] = df_fe[col_i] * df_fe[col_j]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:187: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n  df_fe[f'{p_feat}_x_{x_feat}_interaction'] = df_fe[p_feat] * df_fe[x_feat]\n/tmp/ipykernel_177/4157289091.py:196: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n  df_fe.fillna(method='bfill', inplace=True) # Backfill first\n/tmp/ipykernel_177/4157289091.py:197: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n  df_fe.fillna(method='ffill', inplace=True) # Then forward fill\n","output_type":"stream"},{"name":"stdout","text":"Number of features before PCA/Selection: 1110\nApplying PCA...\nProprietary features available in X for PCA: 890\nPCA applied and top original proprietary features retained alongside PCA components.\nStarting final feature selection...\nNumber of features after final selection: 166\nStarting model training with TimeSeriesSplit CV...\n\n--- Training LightGBM ---\n\n----- LGBM Fold 1/5 -----\nTraining until validation scores don't improve for 100 rounds\nUsing 1e-05 as min_delta for all metrics.\nEarly stopping, best iteration is:\n[10]\tvalid_0's l1: 0.623636\tvalid_0's pearson_corr: 0.0627917\nLGBM Fold 1 Pearson Correlation: 0.0628\n\n----- LGBM Fold 2/5 -----\nTraining until validation scores don't improve for 100 rounds\nUsing 1e-05 as min_delta for all metrics.\nEarly stopping, best iteration is:\n[51]\tvalid_0's l1: 0.576327\tvalid_0's pearson_corr: 0.0161636\nLGBM Fold 2 Pearson Correlation: 0.0162\n\n----- LGBM Fold 3/5 -----\nTraining until validation scores don't improve for 100 rounds\nUsing 1e-05 as min_delta for all metrics.\nEarly stopping, best iteration is:\n[21]\tvalid_0's l1: 0.612274\tvalid_0's pearson_corr: 0.0797333\nLGBM Fold 3 Pearson Correlation: 0.0797\n\n----- LGBM Fold 4/5 -----\nTraining until validation scores don't improve for 100 rounds\nUsing 1e-05 as min_delta for all metrics.\nEarly stopping, best iteration is:\n[13]\tvalid_0's l1: 0.68075\tvalid_0's pearson_corr: 0.073317\nLGBM Fold 4 Pearson Correlation: 0.0733\n\n----- LGBM Fold 5/5 -----\nTraining until validation scores don't improve for 100 rounds\nUsing 1e-05 as min_delta for all metrics.\nEarly stopping, best iteration is:\n[6]\tvalid_0's l1: 0.70314\tvalid_0's pearson_corr: 0.0314175\nLGBM Fold 5 Pearson Correlation: 0.0314\n\nOverall LGBM OOF Pearson Correlation: 0.0282\n\n--- Training CatBoost ---\n\n----- CatBoost Fold 1/5 -----\n0:\tlearn: 0.6286675\ttest: 0.6246648\tbest: 0.6246648 (0)\ttotal: 66ms\tremaining: 52.7s\n100:\tlearn: 0.5726579\ttest: 0.6321759\tbest: 0.6243649 (2)\ttotal: 1.22s\tremaining: 8.43s\nStopped by overfitting detector  (100 iterations wait)\n\nbestTest = 0.6243649404\nbestIteration = 2\n\nShrink model to first 3 iterations.\nCatBoost Fold 1 Pearson Correlation: 0.0696\n\n----- CatBoost Fold 2/5 -----\n0:\tlearn: 0.6266217\ttest: 0.5774716\tbest: 0.5774716 (0)\ttotal: 24.6ms\tremaining: 19.7s\n100:\tlearn: 0.5929034\ttest: 0.5765158\tbest: 0.5760936 (68)\ttotal: 1.91s\tremaining: 13.2s\nStopped by overfitting detector  (100 iterations wait)\n\nbestTest = 0.5760936091\nbestIteration = 68\n\nShrink model to first 69 iterations.\nCatBoost Fold 2 Pearson Correlation: 0.0219\n\n----- CatBoost Fold 3/5 -----\n0:\tlearn: 0.6102080\ttest: 0.6143323\tbest: 0.6143323 (0)\ttotal: 30.2ms\tremaining: 24.1s\n100:\tlearn: 0.5873632\ttest: 0.6091335\tbest: 0.6091335 (100)\ttotal: 2.36s\tremaining: 16.3s\n200:\tlearn: 0.5718197\ttest: 0.6070312\tbest: 0.6070312 (200)\ttotal: 4.78s\tremaining: 14.2s\n300:\tlearn: 0.5597200\ttest: 0.6067314\tbest: 0.6065840 (265)\ttotal: 7.08s\tremaining: 11.7s\n400:\tlearn: 0.5483403\ttest: 0.6064296\tbest: 0.6064022 (398)\ttotal: 9.37s\tremaining: 9.32s\n500:\tlearn: 0.5390946\ttest: 0.6071691\tbest: 0.6062713 (410)\ttotal: 11.7s\tremaining: 6.98s\nStopped by overfitting detector  (100 iterations wait)\n\nbestTest = 0.6062712912\nbestIteration = 410\n\nShrink model to first 411 iterations.\nCatBoost Fold 3 Pearson Correlation: 0.1245\n\n----- CatBoost Fold 4/5 -----\n0:\tlearn: 0.6112476\ttest: 0.6823580\tbest: 0.6823580 (0)\ttotal: 33ms\tremaining: 26.3s\n100:\tlearn: 0.5940709\ttest: 0.6773147\tbest: 0.6772474 (88)\ttotal: 2.85s\tremaining: 19.8s\n200:\tlearn: 0.5818105\ttest: 0.6760538\tbest: 0.6760538 (200)\ttotal: 5.59s\tremaining: 16.7s\n300:\tlearn: 0.5719432\ttest: 0.6757694\tbest: 0.6753027 (256)\ttotal: 8.29s\tremaining: 13.7s\nStopped by overfitting detector  (100 iterations wait)\n\nbestTest = 0.6753027386\nbestIteration = 256\n\nShrink model to first 257 iterations.\nCatBoost Fold 4 Pearson Correlation: 0.0887\n\n----- CatBoost Fold 5/5 -----\n0:\tlearn: 0.6254302\ttest: 0.7036656\tbest: 0.7036656 (0)\ttotal: 38ms\tremaining: 30.4s\n100:\tlearn: 0.6093074\ttest: 0.7029918\tbest: 0.7023911 (39)\ttotal: 3.18s\tremaining: 22s\nStopped by overfitting detector  (100 iterations wait)\n\nbestTest = 0.7023910989\nbestIteration = 39\n\nShrink model to first 40 iterations.\nCatBoost Fold 5 Pearson Correlation: 0.0102\n\nOverall CatBoost OOF Pearson Correlation: 0.0657\n\nEnsembling with weights: LGBM=0.7, CatBoost=0.3\n\nCreating submission file...\nSubmission file '/kaggle/working/submission.csv' created successfully.\n\nScript finished.\n","output_type":"stream"}],"execution_count":2},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}