Ошибки 1 и 2 рода python

data_1 = np.random.uniform(-1, 0, 1000) # равномерное распределение тариф1
data_2 = np.random.normal(-1, 2, 1000) # нормальное распределение тариф2

data = pd.concat([data_1, data_2]).reset_index(drop=True)
# сделаем генеральное распределение для проведение теста

stat, p = stats.shapiro(data)
print(‘Statistics=%.3f, p-value=%.3f’ % (stat, p))

if p < alpha:
print(‘Отклонить гипотезу о нормальности’)
else:
print(‘Принять гипотезу о нормальности’)

Statistics=0.919, p-value=0.000
Отклонить гипотезу о нормальности

test_leven, p = stats.levene(data_1, data_2)
print(‘Statistics=%.3f, p-value=%.3f’ % (test_leven, p))
alpha = 0.05
if p < alpha:
print(‘Отклонить гипотезу о равенстве дисперсий’)
else:
print(‘Принять гипотезу о равенстве дисперсий’)

Statistics=1272.766, p-value=0.000
Отклонить гипотезу о равенстве дисперсий

results = stats.ttest_ind(
data_1[0],
data_2[0],
equal_var=False) # Так как нормальность не соблюдается

print(‘p-значение:’, results.pvalue)

if (results.pvalue < alpha):
print(«Отвергаем нулевую гипотезу»)
else:
print(«Не получилось отвергнуть нулевую гипотезу»)

p-значение: 2.19278763437e-16
Отвергаем нулевую гипотезу

Метрики качества классификаторов

Матрица ошибок (Confusion matrix)

Матрица ошибок — это способ разбить объекты на четыре категории в зависимости от комбинации истинного ответа и ответа алгоритма.

Основные термины:

• TPTP — истино-положительное решение;
• TNTN — истино-отрицательное решение;
• FPFP — ложно-положительное решение (Ошибка первого рода);
• FNFN — ложно-отрицательное решение (Ошибка второго рода).

Интерактивная картинка с большим числом метрик

Accuracy — доля правильных ответов:

Accuracy=TP+TNP+N=TP+TNTP+TN+FP+FN{displaystyle mathrm {Accuracy} ={frac {mathrm {TP} +mathrm {TN} }{P+N}}={frac {mathrm {TP} +mathrm {TN} }{mathrm {TP} +mathrm {TN} +mathrm {FP} +mathrm {FN} }}}

Данная матрика имеет существенный недостаток — её значение необходимо оценивать в контексте баланса классов. Eсли в выборке 950 отрицательных и 50 положительных объектов, то при абсолютно случайной классификации мы получим долю правильных ответов 0.95. Это означает, что доля положительных ответов сама по себе не несет никакой информации о качестве работы алгоритма a(x), и вместе с ней следует анализировать соотношение классов в выборке.

Гораздо более информативными критериями являются точность (precision) и полнота (recall).

Точность показывает, какая доля объектов, выделенных классификатором как положительные, действительно является положительными:
Precision=TPTP+FPPrecision = frac{TP}{TP+FP}

Полнота показывает, какая часть положительных объектов была выделена классификатором:
Recall=TPTP+FNRecall = frac{TP}{TP+FN}

Существует несколько способов получить один критерий качества на основе точности и полноты. Один из них — F-мера, гармоническое среднее точности и полноты:

F_beta = (1 + beta^2) cdot frac{mathrm{precision} cdot mathrm{recall}}{(beta^2 cdot mathrm{precision}) + mathrm{recall}} = frac {(1 + beta^2) cdot mathrm{true positive} }{(1 + beta^2) cdot mathrm{true positive} + beta^2 cdot mathrm{false negative} + mathrm{false positive}}

Среднее гармоническое обладает важным свойством — оно близко к нулю, если хотя бы один из аргументов близок к нулю. Именно поэтому оно является более предпочтительным, чем среднее арифметическое (если алгоритм будет относить все объекты к положительному классу, то он будет иметь recall = 1 и precision больше 0, а их среднее арифметическое будет больше 1/2, что недопустимо).

Чаще всего берут β=1beta=1, хотя иногда встречаются и другие модификации. F2F_2 острее реагирует на recall (т. е. на долю ложноположительных ответов), а F0.5F_{0.5} чувствительнее к точности (ослабляет влияние ложноположительных ответов).

В sklearn есть удобная функция sklearn.metrics.classification_report, возвращающая recall, precision и F-меру для каждого из классов, а также количество экземпляров каждого класса.

import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
%config InlineBackend.figure_format = 'svg'



  


                       
  

Линейная классификация

Основная идея линейного классификатора заключается в том, что признаковое пространство может быть разделено гиперплоскостью на две полуплоскости, в каждой из которых прогнозируется одно из двух значений целевого класса.
Если это можно сделать без ошибок, то обучающая выборка называется линейно разделимой.

Указанная разделяющая плоскость называется линейным дискриминантом.

Логистическая регрессия

Логистическая регрессия является частным случаем линейного классификатора, но она обладает хорошим «умением» – прогнозировать вероятность отнесения наблюдения к классу. Таким образом, результат логистической регрессии всегда находится в интервале [0, 1].

iris = pd.read_csv("https://nagornyy.me/datasets/iris.csv")

sns.lmplot(x="petal_length", y="petal_width", data=iris)

X = iris.iloc[:, 2:4].values
y = iris['species'].values

array([‘setosa’, ‘setosa’, ‘setosa’, ‘setosa’, ‘setosa’], dtype=object)

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
le.fit(y)
y = le.transform(y)
y[:5]

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=0)

from sklearn.preprocessing import StandardScaler

sc = StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)

lr.predict_proba(X_test_std[:3, :]).sum(axis=1)

lr.predict_proba(X_test_std[:3, :]).argmax(axis=1)

Предсказываем класс первого наблюдения

lr.predict(X_test_std[0, :].reshape(1, -1))

На основе его коэффициентов:

array([0.70793846, 1.51006688])

y_pred = lr.predict(X_test_std)

Машина опорных векторов

Основная идея метода — перевод исходных векторов в пространство более высокой размерности и поиск разделяющей гиперплоскости с максимальным зазором в этом пространстве. Две параллельных гиперплоскости строятся по обеим сторонам гиперплоскости, разделяющей классы. Разделяющей гиперплоскостью будет гиперплоскость, максимизирующая расстояние до двух параллельных гиперплоскостей. Алгоритм работает в предположении, что чем больше разница или расстояние между этими параллельными гиперплоскостями, тем меньше будет средняя ошибка классификатора.

На практике случаи, когда данные можно разделить гиперплоскостью, довольно редки. В этом случае поступают так: все элементы обучающей выборки вкладываются в пространство X более высокой размерности, так, чтобы выборка была линейно разделима.

Kernel (ядро) отвечается за гиперплоскость и может принимать значения linear (для линейной), rbf (для нелинейной) и другие.

С — параметр регуляризации. Он в том числе контролирует соотношение между гладкой границей и корректной классификацией рассматриваемых точек.

gamma — это «ширина» rbf ядра (kernel). Она участвует в подгонке модели и может являться причиной переобучения.

y_pred_svm = svm.predict(X_test_std)

Нелинейная классификация

Деревья решений

Деревья решений используются в повседневной жизни в самых разных областях человеческой деятельности.

До внедрения масштабируемых алгоритмов машинного обучения в банковской сфере задача кредитного скоринга решалась экспертами. Решение о выдаче кредита заемщику принималось на основе некоторых интуитивно (или по опыту) выведенных правил, которые можно представить в виде дерева решений:

В этом случае можно сказать, что решается задача бинарной классификации (целевой класс имеет два значения: «Выдать кредит» и «Отказать») по признакам «Возраст», «Наличие дома», «Доход» и «Образование».

Дерево решений как алгоритм машинного обучения – по сути то же самое. Огромное преимущество деревьев решений в том, что они легко интерпретируемы, понятны человеку.

В основе популярных алгоритмов построения дерева решений лежит принцип жадной максимизации прироста информации – на каждом шаге выбирается тот признак, при разделении по которому прирост информации оказывается наибольшим. Дальше процедура повторяется рекурсивно, пока энтропия не окажется равной нулю или какой-то малой величине (если дерево не подгоняется идеально под обучающую выборку во избежание переобучения).
Плюсы:

• Порождение четких правил классификации, понятных человеку, например, «если возраст < 25 и интерес к мотоциклам, то отказать в кредите». Это свойство называют интерпретируемостью модели;
• Деревья решений могут легко визуализироваться, как сама модель (дерево), так и прогноз для отдельного взятого тестового объекта (путь в дереве);
• Быстрые процессы обучения и прогнозирования;
• Малое число параметров модели;
• Поддержка и числовых, и категориальных признаков.

Минусы:

• У порождения четких правил классификации есть и другая сторона: деревья очень чувствительны к шумам во входных данных, вся модель может кардинально измениться, если немного изменится обучающая выборка (например, если убрать один из признаков или добавить несколько объектов), поэтому и правила классификации могут сильно изменяться, что ухудшает интерпретируемость модели;
• Разделяющая граница, построенная деревом решений, имеет свои ограничения (состоит из гиперплоскостей, перпендикулярных какой-то из координатной оси), и на практике дерево решений по качеству классификации уступает некоторым другим методам;

Collecting pydotplus

[?25l Downloading https://files.pythonhosted.org/packages/60/bf/62567830b700d9f6930e9ab6831d6ba256f7b0b730acb37278b0ccdffacf/pydotplus-2.0.2.tar.gz (278kB)

[K 100% |████████████████████████████████| 286kB 1.5MB/s

[?25hRequirement already satisfied: pyparsing>=2.0.1 in /usr/local/lib/python3.7/site-packages (from pydotplus) (2.3.0)

Building wheels for collected packages: pydotplus

Running setup.py bdist_wheel for pydotplus … [?25ldone

[?25h Stored in directory: /Users/hun/Library/Caches/pip/wheels/35/7b/ab/66fb7b2ac1f6df87475b09dc48e707b6e0de80a6d8444e3628

Successfully built pydotplus

Installing collected packages: pydotplus

Successfully installed pydotplus-2.0.2

from pydotplus import graph_from_dot_data
from sklearn.tree import export_graphviz

dot_data = export_graphviz(tree,
                           filled=True, 
                           rounded=True,
                           class_names=iris_pred_names,
                           feature_names=['petal length', 
                                          'petal width'],
                           out_file=None) 
graph = graph_from_dot_data(dot_data)

Метод ближайших соседей

Метод ближайших соседей (k Nearest Neighbors, или kNN) — тоже очень популярный метод классификации, также иногда используемый в задачах регрессии. Это, наравне с деревом решений, один из самых понятных подходов к классификации. На уровне интуиции суть метода такова: посмотри на соседей, какие преобладают, таков и ты. Формально основой метода является гипотеза компактности: если метрика расстояния между примерами введена достаточно удачно, то схожие примеры гораздо чаще лежат в одном классе, чем в разных.

Для классификации каждого из объектов тестовой выборки необходимо последовательно выполнить следующие операции:

• Вычислить расстояние до каждого из объектов обучающей выборки
• Отобрать k объектов обучающей выборки, расстояние до которых минимально
• Класс классифицируемого объекта — это класс, наиболее часто встречающийся среди k ближайших соседей

Под задачу регрессии метод адаптируется довольно легко – на 3 шаге возвращается не метка, а число – среднее (или медианное) значение целевого признака среди соседей.

Примечательное свойство такого подхода – его ленивость. Это значит, что вычисления начинаются только в момент классификации тестового примера, а заранее, только при наличии обучающих примеров, никакая модель не строится. В этом отличие, например, от ранее рассмотренного дерева решений, где сначала на основе обучающей выборки строится дерево, а потом относительно быстро происходит классификация тестовых примеров.

Качество классификации/регрессии методом ближайших соседей зависит от нескольких параметров:

• число соседей
• метрика расстояния между объектами (часто используются метрика Хэмминга, евклидово расстояние, косинусное расстояние и расстояние Минковского). Отметим, что при использовании большинства метрик значения признаков надо масштабировать. Условно говоря, чтобы признак «Зарплата» с диапазоном значений до 100 тысяч не вносил больший вклад в расстояние, чем «Возраст» со значениями до 100.
• веса соседей (соседи тестового примера могут входить с разными весами, например, чем дальше пример, тем с меньшим коэффициентом учитывается его «голос»)

Плюсы и минусы метода ближайших соседей

Плюсы:

• Простая реализация;
• Неплохо изучен теоретически;
• Как правило, метод хорош для первого решения задачи;
• Можно адаптировать под нужную задачу выбором метрики или ядра (ядро может задавать операцию сходства для сложных объектов типа графов, а сам подход kNN остается тем же);
• Неплохая интерпретация, можно объяснить, почему тестовый пример был классифицирован именно так.

Минусы:

• Метод считается быстрым в сравнении, например, с композициями алгоритмов, но в реальных задачах, как правило, число соседей, используемых для классификации, будет большим (100-150), и в таком случае алгоритм будет работать не так быстро, как дерево решений;
• Если в наборе данных много признаков, то трудно подобрать подходящие веса и определить, какие признаки не важны для классификации/регрессии;
• Зависимость от выбранной метрики расстояния между примерами. Выбор по умолчанию евклидового расстояния чаще всего ничем не обоснован. Можно отыскать хорошее решение перебором параметров, но для большого набора данных это отнимает много времени;
• Нет теоретических оснований выбора определенного числа соседей — только перебор (впрочем, чаще всего это верно для всех гиперпараметров всех моделей). В случае малого числа соседей метод чувствителен к выбросам, то есть склонен переобучаться;
• Как правило, плохо работает, когда признаков много, из-за «прояклятия размерности». Про это хорошо рассказывает известный в ML-сообществе профессор Pedro Domingos – тут в популярной статье «A Few Useful Things to Know about Machine Learning», также «the curse of dimensionality» описывается в книге Deep Learning в главе «Machine Learning basics».

Класс KNeighborsClassifier в Scikit-learn

Основные параметры класса sklearn.neighbors.KNeighborsClassifier:

• weights: «uniform» (все веса равны), «distance» (вес обратно пропорционален расстоянию до тестового примера) или другая определенная пользователем функция
• algorithm (опционально): «brute», «ball_tree», «KD_tree», или «auto». В первом случае ближайшие соседи для каждого тестового примера считаются перебором обучающей выборки. Во втором и третьем — расстояние между примерами хранятся в дереве, что ускоряет нахождение ближайших соседей. В случае указания параметра «auto» подходящий способ нахождения соседей будет выбран автоматически на основе обучающей выборки.
• leaf_size (опционально): порог переключения на полный перебор в случае выбора BallTree или KDTree для нахождения соседей
• metric: «minkowski», «manhattan», «euclidean», «chebyshev» и другие

Домашнаяя работа

Примените изученные классификаторы для предсказания выживаемости на Титанике и постойте наилучший классификатор. Каковы значения основных его метрик?

Опирайтесь на эти статьи:

• Kaggle и Titanic — еще одно решение задачи с помощью Python
• Основы анализа данных на python с использованием pandas+sklearn
• Титаник на Kaggle: вы не дочитаете этот пост до конца

import warnings
warnings.filterwarnings(‘ignore’)

import os
import math
import random
import re

import pandas as pd
import numpy as np
import scipy.stats as stats

from matplotlib import pyplot as plt
import matplotlib.ticker as mtick
import seaborn as sns
from matplotlib import cm
import matplotlib.colors

np.random.seed(1234)

size = 10000 # размеры случайных переменных
loc = 0
scale = 1

result = pd.DataFrame([[0] * size], index = [‘chi2_1’]).T

plt.figure(figsize = (15, 5))

# перебираем значения степеней свободы k
for k in range(2, 22, 3):

# создаем фрейм результатов
current_result = pd.DataFrame([[0] * size], index = [1]).T

# генерируем нужное количество нормально распределенных переменных, находим сумму их квадратов
for i in range(1, k + 1): current_result[i] = pd.Series(np.random.normal(loc = loc, scale = scale, size = size))

# находим сумму квадратов
current_result[‘chi2’] = (current_result * current_result).sum(axis = 1)

sns.kdeplot(current_result[‘chi2’], label = ‘k = {}’.format(k))

plt.legend(title = ‘Степени свободы’), plt.ylabel(‘$f_k(x)$’), plt.xlabel(‘$x$’), plt.title(‘Распределения $chi_k^2$’)
plt.show()

• Тест на гомогенность (test of homogeneity, он же goodness of fit) — непараметрический, одновыборочный тест, который проверяет соответствие наблюдаемого распределения категориальной случайной величины некоторому эталонному распределению. В Python реализован функцией scipy.stats.chisquare.
• Тест на независимость (он же test of independence/association) — непараметрический, одновыборочный тест, который проверяет наличие связи между двумя категориальными переменными. В Python реализован функцией scipy.stats.chi2_contingency.
• Тест для дисперсии — параметрический (параметр — дисперсия), одновыборочный тест, который проверяет равенство дисперсии непрерывной случайной величины заданному порогу. В Python для него нет готовой функции.

• O — наблюдаемое значение;
• E — ожидаемое значение.

• H0: между наблюдаемым распределение и эталонным распределением нет различий;
• H1: между наблюдаемым распределение и эталонным распределением есть различия.

• H0: O₁ = O₂ = O₃ = … = Oₙ (то есть наблюдение может относиться с равной вероятностью к каждой из групп);
• H1: Хотя бы одна из вероятностей Oᵢ не равна остальным.

• H0: O₁ = E₁, O₂ = E₂, O₃ = E₃, …, Oₙ = Eₙ (то есть вероятности соответствуют ожидаемому распределению);
• H1: хотя бы в одном случае Oᵢ не равна Eᵢ (то есть вероятности не соответствуют ожидаемому распределению).

1 — stats.chi2.cdf(52.75, 4)

def diy_chisquare(observed, expected):
# рассчитываем статистику
k = len(observed) # число степеней свободы
statistic = (((observed — expected)**2)/expected).sum() # КСП

# рассчитываем p-value
p_value = 1 — stats.chi2.cdf(statistic, k — 1) # вероятность получить значение выше или равное статистике

return k — 1, statistic, p_value

# задаем исходные данные
np.random.seed(1234)

data = np.array([180, 250, 120, 225, 225])
expected = np.array([200, 200, 200, 200, 200])

# результат самодельного теста
display(diy_chisquare(data, expected))

# результат встроенного теста
from scipy.stats import chisquare
chisquare(data, expected)

def generate_max_likelihood_distro(size, num_samples, sample_size, k_range, ax, ax2, ax3, title):

ks_results = []
for line_i, k in enumerate(k_range): # перебираем степени свободы (количество классов, на которые разбиваются наблюдения)

data = pd.Series(np.random.choice(k, size, p = [1 / k] * k)) # не генерируем равномерно распределенный массив групп наблюдений

max_likelihood = []
for i in range(num_samples):
observed = data.sample(sample_size, replace = True).value_counts() # считаем, сколько раз появилось каждое из значений
expected = sample_size/k # ожидаемое число значений
max_likelihood += [[i,
k — 1,
(((observed — expected)**2)/expected).sum() # максимальное правдоподобие
]]

max_likelihood = pd.DataFrame(max_likelihood, columns = [‘Sample #’, ‘Degrees of freedom’, ‘Max likelyhood distribution’])

# строим графики распределений
sns.kdeplot(max_likelihood[‘Max likelyhood distribution’], label = ‘k = {}’.format(k), ax = ax)
ax.legend(title = ‘Степени свободы’), ax.set_ylabel(‘$f_k(x)$’), ax.set_xlabel(‘$x$’), ax.set_title(title)

# строим qq-графики
stats.probplot(max_likelihood[‘Max likelyhood distribution’],
dist = stats.chi2, sparams = (k — 1), # chi2 с числом степеней свободы k-1
plot = ax2, fit = False)
line_index = (line_i + 1) * 2
(ax2.get_lines()[line_index — 2].set_color(ax.get_lines()[line_i].get_color()),
ax2.get_lines()[line_index — 2].set_label(‘k = {}’.format(k)),
ax2.get_lines()[line_index — 2].set_markersize(3),
ax2.get_lines()[line_index — 2].set_alpha(0.5)
)
ax2.get_lines()[line_index — 1].set_color(‘lightgrey’), ax2.get_lines()[line_index — 1].set_linestyle(‘:’)
ax2.set_title(‘Соответствие распределению $chi^2$’), ax2.legend(title = ‘Степени свободы’)

# проводим КС-тест
ks_stat, ks_p = stats.kstest(max_likelihood[‘Max likelyhood distribution’], ‘chi2’, args = (k — 1, ))
ks_results.append([k, ks_stat, ks_p])

ks_results = pd.DataFrame(ks_results, columns = [‘k’, ‘statistic’, ‘p’]).set_index(‘k’)
ks_results[[‘p’]].plot(ax = ax3, xticks = ks_results.index, label = ‘$p$-value’)
ax3.axhline(0.05 / len(k_range), color = ‘red’, linestyle = ‘:’, label = ‘alpha = {:.2f}’.format(0.05 / len(k_range))) # с коррекцией Бонферрони
ax3.set_ylabel(‘$p$-value’), ax3.set_xlabel(‘$k$ (степени свободы)’), ax3.set_title(‘Результаты КС-теста’), ax3.legend()

np.random.seed(12345)

size = 100000 # размер «генеральной совокупности» — исходной большой выборки
num_samples = 1000
sample_size = 100

plt.figure(figsize = (25, 12))
sample_sizes = [10, 50, 100, 500, 1000, 2000]
for i, sample_size in enumerate(sample_sizes):
generate_max_likelihood_distro(size, num_samples, sample_size,
range(2, 22, 3),
title = ‘Размер выборки $n = {}$’.format(sample_size),
ax = plt.subplot(3, len(sample_sizes), i + 1),
ax2 = plt.subplot(3, len(sample_sizes), len(sample_sizes) + i + 1),
ax3 = plt.subplot(3, len(sample_sizes), len(sample_sizes) * 2 + i + 1),
)
plt.tight_layout()

• при увеличении размера выборки результат становится менее шумным;
• сами распределения весьма похожи на χ²;
• QQ-plot показывает, что распределение статистики становится близко к χ² даже для малых k, когда размер выборки превышает 100 наблюдений;
• тест Колмогорова-Смирнова также показывает, что с ростом размера выборок статистика уверенно приближается к χ².

• H0: категориальные переменные A и B независимы;
• H1: категориальные переменные A и B связаны между собой.

def diy_chi2_contingency(contingency_table):

# общее число наблюдений
total = contingency_table.sum().sum()

# суммы по строкам и столбцам
col_probs = contingency_table.sum(axis = 0).values
row_probs = contingency_table.sum(axis = 1).values

# превращаем их в вероятности
col_probs = col_probs / total
row_probs = row_probs / total

# рассчитываем ожидаемые значения
expected = np.array([col_probs]).T @ np.array([row_probs]) # перемножаем вектор-столбец вероятностей в рядах на вектор-стороку вероятностей в столбцах
expected = expected.T
expected = expected * total

# рассчитываем статистику
statistic = ((contingency_table.values — expected)**2)/expected
statistic = statistic.sum()

# определяем число степеней свободы
dof = (contingency_table.shape[0] — 1) * (contingency_table.shape[1] — 1)

# рассчитываем p-value
p_value = 1 — stats.chi2.cdf(statistic, dof) # вероятность получить значение выше или равное критерию МП

return dof, statistic, p_value

contingency_table = pd.DataFrame([[11, 3, 8], [2, 9, 14], [12, 13, 28]])
diy_chi2_contingency(contingency_table)

from scipy.stats import chi2_contingency
chi2_contingency(contingency_table)[0:3]

np.random.seed(1234)

size = 100000 # размер «генеральной совокупности» — исходной большой выборки
num_samples = 1000
sample_size = 1000

std_threshold = 1.1

data_norm = pd.Series(np.random.normal(0, std_threshold, size))
data_exp = pd.Series(np.random.exponential(std_threshold, size))

plt.figure(figsize = (25, 5))
sample_sizes = [10, 30, 50, 100, 500, 1000]
for i, sample_size in enumerate(sample_sizes):

statistics = []
for j in range(num_samples):
statistics += [[j,
(sample_size — 1) * data_norm.sample(sample_size, replace = True).var() / (std_threshold ** 2), # статистика для нормально распределенных данных
(sample_size — 1) * data_exp.sample(sample_size, replace = True).var() / (std_threshold ** 2) # статистика для жкспоненциально распределенных данных
]]

statistics = pd.DataFrame(statistics, columns = [‘Sample #’, ‘Statistic (normal data)’, ‘Statistic (exponential data)’])

# строим графики распределений
ax = plt.subplot(1, len(sample_sizes), i + 1)
sns.kdeplot(statistics[‘Statistic (normal data)’], label = ‘Нормально распределенные данные’, color = ‘orange’, linestyle = ‘:’, ax = ax)
sns.kdeplot(statistics[‘Statistic (exponential data)’], label = ‘Экспоненциально распределенные данные’, color = ‘orange’, ax = ax)
sns.kdeplot(pd.Series(np.random.chisquare(sample_size — 1, size)), color = ‘blue’, label = ‘Эталонное распределение $chi^2$’, ax = ax)
plt.title(‘Размер выборки: {}’.format(sample_size)), plt.xlabel(‘Статистика’), plt.ylabel(‘Частота’)
if i == 0: plt.legend()

plt.tight_layout()

• распределение статистики для нормально распределенных данных повторяет ожидаемое распределение:

• распределение статистики для экспоненциально распределенных данных отличается от эталонного распределения. Более того, различие, похоже, растет с ростом размера выборки.

• двухвыборочным z-тестом для пропорций;
• тестом χ² на независимость данных (test of independence) в ситуации, когда таблица сопряженности имеет размерность 2 x 2.

np.random.seed(1234)

size = 1000
p = 0.4
data = pd.Series(np.random.choice(2, size, p = [1 — p, p]))

contingency_table = pd.DataFrame([data.value_counts().values, [500, 500]], index = [‘Observed’, ‘Expected’])
contingency_table

from scipy.stats import chi2_contingency
chi2_statistic, p_value, dof, exp = chi2_contingency(contingency_table, correction = False) # отключаем коррекцию (с ней результат чуть-чуть отличается)
chi2_statistic, p_value

from statsmodels.stats.proportion import proportions_ztest
z_statistic, p_value = proportions_ztest(contingency_table[0], contingency_table.sum(axis = 1), alternative = ‘two-sided’)
z_statistic, p_value

z_statistic, math.sqrt(chi2_statistic)

from scipy.stats import chisquare
chi2_statistic, p_value = chisquare(contingency_table.loc[‘Observed’], f_exp = contingency_table.loc[‘Expected’]) # тестируем наблюдаемые величины на равновероятность
chi2_statistic, p_value

from scipy.stats import fisher_exact
fisher_exact(contingency_table, alternative = ‘two-sided’)

• каждая из ячеек таблицы сопряженности была больше 5 (если нет, то это легко исправляется умножением таблицы на нужный множитель);
• общий размер сэмпла был не более 500, так как увеличение размера сэмпла вызывает рост статистики и вероятности ложноположительных результатов.

# тестовые данные
test_table = pd.DataFrame([[6, 5.5, 11], [6.25, 7, 12.5], [13.25, 13.25, 26.5]])

# последовательно увеличиваем количество наблюдений
result = []
for mult in range(1, 100, 1):
current = test_table * mult
statistic_ind, p_ind, _, _ = chi2_contingency(current) # тест по увеличиваемой таблице
result += [[current.sum().sum(), p_ind, statistic_ind]]
result = pd.DataFrame(result, columns = [‘sample_size’, ‘p-value’, ‘statistic’]).set_index(‘sample_size’)

# график p-value
ax = result[‘p-value’].plot(figsize = (10, 5), color = ‘red’, grid = True)
plt.ylabel(‘p-value’), plt.xlabel(‘Размер выборки’)

# график статистики
ax2 = ax.twinx()
result[‘statistic’].plot(ax = ax2, color = ‘blue’, label = ‘Статистика’)

# собираем легенду
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax2.legend(lines + lines2, labels + labels2, loc = 1, title = ‘Параметры’)

plt.ylabel(‘Статистика’), plt.title(‘Влияние размера выборки на результаты теста $chi^2$’);

1. создадим набор воронок, состоящих из трех шагов. Каждая воронка будет описываться парой чисел — вероятностью конвертироваться из первого во второй шаг и вероятностью конверсии из второго шага в третий. То есть воронка 100 -> 50 -> 25 будет описываться парой чисел [0.5, 0.5];
2. для каждой из созданных воронок построим N пар выборок;
3. для каждой из пар выборок проведем 5 тестов:

• χ²-тест на гомогенность по таблице воронок;
• χ²-тест на гомогенность по таблице сопряженности;
• χ²-тест на независимость по таблице воронок;
• χ²-тест на независимость по таблице сопряженности;
• z-тест, сравнивающий доли пользователей, достигших последнего шага воронок.

# строим воронки, из которых будем делать сэмплирование
# pop_size — количество пользователей, которые участвуют в каждой воронке
# coeffs — массив процентных значений отличий воронок для тестирования ошибок второго рода
# rel — параметр, управляющий тем, какая воронка будет получена — абсолютная (доля рассчитывается от первого шага воронки) или относительная (доля рассчитывается от предыдущего шага)
def generate_funnel_log(pop_size, coeffs, rel = False, random_state = 12345):

# задаем начальный шаг
result = pd.DataFrame([[0, 1]] * pop_size, columns = [‘step’, ‘user_id’])
result[‘user_id’] = result[‘user_id’].apply(lambda x: ».join(random.choice(‘abcdefghij1234567890’) for i in range(10)))

# на каждом шаге берем только нужный процент пользователей, достигших прошлого шага
for step, step_coeff in enumerate(coeffs):
current = result.query(‘step == @step’)
# если относительная воронка, то число уников на этом шаге считаем как % от предыдущего, если абсолютная, то от всей популяции
current_pop = pop_size
if rel: current_pop = current[‘user_id’].nunique()
current = current.sample(int(np.ceil(current_pop * step_coeff)), random_state = random_state)
current[‘step’] = step + 1
result = result.append(current)

return result

# конструируем разные формы воронок

# steps — на сколько шагов будут разбиты относительные шаги воронок
# pop_size — количество пользователей, которые участвуют в каждой воронке
# differences — массив процентных значений отличий воронок для тестирования ошибок второго рода
# file_name — файл, в который будут записаны результаты генерации лога (при определенных условиях его генерация может занимать существенное время)
def generate_funnel_set(steps, pop_size, differences = [], file_name = None):

result = pd.DataFrame()
funnel_num = 0

# проверяем ранее сгенерированный файл лога воронки
if file_name is not None:
try:
return pd.read_csv(file_name)
except:
print(f'{file_name} не существует.’)

# добавляем 1 к списку различий, чтобы сгенерировать исходную воронку
differences = [1] + differences

for first_step_prob in np.linspace(0, 1, num = steps):
for second_step_prob in np.linspace(0, 1, num = steps):

# отсекаем ситуации, когда воронка плоская
if first_step_prob == 0 or second_step_prob == 0: continue
funnel_coeffs = [first_step_prob, second_step_prob]

# генерируем набор воронок, имеющих отличия от исходной воронки
# здесь же генерируется и она сама с diff = 1
for i, diff in enumerate(differences):
current_funnel = generate_funnel_log(pop_size, [x * diff for x in funnel_coeffs], rel = True)

# номер воронки для быстрого к ней обращения
current_funnel[‘funnel_num’] = funnel_num
current_funnel[‘funnel_diff_num’] = i

# параметры воронки
current_funnel[‘first_step_prob’] = first_step_prob
current_funnel[‘second_step_prob’] = second_step_prob
current_funnel[‘diff’] = diff

result = result.append(current_funnel)

funnel_num += 1

# сохраняем воронку в файл
if file_name is not None:
result.to_csv(file_name)

return result

# набор воронок
log = generate_funnel_set(steps = 25, pop_size = 10000, differences = [], file_name = ‘sample_log.csv’)

display(log.query(‘funnel_num == 10’)[[‘first_step_prob’, ‘second_step_prob’]].drop_duplicates())

report = log.query(‘funnel_num == 10’).groupby(‘step’).agg({‘user_id’: ‘nunique’})
report[‘perc’] = report[‘user_id’] / report.loc[0, ‘user_id’]
display(report)

# выбираем 5 произвольных воронок
sample_funnels = log[‘funnel_num’].drop_duplicates().sample(5, random_state = 1234567)

# строим их
report = log.query(‘funnel_num in @sample_funnels’)
report[‘funnel_name’] = report.apply(lambda x: f»№{x[‘funnel_num’]}. Отн. конверсия {x[‘first_step_prob’]:.2%} -> {x[‘second_step_prob’]:.2%}», axis = 1)
report = report.pivot_table(index = ‘step’, columns = ‘funnel_name’, values = ‘user_id’, aggfunc = ‘nunique’)
report = report.div(report.loc[0], axis = 1)

# выводим графики
ax = report.plot(figsize = (15, 7), grid = True)
ax.yaxis.set_major_formatter(mtick.PercentFormatter(1))
ax.set_xticks(report.index)
plt.xlabel(‘Шаг воронки’), plt.ylabel(‘Абсолютная вероятность конверсии’), plt.legend(title = ‘Воронки’)
plt.title(‘Различные классы воронок’);

• воронки с немедленным падением — те, у которых на первом шаге наблюдается падение на более, чем 50% от нулевого. В этом случае конверсия во второй шаг не важна. На графике к этой категории относятся воронки №211 и №214;
• воронки с умеренным угасанием — те, у которых падение на первом шаге составляет не более 50% от нулевого, а на втором шаге — не более, чем 50% от первого. Например, этим критериям соответствует воронка №377;
• воронки с быстрым угасанием на втором шаге. На картинке выше это воронки №491 и №532.

report = log.query(‘funnel_num in @sample_funnels’)
plot_data = report[[‘funnel_num’, ‘first_step_prob’, ‘second_step_prob’]].drop_duplicates()
x, y, t = plot_data[‘first_step_prob’].values, plot_data[‘second_step_prob’].values, plot_data[‘funnel_num’].values

ax = plt.axes()
plt.scatter(x, y)
plt.xlim((0, 1)), plt.ylim((0, 1))

# границы типов воронок
ax.axvline(0.5, linestyle = ‘-.’, color = ‘red’)
ax.hlines(y = 0.5, xmin = 0.5, xmax = 1, linestyle = ‘-.’, color = ‘red’)
ax.text(0.07, 0.9, ‘Быстрое’, fontsize = 15, color = ‘red’)
ax.text(0.55, 0.9, ‘Умеренное’, fontsize = 15, color = ‘red’)
ax.text(0.55, 0.3, ‘Быстроеn2-й шаг’, fontsize = 15, color = ‘red’);

for i, txt in enumerate(t):
ax.annotate(txt, (x[i] + 0.03, y[i]))

plt.xlabel(‘Вероятность конверсии в первый шаг’), plt.ylabel(‘Вероятность конверсии во второй шаг’);

# генерирует набор воронок, в котором будут не только исходные воронки, но и отличающиеся от них на 75%, 50% и 25%
funnel_log = generate_funnel_set(steps = 25, pop_size = 2000, differences = [0.9, 0.8, 0.7], file_name = ‘funnel_log.csv’)

display(funnel_log.query(‘funnel_num == 10’)[[‘diff’, ‘first_step_prob’, ‘second_step_prob’]].drop_duplicates())

• run_experiment получает на вход данные воронок, получает из них выборки нужного размера, формирует таблицы воронок и сопряженности, а также проводит по ним статистические тесты;
• run_error_experiments перебирает наборы воронок для тестирования и для каждого набора вызывает функцию run_experiment. Помимо этого, run_error_experiments отображает графики результатов.

# для каждого сочетания воронок проводим серию экспериментов

# funnel_log — лог с данными воронок
# sample_size — размер выборок, формируемых в каждом из экспериментов
# number_of_experiments — число экспериментов для каждой из воронок
# alpha — уровень значимости
# test_func — функция, описывающая набор статистических тестов, которые проводятся в каждом из экспериментов
# result_column_names — словарь человеко-читаемых названий колонок с результатами экспериментов
# compare_func — функция, служащая для сравнения p-value в каждом из экспериментов с уровнем значимости
def run_experiment(funnel_log, sample_size, number_of_experiments, alpha, test_func, compare_func):

result = []
errors = 0

# проводим эксперименты
for i in range(number_of_experiments):

# составляем выборки из всех групп
funnel = pd.DataFrame()
for j, group in enumerate(funnel_log[‘group’].unique()):
test_users = funnel_log.query(‘group == @group’)[‘user_id’].drop_duplicates().sample(sample_size, random_state = i + j)
current_funnel = funnel_log.query(‘group == @group and user_id in @test_users’)
funnel = funnel.append(current_funnel)

# формируем таблицу воронок
funnel = funnel.pivot_table(index = ‘step’, columns = ‘group’, values = ‘user_id’, aggfunc = ‘nunique’).fillna(0)

# игнорируются ситуации, когда из-за малого размера выборки воронка состоит только из первого шага
if funnel.shape[0] == 1:
errors += 1
continue

# формируем таблицу сопряженности
for col in funnel.columns:
funnel[f’cont_{col}’] = funnel[col] — funnel[col].shift(-1)

# заполняем пропуски в последнем ряду оставшимися пользователями
funnel_cols = [x for x in funnel.columns if ‘cont’ not in str(x)]
cont_cols = [x for x in funnel.columns if ‘cont’ in str(x)]
funnel.loc[funnel.index.max(), cont_cols] = funnel.loc[funnel.index.max(), funnel_cols].values

# если в таблице сопряженности попадаются нули, то пропускаем такие ситуации
if (funnel[cont_cols] == 0).max().max():
errors += 1
continue

# проводим тесты
result += [test_func(funnel)]

result = pd.DataFrame(result)
result = result.apply(compare_func, args = [alpha], axis = 1)
return list(result.mean().values), errors

# функция отрисовки карты ошибок
def show_contour(data, x_col, y_col, z_col, levels, ax, title):
z = data.pivot_table(index = y_col, columns = x_col, values = z_col, aggfunc = ‘max’)
x, y = z.columns, z.index.values

# закраска областей
ax.contourf(x, y, z, levels = levels, cmap = color_map, alpha = 0.3, norm = matplotlib.colors.BoundaryNorm(levels,len(levels)))
line_colors = [‘black’ for l in levels]

# линии уровня
cp = ax.contour(x, y, z, levels = levels, colors = ‘black’)
ax.clabel(cp, fontsize = 8, colors = line_colors)

# границы типов воронок
ax.axvline(0.5, linestyle = ‘-.’, color = ‘red’)
ax.hlines(y = 0.5, xmin = 0.5, xmax = z.columns.values[-1], linestyle = ‘-.’, color = ‘red’)
ax.text(0.07, 0.9, ‘Быстрое’, fontsize = 15, color = ‘red’)
ax.text(0.55, 0.9, ‘Умеренное’, fontsize = 15, color = ‘red’)
ax.text(0.55, 0.41, ‘Быстроеn2-й шаг’, fontsize = 15, color = ‘red’)

# подписи осей и заголовки
plt.xlabel(‘Вероятность конверсии в первый шаг’), plt.ylabel(‘Вероятность конверсии во второй шаг’)
plt.title(title)

# funnel_log — лог с данными воронок
# diffs — набор воронок, которые сравниваются с эталонной. Например, если diff = [0.7], то c эталонной воронкой будет сравниваться воронка, имеющая 30% отличие от эталонной
# sample_size — размер выборок, формируемых в каждом из экспериментов
# number_of_experiments — число экспериментов для каждой из воронок
# alpha — уровень значимости
# test_func — функция, описывающая набор статистических тестов, которые проводятся в каждом из экспериментов
# result_column_names — словарь человеко-читаемых названий колонок с результатами экспериментов
# compare_func — функция, служащая для сравнения p-value в каждом из экспериментов с уровнем значимости
# levels — линии уровня на карте ошибок
# color_map — цвета для отображения уровней ошибок
# filename_template — шаблон имени файлов, в которые будут записаны результаты экспериментов
def run_error_experiments(funnel_log, diffs, sample_size, number_of_experiments, alpha, test_func, result_column_names, compare_func, levels, color_map, suptitle, filename_template):

# проверяем наличие более ранних рассчетов
existing_result_files = [f for f in os.listdir(‘.’) if re.match(filename_template, f)]
if len(existing_result_files) > 0:
# если результаты более ранниз рассчетов найдены, то просто читаем их
result = pd.read_csv(filename_template + ‘_result.csv’)
errors = pd.read_csv(filename_template + ‘_errors.csv’)
else:
# если нет — считаем все заново
result = []
errors = []

for funnel_num in funnel_log[‘funnel_num’].unique():

# A-воронка
current_funnel_log = funnel_log.query(‘funnel_num == @funnel_num and diff == 1’)
current_funnel_log[‘group’] = 0

# последовательно формируем B-воронки с разной степенью отличия от исходной
for i, diff in enumerate(diffs):

current_funnel_log_another = funnel_log.query(‘funnel_num == @funnel_num and diff == @diff’)
current_funnel_log_another[‘group’] = i + 1
current_funnel_log = current_funnel_log.append(current_funnel_log_another)

# для каждой пары проводим эксперимент
current_exp_results, current_exp_errors = run_experiment(current_funnel_log,
sample_size = sample_size,
number_of_experiments = number_of_experiments,
alpha = alpha,
test_func = test_func,
compare_func = compare_func
)

# собираем разультаты в единый массив
result += [[funnel_num, current_funnel_log[‘first_step_prob’].max(), current_funnel_log[‘second_step_prob’].max()] + current_exp_results]
errors += [[funnel_num, current_funnel_log[‘first_step_prob’].max(), current_funnel_log[‘second_step_prob’].max(), current_exp_errors]]

result = pd.DataFrame(result, columns = [‘funnel_num’, ‘first_step_prob’, ‘second_step_prob’] + list(result_column_names.keys()))
errors = pd.DataFrame(errors, columns = [‘funnel_num’, ‘first_step_prob’, ‘second_step_prob’, ‘errors’])

# сохраняем результаты рассчетов в файлы
result.to_csv(filename_template + ‘_result.csv’, index = False)
errors.to_csv(filename_template + ‘_errors.csv’, index = False)

# визуализация
plt.figure(figsize = (30, 7))

for i, col in enumerate(result_column_names.keys()):
show_contour(result, ‘first_step_prob’, ‘second_step_prob’, col, levels, ax = plt.subplot(1, len(result_column_names), i + 1), title = result_column_names[col])
plt.suptitle(suptitle)
plt.show()

return result, errors

# начальные условия
number_of_experiments = 100
alpha = 0.05

# тестировочная функция для двух воронок
two_funnel_test_function = lambda funnel: [chisquare(funnel[1], funnel[0]).pvalue, # тест на гомогенность по таблице воронок
chisquare(funnel[‘cont_1’], funnel[‘cont_0’]).pvalue, # тест на гомогенность по таблице сопряженности
chi2_contingency(funnel[[0, 1]])[1], # тест на независимость по таблице воронок
chi2_contingency(funnel[[‘cont_0’, ‘cont_1’]])[1], # тест на независимотьс по таблице сопряженности
proportions_ztest(funnel.loc[funnel.shape[0] — 1, [0, 1]].values, funnel.loc[0, [0, 1]].values)[1] # z-тест на последний шаг воронки
]
two_funnel_result_column_names = {‘chisquare_funnel’: ‘$chi^2$-тест на гомогенность, таблица воронок’,
‘chisquare_cont’: ‘$chi^2$-тест на гомогенность, таблица сопряженности’,
‘chi2_contingency_funnel’: ‘$chi^2$-тест на независимость, таблица воронок’,
‘cchi2_contingency_cont’: ‘$chi^2$-тест на независимость, таблица сопряженности’,
‘z_test’: ‘z-тест по последнему шагу воронок’}

# тестирововчная функция для 3 и более воронок
mult_funnel_test_function = lambda funnel: [chi2_contingency(funnel[[x for x in funnel.columns if ‘cont’ not in str(x)]])[1], # тест на независимость по таблице воронок
chi2_contingency(funnel[[x for x in funnel.columns if ‘cont’ in str(x)]])[1] # тест на независимость по таблице сопряженности
]
mult_funnel_result_column_names = {‘chi2_contingency_funnel’: ‘$chi^2$-тест на независимость, таблица воронок’,
‘cchi2_contingency_cont’: ‘$chi^2$-тест на независимость, таблица сопряженности’}

# графические элементы

# уровни и цвета для тестирования ошибок первого рода
type_1_error_levels = [0, 0.01, 0.05, 0.1, 0.2, 0.3, 1]
type_1_error_color_map = matplotlib.colors.ListedColormap([‘forestgreen’,
‘palegreen’,
‘lightcoral’,
‘indianred’,
‘maroon’,
‘red’])

# уровни и цвета для тестирования ошибок второго рода
type_2_error_levels = [0, 0.1, 0.5, 0.7, 0.9, 0.95, 0.98, 1]
type_2_error_color_map = matplotlib.colors.ListedColormap([‘forestgreen’,
‘lightcoral’,
‘indianred’,
‘brown’,
‘firebrick’,
‘maroon’,
‘red’])

# уровни и цвета для анализа технических ошибок при тестировании
error_levels = [0, 0.1, 0.25, 0.5, 0.75, 0.9, 1]
error_color_map = matplotlib.colors.ListedColormap([‘palegreen’,
‘honeydew’,
‘floralwhite’,
‘bisque’,
‘navajowhite’ ,
‘red’])

# ошибки первого рода для двух воронок
diffs = [1]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x < alpha,
levels = type_1_error_levels,
color_map = type_1_error_color_map,
suptitle = f’Вероятность ошибки первого рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, $\alpha$ = {alpha}’,
filename_template = f’chi2_type1err_ss{ss}_diff{str(diffs[0]).replace(«.», «»)}_numexp{number_of_experiments}’)
errors[ss] = err
results[ss] = res

• лучше всего себя показал χ²-тест на независимость на таблице воронок — он продемонстрировал низкий процент ошибок первого рода для любых форм воронок вне зависимости от размера выборки;
• χ²-тест на гомогенность по таблице воронок показывает стабильно хорошие результаты для воронок с умеренным падением и стабильно плохие для воронок с быстрым падением;
• χ²-тест на гомогенность по таблице сопряженности стабильно находит отличия там, где их нет, для любых форм воронок и размеров выборок. Доля ошибок доходит до 30%;
• χ²-тест на независимость по таблице сопряженности и z-тест по последнему шагу воронок показывают приемлемые результаты только на больших выборках.

# анализ ошибок
# data — фрейм с ошибками, полученными при тестировании
# num_exp — число экспериментов для каждой из воронок
# levels — линии уровня на карте ошибок
# color_map — цвета для отображения уровней ошибок
# title — заголовок графиков
def viz_errors(data, num_exp, levels, color_map, title = ‘Число ошибок формирования воронок и таблиц сопряженности в зависимости от размера выборки’):
plt.figure(figsize = (30, 5))

for i, ss in enumerate(data.keys()):

z = data[ss].pivot_table(index = ‘second_step_prob’, columns = ‘first_step_prob’, values = ‘errors’, aggfunc = ‘max’)
z = z / num_exp
x, y = z.index.values, z.columns

# закраска областей
ax = plt.subplot(1, len(errors.keys()), i + 1)
ax.contourf(x, y, z, levels = levels, cmap = color_map, alpha = 0.3, norm = matplotlib.colors.BoundaryNorm(levels,len(levels)))
line_colors = [‘black’ for l in levels]

# линии уровня
cp = ax.contour(x, y, z, levels = levels, colors = ‘black’)
ax.clabel(cp, fontsize = 8, colors = line_colors)

plt.xlabel(‘Вероятность конверсии в первый шаг’), plt.ylabel(‘Вероятность конверсии во второй шаг’)
plt.title(f’Размер выборки: {ss}’)

plt.suptitle(title)

# проверим число сгенерированных ошибок
viz_errors(errors, number_of_experiments, levels = error_levels, color_map = error_color_map)

# ошибки второго рода для двух воронок
diffs = [0.9]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f’Вероятность ошибки второго рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, воронки отличаются на {1-diffs[0]:.0%}, $\alpha$ = {alpha}’,
filename_template = f’chi2_type2err_ss{ss}_diff{str(diffs[0]).replace(«.», «»)}_numexp{number_of_experiments}’)
errors[ss] = err
results[ss] = res

• хуже всего себя показал χ²-тест на независимость по таблице воронок — даже на выборках больших размеров этот тест не находит отличия там, где они есть;
• χ²-тест на гомогенность по таблице воронок и z-тест показывают сопоставимые результаты. В основном они хорошо работают на больших выборках и только в ситуациях умеренного падения;
• лучше всего себя показывают тесты на гомогенность и независимость, выполненные на таблицах сопряженности. С ростом размеров выборок они все лучше и лучше находят различия для воронок с резким падением на втором шаге и для воронок с умеренным падением.

# ошибки второго рода для двух воронок
diffs = [0.8]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f’Вероятность ошибки второго рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, воронки отличаются на {1-diffs[0]:.0%}, $\alpha$ = {alpha}’,
filename_template = f’chi2_type2err_ss{ss}_diff{str(diffs[0]).replace(«.», «»)}_numexp{number_of_experiments}’)
errors[ss] = err
results[ss] = res

• хуже всего тесты работают для воронок с быстрым падением;
• самые плохие результаты показывает χ²-тест на независимость на таблице воронок;
• лучше всего себя проявили тесты на гомогенность и независимость, выполненные по таблицам сопряженности;
• z-тест, похоже, лучше всего работает для воронок с умеренным падением.

# ошибки второго рода для двух воронок
diffs = [0.7]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = two_funnel_test_function,
result_column_names = two_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f’Вероятность ошибки второго рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, воронки отличаются на {1-diffs[0]:.0%}, $\alpha$ = {alpha}’,
filename_template = f’chi2_type2err_ss{ss}_diff{str(diffs[0]).replace(«.», «»)}_numexp{number_of_experiments}’)
errors[ss] = err
results[ss] = res

• χ²-тесты по таблицам сопряженности демонстрируют самую высокую мощность — они способны обнаружить разницу в воронках даже при небольших отличиях, если выборка достаточно велика;
• в то же время они демонстрируют самые высокие ошибки первого рода — чаще засекают разницу там, где ее на самом деле нет;
• χ²-тесты по таблицам воронок показывают обратные результаты. Они консервативны, реже допускают ошибки первого рода, но чаще — второго;
• z-тест не показывает существенно более хороших результатов по сравнению с χ²-тестами. Кроме того, z-тест хорошо работает преимущественно в регионе воронок с умеренным падением;
• при работе с любым χ²-тестом нужно быть внимательным при анализе воронок с быстрым падением — это регион высоких ошибок второго рода для любого χ²-теста;
• из всех χ²-тестов наиболее предпочтительным является χ²-тест на независимость — он демонстрирует оптимальное соотношение между вероятностью ошибок первого рода и мощностью;
• при росте размера выборки нет особенной разницы, проводите ли вы χ²-тест по таблице сопряженности или по таблице воронок.

# ошибки первого рода для трех воронок
diffs = [1, 1]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x < alpha,
levels = type_1_error_levels,
color_map = type_1_error_color_map,
suptitle = f’Вероятность ошибки первого рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, $\alpha$ = {alpha}’,
filename_template = f’chi2_contingency_multiple_type1err_ss{ss}_numexp{number_of_experiments}_diffs{len(diffs)}’)
errors[ss] = err
results[ss] = res

# ошибки первого рода для четырех воронок
diffs = [1, 1, 1]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x < alpha,
levels = type_1_error_levels,
color_map = type_1_error_color_map,
suptitle = f’Вероятность ошибки первого рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, $\alpha$ = {alpha}’,
filename_template = f’chi2_contingency_multiple_type1err_ss{ss}_numexp{number_of_experiments}_diffs{len(diffs)}’)
errors[ss] = err
results[ss] = res

# проверим число сгенерированных ошибок
viz_errors(errors, number_of_experiments, levels = error_levels, color_map = error_color_map)

• как и в случае с двумя воронкам, тесты, проведенные по таблицам воронок, показывают меньшую вероятность ошибок первого рода;
• точность тестов, проведенных по таблицам сопряженности, увеличивается с ростом размера выборок. Интересно, что при размере выборки 100, вероятность ошибок первого рода резко возрастает для практически любых форм воронок, затем снова падает с увеличением размеров выборок. Природа этого эффекта не совсем ясна;
• нет существенной разницы между результатами, полученными для трех и четырех воронок;
• доля технических ошибок велика для воронок с граничными формами. Например, для воронок с резким падением. Но, начиная с выборок, имеющих размер от 100 наблюдений и более, результаты становятся достаточно консистентными.

# ошибки второго рода для трех воронок
diffs = [1, 0.9]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f’Вероятность ошибки второго рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, одна из воронок отличается на {1-diffs[1]:.0%}, $\alpha$ = {alpha}’,
filename_template = f’chi2_contingency_type2err_ss{ss}_diff{str(diffs[0]).replace(«.», «»)}_numexp{number_of_experiments}’)
errors[ss] = err
results[ss] = res

# ошибки второго рода для трех воронок
diffs = [0.9, 0.7]
results, errors = {}, {}
for ss in [25, 50, 100, 200, 500]:
res, err = run_error_experiments(funnel_log, diffs = diffs, sample_size = ss, number_of_experiments = number_of_experiments, alpha = alpha,
test_func = mult_funnel_test_function,
result_column_names = mult_funnel_result_column_names,
compare_func = lambda x, alpha: x > alpha,
levels = type_2_error_levels,
color_map = type_2_error_color_map,
suptitle = f’Вероятность ошибки второго рода для различных видов теста $chi^2$ и различных форм воронок, размер выборки {ss}, одна из воронок отличается на {1-diffs[1]:.0%}, $\alpha$ = {alpha}’,
filename_template = f’chi2_contingency_type2err_ss{ss}_diff{str(diffs[0]).replace(«.», «»)}_numexp{number_of_experiments}’)
errors[ss] = err
results[ss] = res

• в обоих экспериментах тесты по таблицам сопряженности показывают более высокую мощность;
• вероятность ошибки второго рода для тестов по таблице воронок падает с увеличением размеров выборок и ростом отличий воронок, но даже в самом лучшем случае тесты по таблице воронок показывают неплохие результаты только для воронок с умеренным падением.

• для анализа воронок z-тест менее предпочтителен, чем тест χ²;
• для анализа воронок из всех тестов χ² больше всего подходит тест на независимость;
• в ситуации сравнения двух воронок и большого размера выборок χ²-тест на независимость дает примерно одинаковые результаты при проведении теста на таблице воронок и на таблице сопряженности;
• в случае сравнения нескольких воронок выигрывает χ²-тест на независимость, проводимый по таблице сопряженности. Таким образом, можно рекомендовать всегда пользоваться тестом χ²-тест на независимость по таблице сопряженности для анализа воронок.

• Для практических целей бизнес-аналитики применимы только тесты χ²-тест на независимость и гомогенность.
• В ситуации анализа двух пропорций z-тест полностью эквивалентен χ²-тесту на независимость с таблицей сопряженности 2 x 2.
• Для проведения χ²-тестов имеет смысл брать выборки размером порядка 500 наблюдений.
• При решении задач сравнения воронок с помощью χ²-теста предпочтительнее использовать χ²-тест на независимость, проводимый по таблице сопряженности, поскольку он обеспечивает оптимальные результаты с точки зрения ошибок первого и второго рода при сравнении двух и более воронок.