{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.6","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":21651,"databundleVersionId":1595136,"sourceType":"competition"}],"dockerImageVersionId":30018,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Riiid! Answer Correctness Prediction. Data Analysis and visualization and Modeling","metadata":{}},{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport plotly.express as px \n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 5GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2024-12-01T13:18:44.197493Z","iopub.execute_input":"2024-12-01T13:18:44.19775Z","iopub.status.idle":"2024-12-01T13:18:46.750439Z","shell.execute_reply.started":"2024-12-01T13:18:44.197722Z","shell.execute_reply":"2024-12-01T13:18:46.749604Z"}},"outputs":[{"name":"stdout","text":"/kaggle/input/riiid-test-answer-prediction/example_sample_submission.csv\n/kaggle/input/riiid-test-answer-prediction/example_test.csv\n/kaggle/input/riiid-test-answer-prediction/questions.csv\n/kaggle/input/riiid-test-answer-prediction/train.csv\n/kaggle/input/riiid-test-answer-prediction/lectures.csv\n/kaggle/input/riiid-test-answer-prediction/riiideducation/competition.cpython-37m-x86_64-linux-gnu.so\n/kaggle/input/riiid-test-answer-prediction/riiideducation/__init__.py\n","output_type":"stream"}],"execution_count":1},{"cell_type":"markdown","source":"#Number of records","metadata":{}},{"cell_type":"code","source":"!wc -l ../input/riiid-test-answer-prediction/train.csv","metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true,"execution":{"iopub.status.busy":"2024-12-01T13:18:56.196967Z","iopub.execute_input":"2024-12-01T13:18:56.1973Z","iopub.status.idle":"2024-12-01T13:20:07.501327Z","shell.execute_reply.started":"2024-12-01T13:18:56.197271Z","shell.execute_reply":"2024-12-01T13:20:07.500617Z"}},"outputs":[{"name":"stdout","text":"101230333 ../input/riiid-test-answer-prediction/train.csv\n","output_type":"stream"}],"execution_count":2},{"cell_type":"markdown","source":"**Train.csv**\n* row_id: (int64) ID code for the row.\n\n* timestamp: (int64) the time between this user interaction and the first event from that user.\n\n* user_id: (int32) ID code for the user.\n\n* content_id: (int16) ID code for the user interaction\n\n* content_type_id: (int8) 0 if the event was a question being posed to the user, 1 if the event was the user watching a lecture.\n\n* task_container_id: (int16) Id code for the batch of questions or lectures. For example, a user might see three questions in a row before seeing the explanations for any of them. Those three would all share a task_container_id. Monotonically increasing for each user.\n\n* user_answer: (int8) the user's answer to the question, if any. Read -1 as null, for lectures.\n\n* answered_correctly: (int8) if the user responded correctly. Read -1 as null, for lectures.\n\n* prior_question_elapsed_time: (float32) How long it took a user to answer their previous question bundle, ignoring any lectures in between. The value is shared across a single question bundle, and is null for a user's first question bundle or lecture. Note that the time is the total time a user took to solve all the questions in the previous bundle.\n\n* prior_question_had_explanation: (bool) Whether or not the user saw an explanation and the correct response(s) after answering the previous question bundle, ignoring any lectures in between. The value is shared across a single question bundle, and is null for a user's first question bundle or lecture. Typically the first several questions a user sees were part of an onboarding diagnostic test where they did not get any feedback.","metadata":{}},{"cell_type":"code","source":"import pandas as pd\n\n# Загрузка первых 1 млн строк train.csv\ntrain_path = '../input/riiid-test-answer-prediction/train.csv'\ntrain_df = pd.read_csv(train_path, nrows=1_000_000)\n\n# Проверка загруженных данных\nprint(f\"Shape of the loaded data: {train_df.shape}\")\nprint(train_df.head())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-01T13:33:53.895134Z","iopub.execute_input":"2024-12-01T13:33:53.895525Z","iopub.status.idle":"2024-12-01T13:33:54.616739Z","shell.execute_reply.started":"2024-12-01T13:33:53.89549Z","shell.execute_reply":"2024-12-01T13:33:54.615925Z"}},"outputs":[{"name":"stdout","text":"Shape of the loaded data: (1000000, 10)\n   row_id  timestamp  user_id  content_id  content_type_id  task_container_id  \\\n0       0          0      115        5692                0                  1   \n1       1      56943      115        5716                0                  2   \n2       2     118363      115         128                0                  0   \n3       3     131167      115        7860                0                  3   \n4       4     137965      115        7922                0                  4   \n\n   user_answer  answered_correctly  prior_question_elapsed_time  \\\n0            3                   1                          NaN   \n1            2                   1                      37000.0   \n2            0                   1                      55000.0   \n3            0                   1                      19000.0   \n4            1                   1                      11000.0   \n\n  prior_question_had_explanation  \n0                            NaN  \n1                          False  \n2                          False  \n3                          False  \n4                          False  \n","output_type":"stream"}],"execution_count":7},{"cell_type":"code","source":"# Изучение структуры данных\nprint(\"Столбцы и типы данных:\")\nprint(train_df.info())\n\nprint(\"\\nКоличество пропусков в данных:\")\nprint(train_df.isnull().sum())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-01T13:35:08.289439Z","iopub.execute_input":"2024-12-01T13:35:08.28976Z","iopub.status.idle":"2024-12-01T13:35:08.458626Z","shell.execute_reply.started":"2024-12-01T13:35:08.289722Z","shell.execute_reply":"2024-12-01T13:35:08.457879Z"}},"outputs":[{"name":"stdout","text":"Столбцы и типы данных:\n<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 1000000 entries, 0 to 999999\nData columns (total 10 columns):\n #   Column                          Non-Null Count    Dtype  \n---  ------                          --------------    -----  \n 0   row_id                          1000000 non-null  int64  \n 1   timestamp                       1000000 non-null  int64  \n 2   user_id                         1000000 non-null  int64  \n 3   content_id                      1000000 non-null  int64  \n 4   content_type_id                 1000000 non-null  int64  \n 5   task_container_id               1000000 non-null  int64  \n 6   user_answer                     1000000 non-null  int64  \n 7   answered_correctly              1000000 non-null  int64  \n 8   prior_question_elapsed_time     976277 non-null   float64\n 9   prior_question_had_explanation  996184 non-null   object \ndtypes: float64(1), int64(8), object(1)\nmemory usage: 76.3+ MB\nNone\n\nКоличество пропусков в данных:\nrow_id                                0\ntimestamp                             0\nuser_id                               0\ncontent_id                            0\ncontent_type_id                       0\ntask_container_id                     0\nuser_answer                           0\nanswered_correctly                    0\nprior_question_elapsed_time       23723\nprior_question_had_explanation     3816\ndtype: int64\n","output_type":"stream"}],"execution_count":9},{"cell_type":"code","source":"#Анализ столбцов\n#Посмотрим основные характеристики:\n#answered_correctly: распределение правильных ответов (это наша целевая переменная).\n#prior_question_had_explanation: связь с результатами.\n#prior_question_elapsed_time: распределение времени.\n\n\nimport matplotlib.pyplot as plt\n\n# Распределение целевой переменной\nprint(\"Распределение 'answered_correctly':\")\nprint(train_df['answered_correctly'].value_counts(normalize=True))\n\n# Связь между наличием объяснений и правильными ответами\nprint(\"\\nСвязь между 'prior_question_had_explanation' и 'answered_correctly':\")\nprint(train_df.groupby('prior_question_had_explanation')['answered_correctly'].mean())\n\n# Распределение времени на предыдущий вопрос\ntrain_df['prior_question_elapsed_time'].plot(kind='hist', bins=50, title='Время на вопрос (мс)')\nplt.xlabel('Время (мс)')\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-01T13:37:17.051249Z","iopub.execute_input":"2024-12-01T13:37:17.052057Z","iopub.status.idle":"2024-12-01T13:37:17.45765Z","shell.execute_reply.started":"2024-12-01T13:37:17.051988Z","shell.execute_reply":"2024-12-01T13:37:17.456644Z"}},"outputs":[{"name":"stdout","text":"Распределение 'answered_correctly':\n 1    0.637411\n 0    0.342682\n-1    0.019907\nName: answered_correctly, dtype: float64\n\nСвязь между 'prior_question_had_explanation' и 'answered_correctly':\nprior_question_had_explanation\nFalse    0.209978\nTrue     0.665913\nName: answered_correctly, dtype: float64\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}],"execution_count":11},{"cell_type":"code","source":"#Выделение признаков\n\n#Средняя точность пользователя (user_accuracy).\n#Средняя сложность вопроса (question_difficulty).\n\n# Средняя точность пользователя\nuser_accuracy = train_df.groupby('user_id')['answered_correctly'].mean()\ntrain_df['user_accuracy'] = train_df['user_id'].map(user_accuracy)\n\n# Средняя сложность вопроса\nquestion_difficulty = train_df.groupby('content_id')['answered_correctly'].mean()\ntrain_df['question_difficulty'] = train_df['content_id'].map(question_difficulty)\n\nprint(train_df[['user_accuracy', 'question_difficulty']].head())\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-01T14:16:06.671583Z","iopub.execute_input":"2024-12-01T14:16:06.671917Z","iopub.status.idle":"2024-12-01T14:16:06.839611Z","shell.execute_reply.started":"2024-12-01T14:16:06.671884Z","shell.execute_reply":"2024-12-01T14:16:06.838903Z"}},"outputs":[{"name":"stdout","text":"   user_accuracy  question_difficulty\n0       0.695652             0.721068\n1       0.695652             0.768595\n2       0.695652             0.961326\n3       0.695652             0.926108\n4       0.695652             0.959064\n","output_type":"stream"}],"execution_count":18},{"cell_type":"code","source":"# Выделение признаков\n\n# 1. Средняя точность пользователя (user_accuracy).\n# Средняя сложность вопроса (question_difficulty).\n# Средняя точность пользователя\nuser_accuracy = train_df.groupby('user_id')['answered_correctly'].mean()\ntrain_df['user_accuracy'] = train_df['user_id'].map(user_accuracy)\n\n# Средняя сложность вопроса\nquestion_difficulty = train_df.groupby('content_id')['answered_correctly'].mean()\ntrain_df['question_difficulty'] = train_df['content_id'].map(question_difficulty)\n\n# 2. Количество вопросов, отвеченных пользователем\nuser_question_count = train_df.groupby('user_id')['row_id'].count()\ntrain_df['user_question_count'] = train_df['user_id'].map(user_question_count)\n\n# 3. Среднее время ответа пользователя\nuser_avg_time = train_df.groupby('user_id')['prior_question_elapsed_time'].mean()\ntrain_df['user_avg_time'] = train_df['user_id'].map(user_avg_time)\n\n# 4. Среднее время ответа на вопрос\nquestion_avg_time = train_df.groupby('content_id')['prior_question_elapsed_time'].mean()\ntrain_df['question_avg_time'] = train_df['content_id'].map(question_avg_time)\n\n# 5. Количество попыток ответить на вопрос\nquestion_attempt_count = train_df.groupby('content_id')['row_id'].count()\ntrain_df['question_attempt_count'] = train_df['content_id'].map(question_attempt_count)\n\n# 6. Взаимодействие точности пользователя и сложности вопроса\ntrain_df['user_difficulty_interaction'] = train_df['user_accuracy'] * train_df['question_difficulty']\n\n# 7. Взаимодействие времени пользователя и сложности вопроса\ntrain_df['time_difficulty_interaction'] = train_df['user_avg_time'] * train_df['question_difficulty']\n\n# 8. Время с первого ответа пользователя\ntrain_df['timestamp'] = train_df['timestamp'] / 1000  # переводим в секунды\nuser_first_timestamp = train_df.groupby('user_id')['timestamp'].transform('min')\ntrain_df['time_since_start'] = train_df['timestamp'] - user_first_timestamp\n\n# 9. Скользящее среднее точности пользователя (rolling average accuracy)\ntrain_df['rolling_user_accuracy'] = train_df.groupby('user_id')['answered_correctly'].transform(\n    lambda x: x.rolling(window=5, min_periods=1).mean()\n)\n\n# 10. Кумулятивная точность пользователя\ntrain_df['cumulative_accuracy'] = train_df.groupby('user_id')['answered_correctly'].expanding().mean().reset_index(level=0, drop=True)\n\n# Проверяем, что все признаки созданы\nprint(\"Новые признаки:\")\nprint(train_df[['user_accuracy', 'question_difficulty', 'user_question_count', \n                'user_avg_time', 'question_avg_time', 'question_attempt_count', \n                'user_difficulty_interaction', 'time_difficulty_interaction',\n                'time_since_start', 'rolling_user_accuracy', 'cumulative_accuracy']].head())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-01T14:17:57.63553Z","iopub.execute_input":"2024-12-01T14:17:57.635842Z","iopub.status.idle":"2024-12-01T14:18:01.540371Z","shell.execute_reply.started":"2024-12-01T14:17:57.635817Z","shell.execute_reply":"2024-12-01T14:18:01.539092Z"}},"outputs":[{"name":"stdout","text":"Новые признаки:\n   user_accuracy  question_difficulty  user_question_count  user_avg_time  \\\n0       0.695652             0.721068                   46   19933.311111   \n1       0.695652             0.768595                   46   19933.311111   \n2       0.695652             0.961326                   46   19933.311111   \n3       0.695652             0.926108                   46   19933.311111   \n4       0.695652             0.959064                   46   19933.311111   \n\n   question_avg_time  question_attempt_count  user_difficulty_interaction  \\\n0       25673.450980                     337                     0.501613   \n1       21529.198347                     242                     0.534675   \n2       24178.571429                     181                     0.668748   \n3       19392.857143                     203                     0.644249   \n4       20824.561404                     171                     0.667175   \n\n   time_difficulty_interaction  time_since_start  rolling_user_accuracy  \\\n0                 14373.277745      0.000000e+00                    1.0   \n1                 15320.644077      5.694300e-14                    1.0   \n2                 19162.409576      1.183630e-13                    1.0   \n3                 18460.406349      1.311670e-13                    1.0   \n4                 19117.327615      1.379650e-13                    1.0   \n\n   cumulative_accuracy  \n0                  1.0  \n1                  1.0  \n2                  1.0  \n3                  1.0  \n4                  1.0  \n","output_type":"stream"}],"execution_count":19},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#Признаки\n#Количество вопросов, отвеченных пользователем (user_question_count) — позволяет понять, насколько активно пользователь участвует в тестах.\n#Среднее время ответа пользователя (user_avg_time) — помогает понять, насколько быстро или медленно пользователь отвечает на вопросы.\n#Среднее время ответа на вопрос (question_avg_time) — показывает, сколько времени в среднем пользователи тратят на конкретные вопросы.\n#Количество попыток ответа на вопрос (question_attempt_count) — может быть полезно для выявления сложных вопросов.\n#Интерактивные признаки: взаимодействие точности пользователя и сложности вопроса, а также времени пользователя и сложности вопроса.\n#Время с первого ответа пользователя (time_since_start) — помогает оценить, сколько времени прошло с момента начала обучения пользователя.\n#Скользящее среднее точности пользователя (rolling_user_accuracy) — улучшает стабильность модели.\n#Кумулятивная точность пользователя (cumulative_accuracy) — помогает отслеживать, как точность пользователя меняется с течением времени.\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Обработка пропусков\n# Заполняем пропуски в числовых колонках средними значениями\ntrain_df.fillna({\n    'prior_question_elapsed_time': train_df['prior_question_elapsed_time'].mean(),\n    'prior_question_had_explanation': 0,\n    'user_accuracy': train_df['user_accuracy'].mean(),\n    'question_difficulty': train_df['question_difficulty'].mean(),\n    'user_question_count': 0,\n    'user_avg_time': train_df['user_avg_time'].mean(),\n    'question_avg_time': train_df['question_avg_time'].mean(),\n    'question_attempt_count': 0\n}, inplace=True)\n\nprint(\"Проверка пропусков после обработки:\")\nprint(train_df.isnull().sum())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-01T14:19:07.798419Z","iopub.execute_input":"2024-12-01T14:19:07.798721Z","iopub.status.idle":"2024-12-01T14:19:08.028477Z","shell.execute_reply.started":"2024-12-01T14:19:07.798695Z","shell.execute_reply":"2024-12-01T14:19:08.027576Z"}},"outputs":[{"name":"stdout","text":"Проверка пропусков после обработки:\nrow_id                            0\ntimestamp                         0\nuser_id                           0\ncontent_id                        0\ncontent_type_id                   0\ntask_container_id                 0\nuser_answer                       0\nanswered_correctly                0\nprior_question_elapsed_time       0\nprior_question_had_explanation    0\nuser_accuracy                     0\nquestion_difficulty               0\nuser_question_count               0\nuser_avg_time                     0\nquestion_avg_time                 0\ntime_since_start                  0\nrolling_user_accuracy             0\nuser_difficulty_interaction       0\ntime_difficulty_interaction       2\nquestion_attempt_count            0\ncumulative_accuracy               0\nsession_id                        0\ndtype: int64\n","output_type":"stream"}],"execution_count":20},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# Список признаков для визуализации\nfeatures_to_plot = [\n    'user_accuracy', 'question_difficulty', 'user_question_count',\n    'user_avg_time', 'question_avg_time', 'question_attempt_count',\n    'user_difficulty_interaction', 'time_difficulty_interaction',\n    'time_since_start', 'rolling_user_accuracy', 'cumulative_accuracy'\n]\n\n# Создаем графики распределения для каждого признака\nplt.figure(figsize=(16, 20))\nfor i, feature in enumerate(features_to_plot, 1):\n    plt.subplot(4, 3, i)\n    train_df[feature].dropna().hist(bins=50, edgecolor='k', alpha=0.7)\n    plt.title(f'Распределение {feature}', fontsize=12)\n    plt.xlabel(feature)\n    plt.ylabel('Частота')\n\nplt.tight_layout()\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-01T14:47:08.462086Z","iopub.execute_input":"2024-12-01T14:47:08.462459Z","iopub.status.idle":"2024-12-01T14:47:11.171324Z","shell.execute_reply.started":"2024-12-01T14:47:08.462425Z","shell.execute_reply":"2024-12-01T14:47:11.170499Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1152x1440 with 11 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}],"execution_count":26}]}