Ratio metrics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import (\n",
    "    norm, binom, expon, t, pareto, ttest_1samp, ttest_ind, sem, uniform, bernoulli\n",
    ")\n",
    "from statsmodels.stats.api import CompareMeans, DescrStatsW\n",
    "from statsmodels.stats.proportion import proportion_confint\n",
    "import numpy as numpy\n",
    "from seaborn import distplot\n",
    "from matplotlib import pyplot\n",
    "import seaborn\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "import sys\n",
    "sys.path.append('.')\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "numpy.random.seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inverse_plot_colorscheme():\n",
    "    import cycler\n",
    "    def invert(color_to_convert): \n",
    "        table = str.maketrans('0123456789abcdef', 'fedcba9876543210')\n",
    "        return '#' + color_to_convert[1:].lower().translate(table).upper()\n",
    "    update_dict = {}\n",
    "    for key, value in pyplot.rcParams.items():\n",
    "        if value == 'black':\n",
    "            update_dict[key] = 'white'\n",
    "        elif value == 'white':\n",
    "            update_dict[key] = 'black'\n",
    "    \n",
    "    old_cycle = pyplot.rcParams['axes.prop_cycle']\n",
    "    new_cycle = []\n",
    "    for value in old_cycle:\n",
    "        new_cycle.append({\n",
    "            'color': invert(value['color'])\n",
    "        })\n",
    "    pyplot.rcParams.update(update_dict)\n",
    "    pyplot.rcParams['axes.prop_cycle'] = cycler.Cycler(new_cycle)\n",
    "    lec = pyplot.rcParams['legend.edgecolor']\n",
    "    lec = str(1 - float(lec))\n",
    "    pyplot.rcParams['legend.edgecolor'] = lec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "inverse_plot_colorscheme()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Ratio-метрики\n",
    "\n",
    "\n",
    "В сегодняшней лекции мы узнаем, как работать с ratio-метриками.\n",
    "\n",
    "\n",
    "> 📈 **Задача**\n",
    ">\n",
    "> Вы аналитик в Авито. Недавно к вам пришел продукт-менеджер, который захотел поменять цвет кнопки \"написать сообщение\" в объявлениях из синего в красный. По всем стандартным шаблонам.\n",
    ">\n",
    "> Вопрос: увеличит ли это конверсию в нажатие кнопки или конверсию в начатые чаты по объявлениям?\n",
    "\n",
    "Давайте для примера посчитаем эту метрику для 4 пользователей:\n",
    "\n",
    "| Id пользователя | Сколько раз зашел на страницу объявления? | Сколько раз начал общение в чате? |\n",
    "|------|----------------------------------------|-----------------------|\n",
    "| 1    | 5                                      | 5                     |\n",
    "| 2    | 4                                      | 1                     |\n",
    "| 3    | 0                                      | 0                     |\n",
    "| 4    | 6                                      | 4                     |\n",
    "\n",
    "\n",
    "Тогда у нас было 15 заходов на страницу объявлений и 10 объявлений, на которых произошло общение в чате. Интересующая нас конверсия в задаче равна 10/15 или 2/3 или 66%.\n",
    "\n",
    "\n",
    "Хорошо, тогда для решения надо провести AB-тест: Половину пользователей в тест, другую в контроль. Например: пользователь 1 и 3 в контроль, а 2 и 4 в тест.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## T-test. Статистические единицы = заходы на страницу объявления.\n",
    "\n",
    "\n",
    "Какой критерий мы знаем для сравнения конверсий в тесте и в контроле? T-test и хи-квадрат. Но надо понять, к каким выборкам их применять.\n",
    "\n",
    "\n",
    "Пусть нашими статистическими единицами будут \"заходы на страницу объявления\": Если после этого началось общение в чате, то это 1, а если нет – то это 0. Тогда у нас получается следующая ситуация в тесте и в контроле:\n",
    "\n",
    "<img src=\"https://github.com/dimalunin2016/pictures/blob/main/in_ration.png?raw=true\" width=\"1000\" height=\"300\" />\n",
    "\n",
    "Тогда: $M_O^C,\\ M_O^T$ – случайные величины в тесте и в контроле, равные 1 или 0. $O$ внизу означает, что статистическая единица измерения - это число открытых объявлений юзером (opened), а $M$ – началась ли переписка в мессенджере (messenger).\n",
    "\n",
    "Поставим гипотезу на языке математики: $H_0: \\mathbb{E}\\overline{M_O^C} = \\mathbb{E} \\overline{M_O^T}\\ VS.\\ H_1: \\mathbb{E}\\overline{M_O^C} < \\mathbb{E} \\overline{M_O^T}$. Ее должно быть легко проверить через T-test. Но не все так просто.\n",
    "\n",
    "------\n",
    "\n",
    "Можно ли тут использовать T-test для замера разницы конверсий? Давайте проверим. Что если вся разница между группами, задетектированная T-test, будет обусловлена разными пользователями, а не эффектом между тестом и контролем? Например, первый пользователь не любит звонить и всегда пишет в чат, а остальные нет. Тогда конверсия в контроле всегда будет больше.\n",
    "\n",
    "Проверим на Монте-Карло:\n",
    "\n",
    "- Для этого мы создадим функцию для генерации искусственного пользователя $i$.\n",
    "    - На первом этапе мы сгенерируем, на какое число объявлений пользователь зашел на сайте. Пусть это число $O_i$, его мы сгенерируем из нормального распределения для простоты.\n",
    "    - Вторым этапом сгенерируем конверсию $p_i$ нажатия на кнопку \"написать сообщение\".\n",
    "    - Так для каждого пользователя получится выборка размера $O_i$ с конверсией $p_i$. Для ускорения работы будем считать, что число чатов будет ровно $[O_i \\cdot p_i]$ (Целая часть от $O_i \\cdot p_i$).\n",
    "- При этом пользователи будут взяты из одного распределения: не будет никакой разницы между пользователями в тесте и в контроле."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_incorrect_group_sample(group_size, p=0.3):\n",
    "        \n",
    "    # Сгенерируем число заходов на страницу объявлений для всех пользователей группы сразу.\n",
    "    O_array = norm(loc=10, scale=1).rvs(size=group_size).astype(int)\n",
    "    # Сгенерируем конверсию нажатия на кнопку \"написать сообщение\".\n",
    "    p_array = uniform().rvs(size=group_size)\n",
    "    \n",
    "    # размер всей выборки равен Sum (O_i)\n",
    "    sample_size = numpy.sum(O_array)\n",
    "    # Число чатов.\n",
    "    M_sum = numpy.sum((O_array * p_array).astype(int))\n",
    "    \n",
    "    # Неважно, в каком порядке будут стоять элементы\n",
    "    return [1] * M_sum + [0] * (sample_size - M_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "936ad28f322b4c7caa20d5f93fe5beb0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FPR: 0.263\n",
      "CI=(0.23665685979107837, 0.2911570237310747)\n"
     ]
    }
   ],
   "source": [
    "numpy.random.seed(42)\n",
    "mc_size = 1000\n",
    "bad_cnt = 0\n",
    "alpha = 0.05\n",
    "group_size = 1000\n",
    "\n",
    "for _ in tqdm(range(mc_size)):\n",
    "    test_sample = generate_incorrect_group_sample(group_size)\n",
    "    control_sample = generate_incorrect_group_sample(group_size)\n",
    "    \n",
    "    # Запускаю критерий и считаю p-value\n",
    "    pvalue = ttest_ind(test_sample, control_sample, equal_var=True, alternative='two-sided').pvalue\n",
    "\n",
    "    # Проверяю, что pvalue <= alpha\n",
    "    bad_cnt += (pvalue <= alpha)\n",
    "\n",
    "print(f\"FPR: {round(bad_cnt / mc_size, 4)}\")\n",
    "print(f\"CI={proportion_confint(count = bad_cnt, nobs = mc_size, alpha=0.05, method='wilson')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FPR равен 62% вместо 5%. **В этом случае нельзя использовать t-test!**\n",
    "\n",
    "Почему такое произошло? Потому что элементы в контроле **зависимы между собой (их совершил 1 пользователь)**! Это верно и для\n",
    "теста. В этом случае, из-за ограничений критерия (он работает с независимыми элементами), нельзя использовать t-test! **Поэтому всегда помните о зависимостях в данных!** Казалось бы, простая задача про раскраску кнопки в другой цвет, но и она имеет подводные камни.\n",
    "\n",
    "Чтобы лучше понять этот феномен давайте представим, что у нас \n",
    "- по одному пользователю в тесте и в контроле, где каждый из них зашел 10000 раз на объявление. \n",
    "- У первого конверсия в написание в чат равна 1, а у второго 0, причем всегда. Один боится звонков, а второй обожает общаться по телефону, поэтому в чат никогда не напишет.\n",
    "- Тогда у нас в тесте конверсия будет 1, а в контроле 0. \n",
    "- T-test все отвергнет: для него будет 2 выборки размера 10000: одна из единиц, другая из нулей.\n",
    "- А если бы мы поменяли местами пользователей, то было бы наоборот: контроль стал бы лучше теста.\n",
    "\n",
    "Проблема состоит в том, что у нас всего 2 пользователя и t-test неприменим. А мы \"размножили\" их и получили выборки размера 10000 и применяем t-test. Мы просто неправильно работаем с этим критерием.\n",
    "\n",
    "Но давайте посмотрим на условие задачи внимательнее.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "## Решение 0 (бейзлайн). T-test. Статистические единицы = пользователи Авито.\n",
    "\n",
    "Что на самом деле интересует нас в этой задаче? **Не конверсия из открытия объявления в чат, а прирост числа чатов!**\n",
    "\n",
    "Поэтому давайте поменяем нашу гипотезу: вместо  $H_1: \\mathbb{E}\\overline{M_O^C} < \\mathbb{E} \\overline{M_O^T}$ (это изначальная постановка задачи) будем смотреть  $H_1: \\mathbb{E}\\overline{M^C} < \\mathbb{E} \\overline{M^T}$, где $M^C,\\ M^T$ &mdash; среднее число заходов в мессенджер от пользователей в тесте и контроле. В этом случае мы смотрим среднее на юзера, а не на открытое объявление, как в предыдущем случае. А также избавляемся от зависимости в выборках: открытие чата одним пользователем никак не влияет на открытие чата другим пользователем.\n",
    "\n",
    "\n",
    "Проверим, что замена валидна на Монте-Карло."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_group_sample(group_size):\n",
    "        \n",
    "    # Сгенерируем число заходов на страницу объявлений для всех пользователей группы сразу.\n",
    "    O_array = norm(loc=50, scale=5).rvs(size=group_size).astype(int)\n",
    "    # Сгенерируем конверсию нажатия на кнопку \"написать сообщение\".\n",
    "    p_array = uniform().rvs(size=group_size)\n",
    "    \n",
    "    # Число чатов у каждого пользователя [O * p].\n",
    "    M_array = (O_array * p_array).astype(int)\n",
    "        \n",
    "    # Неважно, в каком порядке будут стоять элементы\n",
    "    return {\n",
    "        \"O_array\": O_array,\n",
    "        \"message_array\": M_array\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "41f6fdfd46784c97b1840879e0809c41",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FPR: 0.05\n",
      "CI=(0.03813026239274881, 0.06531382024425081)\n"
     ]
    }
   ],
   "source": [
    "numpy.random.seed(42)\n",
    "mc_size = 1000\n",
    "bad_cnt = 0\n",
    "alpha = 0.05\n",
    "group_size = 1000\n",
    "\n",
    "for _ in tqdm(range(mc_size)):\n",
    "    test_sample = generate_group_sample(group_size)\n",
    "    control_sample = generate_group_sample(group_size)\n",
    "    \n",
    "    # Запускаю критерий и считаю p-value\n",
    "    pvalue = ttest_ind(test_sample['message_array'], control_sample['message_array'],\n",
    "                       equal_var=False, alternative='two-sided').pvalue\n",
    "    # Проверяю, что pvalue <= alpha\n",
    "    bad_cnt += (pvalue <= alpha)\n",
    "\n",
    "print(f\"FPR: {round(bad_cnt / mc_size, 4)}\")\n",
    "print(f\"CI={proportion_confint(count = bad_cnt, nobs = mc_size, alpha=0.05, method='wilson')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Да, в такой формулировке все верно.\n",
    "\n",
    "------\n",
    "\n",
    "Но нам этого мало. Ответьте на вопрос: какое максимальное число чатов может быть у любого юзера Авито? Непонятно. А если вы знаете, что он заходил на страницу лишь 1 объявления? Тогда вы очень легко можете ответить на вопрос: 1 чат.\n",
    "А значит, число чатов может быть сильно связано с числом заходов на объявления у юзера. И нам не хочется терять эту информацию: если мы сможем ее использовать, то мы сможем создать более мощный критерий!\n",
    "\n",
    "Поэтому давайте попытаемся решить задачу для изначальной постановки и сравним мощности текущего и нового решения."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "----\n",
    "\n",
    "## Решение 1: bootstrap\n",
    "\n",
    "Давайте формально выпишем, что значит $H_1: \\mathbb{E}\\overline{M_O^C} < \\mathbb{E} \\overline{M_O^T}$. \n",
    "Пусть\n",
    "\n",
    "- $O^C,\\ O^T$ &mdash; число открытий объявлений пользователями в контроле и тесте.\n",
    "- $M^C,\\ M^T$ &mdash; число заходов в мессенджер пользователями в тесте и контроле.\n",
    "\n",
    "$$\\begin{align}\n",
    "&H_0: \\mathbb{E} \\dfrac{\\sum M^T}{\\sum O^T} - \\mathbb{E} \\dfrac{\\sum M^C}{\\sum O^C} = 0\\ vs.\\ \\\\ &H_1: \\mathbb{E} \\dfrac{\\sum M^T}{\\sum O^T} - \\mathbb{E} \\dfrac{\\sum M^C}{\\sum O^C} > 0\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Мы подробно расписали, что такое числитель и знаменатель, чтобы лучше распознавать наши случайные величины в статистике.\n",
    "\n",
    "В дальнейшем метрики типа $\\dfrac{\\sum X}{\\sum Y}$ мы будем называть __ratio-метриками__. Кстати, обычный поюзерный T-test также можно расписать как Ratio: вместо $H_1: \\mathbb{E}\\overline{M^C} < \\mathbb{E} \\overline{M^T}$ можно написать $H_1: \\mathbb{E} \\dfrac{\\sum M^T}{\\sum U^T} - \\mathbb{E} \\dfrac{\\sum M^C}{\\sum U^C} > 0$, где $U^T, U^C$ – число юзеров в тесте и в контроле.\n",
    "\n",
    "----\n",
    "\n",
    "В итоге, нас интересует посчитать статистику $Z = \\dfrac{\\sum M_T}{\\sum O_T} - \\dfrac{\\sum M_C}{\\sum O_C}$ и построить доверительный интервал для нее. Давайте воспользуемся бутстрапом: он поможет в любой непонятной ситуации.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Важно:** в данном случае надо помнить, что в бутстрапе надо семплировать одновременно, как число чатов, так и число заходов на объявление, потому что они зависимы от одного пользователя!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_group_sample(group_size):\n",
    "        \n",
    "    # Сгенерируем число заходов на страницу объявлений для всех пользователей группы сразу.\n",
    "    O_array = norm(loc=50, scale=5).rvs(size=group_size).astype(int)\n",
    "    # Сгенерируем конверсию нажатия на кнопку \"написать сообщение\".\n",
    "    p_array = uniform().rvs(size=group_size)\n",
    "    \n",
    "    # Число чатов у каждого пользователя [O * p].\n",
    "    M_array = (O_array * p_array).astype(int)\n",
    "        \n",
    "    # Неважно, в каком порядке будут стоять элементы\n",
    "    return {\n",
    "        \"O_array\": O_array,\n",
    "        \"message_array\": M_array\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ratio_bootstrap(message_array, message_control, n_test, n_control, alpha=0.05):\n",
    "    theta_func = lambda MT, MC, OT, OC: numpy.sum(MT, axis=1) / numpy.sum(OT, axis=1) - numpy.sum(MC, axis=1) / numpy.sum(OC, axis=1)\n",
    "    \n",
    "    \n",
    "    B = 1000 # Чтобы ускорить работу\n",
    "    batch_size = B // 20\n",
    "\n",
    "    \n",
    "    theta_asterisk_array = []\n",
    "\n",
    "    test_size = len(message_array)\n",
    "    control_size = len(message_control)\n",
    "\n",
    "    test_inds_array = numpy.arange(0, test_size)\n",
    "    control_inds_array = numpy.arange(0, control_size)\n",
    "    for _ in range(0, B, batch_size):\n",
    "        \n",
    "        boot_t_inds = numpy.random.choice(test_inds_array, replace=True, size=(batch_size, test_size))\n",
    "        boot_c_inds = numpy.random.choice(control_inds_array, replace=True, size=(batch_size, control_size))\n",
    "        \n",
    "        # Неверный способ\n",
    "        # boot_MT = numpy.random.choice(message_array, replace=True, size=(batch_size, test_size))\n",
    "        # boot_MC = numpy.random.choice(message_control, replace=True, size=(batch_size, control_size))\n",
    "        # boot_OT = numpy.random.choice(n_test, replace=True, size=(batch_size, test_size))\n",
    "        # boot_OC = numpy.random.choice(n_control, replace=True, size=(batch_size, control_size))\n",
    "        boot_MT = message_array[boot_t_inds]\n",
    "        boot_MC = message_control[boot_c_inds]\n",
    "        boot_OT = n_test[boot_t_inds] # Берутся те же юзеры, которые были при семплировании boot_OT\n",
    "        boot_OC = n_control[boot_c_inds] # Берутся те же юзеры, которые были при семплировании boot_OC\n",
    "        \n",
    "        theta_asterisk = theta_func(\n",
    "            boot_MT, boot_MC, boot_OT, boot_OC\n",
    "        ).ravel()\n",
    "        assert len(theta_asterisk) == batch_size\n",
    "        theta_asterisk_array = numpy.concatenate([theta_asterisk_array, theta_asterisk])\n",
    "    left_theta_asterisk, right_theta_asterisk = numpy.quantile(theta_asterisk_array, [alpha / 2, 1 - alpha / 2])\n",
    "    \n",
    "    \n",
    "    percentile_left_bound, percentile_right_bound = left_theta_asterisk, right_theta_asterisk\n",
    "    return percentile_left_bound, percentile_right_bound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7530c878d639481ca99b539ec2542ef6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FPR, correct bootstrap: 0.054, [0.0416, 0.0698]\n"
     ]
    }
   ],
   "source": [
    "numpy.random.seed(8)\n",
    "\n",
    "bad_cnt_correct_bootstrap = 0\n",
    "\n",
    "for _ in tqdm(range(mc_size)):\n",
    "    test_sample = generate_group_sample(group_size)\n",
    "    control_sample = generate_group_sample(group_size)\n",
    "\n",
    "  \n",
    "    left_bound_correct, right_bound_correct = ratio_bootstrap(\n",
    "        test_sample['message_array'], \n",
    "        control_sample['message_array'], \n",
    "        test_sample['O_array'], \n",
    "        control_sample['O_array']\n",
    "    )\n",
    "   \n",
    "    bad_cnt_correct_bootstrap += ((left_bound_correct > 0) | (right_bound_correct < 0))\n",
    "\n",
    "corr_fpr = round(bad_cnt_correct_bootstrap / mc_size, 4)\n",
    "corr_left, corr_right = proportion_confint(count = bad_cnt_correct_bootstrap, \n",
    "                                           nobs = mc_size, alpha=0.05, method='wilson')\n",
    "print(f\"FPR, correct bootstrap: {round(corr_fpr, 4)},\"\\\n",
    "      f\" [{round(corr_left, 4)}, {round(corr_right, 4)}]\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Отлично, теперь мы построили корректный критерий для ratio-метрик!\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Зачем вообще нужны Ratio-метрики?\n",
    "\n",
    "Давайте же теперь сравним мощности 2 критериев: T-test и бутстрапа для Ratio-метрики. Правда ли, что мощность стала больше, как мы и думали в начале?\n",
    "\n",
    "Для того, чтобы сгенерировать АБ-тест чуть поменяем функцию генерации пользовательских выборок: добавим возможность изменять конверсии в тесте и в контроле."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_group_sample_equal_cr(group_size, p=0.1):\n",
    "        \n",
    "    # Сгенерируем число заходов на страницу покупки для всех пользователей группы сразу.\n",
    "    O_array = norm(loc=50, scale=5).rvs(size=group_size).astype(int)\n",
    "    \n",
    "    # Число покупок у каждого пользователя [N * p].\n",
    "    p_array = norm(loc=p, scale=p / 10).rvs(group_size)\n",
    "    p_array = numpy.maximum(p_array, 0)\n",
    "    \n",
    "    M_array = (O_array * p_array).astype(int)\n",
    "        \n",
    "    # Неважно, в каком порядке будут стоять элементы\n",
    "    return {\n",
    "        \"O_array\": O_array,\n",
    "        \"message_array\": M_array\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ec95876897a44b5589a191600118ce7b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "power, ratio: 0.494, [0.4631, 0.525]\n",
      "power, means: 0.328, [0.2996, 0.3577]\n"
     ]
    }
   ],
   "source": [
    "numpy.random.seed(8)\n",
    "\n",
    "power_ratio_cnt = 0\n",
    "power_means_cnt = 0\n",
    "\n",
    "for _ in tqdm(range(mc_size)):\n",
    "    # Для лучшего эффекта возьмем, что числитель и знаменатель очень сильно зависят друг от друга;\n",
    "    test_sample = generate_group_sample_equal_cr(group_size, p=0.101)\n",
    "    control_sample = generate_group_sample_equal_cr(group_size, p=0.1)\n",
    "\n",
    "    # Запускаю критерий и строю доверительный интервал\n",
    "    left_bound_ratio, right_bound_ratio = ratio_bootstrap(\n",
    "        test_sample['message_array'], \n",
    "        control_sample['message_array'], \n",
    "        test_sample['O_array'], \n",
    "        control_sample['O_array']\n",
    "    )\n",
    "    \n",
    "    # Запускаю критерий и считаю p-value\n",
    "    pvalue_means = ttest_ind(test_sample['message_array'], control_sample['message_array'],\n",
    "                       equal_var=False, alternative='two-sided').pvalue\n",
    "    \n",
    "   \n",
    "    power_ratio_cnt += (left_bound_ratio > 0)\n",
    "    power_means_cnt += (pvalue_means < 0.05)\n",
    "\n",
    "\n",
    "power_ratio = round(power_ratio_cnt / mc_size, 4)\n",
    "ratio_left, ratio_right = proportion_confint(\n",
    "    count = power_ratio_cnt, nobs = mc_size, alpha=0.05, method='wilson')\n",
    "print(f\"power, ratio: {round(power_ratio, 4)},\"\\\n",
    "      f\" [{round(ratio_left, 4)}, {round(ratio_right, 4)}]\")\n",
    "\n",
    "\n",
    "power_means = round(power_means_cnt / mc_size, 4)\n",
    "means_left, means_right = proportion_confint(count = power_means_cnt, \n",
    "                                           nobs = mc_size, alpha=0.05, method='wilson')\n",
    "print(f\"power, means: {round(power_means, 4)},\"\\\n",
    "      f\" [{round(means_left, 4)}, {round(means_right, 4)}]\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы видим, что мощность практически в 1.5 раза больше (а в реальности может быть и больше)! Отлично, гипотеза подтвердилась! Почему такое произошло?\n",
    "\n",
    "- в ratio метрике в текущем примере вы сравниваете $p^T\\ vs.\\ p^C$ (так как $\\dfrac{O \\cdot p}{O} = p$) \n",
    "- А в t-test происходит сравнение $M^T\\ vs.\\ M^C$, или ${O^T \\cdot p^T}\\ vs.\\ {O^C \\cdot p^C}$, что является более шумной величиной из-за случайной величины O.\n",
    "\n",
    "В реальных задачах все то же самое: вы убираете из данных часть шума, обусловленного знаменателем. Тем самым вы получаете менее шумную метрику.\n",
    "\n",
    "----\n",
    "\n",
    "**Менее важный аргумент**\n",
    "\n",
    "- Вы можете лучше понять, как вы влияете на разные этапы \"воронки\". Например, вы так можете посмотреть, как вы вашим изменением повлияли на конверсию из захода на сайт в заход на страницу объявления, и еще посмотреть, как изменилась конверсия из страницы объявления в заход в чат. Тем самым вы можете лучше выделять проблемы для бизнеса в вашем изменении.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Опасность в использовании ratio-метрики\n",
    "\n",
    "Главная проблема ratio-метрики &mdash; вы добавляете знаменатель к вашей метрике, который также может поменяться от вашего изменения на сайте. И в этот момент результат $H_1: \\mathbb{E} \\dfrac{\\sum M^T}{\\sum O^T} - \\mathbb{E} \\dfrac{\\sum M^C}{\\sum O^C} > 0$ будет не согласован с $H_1: \\mathbb{E} M^T -  \\mathbb{E} M^C > 0$.\n",
    "\n",
    "Например, в нашей задаче мы могли бы вместо покраса кнопки в красный цвет сделать неадекватное изменение: зашел в чат из объявления -> тебя заблокировали. Конверсия в тестовой группе была бы равна 1. Но вот число пользователей, а соответственно, и число заходов на страницу объявления сильно уменьшилось бы (все бы перестали пользоваться Авито).\n",
    "\n",
    "Поэтому бывает полезно не просто замерить изменение ratio-метрики, но и дополнительно проверить знаменатель с помощью t-test! Так вы будете уверены, что вы стат. значимо не изменили знаменатель и данным можно верить. \n",
    "\n",
    "Поэтому, ваш план работы с ratio-метрикой таков:\n",
    "- Если вы уверены, что не повлияли на знаменатель, то просто проверяете изменение ratio-метрики.\n",
    "- Если же есть шанс затронуть знаменатель, то вы проверяете и ratio-метрику, и знаменатель. \n",
    "\n",
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Решение 2: Линеаризация\n",
    "\n",
    "Мы уже поняли, как можно решать задачу через бутстрап. Но его главный недостаток в том, что это очень медленный критерий, который также требует много памяти и ресурсов.\n",
    "\n",
    "Представим, что вы устроились в новую компанию, где все плохо с АB-тестами: каждый делает их, как хочет, совершая при этом множество ошибок. Вы решаете создать единую систему для AB-тестов со следующими свойствами:\n",
    "- Она унифицирует все AB-тесты в компании. Таким образом, сокращается число неверно созданных AB-тестов, если бы все аналитики сами проводили AB, сами собирали данные и применяли критерии, то любая ошибка в коде приводила бы к плачевным результатам.\n",
    "- Сильно сокращает время на создание и анализ AB-теста, что также очень важно для крупных компаний.\n",
    "- Подсвечивает, какие еще эксперименты запущены в компании, что помогает не проводить 2 противоречащих друг другу теста.\n",
    "\n",
    "Это достаточно популярная задача для всех компаний. Например, в Авито также была реализована такая же система, названная \"AB-central\". Подробнее про нее можно прочесть на [хабре](https://habr.com/ru/company/avito/blog/454164/).\n",
    "\n",
    "Так вот, в такой системе очень важно использовать быстрые критерии, требующие небольшого числа памяти. Поэтому для такой системы бутстрап не подходит. Что же тогда использовать?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Часть 1. Многочлен Тейлора**\n",
    "\n",
    "Давайте вспомним, что такое многочлен Тейлора и как с его помощью можно расписать любую функцию:\n",
    "\n",
    "$f(x) = \\sum_{k=0}^{n}\\dfrac{f^{(k)}(x_0)}{k!}(x - x_0)^k + o((x - x_0)^{n}), x \\rightarrow x_0$.\n",
    "\n",
    "Если разложить функцию только до первой производной, то:\n",
    "\n",
    "$f(x) = f(x_0) + f'(x_0)(x-x_0) + o((x - x_0)) \\approx f(x_0) + f'(x_0)(x-x_0), x \\rightarrow x_0$\n",
    "\n",
    "А если у вас функция от 2 переменных, то тогда:\n",
    "\n",
    "$f(x, y) \\approx f(\\theta) + f'_x(\\theta)(x-x_0) + f'_y(\\theta)(y-y_0), (x, y) \\rightarrow \\theta, \\theta := (x_0, y_0)$.\n",
    "\n",
    "Теперь, пусть $f(x, y) = \\dfrac{x}{y}$. Тогда\n",
    "\n",
    "$$\\begin{align}\n",
    "\\dfrac{x}{y} &\\approx \\dfrac{x_0}{y_0} + \\left(\\dfrac{1}{y_0}\\right)(x - x_0) + \\left(-\\dfrac{x_0}{y^2_0}\\right)(y-y_0) \\\\\n",
    "&= \\dfrac{x_0}{y_0} + \\dfrac{1}{y_0}\\left(x - x_0 - \\dfrac{x_0}{y_0}y + x_0\\dfrac{y_0}{y_0}\\right) \\\\\n",
    "&= \\dfrac{x_0}{y_0} + \\dfrac{1}{y_0}\\left(x - \\dfrac{x_0}{y_0}y \\right)\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Часть 2. Разложение $\\dfrac{\\overline{X}}{\\overline{Y}}$**\n",
    "\n",
    "Теперь вспомним нашу интересующую ratio-метрику: это $\\dfrac{\\sum_i^n {X_i}}{\\sum_i^n {Y_i}}$, где суммируются все значения по всем пользователям сайта.\n",
    "\n",
    "Давайте перейдем от суммы к среднему: $\\dfrac{\\sum_i^n {X_i}}{\\sum_i^n {Y_i}} = \\dfrac{\\overline{X}}{\\overline{Y}}$.\n",
    "\n",
    "Какой интересный факт мы знаем про среднее? По УЗБЧ \n",
    "- $\\overline{X} \\stackrel{p}{\\rightarrow} \\mathbb{E} X$, \n",
    "- $\\overline{Y} \\stackrel{p}{\\rightarrow} \\mathbb{E} Y$, \n",
    "- $(\\overline{X}, \\overline{Y}) \\stackrel{p}{\\rightarrow} (\\mathbb{E} X, \\mathbb{E} Y)$\n",
    "\n",
    "Давайте тогда разложим $\\dfrac{\\overline{X}}{\\overline{Y}}$ по формуле Тейлора в точке $(\\mathbb{E} X, \\mathbb{E} Y)$ относительно 2 переменных $\\overline{X}, \\overline{Y}$.\n",
    "\n",
    "$$\n",
    "    \\dfrac{\\overline{X}}{\\overline{Y}} \\approx \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} + \\dfrac{1}{\\mathbb{E} Y}\\left(\\overline{X} - \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y}\\overline{Y} \\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Часть 3. Разделяем результат на N пользователей**\n",
    "\n",
    "\n",
    "$$\\begin{align}\n",
    "    \\dfrac{\\overline{X}}{\\overline{Y}} &\\approx \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} + \\dfrac{1}{\\mathbb{E} Y}\\left(\\overline{X} - \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y}\\overline{Y} \\right) \\\\\n",
    "    &=\\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} +  \\dfrac{1}{\\mathbb{E} Y} \\cdot \\dfrac{1}{N}\\sum_{i}^N \\left(X_i - \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} Y_i \\right) \\\\\n",
    "    &=  \\dfrac{1}{N}\\sum_{i}^N \\left(\\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} + \\dfrac{1}{\\mathbb{E} Y}\\left(X_i - \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} Y_i \\right) \\right)\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Обозначим за $Z'_i := \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} + \\dfrac{1}{\\mathbb{E} Y}\\left(X_i - \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} Y_i \\right)$. \n",
    "\n",
    "Тогда\n",
    "\n",
    "$$\\begin{align}\n",
    "    &\\dfrac{\\overline{X}}{\\overline{Y}} \\approx \\overline Z',\\\\\n",
    "    &\\mathbb{E} \\dfrac{\\overline{X}}{\\overline{Y}} \\approx \\mathbb{E} \\overline Z'\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "При этом все $Z'_i$ независимы между собой (так как сами пользователи независимы), и учет зависимости $X, Y$ между собой автоматически учтен в этой выборке. А значит, мы **можем применить t-test к выборке Z'!**\n",
    "\n",
    "Но мы не знаем $\\mathbb{E} X, \\mathbb{E}Y$. Поэтому остался последний шаг:\n",
    "\n",
    "**Часть 4. Заменяем оценку $\\mathbb{E} X, \\mathbb{E}Y$ на средние**\n",
    "\n",
    "Тогда финальное $Z_i = \\dfrac{\\overline X}{\\overline Y} + \\dfrac{1}{\\overline Y}\\left(X_i - \\dfrac{\\overline X}{\\overline Y} Y_i \\right)$.\n",
    "\n",
    "Так как $(\\overline{X}, \\overline{Y}) \\stackrel{p}{\\rightarrow} (\\mathbb{E} X, \\mathbb{E} Y)$, то \n",
    "\n",
    "$$\\begin{align}\n",
    "Z_i \\stackrel{p}{\\rightarrow} \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} + \\dfrac{1}{\\mathbb{E} Y}\\left(X_i - \\dfrac{\\mathbb{E} X}{\\mathbb{E} Y} Y_i \\right) = Z'_i\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "А значит, при больших размерах выборок $\\mathbb{E} Z \\approx \\mathbb{E} Z'$. А значит, $\\mathbb{E} Z \\approx \\mathbb{E} Z' \\approx \\mathbb{E} \\dfrac{\\overline{X}}{\\overline{Y}}$. Применив T-test к выборке $Z$, мы сможем сравнить $\\dfrac{\\overline{X}}{\\overline{Y}}$.\n",
    "\n",
    "Давайте реализуем линеаризованную поправку и проверим, работает ли критерий:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linearisation(numerator, denominator):\n",
    "    E_num = numpy.mean(numerator)\n",
    "    E_den = numpy.mean(denominator)\n",
    "    return E_num / E_den + 1 / E_den * (numerator - E_num / E_den * denominator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "44af6ad55e674641a935a4e9e7f93f16",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FPR, bootstrap: 0.052, [0.0399, 0.0676]\n",
      "FPR, linearisation: 0.049, [0.0373, 0.0642]\n"
     ]
    }
   ],
   "source": [
    "numpy.random.seed(8)\n",
    "\n",
    "bad_cnt_linearisation = 0\n",
    "bad_cnt_bootstrap = 0\n",
    "\n",
    "for _ in tqdm(range(mc_size)):\n",
    "    test_sample = generate_group_sample_equal_cr(group_size)\n",
    "    control_sample = generate_group_sample_equal_cr(group_size)\n",
    "    test_Z = linearisation(test_sample['O_array'], test_sample['message_array'])\n",
    "    control_Z = linearisation(control_sample['O_array'], control_sample['message_array'])\n",
    "\n",
    "    # Запускаю критерий и строю доверительный интервал\n",
    "    left_bound, right_bound = ratio_bootstrap(\n",
    "        test_sample['O_array'], \n",
    "        control_sample['O_array'], \n",
    "        test_sample['message_array'], \n",
    "        control_sample['message_array']\n",
    "    )\n",
    "    pvalue_linearise = ttest_ind(test_Z, control_Z, equal_var=False, alternative='two-sided').pvalue\n",
    "    \n",
    "   \n",
    "    bad_cnt_linearisation += (pvalue_linearise < 0.05)\n",
    "    bad_cnt_bootstrap += ((left_bound > 0) | (right_bound < 0))\n",
    "\n",
    "\n",
    "bootstrap_fpr = round(bad_cnt_bootstrap / mc_size, 4)\n",
    "bootstrap_left, bootstrap_right = proportion_confint(count = bad_cnt_bootstrap, \n",
    "                                               nobs = mc_size, alpha=0.05, method='wilson')\n",
    "print(f\"FPR, bootstrap: {round(bootstrap_fpr, 4)},\"\\\n",
    "      f\" [{round(bootstrap_left, 4)}, {round(bootstrap_right, 4)}]\")\n",
    "\n",
    "linearise_fpr = round(bad_cnt_linearisation / mc_size, 4)\n",
    "linearise_left, linearise_right = proportion_confint(count = bad_cnt_linearisation, \n",
    "                                           nobs = mc_size, alpha=0.05, method='wilson')\n",
    "print(f\"FPR, linearisation: {round(linearise_fpr, 4)},\"\\\n",
    "      f\" [{round(linearise_left, 4)}, {round(linearise_right, 4)}]\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Да, мы видим, что критерий прекрасно работает! А теперь давайте сравним время работы бутстрапа и линеаризации:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Сравнение линеаризации и бутстрапа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "group_size = 10000\n",
    "test_sample = generate_group_sample_equal_cr(group_size)\n",
    "control_sample = generate_group_sample_equal_cr(group_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 397 ms, sys: 23.9 ms, total: 421 ms\n",
      "Wall time: 420 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "left_bound, right_bound = ratio_bootstrap(\n",
    "                                test_sample['O_array'], \n",
    "                                control_sample['O_array'], \n",
    "                                test_sample['message_array'], \n",
    "                                control_sample['message_array']\n",
    "                            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 0 ns, sys: 1.96 ms, total: 1.96 ms\n",
      "Wall time: 1.27 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "test_Z = linearisation(test_sample['O_array'], test_sample['message_array'])\n",
    "control_Z = linearisation(control_sample['O_array'], control_sample['message_array'])\n",
    "\n",
    "pvalue_linearise = ttest_ind(test_Z, control_Z, equal_var=False, alternative='two-sided').pvalue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Быстрее практически в 400 раз! Что логично, бутстрап работает за `O(NB)` времени (где B &mdash; число бутстрап выборок), а линеаризация работает за `O(N)`.\n",
    "\n",
    "\n",
    "Также хочется отметить, что линеаризация позволяет написать 1 раз t-test и в зависимости от того, хотите ли вы считать ratio-метрику или считать сразу разницу числителей (например, сразу разницу числа покупок), вы должны подставить в код критерия разные выборки: или выборку числителей или Z-выборку. Что сильно упрощает работу автоматизированной системы проведения AB-тестов, о которой мы говорили в начале раздела."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "## Альтернативная гипотеза в T-test. Сравниваем среднюю конверсию на одного пользователя.\n",
    "\n",
    "Часто, когда аналитики сталкиваются с ratio метриками, у них возникает идея вместо гипотезы улучшения конверсии в чат для Авито:\n",
    "\n",
    "$H_1: \\mathbb{E} \\dfrac{\\sum M^T}{\\sum O^T} > \\mathbb{E} \\dfrac{\\sum M^C}{\\sum O^C}$\n",
    "\n",
    "использовать гипотезу улучшения конверсии у каждого отдельного пользователя\n",
    "\n",
    "$H_1: \\mathbb{E} \\dfrac{M^T}{O^T} > \\mathbb{E} \\dfrac{M^C}{O^C}$\n",
    "\n",
    "\n",
    "Например, в нашей изначальной задаче было бы следующее:\n",
    "\n",
    "\n",
    "\n",
    "| Id пользователя | Сколько раз зашел на страницу объявления? | Сколько раз начал общение в чате? | конверсия |\n",
    "|------|----------------------------------------|-----------------------|---------------|\n",
    "| 1    | 5                                      | 5                     | 1              |\n",
    "| 2    | 4                                      | 1                     | 1/4            |\n",
    "| 3    | 0                                      | 0                     | пропускаем     |\n",
    "| 4    | 6                                      | 4                     | 4/6 |\n",
    "\n",
    "\n",
    "Мы получили выборку [1, 1/4, 4/6], где значений меньше, чем пользователей: непонятно, что делать с 0 заказов. Итоговое среднее в этой выборке ~47%, что не совпадает с 66% – нашим искомым значением. В этом случае, мы будем считать другую статистику, а не ту, что нас интересовала изначально в задаче!\n",
    "\n",
    "\n",
    "Посмотрим математически: \n",
    "- $O$ &mdash; число открытий объявлений пользователями.\n",
    "- $M$ &mdash; число заходов в мессенджер пользователями.\n",
    "\n",
    "\n",
    "Нас интересует посчитать $\\mathbb{E} \\dfrac{\\sum M}{\\sum O}$ (общая конверсия из открытия объявления в чат), а в текущем решении мы считаем $\\mathbb{E} \\dfrac{M}{O}$ (средняя конверсия одного пользователя из объявления в чат, или среднее средних), и это разные вещи!\n",
    "\n",
    "$$\\mathbb{E} \\dfrac{\\sum M}{\\sum O} = \\mathbb{E} \\dfrac{\\overline M}{ \\overline O} \\neq \\mathbb{E} \\dfrac{M}{O}$$\n",
    "\n",
    "Рассмотрим такой пример:\n",
    "\n",
    "Пусть есть 10 пользователей: \n",
    "- у одного 1000 заходов, а количество открытий – 100.\n",
    "- а у остальных 1 заход и 1 открытие чата.\n",
    "\n",
    "Конверсия в чаты для всего Авито это 109/1009, что примерно 11%. А средняя конверсия по пользователям – $\\dfrac{1/10 + 9}{10} = 91\\%$. Это очень большая разница.\n",
    "\n",
    "\n",
    "**При этом первая конверсия вас интересует больше**: рост $\\mathbb{E} \\dfrac{\\sum M}{\\sum O}$ на $X\\%$ эквивалентен росту $\\mathbb{E} M$ на $X \\%$ (вы увеличили число чатов на X процентов), что вас и интересует на самом деле. А для второй дроби вы утверждать такое не можете.\n",
    "\n",
    "Поэтому текущий метод не подходит: он не считает то, что нам надо."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Итоги\n",
    "\n",
    "На текущей лекции мы рассмотрели с вами\n",
    "- Что такое ratio-метрики. А также показали, что это отличный способ уменьшить шум в данных и получить более мощный критерий.\n",
    "    - Но надо помнить, что если вы вашим изменением в AB-тесте могли изменить знаменатель, то это стоит дополнительно проверить.\n",
    "- Решили задачу ratio метрики двумя способами: через бутстрап и через линеаризацию. И показали преимущества линеаризации над бутстрапом. \n",
    "- На практике увидели, что такое зависимость в данных и чем она опасна.\n",
    "- Показали 2 примера, как не надо решать задачу про ratio-метрики."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}