{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# **Hackathon *Gamification & AI*, April 2023**\n---\n\n![image.png](attachment:0067f9da-a39e-4b8f-9cc6-358926930a3f.png)","metadata":{},"attachments":{"0067f9da-a39e-4b8f-9cc6-358926930a3f.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"**Introduction**\n\nIn this hackathon you will learn how to apply AI in the context of Gamification. Gamification is the addition of game mechanisms in non-game environments to enhance motivation and engagement of users. Think of a reward system that motivates employees to be more active in sustainable practices on the workplace, or sales-teams that achieve points and badges for sales made (on top of monetary rewards). In addition, gamification creates a lot of (log) data. With machine learning we could personalise learning and reward systems, or even predict a user's chance of success. Predicting a student's chance of success in an e-learning platform is the case you will explore in this hackathon, by joining the kaggle competition *[Predict Student Performance from Game Play](https://www.kaggle.com/competitions/predict-student-performance-from-game-play/discussion)*.\n\n**Goal of the Competition**\n\nThe goal of this competition is to improve the baseline prediction performance of students' success during game-based learning in real-time. You'll develop a model trained on one of the largest open datasets of game logs. Your work will help advance research into knowledge-tracing methods for game-based learning. You'll be supporting developers of educational games to create more effective learning experiences for students.\n\n**How to win** \n\n*Public Competition*\n\nThere is a total of $55,000 [prize money](https://www.kaggle.com/competitions/predict-student-performance-from-game-play/overview/prizes)! Prizes are awarded for best model performance (F1-score) and efficiency (\"~runtime\").\n\nCurrently, the [highest score achieved](https://www.kaggle.com/competitions/predict-student-performance-from-game-play/leaderboard) is 0.753. \n\n*Internal FF Competition*\n\nYou will be graded on F1-score and efficiency as well, and additionally on your presentation and creativity. Refer to the slides for the exact specification of the scoring.\n\n**The game** - *Jo Wilder and the Capitol Case (PBS Wisconsin Education)*\n\nOpen and [play the game](https://pbswisconsineducation.org/jowilder/play-the-game/) to understand how the data is created that you will analyse.\n\n**Do's**\n\n* Think about division of labor / teamwork\n* Workflow (ie seperate or parallel notebooks)\n* Timing of cells (you should finish within 3hrs and score points for efficiency)\n* Smart use of resources (ChatGPT, StackOverflow, other Kaggle comp notebooks, etc.)\n* Work with versioning (possible within Kaggle)\n* Have FUN\n\n**Don'ts**\n\n* Espionage, sabotage, treason\n* Late start on presentation\n* Accidentally delete cell you were working on (undo does not work everytime, trust me, been there). ","metadata":{}},{"cell_type":"markdown","source":"# Recommendations for XGBoost Baseline - LB 0.678 (Leader Board score in terms of F1)\nIn this notebook we present a XGBoost baseline. We train GroupKFold models for each of the 18 questions. Our CV score is 0.678. We infer test using one of our KFold models. \n\n**POSSIBLE IMPROVEMENTS** There are several ways to improve this model and we suggest the following recommendations on improvements. Feel free to deviate from this list if you have a different idea.\n1. Use different methods for feature engineering (e.g. use sum instead of using mean or std)\n2. Use completely newly defined features (e.g. PCA)\n3. Try different sizes for the validation and training data set\n4. Vary the parameters of the XGBoost algorithm itself (manual/automatic hyperparameter tuning)\n5. Try other completely different ML/DL models\n6. Try using more KFold models (different number of folds or fold sizes)","metadata":{"papermill":{"duration":0.005932,"end_time":"2023-02-07T00:59:58.147501","exception":false,"start_time":"2023-02-07T00:59:58.141569","status":"completed"},"tags":[]}},{"cell_type":"code","source":"import pandas as pd, numpy as np, gc\nfrom sklearn.model_selection import KFold, GroupKFold\nfrom xgboost import XGBClassifier\nfrom sklearn.metrics import f1_score","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:23:30.279599Z","iopub.status.busy":"2023-04-04T11:23:30.279140Z","iopub.status.idle":"2023-04-04T11:23:31.068911Z","shell.execute_reply":"2023-04-04T11:23:31.067836Z","shell.execute_reply.started":"2023-04-04T11:23:30.279565Z"},"papermill":{"duration":1.027875,"end_time":"2023-02-07T00:59:59.180261","exception":false,"start_time":"2023-02-07T00:59:58.152386","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!pip install memory_profiler\n%load_ext memory_profiler","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:23:31.071680Z","iopub.status.busy":"2023-04-04T11:23:31.070994Z","iopub.status.idle":"2023-04-04T11:24:04.927468Z","shell.execute_reply":"2023-04-04T11:24:04.925833Z","shell.execute_reply.started":"2023-04-04T11:23:31.071631Z"}},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Load Train Data and Labels\nOn March 20 2023, Kaggle doubled the size of the training data for the \"Predict Student Performance from Game Data\" competition (discussion [here][1]), resulting in a dataset that now occupies 4.7GB of memory. To prevent memory errors, we will read the training data in 5 chunks before concatenating the pieces. This approach allowed us to successfully process the larger dataset.\n\nAlternatively, you could use two notebooks to work with the data: train models in a notebook with 32GB RAM and GPU, save the models, and then load them into a second notebook with only 8GB of RAM and CPU for submission.\n\n[1]: https://www.kaggle.com/competitions/predict-student-performance-from-game-play/discussion/396202","metadata":{"papermill":{"duration":0.004542,"end_time":"2023-02-07T00:59:59.189777","exception":false,"start_time":"2023-02-07T00:59:59.185235","status":"completed"},"tags":[]}},{"cell_type":"code","source":"# READ USER ID ONLY --> to get the row amount for creating chunk sizes.\n%time %memit tmp = pd.read_csv(\"/kaggle/input/predict-student-performance-from-game-play/train.csv\",usecols=[0])\ntmp = tmp.groupby('session_id').session_id.agg('count')\n\n# COMPUTE READS AND SKIPS\nPIECES = 5\nCHUNK = int( np.ceil(len(tmp)/PIECES) )\n\n# Here the data pieces are created\nreads = []\nskips = [0]\nfor k in range(PIECES):\n    a = k*CHUNK\n    b = (k+1)*CHUNK\n    if b>len(tmp): b=len(tmp)\n    r = tmp.iloc[a:b].sum()\n    reads.append(r)\n    skips.append(skips[-1]+r)\n    \nprint(f'To avoid memory error, we will read train in {PIECES} pieces of sizes:')\nprint(reads)","metadata":{"_kg_hide-input":true,"execution":{"iopub.execute_input":"2023-04-04T11:24:04.930637Z","iopub.status.busy":"2023-04-04T11:24:04.929530Z","iopub.status.idle":"2023-04-04T11:25:33.942210Z","shell.execute_reply":"2023-04-04T11:25:33.940618Z","shell.execute_reply.started":"2023-04-04T11:24:04.930565Z"}},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Reduce Memory Usage\n# reference : https://www.kaggle.com/code/arjanso/reducing-dataframe-memory-size-by-65 @ARJANGROEN\ndef reduce_memory_usage(df):\n    start_mem = df.memory_usage().sum() / 1024**2\n    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))\n    \n    # The idea here is to check the maximum decimal precision of every column and convert \n    # the whole column to the max necessary precision to minimize memory usage\n    for col in df.columns:\n        col_type = df[col].dtype.name\n        if ((col_type != 'datetime64[ns]') & (col_type != 'category')):\n            if (col_type != 'object'):\n                c_min = df[col].min()\n                c_max = df[col].max()\n\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                    elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:\n                        df[col] = df[col].astype(np.int64)\n\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                        pass\n            else:\n                df[col] = df[col].astype('category')\n    mem_usg = df.memory_usage().sum() / 1024**2 \n    print(\"Memory usage became: \",mem_usg,\" MB\")\n    \n    return df","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:25:33.946183Z","iopub.status.busy":"2023-04-04T11:25:33.945771Z","iopub.status.idle":"2023-04-04T11:25:33.961405Z","shell.execute_reply":"2023-04-04T11:25:33.959889Z","shell.execute_reply.started":"2023-04-04T11:25:33.946144Z"}},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# LOAD DATA IN PIECES, THEN REDUCE MEMORY USAGE\nall_pieces = []\nprint(f'Loading train as {PIECES} pieces to avoid memory error... ')\nfor k in range(PIECES):\n    print(k,', ',end='')\n    SKIPS = 0\n    if k>0: SKIPS = range(1,skips[k]+1)\n    train = pd.read_csv('/kaggle/input/predict-student-performance-from-game-play/train.csv',\n                        nrows=reads[k], skiprows=SKIPS)\n    df = reduce_memory_usage(train)\n    all_pieces.append(df)","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:25:33.963478Z","iopub.status.busy":"2023-04-04T11:25:33.963151Z","iopub.status.idle":"2023-04-04T11:29:32.559606Z","shell.execute_reply":"2023-04-04T11:29:32.558018Z","shell.execute_reply.started":"2023-04-04T11:25:33.963449Z"}},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# CONCATENATE ALL PIECES TO FULL TRAIN DATA\nprint('\\n')\ndel train; gc.collect()\npre_df = pd.concat(all_pieces, axis=0)\nprint('Shape of all train data:', pre_df.shape )\npre_df.head()","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:29:32.565186Z","iopub.status.busy":"2023-04-04T11:29:32.562858Z","iopub.status.idle":"2023-04-04T11:29:36.774410Z","shell.execute_reply":"2023-04-04T11:29:36.772466Z","shell.execute_reply.started":"2023-04-04T11:29:32.565111Z"}},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# LOAD LABEL DATA\n# Splits the session id and question into seperate columns. \n# Note, that a unique session id consists of all the questions corresponding to that \n# session, i.e. one session represents one user completing the game.\n# We need to seperate this information to verify if the question is answered correctly \n# in later evaluations\ntargets = pd.read_csv('/kaggle/input/predict-student-performance-from-game-play/train_labels.csv')\ntargets['session'] = targets.session_id.apply(lambda x: int(x.split('_')[0]) )\ntargets['q'] = targets.session_id.apply(lambda x: int(x.split('_')[-1][1:]) )\nprint( targets.shape )\ntargets.head()","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:29:36.777195Z","iopub.status.busy":"2023-04-04T11:29:36.776581Z","iopub.status.idle":"2023-04-04T11:29:38.015495Z","shell.execute_reply":"2023-04-04T11:29:38.014207Z","shell.execute_reply.started":"2023-04-04T11:29:36.777155Z"},"papermill":{"duration":0.598155,"end_time":"2023-02-07T01:00:59.082015","exception":false,"start_time":"2023-02-07T01:00:58.48386","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"targets.tail()","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:29:38.017997Z","iopub.status.busy":"2023-04-04T11:29:38.017424Z","iopub.status.idle":"2023-04-04T11:29:38.030383Z","shell.execute_reply":"2023-04-04T11:29:38.028995Z","shell.execute_reply.started":"2023-04-04T11:29:38.017959Z"}},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Exploratory Data Analysis\n\nHere is a schematic overview of the data.\n\n![image.png](attachment:a797c65f-f43f-40b7-a73a-3ea84bc097e1.png)","metadata":{},"attachments":{"a797c65f-f43f-40b7-a73a-3ea84bc097e1.png":{"image/png":"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"}}},{"cell_type":"code","source":"pre_df.info()","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:29:38.032686Z","iopub.status.busy":"2023-04-04T11:29:38.032062Z","iopub.status.idle":"2023-04-04T11:29:38.058729Z","shell.execute_reply":"2023-04-04T11:29:38.057742Z","shell.execute_reply.started":"2023-04-04T11:29:38.032648Z"}},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def summary(df):\n    print(f'data shape: {df.shape}')\n    summ = pd.DataFrame(df.dtypes, columns=['data type'])\n    summ['#missing'] = df.isnull().sum().values * 100\n    summ['%missing'] = df.isnull().sum().values / len(df)\n    summ['#unique'] = df.nunique().values\n    desc = pd.DataFrame(df.describe(include='all').transpose())\n    summ['min'] = desc['min'].values\n    summ['max'] = desc['max'].values\n    return summ","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:34:16.051862Z","iopub.status.busy":"2023-04-04T11:34:16.051353Z","iopub.status.idle":"2023-04-04T11:34:16.066488Z","shell.execute_reply":"2023-04-04T11:34:16.065348Z","shell.execute_reply.started":"2023-04-04T11:34:16.051824Z"}},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Display a summary of the data properties (missing values, unique values, min, max)\nsummary_table = summary(pre_df)\nsummary_table","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:34:17.276167Z","iopub.status.busy":"2023-04-04T11:34:17.275703Z","iopub.status.idle":"2023-04-04T11:35:15.562850Z","shell.execute_reply":"2023-04-04T11:35:15.561176Z","shell.execute_reply.started":"2023-04-04T11:34:17.276132Z"}},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"pre_df['event_name'].value_counts()","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:33:12.451445Z","iopub.status.busy":"2023-04-04T11:33:12.450861Z","iopub.status.idle":"2023-04-04T11:33:12.679790Z","shell.execute_reply":"2023-04-04T11:33:12.678474Z","shell.execute_reply.started":"2023-04-04T11:33:12.451409Z"}},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Additional analyses can be found e.g. here; https://www.kaggle.com/code/banfuzhi/detailed-eda-student-perf-from-game-play or https://www.kaggle.com/code/gehallak/why-are-some-sessions-so-long#3.-Session-Length-and-score.","metadata":{}},{"cell_type":"markdown","source":"# Feature Engineer\nWe create basic aggregate features. Try creating more features to boost CV and LB! The idea for EVENTS feature is from [here][1]\n\n[1]: https://www.kaggle.com/code/kimtaehun/lightgbm-baseline-with-aggregated-log-data","metadata":{"papermill":{"duration":0.005196,"end_time":"2023-02-07T01:00:59.092865","exception":false,"start_time":"2023-02-07T01:00:59.087669","status":"completed"},"tags":[]}},{"cell_type":"code","source":"# A distinction is made between categorical (string), numerical (floats or integers) and \n# event (string).\nCATS = ['event_name', 'fqid', 'room_fqid', 'text']\nNUMS = ['elapsed_time','level','page','room_coor_x', 'room_coor_y', \n        'screen_coor_x', 'screen_coor_y', 'hover_duration']\n\n# https://www.kaggle.com/code/kimtaehun/lightgbm-baseline-with-aggregated-log-data\nEVENTS = ['navigate_click','person_click','cutscene_click','object_click',\n          'map_hover','notification_click','map_click','observation_click',\n          'checkpoint']","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:35:32.680658Z","iopub.status.busy":"2023-04-04T11:35:32.680149Z","iopub.status.idle":"2023-04-04T11:35:32.688237Z","shell.execute_reply":"2023-04-04T11:35:32.687134Z","shell.execute_reply.started":"2023-04-04T11:35:32.680623Z"},"papermill":{"duration":0.014685,"end_time":"2023-02-07T01:00:59.112856","exception":false,"start_time":"2023-02-07T01:00:59.098171","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Based on the different data defined above we engineer features that are grouped by, \n# and aggregated per unique session id and level group. Thus, resulting in a single row \n# for every session id containing the aggregated value of every feature.\n# Note, that the questions within one session are grouped per level group,\n# i.e. the 18 questions are distributed over 22 different levels, which makes up a \n# complete session.\ndef feature_engineer(train):   \n    dfs = []\n    for c in CATS:\n        #Define unique number of categorical data per level group within an unique session\n        tmp = train.groupby(['session_id','level_group'])[c].agg('nunique')\n        tmp.name = tmp.name + '_nunique'\n        dfs.append(tmp)\n    for c in NUMS:\n        #Define the mean of the numerical data per level group within an unique session\n        tmp = train.groupby(['session_id','level_group'])[c].agg('mean')        \n        tmp.name = tmp.name + '_mean'\n        dfs.append(tmp)\n    for c in NUMS:\n        #Define the std of the numerical data per level group within an unique session\n        tmp = train.groupby(['session_id','level_group'])[c].agg('std')         \n        tmp.name = tmp.name + '_std'\n        dfs.append(tmp)\n    for c in EVENTS: \n        train[c] = (train.event_name == c).astype('int8')\n    for c in EVENTS + ['elapsed_time']:\n        #Define the sum of the occurences of an event per level group within an unique session\n        tmp = train.groupby(['session_id','level_group'])[c].agg('sum')         \n        tmp.name = tmp.name + '_sum'\n        dfs.append(tmp)\n    train = train.drop(EVENTS,axis=1)\n        \n    df = pd.concat(dfs,axis=1)\n    df = df.fillna(-1)\n    df = df.reset_index()\n    df = df.set_index('session_id')\n    return df","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:35:32.875272Z","iopub.status.busy":"2023-04-04T11:35:32.874102Z","iopub.status.idle":"2023-04-04T11:35:32.886936Z","shell.execute_reply":"2023-04-04T11:35:32.885318Z","shell.execute_reply.started":"2023-04-04T11:35:32.875215Z"},"papermill":{"duration":0.017716,"end_time":"2023-02-07T01:00:59.136021","exception":false,"start_time":"2023-02-07T01:00:59.118305","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# create the features per piece of training data and display the head\ndf = feature_engineer(pre_df)\ndf.head()","metadata":{"execution":{"iopub.execute_input":"2023-04-04T11:35:34.232088Z","iopub.status.busy":"2023-04-04T11:35:34.231606Z","iopub.status.idle":"2023-04-04T11:36:46.394612Z","shell.execute_reply":"2023-04-04T11:36:46.393175Z","shell.execute_reply.started":"2023-04-04T11:35:34.232054Z"},"papermill":{"duration":34.516494,"end_time":"2023-02-07T01:01:33.658043","exception":false,"start_time":"2023-02-07T01:00:59.141549","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Train XGBoost Model\nWe train one model for each of 18 questions. Furthermore, we use data from `level_groups = '0-4'` to train model for questions 1-3, and `level groups '5-12'` to train questions 4 thru 13 and `level groups '13-22'` to train questions 14 thru 18. Because this is the data we get (to predict corresponding questions) from Kaggle's inference API during test inference. We can improve our model by saving a user's previous data from earlier `level_groups` and using that to predict future `level_groups`.","metadata":{"papermill":{"duration":0.011053,"end_time":"2023-04-12T09:41:34.751562","exception":false,"start_time":"2023-04-12T09:41:34.740509","status":"completed"},"tags":[]}},{"cell_type":"code","source":"FEATURES = [c for c in df.columns if c != 'level_group']\nprint('We will train with', len(FEATURES) ,'features')\nALL_USERS = df.index.unique()\nprint('We will train with', len(ALL_USERS) ,'users info')","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:41:34.777989Z","iopub.status.busy":"2023-04-12T09:41:34.777245Z","iopub.status.idle":"2023-04-12T09:41:34.786523Z","shell.execute_reply":"2023-04-12T09:41:34.785429Z"},"papermill":{"duration":0.024872,"end_time":"2023-04-12T09:41:34.788904","exception":false,"start_time":"2023-04-12T09:41:34.764032","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"``GroupKFold`` **is a variation of k-fold which ensures that the same group is not represented in both testing/validation and training sets. For example if the data is obtained from different subjects with several samples per-subject and if the model is flexible enough to learn from highly person specific features it could fail to generalize to new subjects.** ``GroupKFold`` **makes it possible to detect this kind of overfitting situations.**\n\n![](https://i.stack.imgur.com/a0qtJ.png)","metadata":{"papermill":{"duration":0.011317,"end_time":"2023-04-12T09:41:34.811649","exception":false,"start_time":"2023-04-12T09:41:34.800332","status":"completed"},"tags":[]}},{"cell_type":"code","source":"gkf = GroupKFold(n_splits=5)\n\n# Tip: try different kfold variations\n# kf = KFold(n_splits=5) # example if you would like to try regular KFold\n\n# oof == out of fold (predictions) collected in a dataframe\n# this means all predictions on test subset in each fold are collected\n# in the oof dataframe\noof = pd.DataFrame(data=np.zeros((len(ALL_USERS),18)), index=ALL_USERS) \nmodels = {}\n\n# COMPUTE CV SCORE WITH 5 GROUP K FOLD\nfor i, (train_index, test_index) in enumerate(gkf.split(X=df, groups=df.index)):\n    print('#'*25)\n    print('### Fold',i+1)\n    print('#'*25)\n    \n    # Hyperparameters --> Tip: (automatic) tuning, e.g. GridSearchCV, RandomizedSearhCV,\n    # or better yet: Bayesian Optimization\n    xgb_params = {\n    'objective' : 'binary:logistic',\n    'eval_metric':'logloss',\n    'learning_rate': 0.05,\n    'max_depth': 4,\n    'n_estimators': 1000,\n    'early_stopping_rounds': 50,\n    'tree_method':'hist',\n    'subsample':0.8,\n    'colsample_bytree': 0.4,\n    'use_label_encoder' : False}\n    \n    # ITERATE THRU QUESTIONS 1 THRU 18\n    for t in range(1,19):\n        \n        # USE THIS TRAIN DATA WITH THESE QUESTIONS\n        if t<=3: grp = '0-4'\n        elif t<=13: grp = '5-12'\n        elif t<=22: grp = '13-22'\n            \n        # TRAIN DATA\n        train_x = df.iloc[train_index]\n        train_x = train_x.loc[train_x.level_group == grp]\n        train_users = train_x.index.values\n        train_y = targets.loc[targets.q==t].set_index('session').loc[train_users]\n        \n        # VALID DATA\n        valid_x = df.iloc[test_index]\n        valid_x = valid_x.loc[valid_x.level_group == grp]\n        valid_users = valid_x.index.values\n        valid_y = targets.loc[targets.q==t].set_index('session').loc[valid_users]\n        \n        # TRAIN MODEL        \n        clf =  XGBClassifier(**xgb_params)\n        clf.fit(train_x[FEATURES].astype('float32'), train_y['correct'],\n                eval_set=[ (valid_x[FEATURES].astype('float32'), valid_y['correct']) ],\n                verbose=0)\n        print(f'{t}({clf.best_ntree_limit}), ',end='')\n        \n        # SAVE MODEL, PREDICT VALID OOF\n        models[f'{grp}_{t}'] = clf\n        oof.loc[valid_users, t-1] = clf.predict_proba(valid_x[FEATURES].astype('float32'))[:,1]\n        \n    print()","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:41:34.837269Z","iopub.status.busy":"2023-04-12T09:41:34.836301Z","iopub.status.idle":"2023-04-12T09:44:15.413929Z","shell.execute_reply":"2023-04-12T09:44:15.412818Z"},"papermill":{"duration":160.593348,"end_time":"2023-04-12T09:44:15.416588","exception":false,"start_time":"2023-04-12T09:41:34.823240","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Compute CV Score\nWe need to convert prediction probabilities into `1s` and `0s`. The competition metric is F1 Score which is the harmonic mean of precision and recall. Let's find the optimal threshold for `p > threshold` when to predict `1` and when to predict `0` to maximize F1 Score.","metadata":{"papermill":{"duration":0.016702,"end_time":"2023-04-12T09:44:15.450202","exception":false,"start_time":"2023-04-12T09:44:15.433500","status":"completed"},"tags":[]}},{"cell_type":"code","source":"# PUT TRUE LABELS INTO DATAFRAME WITH 18 COLUMNS\ntrue = oof.copy()\nfor k in range(18):\n    # GET TRUE LABELS\n    tmp = targets.loc[targets.q == k+1].set_index('session').loc[ALL_USERS]\n    true[k] = tmp.correct.values","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:15.491169Z","iopub.status.busy":"2023-04-12T09:44:15.490364Z","iopub.status.idle":"2023-04-12T09:44:15.637111Z","shell.execute_reply":"2023-04-12T09:44:15.635886Z"},"papermill":{"duration":0.172796,"end_time":"2023-04-12T09:44:15.639986","exception":false,"start_time":"2023-04-12T09:44:15.467190","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# FIND BEST THRESHOLD TO CONVERT PROBS INTO 1s AND 0s\nscores = []; thresholds = []\nbest_score = 0; best_threshold = 0\n\nfor threshold in np.arange(0.4,0.81,0.01):\n    print(f'{threshold:.02f}, ',end='')\n    preds = (oof.values.reshape((-1))>threshold).astype('int')\n    m = f1_score(true.values.reshape((-1)), preds, average='macro')   \n    scores.append(m)\n    thresholds.append(threshold)\n    if m>best_score:\n        best_score = m\n        best_threshold = threshold","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:15.676368Z","iopub.status.busy":"2023-04-12T09:44:15.675972Z","iopub.status.idle":"2023-04-12T09:44:23.900897Z","shell.execute_reply":"2023-04-12T09:44:23.899185Z"},"papermill":{"duration":8.246478,"end_time":"2023-04-12T09:44:23.903667","exception":false,"start_time":"2023-04-12T09:44:15.657189","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# PLOT THRESHOLD VS. F1_SCORE\nplt.figure(figsize=(20,5))\nplt.plot(thresholds,scores,'-o',color='blue')\nplt.scatter([best_threshold], [best_score], color='blue', s=300, alpha=1)\nplt.xlabel('Threshold',size=14)\nplt.ylabel('Validation F1 Score',size=14)\nplt.title(f'Threshold vs. F1_Score with Best F1_Score = {best_score:.3f} at Best Threshold = {best_threshold:.3}',size=18)\nplt.show()","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:23.942848Z","iopub.status.busy":"2023-04-12T09:44:23.942432Z","iopub.status.idle":"2023-04-12T09:44:24.276027Z","shell.execute_reply":"2023-04-12T09:44:24.274691Z"},"papermill":{"duration":0.357282,"end_time":"2023-04-12T09:44:24.279740","exception":false,"start_time":"2023-04-12T09:44:23.922458","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## F1-score Macro == Competition metric\n","metadata":{"papermill":{"duration":0.01953,"end_time":"2023-04-12T09:44:24.325589","exception":false,"start_time":"2023-04-12T09:44:24.306059","status":"completed"},"tags":[]}},{"cell_type":"code","source":"print('When using optimal threshold...')\nfor k in range(18):\n        \n    # COMPUTE F1 SCORE PER QUESTION\n    m = f1_score(true[k].values, (oof[k].values>best_threshold).astype('int'), average='macro')\n    print(f'Q{k}: F1 =', m)\n    \n# COMPUTE F1 SCORE OVERALL\nm = f1_score(true.values.reshape((-1)), (oof.values.reshape((-1))>best_threshold).astype('int'), average='macro')\nprint('==> Overall F1 =', m)","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:24.366554Z","iopub.status.busy":"2023-04-12T09:44:24.366038Z","iopub.status.idle":"2023-04-12T09:44:24.785589Z","shell.execute_reply":"2023-04-12T09:44:24.784654Z"},"papermill":{"duration":0.444102,"end_time":"2023-04-12T09:44:24.788838","exception":false,"start_time":"2023-04-12T09:44:24.344736","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Infer Test Data","metadata":{"papermill":{"duration":0.018997,"end_time":"2023-04-12T09:44:25.309951","exception":false,"start_time":"2023-04-12T09:44:25.290954","status":"completed"},"tags":[]}},{"cell_type":"code","source":"# IMPORT KAGGLE API\nimport jo_wilder\nenv = jo_wilder.make_env()\niter_test = env.iter_test()\n\n# CLEAR MEMORY\nimport gc\ndel targets, df, oof, true\n_ = gc.collect()","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:25.350942Z","iopub.status.busy":"2023-04-12T09:44:25.350176Z","iopub.status.idle":"2023-04-12T09:44:25.524161Z","shell.execute_reply":"2023-04-12T09:44:25.523199Z"},"papermill":{"duration":0.197838,"end_time":"2023-04-12T09:44:25.527101","exception":false,"start_time":"2023-04-12T09:44:25.329263","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"limits = {'0-4':(1,4), '5-12':(4,14), '13-22':(14,19)}\n\nfor (test, sample_submission) in iter_test:\n    \n    # FEATURE ENGINEER TEST DATA\n    df = feature_engineer(test)\n    \n    # INFER TEST DATA\n    grp = test.level_group.values[0]\n    a,b = limits[grp]\n    for t in range(a,b):\n        clf = models[f'{grp}_{t}']\n        p = clf.predict_proba(df[FEATURES].astype('float32'))[0,1]\n        mask = sample_submission.session_id.str.contains(f'q{t}')\n        sample_submission.loc[mask,'correct'] = int( p > best_threshold )\n    \n    env.predict(sample_submission)","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:25.570273Z","iopub.status.busy":"2023-04-12T09:44:25.569291Z","iopub.status.idle":"2023-04-12T09:44:25.920183Z","shell.execute_reply":"2023-04-12T09:44:25.919313Z"},"papermill":{"duration":0.375669,"end_time":"2023-04-12T09:44:25.922680","exception":false,"start_time":"2023-04-12T09:44:25.547011","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# EDA submission.csv","metadata":{"papermill":{"duration":0.019854,"end_time":"2023-04-12T09:44:25.962151","exception":false,"start_time":"2023-04-12T09:44:25.942297","status":"completed"},"tags":[]}},{"cell_type":"code","source":"df = pd.read_csv('submission.csv')\nprint( df.shape )\ndf.head()","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:26.003075Z","iopub.status.busy":"2023-04-12T09:44:26.002698Z","iopub.status.idle":"2023-04-12T09:44:26.016123Z","shell.execute_reply":"2023-04-12T09:44:26.015184Z"},"papermill":{"duration":0.037238,"end_time":"2023-04-12T09:44:26.018530","exception":false,"start_time":"2023-04-12T09:44:25.981292","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(df.correct.mean())","metadata":{"execution":{"iopub.execute_input":"2023-04-12T09:44:26.062498Z","iopub.status.busy":"2023-04-12T09:44:26.061743Z","iopub.status.idle":"2023-04-12T09:44:26.068275Z","shell.execute_reply":"2023-04-12T09:44:26.066700Z"},"papermill":{"duration":0.031608,"end_time":"2023-04-12T09:44:26.070775","exception":false,"start_time":"2023-04-12T09:44:26.039167","status":"completed"},"tags":[]},"execution_count":null,"outputs":[]}]}