ИИ: Машинное обучение искусственного интеллекта — полное руководство для начинающих

В этой статье по ИИ — деревьям решений машинного обучения искусственного интеллекта, вы найдете примеры того, как работает алгоритм машинного обучения Random Forest Machine Learning. Она предназначена для того, чтобы дать начинающим интуитивное понимание работы алгоритма Random Forest, чтобы вы могли применять его для решения более крупных проблем.

Кроме того, поскольку Деревья решений (Decision trees) являются фундаментальной частью алгоритма Random Forests, эта статья объясняет, как они работают. В статье также присутствует умеренное количество математики, когда она погружается в детали некоторых различных аспектов Random Forests.

Эта статья была написана в основном для того, чтобы новички не зависели от языка программирования и сосредоточились на том, как работает машинное обучение ИИ. Тем не менее, в статье есть некоторый код, использующий модуль Scikit-learn в Python 2.7.

Также, в той статье, мы даем вам шпаргалку по деревьям решений для начинающих, бесплатно. Поскольку деревья решений составляют основу Random Forests, поэтому важно понимать как они работают. Кроме того, они сами по себе являются полезным методом машинного обучения ИИ по своей сути.

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

Что такое деревья решений / DECISION TREES ?

• Деревья решений (Decision trees) — это тип контролируемого машинного обучения ИИ
• Они используют известные обучающие данные для создания процесса, который предсказывает результаты этих данных. Этот процесс может быть использован для предсказания результата для неизвестных данных
• Дерево решений обрабатывает данные на группы на основе ценности данных и предоставляемых им возможностей
• На каждом этапе принятия решения данные разделяются на две отдельные ветви, которые могут быть разделены еще раз
• Окончательная группировка данных называется листовыми узлами

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

Выбор сплитов

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

• Если признак находится в реальном диапазоне, то разбиение происходит на полпути между двумя точками.
• Разбиение всегда выбирается только по только по одному признаку, без какого-либо взаимодействие между несколькими признаками.
• Это означает, что если есть связь между несколькими признаками, например например, если плотность является критической
  характеристикой, но данные предоставляются в объеме и массе, дерево решений будет разбивать данные как серию
  разбиений по отдельным признакам.

• Он не будет делать то, что может сделать человек (как показано ниже)

Временная сложность

• Для одного дерева решений наиболее дорогостоящей операцией является выбор наилучшее расщепление.
• Выбор наилучшего расщепления требует оценить все возможные разбиения.
• Поиск каждого возможного разбиения требует сортировки всех данных по каждому признаку.
• Это означает, что для M признаков и N точек, это занимает M * N lg(N) времени.
• Для алгоритмов машинного обучения ИИ использующих несколько деревьев решений, такая сортировка может быть выполнена за один раз и кэшировать.

Переподгонка

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

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

Дополнительные разбиения могут происходить до тех пор, пока не будет достигнут пока не будет достигнут критерий остановки

Общими критериями остановки являются:

• Максимальная глубина: максимальное количество расщеплений в ряду было достигнуто.

• Максимальное количество листьев: не допускать больше листьев.
• Min Samples Split: Разделяйте узел только в том случае, если в нем есть по крайней мере столько образцов.
• Min Samples Leaf: Разделяйте узел только в том случае, если оба дочерних узла в результате имеют не менее этого количества образцов.
• Min Weight Fraction: Разбивает узел только в том случае, если он имеет по крайней мере такой процент от общего числа образцов.

Рандомизация

• Когда запускается одно дерево решений, оно обычно рассматривает каждую точку в доступных данных.
• Однако некоторые алгоритмы объединяют несколько деревьев решений, чтобы получить их преимущества, одновременно уменьшая чрезмерную подгонку
• Два широко используемых алгоритма, которые используют несколько деревьев решений, это Случайные леса и градиентные
  Boosted Trees.
• Случайные леса используют большое количество несколько различных деревьев решений, которые запускаются параллельно и усредняются для получения окончательный результат.
• Градиентные бустерные деревья используют деревья решений, запускаемые последовательно. Последующие деревья исправляют ошибки предыдущих деревьев.
• Если объединяются несколько деревьев, то может быть полезно использовать элемент случайности при создании деревьев, что может смягчить чрезмерные подгонки.
• Bagging — (сокращение от агрегатирование в Bootstrap: Bootstrap aggregating) — это выборка из набора данных с заменой.
• Если у вас есть 100 точек данных, вы вы бы выбрали случайным образом 100 точек и в среднем получили бы 63,2 % уникальных точек и 36,8 % повторов.
• Субвыборка — построение меньшего меньшего набора, чем ваш набор данных. Например, если у вас есть 100 точек, возьмите случайным образом 60 из них (обычно без замены).
• Случайные леса обычно используют мешки, а деревья с градиентным усилением как правило, используют субвыборку.
• Кроме того, признаки, по которым дерево может быть рандомизирован.
• Вместо того чтобы оценивать каждый признак для оптимального разбиения, подмножество признаков может быть оценено (часто квадратный корень из количества оцениваемых признаков).

Регрессивные деревья решений

• Деревья регрессии по умолчанию разбивают данных на основе средней квадратичной ошибки (MSE).
• Чтобы рассчитать MSE, возьмите среднее значение для всех точек в каждой группе, и для каждой точки в этой группе вычтите среднее значение из истинного значения, возведите ошибку в квадрат, просуммируйте все квадратов и возьмите среднее значение.
• На диаграмме ниже показаны данные, которые были разделены, чтобы получить две новых групп, которые имели наименьший минимальный MSE.

• MSE по умолчанию стремится сосредоточиться на точках с наибольшей ошибкой и разделить их на свои группы, поскольку их ошибка имеет квадратичный эффект.
• Средняя ошибка (MAE) также является вариант для выбора разбиений вместо вместо MSE.
• Чтобы рассчитать MAE, возьмите медиану (не среднее) всех точек в группы, и для каждой точки вычесть медианное значение из истинного значения, возьмите абсолютное значение этой ошибки, просуммируйте результаты и возьмите среднее.

Пример регрессии

• Это пример регрессионного дерева регрессии, пытающегося сопоставить синусоиду волны с помощью одного сплита.

• Ниже приведен пример дерева регрессии глубиной 2 регрессионного дерева, которое получает 3 расщепления (т.е. 4 конечные группы).

• Деревья решений выбирают расщепление для того, чтобы максимизировать «Информационный Прирост».
• «Информация» — это метрика, которая говорит о том, сколько ошибок, вероятно, в вашем дереве решений.
• Информационный Прирост — это то, насколько меньше ошибок после разбиения, чем до разбиения.

Информационный Прирост дерева регрессии

• Деревья регрессии используют либо MSE, либо MAE в качестве метрики.
• Информационный Прирост — это MSE / MAE до разделения минус MSE / MAE после разбиения (взвешенное по числу точек данных, с которыми оперировал).
• Наилучшее значение MSE / MAE равно нулю Информационного Прироста при классификации.
• Классификационные деревья измеряют свой информационный выигрыш либо по «Entropy» или «Gini Impurity».
• Наилучшим результатом для этих значений является также ноль, а наихудший результат происходит, когда каждая категория имеет равную вероятность оказаться в любом данном узле.
• Уравнение Gini

• Где p — вероятность того, что вероятность наличия данного класса данных в вашем наборе данных.
• Уравнение Entropy

• В итоге эти результаты оказались довольно схожи

Значение характеристик

• Деревья решений позволяют определить, какие признаки являются наиболее важными.
• Это делается путем вычисления того, какой признак привел к наибольшему информационному выигрышу (взвешенному по количеству точек данных) по всем разбиениям.
• Информационный выигрыш может быть равен MSE / MAE для деревьев регрессии или Entropy / Gini для деревьев классификации.

Обзор Random Forest

Случайный лес (Random Forest) — это один из типов алгоритмов машинного обучения ИИ. Обычно они используются для классификации чего-либо на основе других имеющихся у вас данных. Например, вы можете захотеть классифицировать животных по их размеру, весу и внешнему виду или классифицировать болезнь по симптомам человека.

Цель этой статьи — помочь начинающим понять, как работает Random Forests, а также различные варианты, которые вы можете использовать при анализе проблемы.

Чтобы действительно хорошо использовать Random Forests или любой другой вид машинного обучения ИИ, необходимо знать две разные вещи:

1. Первое — как настроить код, т. е. как работать с данными, как строить графики, какое программное обеспечение использовать и т. д. использовать и т. д. Это можно считать тонкостями работы.
2. Второе, что необходимо знать, — это то, как Random Forest работает на концептуальном уровне. Почему он делает то, что делает, и какие еще есть варианты? Если настройку кода можно рассматривать как знание того, какие кнопки нужно нажать, чтобы программа заработала, то здесь речь идет о знании того, зачем нажимать эти кнопки и когда нажимать другие кнопки.

Знание того, как Random Fores работают, почему они работают именно так, как работают, и какие существуют варианты улучшения результатов. В статье интуитивно понятно рассказывается о том, как работают «Случайные леса», а также объясняются уравнения, лежащие в основе многих функций, но в ней лишь небольшое количество фактического кода (на python).

Машинное обучение ИИ — что это такое?

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

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

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

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

Основы большинства алгоритмов машинного обучения ИИ

1. Начните с набора данных, на которые вы знаете ответ.
2. Обучите алгоритм машинного обучения ИИ на этом наборе данных, часто называемом обучающий набор
3. Получите набор данных, на которых вы хотите узнать ответ, часто называемый тестовый набор
4. Пропустите эти данные через обученный алгоритм и найдите результат.

Как правило, алгоритмы машинного обучения ИИ отличаются друг от друга тем, как это делается.

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

В этом примере используется набор данных iris, потому что он широко доступен, и фактически Более того, он включен в состав python sklearn. Во многих других задачах в этой книге используется набор данных fruit, специально созданный для этих примеров.

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

Показанный код, а также код, используемый для генерации многих примеров в этой статье, был адаптирован из программы-примера plot_forest_iris.py, под лицензией BSD 3.

Что такое случайный лес Random Forest и как он работает

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

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

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

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

Как вы могли бы это сделать?

Один из способов — просто показать человеку кучу фруктов и назвать их.

• Возьмите в руки банан и скажите: «Это банан» или «Это яблоко». Этот метод сработает, если у вас будет достаточно времени и примеров, и в основном именно так мы обычно учим детей, что такое разные вещи.
• Другой способ — составить блок-схему вопросов, через которые нужно пройти, чтобы чтобы определить, к какому типу фруктов относится тот или иной предмет. Ваша блок-схема может содержать такие вопросы, как:

1. Он желтый?
2. Если да, то длинный и худой?
3. Если да, то легко ли его очистить от кожуры?
4. Значит, это банан.

По сути, это и есть дерево решений. Схема этого простого дерева решений показана ниже:

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

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

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

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

О том, как именно алгоритм Random Forest это делает, мы поговорим далее в этой статье.

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

Начало работы Random Forest с примера

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

Вот различные типы фруктов в этом примере:

• Яблоки
• Апельсины
• Бананы
• Грейпфрут

Что касается цвета, мы предполагаем, что фрукты могут быть разных цветов:

• Яблоки красные, зеленые или желтые
• Апельсины оранжевые
• Бананы желтые или зеленые
• Виноград оранжевый или желтый

Для определения размеров мы измерили несколько фруктов разных типов и получили размеры, показанные ниже:

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

Всего имеется 88 данных, и было измерено столько предметов каждого типа:

• Яблоки 24
• Апельсины 24
• Бананы 19
• Грейпфруты 21

Random Forests, Decision Trees и другие типы алгоритмов машинного обучения ИИ алгоритмы наиболее полезны для получения данных высокой размерности или большого количества данных. количество данных и придать им смысл.

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

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

Классификация данных вручную

Если бы мы дали эту задачу классификации фруктов человеку, а не алгоритму, как бы он ее решил? На самом деле, если забыть о цвете фруктов, то как бы вы смогли классифицировать фрукты, основываясь только на их размерах, изображенных на диаграмме выше?

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

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

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

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

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

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

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

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

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

Тем не менее, если бы нам пришлось принимать решение, основываясь только на этих данных, мы, вероятно, провели бы линии следующим образом:

Мы смогли разделить некоторые апельсины и яблоки, но в центре осталась область, где есть тонна апельсинов и яблок, которые все пересекаются.

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

В итоге мы получаем график, который выглядит следующим образом:

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

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

Хотя разные люди могут по-разному нарисовать приведенные выше линии, для человека это, безусловно, разумный способ классифицировать фрукты, основываясь только на размере. По сути, эта схема представляет собой дерево решений, которое мы составили вручную. Поскольку цель этой книги — объяснить, как это делают компьютеры, используя алгоритмы Decision Tree и Random Forest, настало время погрузиться в различные алгоритмические техники.

Пример дерева решений

Помните, что алгоритм Random Forest — это просто набор деревьев решений, каждое из которых было сгенерировано немного по-разному. Поэтому имеет смысл начать с рассмотрения того, как одно дерево решений классифицирует данные. Ниже показана классификация дерева решений.

График был создан путем создания дерева решений, а затем тестирования тысяч комбинаций длины и ширины и затенения каждого места в зависимости от его результата в дереве решений. Есть также более грубый график из нескольких сотен точек, созданный таким же образом. Эти точки будут более значимыми в разделе «Случайный лес».

В общих чертах этот график очень похож на тот, который мы сгенерировали вручную:

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

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

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

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

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

Но чтобы получить диагональную линию, нам нужно разделить ее на два значения одновременно.

Лучшее, что может сделать дерево решений, — это разделиться на одно значение, затем на другое и повторить этот процесс.

Возьмем этот пример с выдуманными данными:

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

Это один из способов улучшить результаты случайного леса. Если вы видите связь, например соотношение, между различными критериями в данных, вы можете облегчить работу кода, сделав соотношение собственным значением. В примере выше потребовалось 20 строк, чтобы отделить красные точки от синих. Но сами данные очень просты. Это просто выражение уравнения y = 9,5 — x для красных точек и y = 10,5 — x для синих точек. Если бы я добавил значение X к значению Y для этого графика, Random Forest мог бы разделить их одной линией, просто все, что с Y ниже 10 было красным, а все, что с Y выше 10, — синим.

Говоря иначе, если бы вы пытались классифицировать объекты в зависимости от того, будут ли они плавают или нет, у вас могут быть данные, основанные на их весе и объеме.

Если вы используете Random Forest для этих данных, вы получите результат, но он может быть сложным. Однако если вы отредактируете данные и передадите им критерий, в котором вы разделить вес на объем, чтобы получить плотность, то вы действительно получите что-то полезное.

Избыточная подгонка в деревьях принятия решений

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

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

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

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

Существует несколько способов борьбы с чрезмерной подгонкой в деревьях решений. Один из них — ограничить количество разбиений, которые делает дерево решений. До сих пор мы позволяли ему делать столько разбиений, сколько оно хотело, пока не получали каждый фрагмент данных в чистую категорию. Мы можем указать ему, чтобы он делал не более 1 разбиения, или 2 разбиений, или 10 или 10, или любое другое число, чтобы ограничить количество разбиений.

Вот пример того, как выглядит дерево решений, если мы ограничиваем его только одним сплитом:

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

Вот дерево решений с двумя расщеплениями:

Обратите внимание, что, хотя мы указали максимальное число расщеплений как 2, на самом деле расщеплений 3. Это потому, что указание максимального числа расщеплений как 2 на самом деле означает, что максимальная глубина вдоль любой данной ветви равна 2. Таким образом, первое расщепление создало 2 новые ветви, а второе расщепление превратило каждую из них в 2 ветви, в результате чего получилось 4 ветви.

Если мы допустим 3 расщепления, то график будет выглядеть следующим образом:

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

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

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

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

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

Пример случайного леса (Random Forest)

До сих пор мы рассматривали Деревья решений, которые являются компонентами Random Forest. Теперь пришло время взглянуть на сам случайный лес.

Чем отличается Random Forest

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

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

Случайные леса пытаются решить эту проблему, используя несколько деревьев решений и усреднения результатов. Однако генерировать несколько деревьев решений, используя одного и того же набора данных раз за разом не принесет пользы, поскольку вы просто получите несколько (или, по крайней мере, очень похожие деревья решений, в зависимости от того, была ли в их создании какая-то случайность или нет). Поэтому случайные Forests генерируют свои деревья решений, используя подмножества полного набора данных, которые выбранные случайным образом.

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

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

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

Прогнозирование с помощью случайных лесов

Что же делать с графиком, на котором в одном и том же месте присутствуют оттенки нескольких цветов? Если несколько деревьев решений дают разные результаты, какой из них следует использовать?

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

• Первый способ, при котором побеждает наибольшее количество голосов, похож на то, как выбирают политиков.
• Второй способ похож на то, как 5 друзей спорят о начинках для пиццы и в итоге заказывают пиццу с 60 % пепперони и 40 % грибов.

С математической точки зрения, второй ответ, который может быть получен, — это взвешивание всех результатов. Так, если 9 деревьев предсказывают апельсин, а 7 деревьев предсказывают грейпфрут, то в результате будет получено 56,25 % апельсинов и 43,75 % грейпфрут. Обратите внимание — то, что происходит на самом деле, это просто усреднение всех результатов всех деревьев. Поэтому если вы ограничили деревья так, что у них есть листья которые не являются на 100% чистыми, то даже одно дерево может вернуть результат, который на 60% состоит из одной категории и 40% — другой. Этот вес будет просто усреднен вместе с остальными.

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

В python, если вам просто нужно получить наибольшее количество голосов для наиболее распространенной категории, вы можете можно использовать функцию predict(X). Если вы хотите вернуть весовые коэффициенты для всех различных деревьев, вы можете использовать функцию predict_proba(X).

На предыдущем графике со штриховкой показаны результаты обработки этого набора данных о фруктах с помощью 16 деревьев в Random Forest.

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

Самое очевидное различие между 9 различными графиками — это штриховка.

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

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

Там, где деревья решений дают разные результаты, затеняются двумя или более цветами.

Менее очевидное различие между графиками заключается в том, что на них не все данные одинаковы. Данные на каждом из них выбраны из одного и того же источника, но в среднем каждый из них содержит только 63,2 % от исходного набора данных. Это явление известно как Boot Strapping, и о нем пойдет речь в следующем разделе.

На рисунке ниже показаны два дерева, а стрелки указывают на некоторые данные, которые отличаются друг от друга.

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

Случайность в случайном лесу

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

Получение данных для каждого дерева: Boot Strapping

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

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

Эта техника известна как Boot Strapping. Каждое из деревьев использует набор данных такого же размера, как и исходный набор данных.

В качестве примера предположим, что вы генерируете дерево из набора чисел 1-10. В исходном наборе данных 10 чисел, поэтому в новом дереве будет 10 чисел. В исходном наборе данных есть числа только из диапазона 1-10, поэтому в новом дереве будут только числа из диапазона 1-10.

Однако в исходном наборе данных есть все числа 1-10, а в новом дереве возможно, только некоторые из них. Например, дерево может быть:

1, 2, 2, 3, 5, 7, 7, 7, 9, 9

Это дерево было сгенерировано путем выбора 10 чисел из набора 1-10 с т. е. после того, как число было выбрано, оно может быть выбрано снова.

Если сгенерировать другое дерево, то оно может быть следующим:

2, 3, 3, 5, 6, 6, 7, 7, 8, 9

Это дерево будет похоже на первое созданное дерево, так как они используют один и тот же пул данных, но они не будут одинаковыми. Например, это дерево включает 8 в свой Например, это дерево включает 8 в свой набор и опускает 1. Оба дерева все равно опускают 10, просто по счастливой случайности.

Если вы проведете эту случайную выборку достаточно много раз, используя достаточно большие наборы данных, вы вы обнаружите, что в среднем 63,2 % исходного набора данных попадает в каждое дерево. Поскольку каждое дерево имеет тот же размер, что и исходный набор данных, это означает, что остальные 36,8% — это дубликаты исходного набора данных.

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

Выбор критериев

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

Способ, которым Random Forest решает эту проблему, заключается в том, чтобы не позволять деревьям просматривать все признаки. На любой ветке дерева решений для классификации доступно только подмножество признаков. Другие ветви, даже более высокие или низкие ветви того же дерева, будут иметь другие признаки, по которым они могут классифицировать.

Например, допустим, у вас есть Random Forest, который пытается классифицировать фрукты на груши или яблоки. Вы создаете случайный лес с двумя деревьями решений в нем, и передаете ему 4 признака, по которым он может классифицировать:

• Вес
• Размер
• Цвет
• Форма

По умолчанию Random Forest использует квадратный корень из числа признаков как максимальное количество признаков, которое он будет искать на любой ветви. В данном случае у нас 4 признака, поэтому каждое решение будет лучшим из 2 случайно выбранных признаков.

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

Сколько деревьев в случайном лесу?

Случайный лес состоит из множества деревьев решений, но сколько именно деревьев решений? Этот вопрос нужно решить, когда вы когда вы создаете свой случайный лес. Большинство программ позволяет контролировать количество деревьев в Random Forest с помощью параметра. Вот как можно управлять этим параметром в python, установив количество деревьев равным 100 вместо 10 по умолчанию.

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

И наоборот, количество времени, затрачиваемого на выполнение программы, скорее всего, будет увеличиваться линейно зависит от количества деревьев. Каждое из них нужно будет генерировать отдельно, и тестовые данные должны проходить через каждое из них по отдельности. Так что если у вас не 100, а 1000 деревьев, эта часть вашей программы будет выполняться в 10 раз дольше.

Решение о том, сколько деревьев должно быть в Random Forest, является компромиссом, зависящим от вашей задачи и ваших вычислительных ресурсов. Переход от 10 деревьев к 50 может значительно улучшить результаты и не добавить много времени. Переход от 1 000 деревьев к 50 000 деревьев может потребовать значительного времени, но при этом не сильно улучшить результаты. Хороший план — начать с небольшого количества деревьев и увеличивать их число, используя результаты перекрестной проверки, чтобы определить, когда преимущество больше не стоит дополнительного времени работы. Использование 100 деревьев в Random Forest — хорошее начало.

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

Ошибки вне мешка

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

Подумайте вот о чем: как только вы создадите модель машинного обучения ИИ, как вы узнаете, насколько она хороша? Один из способов — отложить часть, скажем 10 %, ваших обучающих данных, прежде чем проводить на них обучение. После подгонки алгоритма машинного обучения ИИ к обучающим данным вы можете прогнать отложенные 10 % через свой классификатор и выяснить, совпадают ли эти предсказания с реальными значениями. Эта техника известна как «перекрестная проверка» и является чрезвычайно полезной.

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

Способ работы Random Forests по своей сути предполагает отбрасывание части данных. Когда каждое дерево генерируется из набора данных. В среднем оно использует только 63,2 % набора данных. Таким образом, оставшиеся 36,8 % неявно откладываются в сторону.

Данные, которые не используются для какого-либо дерева, известны как «Out of Bag» для этого дерева. Обратите внимание, что данные являются «Out of Bag» только для данного дерева. При достаточно большом Достаточно большой случайный лес, все данные будут включены в некоторые деревья. Поскольку любое дерево имеет данные из мешка, мы можем использовать эти данные для проверки качества каждого дерева. Средняя ошибка по всем деревьям будет нашей ошибкой вне мешка.

Например, предположим, что у нас есть 10 точек данных в нашем случайном лесу, и он состоит из 15 деревьев. В среднем каждая точка будет присутствовать примерно в 2/3 деревьев, а значит, примерно в 1/3 деревьев она окажется вне мешка. Это означает, что мы ожидаем, что любая данная точка данных окажется вне мешка для 5 деревьев, хотя некоторые из них, скорее всего, окажутся вне мешка только для 3 или 4 деревьев, а другие — для 6 или 7.

Теперь представьте, что у нас есть 3 различные категории, к которым мы пытаемся отнести наши точки данных: категории A, B, C. Для каждой из 10 точек данных мы «предсказываем» их, то есть пытаемся классифицировать их с помощью Random Forest, но включаем только те деревья, для которых они выходят из мешка предсказаний.

Затем мы задаем вопрос, была бы эта точка классифицирована правильно?

Итак, для пары из 10 пунктов:

1. Точка 1 на самом деле относится к категории А. Она не подходит для 5 деревьев. При проверке на этих 5 деревьях 3 дерева предсказывают категорию A, 1 — B, 1 — C. Наиболее распространенной категорией является A, что является правильным.
2. Точка 2 на самом деле относится к категории A. Она находится вне мешка для 7 деревьев. Результаты: 3 A, 2 B и 2 C. Наиболее распространенной категорией здесь также является A, хотя она и не является большинством. Пункт 2 также верен.
3. Пункт 3 относится к категории B. Он не подходит для 3 пунктов. Результаты: 1 B, 2 C. Этот пункт неверен.
4. Пункт 4 относится к категории B. Он выведен из мешка на 4 балла, результаты — 2 B, 2 C. Этот пункт сложный, потому что есть ничья, так что все зависит от того, как реализовано программное обеспечение. В python sklearn ничья по умолчанию будет равна первому значению в ничьей (потому что ни одно последующее значение не больше этого значения, поэтому оно не изменится). В данном случае первым значением в галстуке является категория B, которая совпадает с истинной категорией. Поэтому в данном случае этот пункт будет верным, но ничья может оказаться и неверной.

После всех 10 очков у нас может быть 7, которые были классифицированы правильно, и 3, которые были классифицированы неправильно. Таким образом, результирующий показатель Out Of Bag будет равен .7. Ошибка вне мешка будет равна .3.

Перекрестная валидация

Перекрестная проверка — полезная концепция для всех типов машинного обучения ИИ. В разделе ошибки мешка мы увидели, что кросс-валидация не является строго необходимой для Random Forests, поскольку ошибка Out of Bag является чем-то вроде заготовки при кросс-валидации валидации.

Однако часто более общая кросс-валидация может быть более полезной. При типичной кросс-валидации вы выделяете часть данных и используете ее в качестве метрикой того, насколько хорошо работает ваша модель. Например, я могу выделить 20 % своих данных, обучиться на остальных 80 % и определить качество своей модели, оценив 20 %, которые я отложил. Чтобы оценить отложенные 20 %, можно использовать различные метрики, такие как среднеквадратичная ошибка, логарифмические потери, точность классификации точность или другие. Если вы участвуете в каком-то соревновании по науке о данных соревнования, например на Kaggle, то метрика обычно предоставляется вам.

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

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

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

Ниже приведен пример перекрестной валидации, когда классификатор обучается на 90 % модели, а остальные 10 % используются для оценки, 10 раз. Приведенный ниже код делает Это происходит путем случайного изменения порядка входных данных (перетасовка), а затем вырезания первые 10 %, затем следующие 10 % и т. д.

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

Как дерево решений выбирает свои части

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

Возникает очевидный вопрос: «Что лучше?»

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

В первом примере все просто и очевидно. Проведите вертикальную линию посередине, и вы отделите все красные круги от оранжевых квадратов. Однако в примере ниже это сложнее:

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

Решение приходит из «Теории информации», которая является самостоятельной областью исследования.

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

В Python по умолчанию используется критерий Gini (Джини), поэтому мы начнем с него.

Критерий Gini (Джини)

Уравнение для примеси Gini (Джини) выглядит следующим образом:

Где p — вероятность наличия заданного класса данных в вашем наборе данных.

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

• 10 яблок
• 6 бананов
• 4 кокоса

Вероятность для каждого класса составляет

• .5 — яблоки
• .3 — Бананы
• .2 — кокосы

Таким образом, примесь Gini составляет:

Что равно 0,62. Наилучшее значение, которое мы могли бы иметь, — это примесь 0.

Это произошло бы, если бы у нас была ветвь, которая на 100% состоит из одного класса, так как уравнение станет равным 1 — 1.

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

Первая ветвь

• 10 яблок
• 5 бананов

Вторая ветвь

• 1 банан
• 4 кокоса

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

Альтернативное первое отделение

• 10 яблок
• 6 бананов
• 1 кокос

Альтернативная вторая ветвь

• 3 кокоса

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

Для первого возможного разделения мы рассчитаем примесь Gini для ветви 1 в размере .444 а примесь Джини для ветви 2 — .32

В ветке 1 находится 15 предметов, а в ветке 2 — 5 предметов. Таким образом, мы можем рассчитать суммарную примесь Джини для обеих ветвей, взяв средневзвешенное значение для двух ветвей = ( 15 .444 + 5 .32 ) / 20, что дает общее значение .413.

Примесь .413 — это значительное улучшение по сравнению с примесью .62, которая была у нас до этого разделения. Но лучше ли это, чем другой сплит, который мы могли бы сделать?

Рассчитаем примесь для этого сплита:

Мы получаем суммарную примесь Gini, равную .447, что выше, чем у первой альтернативы, равной .413. Таким образом, при этих двух альтернативах будет сгенерировано дерево решений с с первым вариантом, дающим одну ветвь с 10 яблоками и 5 бананами, и вторую ветвь с 1 бананом и 4 кокосами.

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

Возвращаясь к исходному вопросу: «Какая линия лучше всего отделяет красные круги от оранжевых квадратов?», выяснилось, что самая левая из трех линий левая из трех линий является лучшей на основе критерия Джини. На левой стороне линии было 10 красных кругов, 0 оранжевых квадратов. На правой стороне линии было 7 красных красных кругов, 17 оранжевых квадратов. Таким образом, коэффициент Джини равен .292. Центральная линия имела примесь .36, а правая линия — .346, так что они обе были хуже.

Критерии энтропии

В приведенных выше примерах было показано, как рассчитываются доли с использованием примеси Джини. Альтернативным критерием для определения расщепления является энтропия.

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

Уравнение для энтропии выглядит следующим образом:

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

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

Если мы вернемся к сценарию, в котором у нас есть:

• 10 яблок
• 6 бананов
• 4 кокоса

Мы можем вычислить общую энтропию, равную 1,485, как показано ниже:

Примечание — если в ветке есть более 2 различных классов, энтропия может быть больше 1,0. Вы получите максимальную энтропию, если каждый класс имеет одинаковую вероятность. В данном случае, если бы у нас было 33 % каждой из категорий, энтропия составила бы 1,585. Если бы у нас было 10 категорий, каждая с вероятностью 10 %, энтропия составила бы 3,322.

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

Первая ветвь

• 10 яблок
• 5 бананов

Вторая ветвь

• 1 банан
• 4 кокоса

Или альтернативный вариант:

Первая ветка

• 10 яблок
• 6 бананов
• 1 кокос

Альтернативная вторая ветка

• 3 кокоса

Если мы рассчитаем энтропию для обеих этих возможностей, то для первого возможного разделения получим:

Чтобы найти общую энтропию между двумя ветвями, мы используем взвешенную сумму двух ветвей. В данном случае (15 .918 + 5 .722) / 20 = .869

Для второго возможного разделения получаем:

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

Общий прирост информации для первого расщепления будет равен энтропии до расщепления минус энтропия после расщепления. Что составляет 1,485 — .869 = .616

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

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

А затем мы суммируем количества в зависимости от того, какая функция используется. В данном примере есть только одно разделение по признакам A и C, так что это просто их значения, как показано в таблице выше, и два сплита на основе признака B, поэтому его важность равна 2,7, что представляет собой сумму значений 2,4 и .3 для каждого отдельных сплитов.

После нормализации значений мы можем увидеть относительную важность признаков. В данном примере признак B был немного важнее признака A, и оба они были важнее признака C.

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

Второй способ получения важности признаков

Не существует единого общепринятого способа получения важности признаков. Различные программные инструменты используют разные методы. Второй распространенный способ получения важности признака использует функцию ошибки Out of Bag. Этот метод доступен в языке R, но в настоящее время не доступен в python sklearn.

Случайный лес может генерировать ошибку Out Of Bag. Это означает, что все точки данных, которые не были отобраны для дерева, нужно прогнать через дерево решений и определить, правильно ли дерево решений их классифицировало или нет.

Этот метод определения важности признаков использует ошибку Out of Bag и работает следующим образом:

1. Сгенерируйте ошибку out of bag для базового дерева, не внося в него никаких изменений. Это базовая ошибка out of bag error.
2. Для каждого признака в данных, используемых для создания дерева, определите диапазон чисел, в котором могут находиться эти признаки. То есть каковы максимальные и минимальные значения в данных?
3. Для каждого признака по одному случайным образом переставьте значения этого признака во всех точках данных между максимальным и минимальным значениями, возможными для этого признака.
4. Затем, изменив только один признак, найдите ошибку out of bag.
5. Вычислите разницу между новой ошибкой out of bag и базовой ошибкой out of bag. Новая ошибка out of bag почти наверняка будет иметь большую погрешность, чем базовое значение.
6. Верните перестановочные признаки к их исходным значениям и начните процесс снова, изменив новый признак.
7. Признаки, которые имеют наибольшее увеличение ошибки при перестановки, являются наиболее важными. Характеристики с наименьшим Наименее важными являются признаки с наименьшим увеличением ошибки.

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

Импортация деталей — общие сведения

Независимо от того, какой метод используется для получения данных об импорте характеристик, есть некоторые общие сведения, которые полезно знать:

1. Показатели импорта признаков почти всегда представляются в виде нормализованных значений. То есть на самом деле вы видите, насколько важна та или иная особенность по отношению к другим особенностям.
2. Как правило, чем больше функций, тем менее важной будет любая отдельная функция.
3. Чем сильнее коррелируют признаки с другими признаками, тем больше они разделит их важность. Например, если вы пытаетесь предсказать зарплату человека. зарплаты, то вполне возможно, что его рост может быть важным признаком. (т. е. возможно, высокие люди зарабатывают больше денег). Однако если у вас также есть такие характеристики такие как размер обуви и размер брюк, которые они носят, которые которые сильно коррелируют с ростом, то важность признака роста будет размыта, поскольку часть сегментации данных будет производиться по другие похожие признаки.

Что делать с именованными категориями, а не с числами

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

Самый простой способ преобразовать категории в числовые значения — просто присвоить номер для каждого элемента в категории. Например, животные с мехом получают номер 1, животные с перьями — номер 2, а чешуйчатые — номер 3. Этот будет работать хорошо, и алгоритм Random Forest сможет легко отделить одну из категорий от остальных.

Однако иногда категории можно напрямую преобразовать в числа.

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

Ограничения случайного леса

Классификатор Random Forest и рассмотренные ранее классификаторы Decision Tree не выполняют экстраполяцию. Например, если у вас есть точки данных, которые показывают ваш заработок в зависимости от отработанных часов:

• 1 час вы зарабатываете $ 10
• 2 часа — 20 долларов
• 3 часа — 30 долларов.

Если вы используете алгоритм классификатора random forest, чтобы попытаться оценить, сколько вы заработаете после 10 часов работы, вы не получите ожидаемые 100 долларов. Скорее всего, он даст вам 30 долларов, исходя из того, где он установит порог.

Заключительные советы и резюме по Random Forest

Вот несколько заключительных советов, как лучше использовать Random Forest:

• Используйте кросс-валидацию или ошибку вне мешка, чтобы судить о том, насколько хорошо он подходит.
• Улучшение характеристик данных — самый мощный инструмент для улучшения результатов.
  Они превосходят все остальные.
• Используйте важность признаков, чтобы определить, на что потратить время.
• Увеличивайте количество деревьев до тех пор, пока польза не снизится.
• Задайте случайное зерно перед генерацией Random Forest, чтобы каждый раз получать воспроизводимые результаты.
• Используйте predict() или predict_proba() там, где это имеет смысл, в зависимости от того, нужен ли вам только наиболее вероятный ответ или вы хотите знать вероятность всех ответов.
• Исследуйте ограничение ветвления либо по:

— Количество разветвлений
— Количество точек данных в ветви для разделения
— Количество точек данных в конечных результирующих листьях

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

Если вы найдете ошибки и упущения:

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

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

Другие научные статьи по ИИ

Если вам понравилась эта статья, возможно, вам будет интересно ознакомиться с другими научными статьями, такими как:

Machine Learning With Boosting — Random Forests используют деревья решений, которые создаются параллельно, а затем усредняются. Деревья с градиентным бустингом также используют деревья решений, но они создаются последовательно, и каждое из них исправляет ошибки предыдущих деревьев. Бустинг стал одним из самых распространенных алгоритмов в соревнованиях по науке о данных, поэтому о нем стоит знать.

Linear Regression and Correlation — в этой книге рассказывается о том, как проводить регрессионный анализ. При этом она демонстрирует, что означает корреляция. В ней также показано, как проводить множественный регрессионный анализ, причем совершенно понятным способом.

Hypothesis Testing — A Visual Introduction To Statistical Significance — Проверка гипотез — это то, как определить, является ли что-то статистически значимым, или это, скорее всего, просто случайность. Эта книга демонстрирует различные типы проверки гипотез и как проводить каждую из ни