1.1. Что такое ИИ и чем он не является

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

Сначала о слове «интеллект». Так называют умение решать новые задачи: узнавать, понимать, делать выводы. Ты узнаёшь друга в толпе, хотя он в новой шапке. Понимаешь фразу, которую никогда раньше не слышал. Это и есть интеллект.

Искусственный интеллект (ИИ) – это программы, которые решают задачи, для которых человеку нужен интеллект: узнать лицо на фото, понять речь, перевести текст, сыграть в шахматы, нарисовать картинку по описанию. Сами слова «искусственный интеллект» предложил американский учёный Джон Маккарти в 1955 году, когда готовил заявку на научный семинар. Сам семинар прошёл летом 1956 года.

Не путай ИИ с любой программой. Возьми школьный звонок: он звенит по расписанию, которое вбил завхоз. Это алгоритм – точная последовательность шагов, записанная человеком. Звонок ничего не узнаёт и ничему не учится. Так же устроены калькулятор, будильник, светофор, который переключается каждые 40 секунд. Всё это не ИИ.

Большинство нынешних ИИ-программ устроены по-другому. Им не пишут правило «кошка – это когда уши треугольником». Им показывают тысячи фотографий с подписями «кошка» и «не кошка», и программа сама находит, чем они отличаются. Такой способ называется машинное обучение (machine learning): компьютер учится на примерах. А самый мощный сегодня вид машинного обучения – нейросети, о них раздел 1.5.

Получаются круги один в другом. Все нейросети – это машинное обучение, и всё машинное обучение – это ИИ. Но не наоборот: не весь ИИ – нейросети. Старые шахматные программы перебирали ходы по правилам, которые записали люди, – это ИИ, но без обучения. Бывают и модели, которые учатся на примерах, но обходятся без нейронов, например «дерево решений» – цепочка вопросов «да или нет», которую компьютер сам составил по таблице примеров.

Ещё два деления, которые любят спрашивать:

• Узкий и общий ИИ. Узкий умеет свои задачи: переводчик переводит, но не играет в шахматы. Общий ИИ умел бы всё, что умеет человек, и учился бы любому новому делу. Все системы, которые существуют сегодня, – узкие. Общий ИИ пока не создан, и учёные спорят, когда и как он появится.
• Генеративный и негенеративный ИИ. Генеративный создаёт новое: пишет текст, рисует картинку, сочиняет музыку. Так работают чат-боты GigaChat, Алиса и DeepSeek, когда пишут ответ на твой вопрос. Негенеративный распознаёт и предсказывает: узнаёт лицо, отличает спам от обычного письма, прогнозирует погоду. Он выбирает ответ, а не сочиняет его.

Где ИИ уже есть в твоей жизни:

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

Чем ИИ не является. Он не думает, как человек, и ничего не «знает» о мире. Он находит закономерности в примерах, которые ему дали. Отсюда его слабости. Учили на плохих примерах – будет плохо работать. Попал в ситуацию, которой в примерах не было, – может ошибиться, причём очень уверенно. Чат-бот способен выдумать несуществующую книгу с автором и годом издания и выдать это спокойным тоном. Поэтому ответы ИИ всегда проверяют.

1.2. Машинное обучение: учимся на примерах

Никто не объяснял правило словами. Посмотрели на примеры с ответами – и новый предмет узнаётся сам.

Вспомни, как малыш учится отличать собаку от кошки. Ему не читают лекцию про форму ушей. Ему много раз показывают: «Это собака. А это кошка». Через месяц он уверенно тычет пальцем в незнакомую собаку во дворе. Машинное обучение устроено так же. Нужны примеры и правильные ответы к ним.

Примеры для машины записывают в таблицу. Одна строка – один объект: один день, один ученик, одна фотография, один астероид. Столбцы – то, что мы знаем про объект.

Столбцы бывают трёх видов:

• Признаки – то, по чему модель угадывает ответ. Здесь это температура, облачность и давление. Признак может быть числом (−8 °C) или словом (отсек «А», цвет «красный»).
• Ответ, или целевая переменная, – то, что модель должна научиться угадывать. Здесь – «снег завтра: да или нет». В обучающих примерах ответ известен, а для нового дня его как раз и предсказывают.
• Идентификаторы – номер, фамилия, код пропуска. Они нужны людям, чтобы отличать строки друг от друга, но ничего не говорят об ответе. Снег идёт не потому, что сегодня 12-е число. Перед обучением такие столбцы убирают: модель может «зацепиться» за номер строки и начать угадывать по нему, а это ерунда. Но если в коде зашиты свойства (в номере каюты – палуба и сторона борта), такой код может быть признаком: удаляют только то, что лишь называет строку.

Слово модель будет встречаться постоянно. Модель – это то, что получилось после обучения: правило, которое программа нашла в примерах и теперь применяет к новым объектам.

Учиться можно по-разному:

• Обучение с учителем – в примерах есть правильные ответы. Как в задачнике с ответами в конце: решил, сверился, исправился. Так решают классификацию и регрессию (раздел 1.3).
• Обучение без учителя – ответов нет совсем. Модели дают кучу объектов и просят найти в них порядок: разбить на похожие группы (кластеризация) или оставить меньше признаков, сохранив главное (снижение размерности: например, выбрать несколько главных цветов картины).
• Обучение с подкреплением – ответов нет, но есть награда и штраф. Так учат играть в игры: выиграл – молодец, упал в яму – минус очки. Играющий – агент, игра вокруг него – среда, очки – награда и штраф. Модель пробует снова и снова и выбирает действия, за которые хвалят.

1.3. Типы задач: классификация, регрессия, кластеризация

Классификация раскладывает по коробкам, на которых уже есть подписи. Регрессия угадывает число. Кластеризация сама находит кучки, и подписей у них нет.

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

Классификация (classification) – отнести объект к одной из заранее известных групп (их называют классами). Письмо: спам или не спам. Снимок: кошка, собака или попугай. Астероид: опасен или нет. Классов может быть два (тогда ответ «да или нет») или больше, но список классов известен заранее.

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

Кластеризация (clustering) – разбить объекты на группы похожих, когда правильных ответов нет. Никто заранее не говорил, какие будут группы и сколько их. Галерея телефона собирает фото одного и того же лица в альбом, хотя имени человека не знает, – это кластеризация. Магазин делит покупателей на группы по покупкам, чтобы понять, кто к ним ходит, – тоже она.

Как узнать тип по условию – два вопроса по порядку:

Смотри на ответ, а не на слова вокруг. Слово «прогноз» ничего не решает: «прогноз, пойдёт ли завтра снег» – классификация (да или нет), а «прогноз, сколько сантиметров снега выпадет» – регрессия.

Спотыкаются тут в двух местах. Бывает, что ответ записан цифрой, но это номер класса. «Отнести астероид к классу опасности 1, 2 или 3» – классификация: класс 2 не «вдвое больше» класса 1, а класса 2,5 не бывает. А бывает, что группы есть, но подписи неизвестны. «Разложи 500 снимков на кошек и собак» – классификация, если в обучающих снимках подписано, где кто. «Разложи 500 снимков на группы похожих» без подписей – кластеризация.

1.4. Обучающая и проверочная выборка

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

Допустим, у нас 1000 примеров с ответами. Если учить модель на всех 1000 и на них же проверять, мы ничего не узнаем. Модель могла просто запомнить ответы. Это как выучить наизусть ответы из конца задачника: на тех же задачах – пятёрка, а на контрольной с новыми числами – двойка.

Поэтому примеры заранее делят на две части. Каждую часть называют выборкой:

• Обучающая выборка (её ещё называют тренировочной) – на ней модель учится, ответы видны. Обычно это большая часть: 70–80 %.
• Проверочная выборка (тестовая) – её откладывают и во время обучения модели не показывают. Когда обучение закончено, модель отвечает на эти примеры, а мы сравниваем её ответы с настоящими.

Пример. Из 1000 примеров 80 % идут в обучающую выборку: $1000 \cdot 80 / 100 = 800$. В проверочную – остальные: $1000 - 800 = 200$.

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

1.5. Нейрон – весы с порогом

Каждая причина «за» – кубик своей высоты. Башня выросла выше черты – решение «да». Не доросла – «нет».

Как ты решаешь, пойти ли гулять? У каждой причины свой «вес». Солнце – приятно, +3. Друг свободен – +2. Уроки уже сделаны – сразу +4, это важнее всего. Складываешь то, что совпало, и сравниваешь с внутренней чертой – порогом. Набралось 9, а порог 5 – идёшь. Свободен только друг – всего 2, сидишь дома.

Так же устроен искусственный нейрон – маленький кирпичик нейросети:

1. На вход приходят числа $x_1, x_2, x_3, \ldots$ – это признаки объекта. Часто это 1 («да, есть») и 0 («нет»), но бывают и любые числа: температура, высота камня.
2. У каждого входа есть вес $w_1, w_2, w_3, \ldots$ – число, которое говорит, насколько этот вход важен. Большой вес – сильно влияет, маленький – слабо. Отрицательный вес тянет против: мороз −30 °C – повод не идти на улицу.
3. Нейрон умножает каждый вход на его вес и всё складывает. Получается сумма $S$.
4. Сумму сравнивают с порогом $T$. Если $S$ не меньше порога – на выходе 1, иначе 0.

Словами: сумма равна первому входу, умноженному на свой вес, плюс второму, умноженному на свой вес, и так далее. Буквами:

$$S = x_1 \cdot w_1 + x_2 \cdot w_2 + x_3 \cdot w_3.$$

Если $S \ge T$ – на выходе 1. Если $S < T$ – на выходе 0. Здесь $x$ – входы, $w$ – веса, $T$ – порог, знак $\ge$ читается «больше или равно».

Пример. Нейрон решает, идти ли гулять: $w_1 = 3$ (солнце), $w_2 = 2$ (друг свободен), $w_3 = 4$ (уроки сделаны), порог $T = 5$. Сегодня солнца нет, друг свободен, уроки сделаны: $x = (0, 1, 1)$. $S = 0 \cdot 3 + 1 \cdot 2 + 1 \cdot 4 = 6$. $6 \ge 5$ – выход 1, идём гулять.

Тот же расчёт на Python. Если ты ещё не писал программ, читай по строчке:

w = [3, 2, 4]              # веса: солнце, друг, уроки
x = [0, 1, 1]              # входы: 1 – да, 0 – нет
T = 5                      # порог

S = 0                      # сумма пока равна нулю
for xi, wi in zip(x, w):   # берём пары «вход – вес» по очереди
    S = S + xi * wi        # добавляем к сумме вход, умноженный на вес
if S >= T:
    print(S, "выход 1")
else:
    print(S, "выход 0")
# 6 выход 1

• w и x – списки: несколько чисел в квадратных скобках через запятую.
• Всё после знака # – комментарий, пояснение для человека. Компьютер его пропускает.
• zip(x, w) складывает два списка в пары: (0 и 3), (1 и 2), (1 и 4). for проходит по этим парам, и строка с отступом под ним повторяется для каждой пары. После трёх повторов в S лежит $0 + 2 + 4 = 6$.
• if S >= T: – «если сумма больше или равна порогу», else: – «иначе». print выводит на экран.

Опытные программисты пишут сумму в одну строку: S = sum(xi * wi for xi, wi in zip(x, w)). Это то же самое, sum складывает все произведения. Такая запись встретится в проверках ниже.

Как нейрон учится. Сначала веса ставят наугад, и нейрон отвечает невпопад. На каждом обучающем примере его ответ сравнивают с правильным. Ошибся – веса чуть-чуть подкручивают так, чтобы ответ стал ближе к верному. Тысячи таких поправок – и веса становятся «правильными». Вот что значит «модель обучилась»: подобрались веса. Первый такой обучаемый нейрон – перцептрон – построил американский учёный Фрэнк Розенблатт в 1957 году.

Нейросеть – это много нейронов, соединённых слоями. Выход одних нейронов – вход для следующих.

• Входной слой получает признаки объекта: сколько признаков, столько входов.
• Скрытые слои – нейроны внутри сети. Их не видно снаружи, отсюда название. Чем их больше, тем более сложные закономерности сеть может уловить.
• Выходной слой выдаёт ответ: «снег да или нет», номер класса, число.

Правило, по которому нейрон превращает сумму в свой выход, называется функцией активации. Наш порог «1 или 0» – самая простая функция активации, ступенька.

1.6. Точность и ошибка

Точность – доля верных ответов. Восемь верных из десяти – это 80 %.

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

Точность (accuracy) – доля верных ответов. Словами: точность равна числу верных ответов, делённому на число всех ответов. Обычно её переводят в проценты:

$$\text{точность} = \frac{\text{верных}}{\text{всего}} \cdot 100\ \%.$$

В таблице верных ответов 4 из 5: $4 / 5 \cdot 100 = 80$ %. Доля ошибок – всё остальное: $100 - 80 = 20$ %, то есть одна ошибка из пяти.

Ту же точность можно посчитать программой – удобно, когда примеров сотня. Счётчик vernyh сначала равен 0. Запись vernyh += 1 – короткое vernyh = vernyh + 1: прибавить единицу. Двойное == значит «равно ли?». len – длина списка, то есть сколько в нём элементов:

nastoyashchie = ["спам", "не спам", "не спам", "спам", "не спам"]
otvety_modeli = ["спам", "не спам", "спам", "спам", "не спам"]

vernyh = 0
for a, b in zip(nastoyashchie, otvety_modeli):
    if a == b:              # ответ модели совпал с настоящим
        vernyh += 1
print(vernyh, "из", len(nastoyashchie))                   # 4 из 5
print("точность", vernyh / len(nastoyashchie) * 100, "%")  # точность 80.0 %

И ошибки не все одинаковые. Модель может пропустить – сказать «не спам» про настоящий спам. А может поднять ложную тревогу – назвать спамом письмо от бабушки. В таблице выше одна ошибка, и это ложная тревога (строка 3). Для почты ложная тревога хуже: письмо бабушки уйдёт в спам, и его никто не прочтёт.

Ловушка редких случаев. Представь: из 100 астероидов опасен один. «Ленивая» модель на всё отвечает «не опасен» – и угадывает 99 раз из 100, точность 99 %. Звучит отлично, а толку ноль: единственный опасный астероид она пропустила. Поэтому, когда один класс встречается редко, смотрят не только на точность, но и на то, сколько редких случаев модель нашла.

Ошибка в регрессии. Когда модель предсказывает число, «угадала или нет» не подходит: прогноз −12 °C при настоящих −11 °C почти верный. Здесь считают, на сколько модель ошиблась в каждом примере (разность без знака минус), и находят среднюю ошибку. Прогноз −10, −9, −13 при настоящих −12, −8, −13: ошибки 2, 1 и 0, средняя $(2 + 1 + 0) / 3 = 1$ градус. Чем меньше средняя ошибка, тем лучше модель. Правило, по которому считают ошибку модели, называют функцией потерь (loss), а число, по которому модели сравнивают, – метрикой. Точность и средняя ошибка – две самые простые метрики.

1.7. Разбираем задачи

w = [5, 2, -3, 3]
T = 6
for x in ([1, 0, 1, 1], [1, 1, 0, 1], [0, 1, 0, 1]):
    S = sum(xi * wi for xi, wi in zip(x, w))
    print(S, 1 if S >= T else 0)   # 1, если S ≥ T, иначе 0
# 5 0
# 10 1
# 5 0

Задача 1.7^* Порог для лунохода

искусственный нейрон, подбор порога, неравенства

Луноход решает, объезжать камень или ехать прямо. Нейрон получает два числа: $x_1$ – высота камня в сантиметрах, $x_2$ – крутизна склона в градусах. Веса: $w_1 = 2$, $w_2 = 1$. Если сумма не меньше порога $T$, выход 1 – «объезжать», иначе 0 – «ехать прямо». Порог – целое число, его надо подобрать по пяти примерам, где инженеры уже знают правильный ответ:

Таблица 1.5

№	Высота камня, см	Крутизна, °	Ответ
1	10	5	ехать прямо
2	15	12	объезжать
3	8	20	объезжать
4	12	6	ехать прямо
5	5	18	ехать прямо

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

Дано: $w_1 = 2$, $w_2 = 1$; пять примеров с ответами; $T$ – целое.
Найти: сколько целых $T$ подходят, наименьшее и наибольшее $T$.

Шаг 1. Что происходит. Порог – черта. Для «объезжать» сумма должна быть не ниже черты, для «ехать прямо» – ниже. Значит, сначала посчитаем сумму для каждого примера, а потом найдём, куда можно провести черту.

Шаг 2. Суммы. $S = 2 \cdot x_1 + 1 \cdot x_2$:

• № 1: $2 \cdot 10 + 5 = 25$ (ехать прямо);
• № 2: $2 \cdot 15 + 12 = 42$ (объезжать);
• № 3: $2 \cdot 8 + 20 = 36$ (объезжать);
• № 4: $2 \cdot 12 + 6 = 30$ (ехать прямо);
• № 5: $2 \cdot 5 + 18 = 28$ (ехать прямо).

Шаг 3. Условие для «объезжать». Нужно $S \ge T$ для примеров 2 и 3. Самая маленькая из этих сумм – 36. Если $36 \ge T$, то и $42 \ge T$. Значит, $T \le 36$.

Шаг 4. Условие для «ехать прямо». Нужно $S < T$ для примеров 1, 4, 5. Самая большая из этих сумм – 30. Если $30 < T$, то и 25, и 28 меньше $T$. Значит, $T > 30$, то есть целое $T$ не меньше 31.

Шаг 5. Собираем. Подходят целые $T$ от 31 до 36: 31, 32, 33, 34, 35, 36. Их $36 - 31 + 1 = 6$.

Шаг 6. Проверяем края. $T = 31$: пример 4 даёт $30 < 31$ – «прямо», верно; пример 3 даёт $36 \ge 31$ – «объезжать», верно. $T = 36$: пример 3 даёт $36 \ge 36$ – «объезжать», верно (равенство считается за «да»). $T = 37$ уже не подходит: $36 < 37$, и нейрон скажет про камень № 3 «прямо». $T = 30$ тоже не подходит: $30 \ge 30$, и про камень № 4 выйдет «объезжать».

Проверка кодом.

# (высота, крутизна, правильный ответ): 1 – объезжать, 0 – ехать прямо
primery = [(10, 5, 0), (15, 12, 1), (8, 20, 1), (12, 6, 0), (5, 18, 0)]
podhodyat = []                      # сюда соберём подходящие пороги
for T in range(0, 100):             # пробуем все пороги от 0 до 99
    vse_verno = True
    for h, k, otvet in primery:
        S = 2 * h + 1 * k
        vyhod = 1 if S >= T else 0
        if vyhod != otvet:          # != значит «не равно»: нейрон ошибся
            vse_verno = False
    if vse_verno:
        podhodyat.append(T)         # append добавляет число в конец списка
print(podhodyat, len(podhodyat))    # [31, 32, 33, 34, 35, 36] 6

Почему порогов целых шесть. Примеров всего пять, и на этих камнях все шесть порогов отвечают одинаково. Разница появится на новом камне: высота 11 см, склон 10° дают $S = 32$. При пороге 31 нейрон скажет «объезжать», при пороге 33 – «ехать прямо». Вот инженеры и собирают побольше примеров: каждый новый пример сужает промежуток.

Частый промах – записать $30 \le T$ и включить 30 в ответ – тогда пример 4 окажется «объезжать», потому что $30 \ge 30$. Где стоит знак «не меньше», а где «меньше», решает условие задачи, – проверяй границы подстановкой. А на самом финише теряют балл так: считают количество как $36 - 31 = 5$ и забывают, что оба края входят.

Ответ: 6 значений, от 31 до 36.

Своя задача по программе сферы, модуль 1

2.1. Множество и его элементы

Всё, что лежит внутри обруча, – элементы множества. Обруч поменьше внутри большого – подмножество.

Множество – это набор каких-то предметов, собранных вместе по одному признаку. Игрушки в коробке, ученики твоего класса, буквы в слове, книги в школьной библиотеке – всё это множества. Каждый предмет из набора называется элементом множества. Мяч – элемент множества «игрушки в коробке», а твой сосед по парте – элемент множества «ученики 6 «Б»».

Множество записывают в фигурных скобках: $A = \{\text{мяч}, \text{кубик}, \text{машинка}, \text{самокат}\}$. Два правила отличают множество от обычного списка:

• порядок не важен: $\{1, 2, 3\}$ и $\{3, 1, 2\}$ – одно и то же множество;
• повторов нет: каждый элемент либо есть в множестве, либо его нет. В слове «КОЛОКОЛ» семь букв, но множество его букв – всего $\{\text{К}, \text{О}, \text{Л}\}$, три элемента.

Число элементов множества $A$ обозначают $n(A)$. Для игрушек $n(A) = 4$, для букв слова «КОЛОКОЛ» – 3. Бывает и пустое множество – в нём нет ни одного элемента, $n = 0$. Например, множество учеников твоего класса ростом больше трёх метров.

Множество можно задать двумя способами. Можно перечислить элементы: $\{2, 4, 6, 8\}$. А можно описать правилом: «чётные числа от 1 до 9». Получится то же самое. Правилом удобнее, когда элементов много: «все книги библиотеки с отметкой 10+» перечислять долго, а описать можно одной строкой.

Подмножество – часть множества: каждый его элемент есть и в большом множестве. Игрушки с колёсами – подмножество игрушек в коробке. Девочки 6 «Б» – подмножество учеников 6 «Б». Два особых случая математики тоже считают подмножествами: всё множество целиком и пустое множество – в нём нет ни одного «чужого» элемента.

Зачем это ИИ? Нейросеть, которая учится узнавать котов на фото, получает набор данных – множество картинок. У части из них стоит метка «кот» – это подмножество. Когда говорят «модель ошиблась на 15 картинках из 200», считают элементы подмножества «ошибки». Слова «множество», «подмножество», «пересечение» будут встречаться во всей книге.

В Python для множеств есть готовый тип set. Он сам выбрасывает повторы:

bukvy = set("КОЛОКОЛ")     # множество букв слова
print(bukvy)               # {'К', 'О', 'Л'} – порядок при печати может быть любым
print(len(bukvy))          # 3 – число элементов, наше n(A)
print("Л" in bukvy)        # True – буква «Л» есть в множестве
print("М" in bukvy)        # False – буквы «М» нет

Построчно: set("КОЛОКОЛ") разбирает слово на буквы и оставляет каждую по одному разу; len считает элементы; in проверяет, есть ли элемент в множестве, и отвечает True («да, истина») или False («нет, ложь»).

2.2. Пересечение и объединение: круги Эйлера

Тот, кто и в шапке, и в шарфе, должен стоять сразу в двух обручах. Поэтому обручи кладут внахлёст, а он встаёт в середину.

Представь зимнюю перемену. Учитель кладёт на пол два обруча и просит: «Кто в шапке – в левый, кто в шарфе – в правый». Тем, у кого есть и то, и другое, придётся встать туда, где обручи перекрываются. А кто без шапки и без шарфа, останется снаружи. Вот и весь смысл кругов Эйлера: каждое множество рисуют кругом, и сразу видно, кто где.

Рисовать множества кругами придумал Леонард Эйлер – великий математик, который много лет работал в Петербургской академии наук. Поэтому их так и называют: круги Эйлера. В книгах встречается и название «диаграммы Эйлера – Венна».

Круги рисуют внутри прямоугольника. Прямоугольник – это всё, о чём речь в задаче: весь класс, все книги библиотеки, все страницы интернета. Без него непонятно, что значит «снаружи». Те, кто без шапки и без шарфа, стоят в прямоугольнике, но вне обоих кругов.

Два круга режут прямоугольник на четыре кусочка: «только $A$», «только $B$», общая серединка и всё, что снаружи. Из этих кусочков, как из деталей конструктора, собирают четыре главных понятия. Некоторые занимают один кусочек, а некоторые – сразу несколько.

• Пересечение $A \cap B$ – элементы, которые есть и в $A$, и в $B$. Это один кусочек – общая серединка. Дети и в шапке, и в шарфе.
• Объединение $A \cup B$ – элементы, которые есть хотя бы в одном из множеств: в $A$, или в $B$, или в обоих сразу. Это три кусочка вместе: оба круга целиком. Все, кто стоит хоть в каком-то обруче.
• Разность «$A$, но не $B$» – один кусочек, левый «полумесяц»: в шапке, но без шарфа.
• Дополнение «не $A$» – всё, что внутри прямоугольника, но снаружи круга $A$. Это два кусочка: «только $B$» и «вне обоих». Все, кто без шапки: и те, кто в одном шарфе, и те, у кого нет ни шапки, ни шарфа.

Как не перепутать значки? $\cap$ похож на букву «П» – Пересечение. $\cup$ похож на чашку, в которую сливают всё вместе, – объединение.

Пример на числах. $A = \{1, 2, 3, 4, 6\}$, $B = \{2, 4, 5, 8\}$. Общие элементы – 2 и 4, значит, $A \cap B = \{2, 4\}$. Всё вместе, без повторов: $A \cup B = \{1, 2, 3, 4, 5, 6, 8\}$ – семь элементов. Только в $A$: $\{1, 3, 6\}$.

В Python пересечение пишут значком &, объединение – значком |, разность – минусом:

A = {1, 2, 3, 4, 6}
B = {2, 4, 5, 8}
print(A & B)          # {2, 4} – пересечение
print(A | B)          # {1, 2, 3, 4, 5, 6, 8} – объединение
print(A - B)          # {1, 3, 6} – есть в A, но нет в B
print(len(A | B))     # 7

2.3. Считаем элементы: формула включений и исключений

Двое из середины попали и в «шапки», и в «шарфы». Сложили – посчитали их дважды. Один лишний раз надо вычесть.

Главная ловушка задач на множества – двойной счёт. Если просто сложить, сколько детей в шапке и сколько в шарфе, тех, кто в середине, мы посчитаем два раза. Поэтому после сложения пересечение вычитают один раз:

$$n(A \cup B) = n(A) + n(B) - n(A \cap B).$$

Словами: хотя бы в одном = в первом + во втором – в обоих. Сначала всех «включили» (сложили), потом лишних «исключили» (вычли), отсюда и название – формула включений и исключений.

Пример. В 6 «А» 27 учеников. На плавание ходят 15 человек, на лыжи – 11, и туда, и туда – 6. Сколько человек ходят хотя бы в одну секцию и сколько – ни в одну?

• Хотя бы в одну: $15 + 11 - 6 = 20$ человек.
• Ни в одну: из всего класса вычитаем тех, кто хотя бы в одной: $27 - 20 = 7$ человек.
• Только на плавание: $15 - 6 = 9$. Только на лыжи: $11 - 6 = 5$. Проверка: $9 + 5 + 6 = 20$ – сходится.

Эту формулу можно «вертеть» как угодно: из четырёх чисел $n(A)$, $n(B)$, $n(A \cap B)$ и $n(A \cup B)$ по любым трём находится четвёртое. Чаще всего на отборе спрашивают пересечение:

$$n(A \cap B) = n(A) + n(B) - n(A \cup B).$$

Если про плавание знаем 15, про лыжи 11 и что хотя бы в одну секцию ходят 20 – в обе ходят $15 + 11 - 20 = 6$.

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

Опросили 30 учеников 6 «Б», у кого какие питомцы. Кошка есть у 12, собака у 10, рыбки у 6. Кошка и собака – у 4, кошка и рыбки – у 3, собака и рыбки – у 2, все три – у одного.

1. Центр – все три питомца: 1.
2. Ровно два питомца. Кошка и собака есть у 4, но один из них – в центре, у него ещё и рыбки. Значит, только кошка и собака, без рыбок: $4 - 1 = 3$. Так же кошка и рыбки: $3 - 1 = 2$, собака и рыбки: $2 - 1 = 1$.
3. Только один питомец. Из всего круга вычитаем то, что в нём уже вписано. Только кошка: $12 - 3 - 2 - 1 = 6$. Только собака: $10 - 3 - 1 - 1 = 5$. Только рыбки: $6 - 2 - 1 - 1 = 2$.
4. Сумма всех кусочков – сколько учеников хотя бы с одним питомцем: $6 + 5 + 2 + 3 + 2 + 1 + 1 = 20$.
5. Снаружи – без питомцев: $30 - 20 = 10$ учеников.

Когда все кусочки вписаны, можно ответить на любой вопрос. «Сколько учеников держат ровно одного питомца?» – $6 + 5 + 2 = 13$. «Ровно двух?» – $3 + 2 + 1 = 6$.

Проверка формулой. Для трёх кругов тоже есть формула включений и исключений, только длиннее:

$$\begin{aligned} & n(A \cup B \cup C) = \\ & \quad n(A) + n(B) + n(C) \\ & \quad - n(A \cap B) - n(A \cap C) - n(B \cap C) \\ & \quad + n(A \cap B \cap C). \end{aligned}$$

Словами: сложи три круга, вычти три пары и прибавь центр. Для питомцев: $12 + 10 + 6 - 4 - 3 - 2 + 1 = 20$ – столько же, сколько при заполнении.

Откуда в конце плюс? Посмотри на единственного ученика в центре – у него все три питомца. Когда сложили три круга, его посчитали три раза. Потом вычли три пары, а он есть в каждой – вычли его тоже три раза. Вышло $3 - 3 = 0$: ученик пропал из подсчёта совсем. Возвращаем его, прибавив один раз.

2.4. Логика: И, ИЛИ, НЕ

И – как два замка на одной двери: войдёшь, только если открыты оба. ИЛИ – как две двери в комнату: хватит одной открытой. НЕ – как фонарь во дворе: он делает всё наоборот и горит, когда НЕ светло.

Высказывание – фраза, про которую можно сказать «верно» или «неверно». «Новосибирск стоит на Оби» – верно. «В неделе 8 дней» – неверно. «Который час?» – не высказывание: это вопрос, он не бывает верным или неверным. В логике вместо «верно» говорят истина, вместо «неверно» – ложь. Коротко истину пишут 1, ложь – 0.

Из простых высказываний собирают сложные с помощью связок:

• И – истинно, только когда оба высказывания истинны. «Идёт снег И дует ветер» – верно, только если есть и снег, и ветер.
• ИЛИ – истинно, когда хотя бы одно истинно (или оба). «Возьму на дачу книгу ИЛИ планшет» – обещание выполнено, если взял книгу, планшет или и то, и другое. Ложно, только если не взял ничего.
• НЕ – переворачивает: истину делает ложью, ложь – истиной. «НЕ идёт снег» верно ровно тогда, когда снега нет.

Осторожно с ИЛИ. В обычной речи «чай или компот?» значит «что-то одно». В логике ИЛИ разрешает и оба сразу. В задачах всегда логическое ИЛИ, если не сказано иначе.

Таблица истинности – таблица, где перебраны все возможные сочетания «истина/ложь» и для каждого написан результат. У двух высказываний $A$ и $B$ сочетаний четыре: оба ложны, ложно только одно (два случая), оба истинны.

Столбец «И» – одна единица, только в последней строке. Столбец «ИЛИ» – один ноль, только в первой. Больше тут запоминать нечего.

Посмотри на круги Эйлера из раздела 2.2 – это та же логика. Элемент попадает в пересечение, если он в $A$ И в $B$. В объединение – если он в $A$ ИЛИ в $B$. В дополнение – если он НЕ в $A$. Поэтому задачи про множества и задачи про логику решаются одними и теми же картинками.

Сложные выражения. Связки можно соединять: «(дома есть хлеб ИЛИ есть деньги) И магазин НЕ закрыт». Порядок такой же строгий, как у действий в арифметике: сначала то, что в скобках, потом НЕ, потом И и в конце ИЛИ.

Это как в арифметике, где умножение делают раньше сложения. Связка И и правда похожа на умножение: $0 \cdot 1 = 0$, и «ложь И истина» – тоже ложь. Сомневаешься в порядке – ставь скобки, лишними они не бывают.

Пример. $A = 1$, $B = 0$, $C = 0$. Чему равно $A$ ИЛИ $B$ И НЕ $C$? По порядку: НЕ $C$ = 1. Потом И: $B$ И 1 = 0 И 1 = 0. В конце ИЛИ: $A$ ИЛИ 0 = 1 ИЛИ 0 = 1. Ответ: 1, истина.

Если высказываний три, строк в таблице истинности будет $2 \cdot 2 \cdot 2 = 8$: каждое из трёх может быть 0 или 1 (это правило умножения из главы 3). Для четырёх – 16 строк. Перебирать руками долго, а компьютер делает это мгновенно. В Python связки пишут по-английски: И – and, ИЛИ – or, НЕ – not:

# печатаем таблицу истинности для выражения A и не B
for A in [0, 1]:
    for B in [0, 1]:
        rez = A and not B
        print(A, B, int(rez))

Как это читать: for A in [0, 1]: – «по очереди подставь в $A$ сначала 0, потом 1». Второй for внутри первого перебирает $B$ для каждого $A$ – так получаются все четыре строки. rez = A and not B считает выражение, а int(rez) печатает результат цифрой 0 или 1. Программа выведет четыре строки: 0 0 0, 0 1 0, 1 0 1, 1 1 0. Истина только в одной строке: $A = 1$, $B = 0$.

2.5. Запросы к поисковику

ИЛИ собирает оба круга – находится больше. И оставляет только общую часть – находится меньше.

Поисковик – это огромная машина для работы с множествами. На каждое слово у него есть множество страниц, где это слово встречается. Запрос из нескольких слов – это пересечение или объединение таких множеств. В задачах (и в школьных учебниках) обычно пишут так:

• кот | пёс – ИЛИ: страницы, где есть хотя бы одно из слов, – объединение;
• кот & пёс – И: страницы, где есть оба слова, – пересечение.

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

Нарисуй круги Эйлера – и сразу увидишь два правила:

• И сужает. Каждое новое слово через & может только убрать страницы. кот & пёс найдёт не больше, чем кот, а кот & пёс & попугай – не больше, чем кот & пёс.
• ИЛИ расширяет. Каждое новое слово через | может только добавить. кот | пёс найдёт не меньше, чем кот.

Поэтому запросы легко выстроить по числу найденных страниц: меньше всего – у запроса с самым длинным «И», больше всего – у запроса с самым длинным «ИЛИ». А если даны числа, работает формула из раздела 2.3. Нашлось «кот» – 800 страниц, «пёс» – 600, «кот | пёс» – 1100. Тогда «кот & пёс»: $800 + 600 - 1100 = 300$ страниц.

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

2.6. Разбираем задачи

A = set("НЕЙРОСЕТЬ")
B = set("РОБОТ")
print(len(A), len(B), len(A & B), len(A | B))   # 8 4 3 9

Задача 2.3 Каталог школьной библиотеки

пересечение, формула включений и исключений, фильтры

У школьной библиотеки есть сайт-каталог. У каждой книги указан один или несколько жанров и одна возрастная отметка (6+, 10+, 12+ и так далее). В фильтре можно выбрать сразу несколько жанров – тогда сайт показывает книги, у которых есть хотя бы один из выбранных жанров. Катя попробовала разные фильтры и записала, сколько книг нашлось:

Таблица 2.2

Фильтр	Отметка 10+	Любой возраст
фантастика	9	24
приключения	7	15
оба жанра	14	33

В строке «оба жанра» в фильтре выбраны сразу фантастика и приключения.

Сколько в библиотеке книг, у которых есть оба жанра – и фантастика, и приключения, – а возрастная отметка не 10+?

Дано: отметка 10+: $n(Ф) = 9$, $n(П) = 7$, $n(Ф \cup П) = 14$; все книги: $n(Ф) = 24$, $n(П) = 15$, $n(Ф \cup П) = 33$.
Найти: книги с обоими жанрами и отметкой не 10+ – ?

Шаг 1. Что происходит. Когда выбраны оба жанра, сайт показывает книги хотя бы одного жанра – это объединение $Ф \cup П$. А нам нужны книги обоих жанров – пересечение $Ф \cap П$. Сайт его не показывает, досчитаем сами. Сделаем это два раза: для отметки 10+ и для всех книг.

Шаг 2. Оба жанра с отметкой 10+. $n(Ф \cap П) = 9 + 7 - 14 = 2$ книги.

Шаг 3. Оба жанра, все возрасты. $n(Ф \cap П) = 24 + 15 - 33 = 6$ книг.

Шаг 4. Оба жанра, но не 10+. У каждой книги ровно одна возрастная отметка. Значит, 6 книг обоих жанров делятся на две группы: 2 с отметкой 10+ и все остальные. Остальных: $6 - 2 = 4$ книги.

На чём ловит эта задача. Кажется, что фильтр с двумя жанрами показывает книги обоих жанров, – и тянет сразу ответить $33 - 14 = 19$. Но 33 и 14 – объединения, «хотя бы один жанр». Читай в условии, что делает фильтр: здесь выбор двух жанров – это ИЛИ, а не И.

Ответ: 4 книги.

По мотивам задачи отборочного этапа НТО Junior 2023/24 «Круги Эйлера»

Задача 2.6^* Разметка фотографий для нейросети

три множества, заполнение кругов Эйлера

Чтобы научить нейросеть находить на фото кошек, собак и людей, ребята из кружка разметили 200 фотографий: поставили метки «кошка», «собака», «человек». На одном фото может быть несколько меток, а может не быть ни одной (например, пейзаж). Итог разметки:

• метка «кошка» – на 70 фото, «собака» – на 60, «человек» – на 90;
• «кошка» и «собака» вместе – на 20 фото, «кошка» и «человек» – на 30, «собака» и «человек» – на 25 (на части этих фото может стоять и третья метка);
• все три метки – на 10 фото.

а) Сколько фото остались без единой метки? б) Сколько фото получили ровно одну метку?

Дано: всего 200; $n(К) = 70$; $n(С) = 60$; $n(Ч) = 90$; $n(К \cap С) = 20$; $n(К \cap Ч) = 30$; $n(С \cap Ч) = 25$; $n(К \cap С \cap Ч) = 10$.
Найти: без меток – ?; ровно одна метка – ?

Шаг 1. Что происходит. Три множества, которые пересекаются. Рисуем три круга и заполняем кусочки от центра наружу – так ответим на оба вопроса сразу.

Шаг 2. Центр – все три метки: 10.

Шаг 3. Ровно две метки. Из каждой пары вычитаем центр: только кошка и собака $20 - 10 = 10$; только кошка и человек $30 - 10 = 20$; только собака и человек $25 - 10 = 15$.

Шаг 4. Ровно одна метка. Из каждого круга вычитаем всё, что в нём уже вписано:

• только кошка: $70 - 10 - 20 - 10 = 30$;
• только собака: $60 - 10 - 15 - 10 = 25$;
• только человек: $90 - 20 - 15 - 10 = 45$.

Шаг 5. Хотя бы одна метка – сумма всех семи кусочков: $30 + 25 + 45 + 10 + 20 + 15 + 10 = 155$ фото. Проверим формулой: $70 + 60 + 90 - 20 - 30 - 25 + 10 = 155$ – то же число.

Шаг 6. Ответы. а) Без меток: $200 - 155 = 45$ фото. б) Ровно одна метка: $30 + 25 + 45 = 100$ фото.

Все ли фото на месте? 100 фото с одной меткой, $10 + 20 + 15 = 45$ – с двумя, 10 – с тремя, 45 – без меток. $100 + 45 + 10 + 45 = 200$ – ни одно не потерялось. И ни один кусочек не вышел отрицательным.

Типичная ошибка. Забыть в конце прибавить центр: $70 + 60 + 90 - 20 - 30 - 25 = 145$, и тогда без меток «55». А в пункте б) рука тянется сразу написать $70 + 60 + 90 = 220$ «фото с одной меткой»: так каждое фото с двумя метками посчитано дважды, а с тремя – трижды. Да и 220 больше, чем всех фото, – верный знак, что что-то не так.

Ответ: а) 45 фото; б) 100 фото.

Своя задача по программе сферы, модуль 2

schet = 0
for A in [0, 1]:
    for B in [0, 1]:
        for C in [0, 1]:
            if (A and B) or not C:
                schet = schet + 1
print(schet)   # 5

3.1. Дерево возможностей и правило умножения

Каждая шапка ветвится на три шарфа. Веток две, в каждой по три – всего 2 · 3 = 6 нарядов.

Утром в прихожей висят две шапки – синяя и оранжевая – и три шарфа. Сколько разных нарядов можно собрать? Перебирать наугад рискованно: что-нибудь пропустишь или посчитаешь дважды. Надёжнее нарисовать дерево возможностей – схему, где каждый выбор разветвляется на все свои варианты. Из начальной точки выходят ветки «синяя шапка» и «оранжевая шапка», из каждой – по три ветки-шарфа. Концы веток называют листьями. Каждый лист – один готовый вариант. Листьев шесть, значит, и нарядов шесть.

Чат-боты устроены так же. Бот «Что почитать?» сначала спрашивает жанр: фантастика, детектив или приключения. Потом уточняет, какую книгу хочется – короткую или длинную. Каждый путь от начала до листа – один сценарий разговора.

Рисовать дерево каждый раз не обязательно – достаточно посмотреть на его форму. Из начала выходят 3 ветки, и каждая делится ещё на 2. Получается 3 раза по 2, то есть $3 \cdot 2 = 6$. Это правило умножения: если выбор идёт по шагам, на первом шаге $a$ вариантов, а на втором – $b$ вариантов при любом первом выборе, то всего вариантов $a \cdot b$. Шагов больше – множителей больше. Добавим боту третий вопрос «бумажная или электронная?» – каждый из шести листьев раздвоится, и получится $3 \cdot 2 \cdot 2 = 12$ сценариев.

Умножать можно, только если на втором шаге всегда одно и то же число вариантов, что бы ни выбрали на первом. Если после «фантастики» бот предлагает два объёма, а после «детектива» – один, правило ломается. Тогда листья считают по веткам и складывают. Об этом – следующий раздел.

Пересчитать листья может и программа. Два цикла for, один внутри другого, – это и есть дерево: внешний цикл идёт по веткам первого шага, внутренний – по веткам второго.

zhanry = ["фантастика", "детектив", "приключения"]
obyomy = ["короткая", "длинная"]

n = 0
for zh in zhanry:          # первый шаг дерева: жанр
    for ob in obyomy:      # второй шаг: для каждого жанра – оба объёма
        n += 1
        print(n, zh, ob)
print("всего:", n)         # всего: 6

Цикл for zh in zhanry по очереди берёт каждый жанр из списка. Для каждого жанра вложенный цикл перебирает оба объёма. Строка n += 1 прибавляет к счётчику единицу на каждом листе, а print выводит номер листа и сам сценарий.

3.2. Правило сложения: «или» против «и»

Кашу и напиток берут вместе – каждая каша с каждым напитком, 2 · 3 = 6 пар. Книгу или фильм выбирают одно – все варианты встают в одну очередь, 5 + 3 = 8.

Прислушивайся к союзам в условии. На завтрак берут кашу и напиток – обе вещи сразу, и каждая каша сочетается с каждым напитком. Это правило умножения. А вечером читают книгу или смотрят фильм – что-то одно. Тогда варианты просто выстраиваются в один ряд: 5 книг да 3 фильма – $5 + 3 = 8$ способов провести вечер. Это правило сложения: если выбираем один вариант из нескольких групп, которые не пересекаются, числа вариантов складываем.

Часто в одной задаче есть и то, и другое. Бот кинотеатра спрашивает: «Мультфильм или кино?» Мультфильмов в афише 4, фильмов 2. Потом предлагает к сеансу напиток – один из трёх. Первый шаг – «или»: $4 + 2 = 6$ сеансов. Второй шаг – «и»: к любому сеансу подходит любой напиток. Итого $(4 + 2) \cdot 3 = 6 \cdot 3 = 18$. Скобки тут обязательны: сначала собираем все варианты одного шага, потом перемножаем шаги.

Ловушка – группы с общими элементами. На полке 5 книг про космос и 4 фантастических, но одна из них – фантастика про космос. Сколько есть книг «про космос или фантастика»? Не 9, а $5 + 4 - 1 = 8$: общую книгу посчитали в обеих группах, и одну лишнюю надо вычесть. Это те же круги Эйлера из главы 2.

3.3. Перестановки: кто за кем

На первое место – любой из трёх, на второе – любой из двух оставшихся, на третье – последний. 3 · 2 · 1 = 6 очередей.

Три робота – А, Б и В – встают в очередь на зарядку. Сколькими способами это можно сделать? Выпишем все очереди: АБВ, АВБ, БАВ, БВА, ВАБ, ВБА – шесть. Выписывай по порядку, иначе запутаешься: сначала все очереди, где первым стоит А, потом где первым Б, потом В.

А можно посчитать по местам – тем же правилом умножения. На первое место встаёт любой из 3 роботов. Когда первый встал, на второе место остаются 2. На третье – 1, последний. Всего $3 \cdot 2 \cdot 1 = 6$. Отличие от шапок и шарфов в том, что здесь каждый следующий шаг беднее предыдущего: робот, который уже стоит в очереди, второй раз в неё не встанет.

Такие расстановки всех предметов в ряд называют перестановками. Для четырёх роботов: $4 \cdot 3 \cdot 2 \cdot 1 = 24$. Для пяти: $5 \cdot 4 \cdot 3 \cdot 2 \cdot 1 = 120$. Число растёт очень быстро. Десять школьников можно выстроить в очередь в столовой 3 628 800 способами. Если пробовать каждую минуту новый порядок без сна и выходных, уйдёт почти семь лет.

Произведение $1 \cdot 2 \cdot 3 \cdot \ldots \cdot n$ встречается так часто, что у него есть имя – факториал – и значок $n!$ (читается «эн факториал»): $3! = 6$, $4! = 24$, $5! = 120$, $6! = 720$. Это просто короткая запись. Считать всё равно удобнее по местам.

Не все места. Из 10 команд надо выбрать призёров: золото, серебро и бронзу. Считаем по местам, но останавливаемся на третьем: $10 \cdot 9 \cdot 8 = 720$. Порядок здесь важен: «Альфа – золото, Бета – серебро» и «Бета – золото, Альфа – серебро» – разные итоги турнира.

Когда порядок не важен. Пятеро друзей при встрече пожали руки – каждый каждому. Каждый жмёт руку четверым, и кажется, что рукопожатий $5 \cdot 4 = 20$. Но рукопожатие Ани с Борей и Бори с Аней – одно и то же, а мы посчитали его дважды. Делим на 2: $20 / 2 = 10$. Так же считают партии в турнире «каждый с каждым» и пары дежурных.

Перестановки умеет перебирать и Python. В модуле itertools – наборе готовых инструментов, который есть в любом Python, – есть функция permutations («перестановки»). Она выдаёт все расстановки сразу.

from itertools import permutations

ocheredi = list(permutations(["А", "Б", "В"]))
for o in ocheredi:
    print(*o)
print("всего:", len(ocheredi))           # всего: 6
print(len(list(permutations("АБВГД"))))  # 120 – очередей из пяти

len считает, сколько элементов в списке, а print(*o) печатает буквы одной очереди через пробел.

3.4. Вероятность – доля подходящих исходов

Шариков 10, оранжевых среди них 3. Вероятность вытащить оранжевый – 3 из 10, то есть 30 %.

В мешке 10 одинаковых на ощупь шариков: 3 оранжевых и 7 голубых. Тянешь один не глядя. Может попасться любой из десяти, и ни у одного нет преимущества. Оранжевых – три из десяти. Поэтому говорят: вероятность вытащить оранжевый шарик равна $\frac{3}{10}$.

Несколько слов, без которых дальше не обойтись:

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

Вероятность – это доля подходящих исходов среди всех. Словами: вероятность равна числу подходящих исходов, делённому на число всех исходов. Буквами:

$$P = \frac{m}{n},$$

где $P$ – вероятность, $m$ – сколько исходов подходит, $n$ – сколько всего равновозможных исходов. Дробь переводим в проценты умножением на 100: $\frac{3}{10} = 0{,}3 = 30$ %.

• Монета. Исходов 2, орёл – один из них: $P = \frac{1}{2} = 50$ %.
• Кубик. Исходов 6. Чётное число (2, 4 или 6) – 3 исхода: $\frac{3}{6} = \frac{1}{2} = 50$ %. Шестёрка – один исход: $\frac{1}{6} \approx 16{,}7$ %.
• Выбор из списка. Кого вызвать к доске, выбирает программа-жребий, и у всех 24 учеников класса шансы равные. Вероятность, что выпадет именно тебе, – $\frac{1}{24} \approx 4{,}2$ %.

У вероятности две границы. Меньше 0 она не бывает: 0 – у события, которое никогда не случится (на кубике выпало 7). Больше 1 тоже не бывает: 1 – у события, которое случится всегда (на кубике выпало меньше 10). Вышло 1,3 или 130 % – ищи ошибку в решении.

Противоположное событие. «Вытащу оранжевый» и «не вытащу оранжевый» вместе покрывают все исходы. Поэтому $P(\text{не } A) = 1 - P(A)$. Не оранжевый: $1 - 0{,}3 = 0{,}7$, то есть 70 %. Иногда так считать заметно быстрее.

Две монеты. Сколько исходов, если бросить две монеты? Хочется сказать «три: два орла, две решки, орёл с решкой». Это главная ловушка темы, в неё попадали даже взрослые учёные. Покрась монеты мысленно: одна синяя, другая красная. Тогда исходы такие: ОО, ОР, РО, РР – четыре, и все равновозможные (дерево: $2 \cdot 2 = 4$). «Орёл с решкой» получается двумя способами – ОР и РО. Поэтому вероятность ровно одного орла – $\frac{2}{4} = 50$ %, а не $\frac{1}{3}$.

Вероятность двух орлов – $\frac{1}{4}$. Её можно найти и по-другому. В половине бросков синяя монета – орёл, и среди этих бросков в половине красная тоже орёл. Половина от половины: $\frac{1}{2} \cdot \frac{1}{2} = \frac{1}{4} = 25$ %. Это правило пригодится ещё не раз: вероятности двух независимых событий (одно никак не влияет на другое) перемножаются.

Два кубика. Исходов $6 \cdot 6 = 36$. Их удобно разложить в таблицу: строки – первый кубик, столбцы – второй, в клетке – сумма очков.

Сумма 7 стоит в 6 клетках: $P = \frac{6}{36} = \frac{1}{6} \approx 16{,}7$ %. А сумма 2 – только в одной (1 и 1): $\frac{1}{36} \approx 2{,}8$ %. Суммы от 2 до 12 не равновозможные, поэтому рассуждать «сумм всего 11, значит, каждая – одна одиннадцатая» нельзя.

Программа проверит подсчёт перебором всех 36 клеток:

vse = 0
podhodyat = 0
for a in range(1, 7):          # первый кубик: 1, 2, …, 6
    for b in range(1, 7):      # второй кубик
        vse += 1
        if a + b == 7:
            podhodyat += 1
print(podhodyat, "из", vse)                  # 6 из 36
print(round(podhodyat / vse * 100, 1), "%")  # 16.7 %

range(1, 7) – это числа от 1 до 6: правая граница в range не входит. round(…, 1) округляет до десятых.

3.5. Частота в эксперименте

За 10 бросков орёл вполне может выпасть 7 раз. За 1000 бросков доля орлов подбирается к половине.

Вероятность орла – 50 %. Значит ли это, что из 10 бросков ровно 5 будут орлами? Попробуй – скорее всего, нет. Мы попросили компьютер бросить монету 10 раз и получили 7 орлов. Монета тут ни при чём: на коротком отрезке случай «гуляет».

Частота события – доля опытов, в которых оно случилось. Считают её так:

$$\text{частота} = \frac{\text{сколько раз случилось}}{\text{сколько было опытов}}.$$

7 орлов из 10 – частота $\frac{7}{10} = 70$ %. Бросаем дальше. После 100 бросков набралось 54 орла – 54 %. После 1000 – 508 орлов, 50,8 %.

Это одно из главных наблюдений теории вероятностей, его называют законом больших чисел: чем больше опытов, тем ближе частота к вероятности. Ближе, но не обязательно ровно: 508 орлов из 1000 – самое обычное дело.

Сколько раз ожидать. Если вероятность известна, то в $N$ опытах событие случится примерно $P \cdot N$ раз. Кубик бросили 600 раз – шестёрка выпадет около $\frac{1}{6} \cdot 600 = 100$ раз. Может, 93, может, 108, но не 20 и не 300.

Вероятность по опыту. Бывает, что исходы не пересчитать. Вероятность того, что школьный автобус опоздает, по дереву не найдёшь. Зато можно вести записи: за 80 учебных дней автобус опоздал 12 раз. Частота $\frac{12}{80} = 0{,}15$, и вероятность опоздания завтра оценим в 15 %. Так же учится машинное обучение: модель смотрит на тысячи примеров и запоминает, как часто что встречается. Чем больше примеров, тем точнее оценка – тот же закон больших чисел.

Бросать монету тысячу раз руками долго, а компьютер справится за долю секунды. Модуль random (он тоже есть в любом Python) выдаёт случайные числа: random.randint(0, 1) – случайно 0 или 1, как монета.

import random

orly = 0
for n in range(1, 1001):
    if random.randint(0, 1) == 1:    # 1 – орёл, 0 – решка
        orly += 1
    if n in (10, 100, 1000):
        print(n, "бросков:", round(orly / n * 100, 1), "% орлов")

Запусти программу несколько раз. Числа каждый раз будут другими – на то он и случай. Но после 1000 бросков доля орлов почти всегда окажется где-то между 45 и 55 %.

3.6. Вероятность в ИИ: «модель уверена на 80 %»

Модель не говорит просто «кошка». Она выдаёт вероятность каждому классу, который знает, и вместе выходит 100 %.

В главе 1 модель отвечала одним словом: «спам» или «не спам». На самом деле модель-классификатор обычно сначала выдаёт вероятности для каждого класса: кошка – 0,80, собака – 0,15, лиса – 0,05. Все 100 % она делит между классами, которые знает. Ответом называет класс с наибольшей вероятностью, а это число – 80 % – называют уверенностью модели. В Teachable Machine (её проходят в модуле 9 программы) такие проценты видны при проверке модели: у каждого класса своя полоска.

Что значит «уверена на 80 %»? Не то, что на фото «на 80 % кошка»: кошка там либо есть, либо нет. Смысл другой, и тут выручает частота. Если модель хорошо обучена, то среди всех фото, про которые она сказала «кошка, 80 %», кошки окажутся примерно на 80 из каждых 100. На остальных двадцати она ошибётся. Уверенность – обещание про частоту верных ответов на многих примерах, а не гарантия для одного снимка.

Модель может и переоценивать себя: говорит «90 %», а права лишь в 70 случаях из 100. Проверяют это как в разделе 3.5: берут много ответов с одинаковой уверенностью и считают частоту верных. Такая модель похожа на одноклассника, который на каждый вопрос уверенно тянет руку, а отвечает верно через раз.

Порог уверенности. Часто модели разрешают отвечать, только если уверенность выше порога, а иначе зовут человека. Камера на въезде во двор распознала номер машины с уверенностью 55 % – шлагбаум не поднимается, фото уходит охраннику. Вот такое правило на Python:

otvet = {"кошка": 0.80, "собака": 0.15, "лиса": 0.05}

klass = max(otvet, key=otvet.get)    # класс с самой большой вероятностью
if otvet[klass] >= 0.7:
    print("На фото", klass, "– уверенность", otvet[klass] * 100, "%")
else:
    print("Не уверена – пусть посмотрит человек")

otvet – это словарь: набор пар «ключ: значение», здесь «класс: вероятность». max(otvet, key=otvet.get) находит ключ с самым большим значением. Программа напечатает На фото кошка – уверенность 80.0 %. Поменяй 0.80 на 0.55 (а 0.15 на 0.40) – и ответом станет просьба позвать человека.

Вероятность в генеративном ИИ. Чат-боты вроде GigaChat или Алисы пишут ответ по кусочку – обычно это слово или часть слова. На каждом шаге языковая модель (программа, обученная на огромном количестве текстов) оценивает, что может идти дальше, и раздаёт вероятности. После «На Обском море дует сильный …» слову «ветер» достаётся много, слову «кактус» – почти ничего. Потом модель выбирает кусочек – чаще один из самых вероятных, но не всегда самый-самый. Поэтому на один и тот же вопрос чат-бот может ответить немного по-разному.

Вероятность целой фразы считают по дереву, как у двух монет, – доля от доли. Пусть модель начинает ответ со слова «привет» в 60 % случаев, а после «привет» дописывает «друг» в половине случаев. Тогда фраза «привет, друг» выходит в $0{,}6 \cdot 0{,}5 = 0{,}3$, то есть в 30 % случаев. Проще всего это увидеть на сотне ответов.

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

3.7. Разбираем задачи

Задача 3.2 Бот с развилкой

дерево возможностей, правила сложения и умножения

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

Дано: книга – 3 способа подбора; фильм – 2 способа; викторина – 4 вида; отказ – 1 вариант.
Найти: $N$ – число сценариев.

Шаг 1. Делим разговор на шаги. Сначала бот выясняет, что и как подбирать, потом – чем закончить разговор.

Шаг 2. Первый шаг – это «или». Посетитель берёт книгу по одному из 3 признаков или фильм по одному из 2. Книгу и фильм сразу не подобрать, общих вариантов у веток нет. Складываем: $3 + 2 = 5$ вариантов первого шага.

Шаг 3. Второй шаг – тоже «или». Викторина одного из 4 видов или прощание: $4 + 1 = 5$ вариантов.

Шаг 4. Шаги между собой – «и». После любого из 5 вариантов подбора возможны все 5 окончаний. Умножаем: $5 \cdot 5 = 25$.

А если по большим веткам? Ветка «книга» даёт $3 \cdot 5 = 15$ сценариев, ветка «фильм» – $2 \cdot 5 = 10$. Вместе $15 + 10 = 25$ – то же число.

Типичная ошибка. Перемножить всё подряд: $3 \cdot 2 \cdot 4 = 24$. Но книга и фильм – ветки «или», их складывают. Коварство в том, что 24 очень похоже на 25, и прикидкой «на глаз» ошибку не поймать. Ещё часто забывают отказ от викторины и получают $5 \cdot 4 = 20$. Прощание – тоже конец разговора, то есть отдельный лист дерева.

Ответ: 25.

По мотивам задачи отборочного этапа НТО Junior 2023/24 «Дерево возможностей»

Задача 3.7^* Что допишет модель

вероятность цепочки событий, генеративный ИИ

Маленькая языковая модель продолжает фразу «Завтра в Новосибирске …» двумя словами. Первое слово она выбирает так: «пойдёт» – с вероятностью 0,5, «будет» – 0,4, «ожидается» – 0,1. Второе слово зависит от первого. После «пойдёт»: «снег» – 0,45, «дождь» – 0,35, «град» – 0,2. После «будет»: «мороз» – 0,9, «оттепель» – 0,1. После «ожидается» – всегда «метель». Какое продолжение из двух слов модель пишет чаще всего и с какой вероятностью? Вероятность дай в процентах.

Дано: вероятности первого слова – 0,5; 0,4; 0,1; вероятности второго слова после каждого первого – по условию.
Найти: самую вероятную фразу из двух слов и её вероятность $P$.

Шаг 1. Рисуем дерево. Из начала – три ветки первого слова, на каждой подписана её вероятность. Из каждого первого слова – ветки второго.

Шаг 2. Как посчитать одну фразу. Возьмём «пойдёт снег». В половине запусков модель начинает со слова «пойдёт», и среди этих запусков в 45 % дописывает «снег». Доля от доли: $0{,}5 \cdot 0{,}45 = 0{,}225$, то есть 22,5 %. На пальцах: из 1000 запусков «пойдёт» появится примерно в 500, а «снег» после него – в $500 \cdot 0{,}45 = 225$. Это тот же приём, что с сотней клеток в разделе 3.6.

Шаг 3. Считаем все шесть фраз.

Таблица 3.1

Фраза	Расчёт	Вероятность
пойдёт снег	$0{,}5 \cdot 0{,}45$	0,225 = 22,5 %
пойдёт дождь	$0{,}5 \cdot 0{,}35$	0,175 = 17,5 %
пойдёт град	$0{,}5 \cdot 0{,}2$	0,1 = 10 %
будет мороз	$0{,}4 \cdot 0{,}9$	0,36 = 36 %
будет оттепель	$0{,}4 \cdot 0{,}1$	0,04 = 4 %
ожидается метель	$0{,}1 \cdot 1$	0,1 = 10 %

Шаг 4. Выбираем наибольшую. Больше всех – «будет мороз», 36 %.

Не потеряли ли ветку? Модель всегда что-нибудь допишет, поэтому шесть фраз вместе обязаны дать 1: $0{,}225 + 0{,}175 + 0{,}1 + 0{,}36 + 0{,}04 + 0{,}1 = 1$. Все на месте. Ту же таблицу выдаст программа:

pervoe = {"пойдёт": 0.5, "будет": 0.4, "ожидается": 0.1}
vtoroe = {"пойдёт": {"снег": 0.45, "дождь": 0.35, "град": 0.2},
          "будет": {"мороз": 0.9, "оттепель": 0.1},
          "ожидается": {"метель": 1.0}}

for w1 in pervoe:
    for w2 in vtoroe[w1]:
        p = pervoe[w1] * vtoroe[w1][w2]      # доля от доли
        print(w1, w2, round(p * 100, 1), "%")

Типичная ошибка. Взять самое вероятное первое слово («пойдёт», 0,5), к нему самое вероятное второе («снег», 0,45) и ответить «пойдёт снег». Но у «пойдёт» вероятность размазана по трём продолжениям, а у «будет» почти вся досталась «морозу». Выбор «по одному лучшему слову за раз» не всегда даёт самую вероятную фразу. А кто-то складывает вероятности вдоль ветки: $0{,}4 + 0{,}9 = 1{,}3$. Больше 1 вероятность не бывает – это сигнал, что нужно было умножать.

Ответ: «будет мороз», 36 %.

Своя задача по программе сферы, модули 1 и 2