{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":82611,"databundleVersionId":9553358,"sourceType":"competition"}],"dockerImageVersionId":30786,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Welcome to the AutoML Tutorial for Blood Glucose Prediction \n\nWelcome to this notebook, where we will explore how to harness the power of **Automated Machine Learning (AutoML)** to predict blood glucose levels based on a variety of features, such as insulin intake, carbohydrate consumption, and physical activity.\n\n### What You Will Learn:\nIn this tutorial, you will see how **AutoML** can streamline the model-building process by automatically selecting the best algorithms, tuning hyperparameters, and evaluating performance, saving time and effort for both beginners and experienced data scientists. 🚀\n\n### What AutoML Can and Cannot Do:\nWhile AutoML is powerful in automating many aspects of machine learning, there are certain steps in the data preprocessing pipeline that require manual intervention. For example, tasks like:\n- **Handling missing values** 🧹\n- **Feature engineering** 🔧\n- **Time-based data transformations** ⏳\n\nare not fully covered by AutoML and will need to be done manually before we apply the AutoML framework.\n\nThis notebook will guide you through these necessary steps, after which we will allow AutoML to take over and do the heavy lifting. By the end of this tutorial, you will be able to build models efficiently while understanding the balance between automation and human input.\n\nLet’s get started! 🔬","metadata":{}},{"cell_type":"markdown","source":"Flowchart:\n![Blank diagram.jpeg](attachment:219adaea-09f9-45f8-a56e-614ac8ce97eb.jpeg)","metadata":{},"attachments":{"219adaea-09f9-45f8-a56e-614ac8ce97eb.jpeg":{"image/jpeg":"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"}}},{"cell_type":"markdown","source":"# Load Data","metadata":{}},{"cell_type":"code","source":"# Import necessary libraries\nimport pandas as pd\n\n# Loading dataset\ntrain_df = pd.read_csv(\"/kaggle/input/brist1d/train.csv\")\ntest_df = pd.read_csv(\"/kaggle/input/brist1d/test.csv\")","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-10-26T23:07:31.189102Z","iopub.execute_input":"2024-10-26T23:07:31.190085Z","iopub.status.idle":"2024-10-26T23:07:46.723091Z","shell.execute_reply.started":"2024-10-26T23:07:31.190010Z","shell.execute_reply":"2024-10-26T23:07:46.721432Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Data inspection\nCatching common picture of dataset","metadata":{}},{"cell_type":"code","source":"train_df.head()","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:07:46.726185Z","iopub.execute_input":"2024-10-26T23:07:46.726665Z","iopub.status.idle":"2024-10-26T23:07:46.780533Z","shell.execute_reply.started":"2024-10-26T23:07:46.726617Z","shell.execute_reply":"2024-10-26T23:07:46.778692Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_df.head()","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:07:46.782464Z","iopub.execute_input":"2024-10-26T23:07:46.783080Z","iopub.status.idle":"2024-10-26T23:07:46.813520Z","shell.execute_reply.started":"2024-10-26T23:07:46.783026Z","shell.execute_reply":"2024-10-26T23:07:46.811838Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Visualizing null values\nIt would be hard to read output using isnull().sum(), because there is 507 features in the dataset. Solution for it distribute each feature for 4 batch.","metadata":{}},{"cell_type":"code","source":"# Import necessary libraries\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport numpy as np\n\n# Creating function to diplay graphs\ndef visualize_null_values(df):\n        \n    # Calculate the percentage of null values per feature\n    null_percentage = df.isnull().mean() * 100\n    \n    # Create categories based on null percentage ranges\n    bins = [0, 25, 50, 75, 100]\n    labels = ['0-25%', '25-50%', '50-75%', '75-100%']\n    category_counts = pd.cut(null_percentage, bins=bins, labels=labels).value_counts().sort_index()\n    \n    # Create a figure with two subplots, one for the bar chart and one for the pie chart\n    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n    \n    # Plot 1: Bar graph showing number of features in each null percentage category\n    bar = ax1.bar(category_counts.index, category_counts.values, color='skyblue')\n    \n    # Add numbers on top of each bar\n    for i, value in enumerate(category_counts.values):\n        ax1.text(i, value + 0.1, str(value), ha='center', fontsize=12)\n    \n    ax1.set_title('Features by Percentage of Null Values', fontsize=14)\n    ax1.set_xlabel('Percentage of Null Values', fontsize=12)\n    ax1.set_ylabel('Number of Features', fontsize=12)\n    \n    # Plot 2: Pie chart showing features with null values and without null values\n    features_with_nulls = (null_percentage > 0).sum()\n    features_without_nulls = (null_percentage == 0).sum()\n    \n    labels = ['Features with Null Values', 'Features without Null Values']\n    sizes = [features_with_nulls, features_without_nulls]\n    colors = ['#ff9999','#66b3ff']\n    \n    ax2.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90)\n    ax2.set_title('Features with and without Null Values', fontsize=14)\n    \n    # Adjust layout\n    plt.tight_layout()\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:07:46.817049Z","iopub.execute_input":"2024-10-26T23:07:46.817576Z","iopub.status.idle":"2024-10-26T23:07:46.834746Z","shell.execute_reply.started":"2024-10-26T23:07:46.817524Z","shell.execute_reply":"2024-10-26T23:07:46.832934Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"visualize_null_values(train_df)\nvisualize_null_values(test_df)","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:07:46.837154Z","iopub.execute_input":"2024-10-26T23:07:46.837870Z","iopub.status.idle":"2024-10-26T23:07:48.573640Z","shell.execute_reply.started":"2024-10-26T23:07:46.837798Z","shell.execute_reply":"2024-10-26T23:07:48.572122Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Summary\nThe dataset contains a large amount of missing data, as shown in the visualizations above. Given the complex and time-dependent nature of the features, filling the missing values using basic statistical methods like mean or mode imputation would be simplistic and potentially harmful to the model’s performance. Instead, we’ll take a logical approach, filling the missing values based on the specific context of each feature, as outlined below:\n\n* Time-dependent features (e.g., bg-X:XX, insulin-X:XX, carbs-X:XX) will require interpolation or forward/backward filling, based on time-series relationships.\n* Participant-specific features (e.g., p_num, steps-X:XX, cals-X:XX, hr-X:XX) will be filled using participant-related data trends.\n* Self-reported features (e.g., activity-X:XX) may involve special handling, depending on the activity frequency and type.\n\nThis approach ensures that the imputation aligns with the nature of the data and avoids introducing bias by oversimplifying.\n\nAdditionlly, other methods as info() or describe() woulde be hard to read as number of features is large.","metadata":{}},{"cell_type":"markdown","source":"# Handling Null Values","metadata":{}},{"cell_type":"markdown","source":"### Filling columns with bfill and ffill as they are sequential","metadata":{}},{"cell_type":"code","source":"# Identify all columns for each feature type based on prefixes\nbg_columns = [col for col in train_df.columns if col.startswith('bg-')]\nhr_columns = [col for col in train_df.columns if col.startswith('hr-')]\nsteps_columns = [col for col in train_df.columns if col.startswith('steps-')]\n\n# Combine columns to process together\nfeature_columns = {\n    'bg': bg_columns,\n    'hr': hr_columns,\n    'steps': steps_columns\n}\n\n# Function to apply rolling, forward/backward fill, and group-based median imputation\ndef impute_time_series_features(df, columns, method='median', window=5):\n    for col in columns:\n        # Rolling mean or median imputation for temporal smoothing\n        df[col] = df[col].fillna(df[col].rolling(window=window, min_periods=1).median())\n        \n        # Forward fill for remaining nulls\n        df[col] = df[col].fillna(method='ffill')\n        \n        # Backward fill for any leading nulls\n        df[col] = df[col].fillna(method='bfill')\n        \n        # Group-based median for participant-specific imputation\n        df[col] = df.groupby('p_num')[col].transform(lambda x: x.fillna(x.median()))\n    return df\n\n# Apply imputation to each feature type in both datasets\nfor feature, columns in feature_columns.items():\n    train_df = impute_time_series_features(train_df, columns, method='median')\n    test_df = impute_time_series_features(test_df, columns, method='median')\n\n# Verify if all nulls are handled in the specified columns\nall_imputed_columns = bg_columns + hr_columns + steps_columns\nprint(\"Remaining null values in training set:\", train_df[all_imputed_columns].isnull().sum().sum())\nprint(\"Remaining null values in testing set:\", test_df[all_imputed_columns].isnull().sum().sum())","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:07:48.575499Z","iopub.execute_input":"2024-10-26T23:07:48.575987Z","iopub.status.idle":"2024-10-26T23:08:10.669280Z","shell.execute_reply.started":"2024-10-26T23:07:48.575940Z","shell.execute_reply":"2024-10-26T23:08:10.667577Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Filling with median value","metadata":{}},{"cell_type":"code","source":"# Identify all insulin and cals columns based on prefixes\ninsulin_columns = [col for col in train_df.columns if col.startswith('insulin-')]\ncals_columns = [col for col in train_df.columns if col.startswith('cals-')]\n\n# Combine columns to process together\nfeature_columns_insulin_cals = {\n    'insulin': insulin_columns,\n    'cals': cals_columns\n}\n\n# Function to apply group-based median and rolling median imputation for insulin and cals\ndef impute_non_temporal_features(df, columns, method='median', window=5):\n    for col in columns:\n        # Group-based median for participant-specific imputation\n        df[col] = df.groupby('p_num')[col].transform(lambda x: x.fillna(x.median()))\n        \n        # Rolling median for remaining nulls (temporal smoothing)\n        df[col] = df[col].fillna(df[col].rolling(window=window, min_periods=1).median())\n    return df\n\n# Apply imputation to insulin and cals columns in both datasets\nfor feature, columns in feature_columns_insulin_cals.items():\n    train_df = impute_non_temporal_features(train_df, columns, method='median')\n    test_df = impute_non_temporal_features(test_df, columns, method='median')\n\n# Verify if all nulls are handled in insulin and cals columns\nall_imputed_columns_insulin_cals = insulin_columns + cals_columns\nprint(\"Remaining null values in training set:\", train_df[all_imputed_columns_insulin_cals].isnull().sum().sum())\nprint(\"Remaining null values in testing set:\", test_df[all_imputed_columns_insulin_cals].isnull().sum().sum())","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:08:10.670945Z","iopub.execute_input":"2024-10-26T23:08:10.671338Z","iopub.status.idle":"2024-10-26T23:08:26.971378Z","shell.execute_reply.started":"2024-10-26T23:08:10.671297Z","shell.execute_reply":"2024-10-26T23:08:26.969664Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Modifying columns to simply refer to the presence or absence of the value in the column","metadata":{}},{"cell_type":"code","source":"# Identify all carbs and activity columns based on prefixes\ncarbs_columns = [col for col in train_df.columns if col.startswith('carbs-')]\nactivity_columns = [col for col in train_df.columns if col.startswith('activity-')]\n\n# Combine columns to process together\nfeature_columns_carbs_activity = {\n    'carbs': carbs_columns,\n    'activity': activity_columns\n}\n\n# Function to convert presence of values to binary indicators (1 for presence, 0 for missing)\ndef encode_presence(df, columns):\n    for col in columns:\n        # Create a binary indicator for presence of values\n        df[col + '_presence'] = df[col].notna().astype(int)\n        \n        # Drop original column as it has high missing values\n        df.drop(columns=[col], inplace=True)\n    return df\n\n# Apply binary encoding for presence/absence to carbs and activity columns in both datasets\nfor feature, columns in feature_columns_carbs_activity.items():\n    train_df = encode_presence(train_df, columns)\n    test_df = encode_presence(test_df, columns)\n\n# Verify the new columns\nprint(\"Train Data Columns after Encoding:\", train_df.columns)\nprint(\"Test Data Columns after Encoding:\", test_df.columns)","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:08:26.973188Z","iopub.execute_input":"2024-10-26T23:08:26.973604Z","iopub.status.idle":"2024-10-26T23:10:06.102516Z","shell.execute_reply.started":"2024-10-26T23:08:26.973563Z","shell.execute_reply":"2024-10-26T23:10:06.100455Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Checking for null values","metadata":{}},{"cell_type":"code","source":"visualize_null_values(train_df)\nvisualize_null_values(test_df)","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:10:06.105269Z","iopub.execute_input":"2024-10-26T23:10:06.105838Z","iopub.status.idle":"2024-10-26T23:10:07.229585Z","shell.execute_reply.started":"2024-10-26T23:10:06.105785Z","shell.execute_reply":"2024-10-26T23:10:07.227996Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Feature Engineering","metadata":{}},{"cell_type":"markdown","source":"### Time based feature engineering","metadata":{}},{"cell_type":"code","source":"import numpy as np\n\n# Convert `time` to cyclic features (sin and cos encoding for hours)\ntrain_df['time_hour'] = pd.to_datetime(train_df['time']).dt.hour\ntest_df['time_hour'] = pd.to_datetime(test_df['time']).dt.hour\n\n# Sine and Cosine transformation for cyclic hour\ntrain_df['time_hour_sin'] = np.sin(2 * np.pi * train_df['time_hour'] / 24)\ntrain_df['time_hour_cos'] = np.cos(2 * np.pi * train_df['time_hour'] / 24)\ntest_df['time_hour_sin'] = np.sin(2 * np.pi * test_df['time_hour'] / 24)\ntest_df['time_hour_cos'] = np.cos(2 * np.pi * test_df['time_hour'] / 24)\n\n# Drop the original `time` and `time_hour` columns to avoid redundancy\ntrain_df.drop(columns=['time', 'time_hour'], inplace=True)\ntest_df.drop(columns=['time', 'time_hour'], inplace=True)\n\n# Verify new features\nprint(\"Train Data with Time Features:\", train_df[['time_hour_sin', 'time_hour_cos']].head())\nprint(\"Test Data with Time Features:\", test_df[['time_hour_sin', 'time_hour_cos']].head())","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:10:07.233655Z","iopub.execute_input":"2024-10-26T23:10:07.234236Z","iopub.status.idle":"2024-10-26T23:10:07.716612Z","shell.execute_reply.started":"2024-10-26T23:10:07.234184Z","shell.execute_reply":"2024-10-26T23:10:07.714757Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Lagged and Rolling features","metadata":{}},{"cell_type":"code","source":"# Define the time-series columns for which to create lagged and rolling features\ntime_series_columns = bg_columns + hr_columns + steps_columns  # Use the actual list of columns prefixed by 'bg-', 'hr-', and 'steps-'\n\n# Function to create lagged and rolling features\ndef create_lagged_rolling_features(df, columns, lags=[1, 2, 3], windows=[3, 5, 10]):\n    for col in columns:\n        # Lagged features\n        for lag in lags:\n            df[f'{col}_lag_{lag}'] = df[col].shift(lag)  # Create lagged features based on the lag intervals\n\n        # Rolling features\n        for window in windows:\n            df[f'{col}_rolling_mean_{window}'] = df[col].rolling(window=window).mean()  # Rolling mean\n            df[f'{col}_rolling_median_{window}'] = df[col].rolling(window=window).median()  # Rolling median\n            df[f'{col}_rolling_sum_{window}'] = df[col].rolling(window=window).sum()  # Rolling sum\n    return df\n\n# Apply lagged and rolling features to both train and test datasets\ntrain_df = create_lagged_rolling_features(train_df, time_series_columns)\ntest_df = create_lagged_rolling_features(test_df, time_series_columns)\n\n# Verify new features\nprint(\"Train Data with Lagged and Rolling Features:\", train_df.head())\nprint(\"Test Data with Lagged and Rolling Features:\", test_df.head())","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:10:07.718943Z","iopub.execute_input":"2024-10-26T23:10:07.719448Z","iopub.status.idle":"2024-10-26T23:11:23.525412Z","shell.execute_reply.started":"2024-10-26T23:10:07.719398Z","shell.execute_reply":"2024-10-26T23:11:23.523862Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Handling categorical data","metadata":{}},{"cell_type":"code","source":"# Perform one-hot encoding for `p_num` (participant number) in both datasets\ntrain_df = pd.get_dummies(train_df, columns=['p_num'], prefix='participant')\ntest_df = pd.get_dummies(test_df, columns=['p_num'], prefix='participant')\n\n# Align columns between train and test to ensure both have the same structure\ntrain_df, test_df = train_df.align(test_df, join='outer', axis=1, fill_value=0)\n\n# Verify the columns are aligned\nprint(\"Train Data Columns:\", train_df.columns)\nprint(\"Test Data Columns:\", test_df.columns)","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:11:23.527659Z","iopub.execute_input":"2024-10-26T23:11:23.528193Z","iopub.status.idle":"2024-10-26T23:11:57.694093Z","shell.execute_reply.started":"2024-10-26T23:11:23.528144Z","shell.execute_reply":"2024-10-26T23:11:57.691918Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Checking for categorical data in the dataframe","metadata":{}},{"cell_type":"code","source":"# Function that checks categorical or object columns \ndef check_categorical_columns(df):\n    # Select columns of dtype 'object' or 'category'\n    categorical_columns = df.select_dtypes(include=['object', 'category']).columns\n    \n    # Check if any categorical columns exist\n    if len(categorical_columns) > 0:\n        print(f\"Categorical or object columns found: {list(categorical_columns)}\")\n        return True\n    else:\n        print(\"No categorical or object columns found.\")\n        return False\n\ncheck_categorical_columns(train_df)\ncheck_categorical_columns(test_df)\n","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:11:57.696479Z","iopub.execute_input":"2024-10-26T23:11:57.697030Z","iopub.status.idle":"2024-10-26T23:11:57.720477Z","shell.execute_reply.started":"2024-10-26T23:11:57.696977Z","shell.execute_reply":"2024-10-26T23:11:57.718739Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Reduce data types for numeric columns\ndef reduce_memory_usage(df):\n    for col in df.columns:\n        col_type = df[col].dtype\n\n        if col_type != object:\n            c_min = df[col].min()\n            c_max = df[col].max()\n            if str(col_type)[:3] == 'int':\n                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:\n                    df[col] = df[col].astype(np.int8)\n                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:\n                    df[col] = df[col].astype(np.int16)\n                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:\n                    df[col] = df[col].astype(np.int32)\n                else:\n                    df[col] = df[col].astype(np.int64)\n            else:\n                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:\n                    df[col] = df[col].astype(np.float16)\n                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:\n                    df[col] = df[col].astype(np.float32)\n                else:\n                    df[col] = df[col].astype(np.float64)\n    return df\n\n# Apply memory reduction\ntrain_df = reduce_memory_usage(train_df)\ntest_df = reduce_memory_usage(test_df)\n\n# Optional: Downsample dataset by taking a random sample of rows\ntrain_df = train_df.sample(frac=0.5, random_state=1)  # Adjust `frac` as needed to reduce dataset size\ntest_df = test_df.sample(frac=0.5, random_state=1)    # For test data, optional based on limits\n\nprint(\"Memory usage after optimization:\", train_df.memory_usage(deep=True).sum() / (1024**2), \"MB\")","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:11:57.723648Z","iopub.execute_input":"2024-10-26T23:11:57.724211Z","iopub.status.idle":"2024-10-26T23:12:14.694005Z","shell.execute_reply.started":"2024-10-26T23:11:57.724157Z","shell.execute_reply":"2024-10-26T23:12:14.692617Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Drop columns","metadata":{}},{"cell_type":"code","source":"# Drop `id` from the training data\ntrain_df.drop(columns=['id'], inplace=True)\n\n# Keep `id` in test_df for reference if needed for output\ntest_ids = test_df['id']\ntest_df.drop(columns=['id', \"bg+1:00\"], inplace=True) # We need to drop target column after aligning function","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:15:52.108550Z","iopub.execute_input":"2024-10-26T23:15:52.109335Z","iopub.status.idle":"2024-10-26T23:15:53.576285Z","shell.execute_reply.started":"2024-10-26T23:15:52.109273Z","shell.execute_reply":"2024-10-26T23:15:53.574607Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# AutoML\nThere is a lot of different frameworks for AutoML like FlAML, TPOT, or Auto-sklearn. But in this notebook we will use H20 AutoML. First of all we need download dependencies.","metadata":{}},{"cell_type":"code","source":"!pip install --upgrade pip setuptools wheel","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:15:57.348076Z","iopub.execute_input":"2024-10-26T23:15:57.349926Z","iopub.status.idle":"2024-10-26T23:16:05.603322Z","shell.execute_reply.started":"2024-10-26T23:15:57.349851Z","shell.execute_reply":"2024-10-26T23:16:05.600618Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!pip install autogluon.tabular","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:16:05.607725Z","iopub.execute_input":"2024-10-26T23:16:05.608298Z","iopub.status.idle":"2024-10-26T23:16:13.014843Z","shell.execute_reply.started":"2024-10-26T23:16:05.608245Z","shell.execute_reply":"2024-10-26T23:16:13.011130Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from autogluon.tabular import TabularPredictor\nimport pandas as pd\n\n# Define the target column\ntarget_column = 'bg+1:00'  # Replace with the actual target column in your dataset\n\n# Split training data into batches\nnum_batches = 5  # Adjust based on available memory and batch size needs\nbatch_size = len(train_df) // num_batches\nmodels = []\n\n# Maximize time limit per batch (adjust as needed based on your environment)\ntime_limit_per_batch = 3600  \nfor i in range(num_batches):\n    print(f\"Training on batch {i + 1} of {num_batches}\")\n    batch_df = train_df.iloc[i * batch_size: (i + 1) * batch_size]\n    \n    # Initialize and train AutoGluon on each batch, excluding RandomForest models\n    predictor = TabularPredictor(label=target_column, eval_metric='rmse').fit(\n        train_data=batch_df,\n        time_limit=time_limit_per_batch,  # Use maximized time limit per batch\n        presets='best_quality',  # Use desired presets\n        excluded_model_types=['RF', 'XT']  # Exclude RandomForest (RF) and ExtraTrees (XT)\n    )\n    models.append(predictor)\n\n# Ensemble or average predictions\ndef batch_predict(models, test_df):\n    # Get predictions from each model in the ensemble\n    predictions = [model.predict(test_df) for model in models]\n    \n    # Average predictions from each batch model\n    final_predictions = pd.DataFrame(predictions).mean(axis=0)\n    return final_predictions\n\n# Generate predictions on the test set using batch ensemble\ntest_predictions = batch_predict(models, test_df)\n\n# Combine predictions with ID for output\nfinal_output = test_ids.to_frame()  # Restore `id` as a DataFrame\nfinal_output['bg+1:00'] = test_predictions","metadata":{"execution":{"iopub.status.busy":"2024-10-26T23:28:11.436259Z","iopub.execute_input":"2024-10-26T23:28:11.436994Z","iopub.status.idle":"2024-10-27T02:02:21.319221Z","shell.execute_reply.started":"2024-10-26T23:28:11.436934Z","shell.execute_reply":"2024-10-27T02:02:21.316900Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"final_output.to_csv(\"submission.csv\", index=False)","metadata":{"execution":{"iopub.status.busy":"2024-10-27T02:04:00.238506Z","iopub.execute_input":"2024-10-27T02:04:00.240067Z","iopub.status.idle":"2024-10-27T02:04:00.263495Z","shell.execute_reply.started":"2024-10-27T02:04:00.239987Z","shell.execute_reply":"2024-10-27T02:04:00.261257Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Thank you for reading notebook about using AutoML! Will be glad if you leave your comments.","metadata":{}}]}