Случайность

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

В этой главе мы начинаем анализировать случайность. Сначала мы будем использовать Python для случайного выбора. В numpy есть модуль под названием random, который содержит множество функций, связанных со случайным выбором. Одна из этих функций называется choice. Она выбирает случайный элемент из массива, причём любой элемент имеет одинаковую вероятность быть выбранным. Вызов функции выглядит так: np.random.choice(array_name), где array_name — это имя массива, из которого нужно выбрать элемент.

Таким образом, следующий код с вероятностью 50% возвращает значение treatment, а с вероятностью 50% — значение control.

two_groups = make_array('treatment', 'control')
np.random.choice(two_groups)
'treatment'

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

np.random.choice(two_groups, 10)
array(['treatment', 'control', 'treatment', 'control', 'control',
       'treatment', 'treatment', 'control', 'control', 'control'], 
      dtype='<U9')

Основная проблема случайных событий заключается в их возникновении. Например:

• Будет ли индивидуум распределён в экспериментальную группу?
• Выиграет ли игрок?
• Даст ли опрос точное предсказание?

Как только событие происходит, на все эти вопросы можно ответить «да» или «нет». В программировании это обычно делается путём присвоения утверждениям значения True или False. Например, если индивидуум был распределён в экспериментальную группу, утверждение «индивидуум был распределен в экспериментальную группу» будет истинным. Если нет, оно будет ложным.

Булевы значения и сравнения

В Python булевы значения (названные в честь логика Джорджа Буля) представляют собой истинные значения и имеют только два возможных значения: True и False. Независимо от того, связано ли вопрос со случайностью, булевы значения обычно создаются с помощью операторов сравнения. Python содержит различные операторы сравнения. Например, 3 больше 1 + 1.

3 > 1 + 1
True

True указывает на то, что сравнение было успешным; Python уже подтвердил отношение между 3 и 1 + 1. Ниже приведена полная таблица универсальных операторов сравнения.

Обратите внимание, что в сравнении используются два знака равенства == для определения равенства. Это необходимо, поскольку Python использует = для обозначения присваивания имени, которое мы видели ранее. Нельзя использовать один и тот же символ для разных целей. Поэтому, если вы хотите проверить, равно ли 5 10/2, вы должны быть осторожны: 5 = 10 / 2 вернёт сообщение об ошибке, потому что Python предполагает, что вы пытаетесь присвоить значение выражения 10 / 2 имени, которым является число 5. Вместо этого вы должны использовать 5 == 10 / 2, результат вычисления которого равен True.

5 = 10/2
  File "<ipython-input-4-5c7d3e808777>", line 1
    5 = 10/2
            ^
SyntaxError: can't assign to literal
5 == 10/2
True

Выражение может содержать несколько сравнений, и все они должны выполняться, чтобы выражение было истинным. Например, мы можем использовать следующее выражение, чтобы представить, что 1 + 1 находится между 1 и 3.

1 < 1 + 1 < 3
True

Среднее значение двух чисел всегда находится между меньшим числом и большим числом. Мы используем переменные x и y для представления этого отношения. Вы можете попробовать разные значения x и y, чтобы убедиться в этом.

x = 12
y = 5
min(x, y) <= (x+y)/2 <= max(x, y)
True

Сравнение строк

Строки также можно сравнивать, их порядок определяется лексикографически. Более короткая строка меньше более длинной строки, начинающейся с более короткой строки.

'Dog' > 'Catastrophe' > 'Cat'

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

np.random.choice(two_groups) == 'treatment'
False

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

Сравнение массивов и значений

Напомним, что мы можем выполнять арифметические операции над многими числами в массиве. Например, make_array(0, 5, 2) * 2 эквивалентно make_array(0, 10, 4). Аналогично, если мы сравниваем массив и значение, каждый элемент массива сравнивается с этим значением, и результаты сравнения вычисляются как массив логических значений.

tosses = make_array('Tails', 'Heads', 'Tails', 'Heads', 'Heads')
tosses == 'Heads'
array([False,  True, False,  True,  True], dtype=bool)

Метод numpy count_nonzero подсчитывает количество ненулевых (то есть True) элементов в массиве.

np.count_nonzero(tosses == 'Heads')
3

Условные операторы

Во многих случаях действия и результаты зависят от выполнения определённых условий. Например, индивидуумы, случайно назначенные в экспериментальную группу в рандомизированном контрольном исследовании, получают лечение. Игроки выигрывают, если они угадывают правильно.

В этом разделе мы узнаем, как использовать код для описания таких ситуаций. Условный оператор — это многострочный оператор, который позволяет Python выбирать разные варианты действий в зависимости от значения выражения. Хотя условные операторы могут появляться в любом месте, они обычно появляются внутри функций, чтобы обеспечить изменяемое поведение в зависимости от значений параметров.

Условные операторы всегда начинаются с if, за которым следует одна строка, а за ней следует тело с отступом. Только когда выражение после if (называемое выражением if) оценивается как истинное, выполняется тело. Если результат вычисления выражения if равен false, тело пропускается.

Давайте начнём с определения функции, которая возвращает знак числа.

def sign(x):

    if x > 0:
        return 'Positive'
sign(3)
'Positive'

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

sign(-3)

Итак, давайте улучшим нашу функцию, чтобы она возвращала отрицательное значение, если ввод отрицательный. Мы можем сделать это, добавив предложение elif, где elif — это сокращение от else, if в Python.

def sign(x):

    if x > 0:
        return 'Positive'

    elif x < 0:
        return 'Negative'

Теперь, когда входное значение равно -3, функция возвращает правильное значение.

sign(-3)
'Negative'

А что, если входным значением будет 0? Чтобы обработать этот случай, мы можем добавить предложение elif:

def sign(x):

    if x > 0:
        return 'Positive'

    elif x < 0:
        return 'Negative'

    elif x == 0:
        return 'Neither positive nor negative'
sign(0)
'Neither positive nor negative' **Текст запроса:**

与之等价，мы можем использовать `else` вместо последнего `elif` предложения, только если все предыдущие сравнения ложны, будет выполнено его тело. То есть, когда значение входного параметра равно 0.

```py
def sign(x):
    if x > 0:
        return 'Positive'
    elif x < 0:
        return 'Negative'
    else:
        return 'Neither positive nor negative'
sign(0)
'Neither positive nor negative'

Перевод:

Эквивалентно этому мы можем заменить последнее предложение elif на else, и тогда его тело будет выполняться только в том случае, если все предыдущие сравнения оказались ложными. То есть когда значение входного аргумента равно нулю.

def sign(x):
  if x > 0:
    return 'Положительно'
  elif x < 0:
    return 'Отрицательно'
  else:
    return 'Ни положительно, ни отрицательно'
sign(0)
'Ни положительно, ни отрицательно'

Примечание: в запросе не было указано, как переводить названия функций и переменных, поэтому они оставлены без перевода.

Продолжение текста запроса:

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

if <выражение if>:
    <тело if>
elif <выражение elif 0>:
    <тело elif 0>
elif <выражение elif 1>:
    <тело elif 1>
...
else:
    <иное тело>

Всегда существует только один оператор if, но может быть любое количество операторов elif. Python последовательно оценивает выражения в заголовках if и elif, пока не найдёт истинное значение, а затем выполняет соответствующее тело. Оператор else является необязательным. Когда предоставляется заголовок else, тело else выполняется только тогда, когда все выражения в предыдущих заголовках ложны. Тело else всегда должно быть последним (или его вообще может не быть).

Перевод продолжения текста запроса:

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

if <условие if>:
   <блок if>
elif <условие elif 0>:
   <блок elif 0>
elif <условие elif 1>:
   <блок elif 1>
…
else:
   <иной блок>

Здесь всегда присутствует только один блок if, а блоков elif может быть сколько угодно. Python поочерёдно проверяет условия в блоках if и elif, пока не встретит истинное условие, после чего выполняет соответствующий блок. Блок else опционален. Если он присутствует, то выполняется только в случае, когда все условия в предыдущих блоках оказались ложными. Блок else должен располагаться в самом конце (либо его может не быть вовсе).

Примечание: перевод названий функций и переменных оставлен без изменений.

Окончание текста запроса:

Теперь мы будем использовать условный оператор для определения функции, которая кажется довольно фиктивной и противоречивой, но станет полезной в последующих главах. Ей нужен массив, содержащий два элемента (например, red и blue), и ещё один элемент для сравнения. Если этот элемент равен red, функция возвращает blue. Если элемент равен (например), blue, функция возвращает red. Вот почему мы называем эту функцию other_one.

def other_one(x, a_b):
"""Сравнить x с двумя элементами a_b;
если он равен одному из них, вернуть другой;
если он не равен ни одному из них, выдать сообщение об ошибке.
"""
if x == a_b.item(0):
    return a_b.item(1)
elif x == a_b.item(1):
    return a_b.item(0)
else:
    return 'Ввод некорректен.'
colors = make_array('red', 'blue')
other_one('red', colors)
'blue'
other_one('blue', colors)
'red'
other_one('potato', colors)
'Ввод некорректен.'

Перевод окончания текста запроса:

Сейчас мы создадим функцию с помощью условного оператора, которая может показаться довольно странной и противоречащей здравому смыслу, однако она пригодится нам в следующих главах. Для работы ей потребуется массив, состоящий из двух элементов (например, «красный» и «синий»), а также ещё один элемент, который будет использоваться для сравнения. Функция вернёт «синий», если сравниваемый элемент равен «красному». Если же сравниваемый элемент (к примеру) «синий», то функция вернёт «красный». Именно поэтому мы назвали эту функцию «other_one».

def other_one(x, a_b):
"""Сравниваем x с двумя элементами массива a_b,
если x равен одному из элементов, возвращаем второй,
иначе выдаём сообщение об ошибке."""
if x == a_b[0]:
    return a_b[1]
elif x == a_b[1]:
    return a_b[0]
else:
    return "Ввод некорректен."
colors = ['red', 'blue']
other_one("red", colors)
"blue"
other_one("blue", colors)
"red"
other_one("potato", colors)
"Ввод некорректен."

Примечание: названия функций и переменных оставлены без изменений. Хотя это образцы фильмов, они не связаны с вероятностью.

Вероятностная выборка

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

Генеральная совокупность — это набор всех элементов, из которых извлекается выборка.

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

В вероятностной выборке все элементы не обязательно имеют одинаковую вероятность выбора.

План случайной выборки

Например, предположим, что согласно следующему плану выбираются два человека из группы, состоящей из трёх человек: A, B и C:

• Человек A выбирается с вероятностью 1.
• Человека B или C выбирают по подбрасыванию монеты: если выпадает орёл, выбирают B, иначе выбирают C.

Это выборка размером 2. Вероятность выбора каждого подмножества следующая:

A: 1 
B: 1/2
C: 1/2
AB: 1/2
AC: 1/2
BC: 0
ABC: 0

У человека A более высокая вероятность быть выбранным; действительно, человек A будет выбран наверняка. Поскольку эти различия известны и измеримы, их можно учитывать при работе с выборкой.

Систематическая выборка

Представьте себе, что все элементы генеральной совокупности перечислены в последовательности. Один из способов выборки — сначала выбрать случайное местоположение в списке, а затем выбирать каждое десятое местоположение после него. Выборка состоит из элементов в этих местоположениях. Такая выборка называется систематической выборкой.

Здесь мы выберем систематическую выборку из нескольких верхних строк. Сначала мы случайным образом выбираем одну строку из первых 10, а затем выбираем каждую десятую строку после неё.

(Опущено 10 строк)

Запустите код несколько раз, чтобы увидеть, как меняется вывод.

Эта систематическая выборка является вероятностной выборкой. В этом плане у каждой строки есть шанс быть выбранной. Например, когда выбрана третья строка, вторая строка выбирается только тогда, и её вероятность равна 1/10.

Но не все подмножества имеют одинаковую вероятность выбора. Поскольку выбранные строки расположены через равные промежутки, большинство строк не имеют шансов быть выбранными. Единственное возможное подмножество состоит из всех строк, расположенных с интервалом в 10. Любое такое подмножество имеет вероятность 1/10 быть выбранным. Другие подмножества, такие как подмножество, содержащее первые 11 строк таблицы, имеют нулевую вероятность выбора.

Выборка с возвратом или без возврата

В этом курсе мы сосредоточимся на двух наиболее прямых методах выборки.

Первый — выборка с возвращением, которая (как мы видели ранее) является поведением по умолчанию при использовании np.random.choice для выборки из массива.

Другой называется «простой случайной выборкой» и представляет собой выборку без возвращения. Перед выбором следующего элемента выборки выбранный элемент не возвращается в совокупность. Например, это происходит при раздаче карт.

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

Создание случайных выборок требует осторожности и точности. Это не просто, даже если это значение слова «случайный» в разговорном смысле. Если вы стоите на улице и выбираете первых десяти проходящих мимо людей в качестве выборки, вы можете подумать, что вы делаете случайную выборку, потому что вы не выбирали, кто пройдёт мимо. Но это не случайная выборка — это наглядный пример. Вы заранее не знаете вероятность того, что каждый человек попадёт в выборку, возможно, вы даже не указали конкретно, кто находится в совокупности.