МАШИННОЕ ОБУЧЕНИЕ НА PYTHON ПРИМЕРЫ

Предисловие

Мы живем посреди потока данных. По последним оценкам, ежедневно генерируется 2,5 квинтилианских ( ) байта данных. Это настолько большой объем данных, что более 90 процентов информации, которую мы храним сегодня, было создано только за последнее десятилетие. К сожалению, большая часть этой информации не может быть использована людьми. Либо данные выходят за пределы возможностей стандартных аналитических методов, либо они просто слишком обширны, чтобы наш ограниченный разум мог их даже осмыслить.

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

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

1 Введение

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

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

• Общие понятия машинного обучения
• Три типа обучения и базовая терминология
• Основы успешного проектирования систем машинного обучения
• Установка и настройка Python для анализа данных и машинного обучения

1.1 Создание интеллектуальных машин для преобразования данных в знания

1.2 Три разных типа машинного обучения

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

1.2.1 Прогнозирование будущего с помощью контролируемого обучения

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

1.2.1.1 Классификация для прогнозирования меток классов

1.2.1.2 Регрессия для прогнозирования непрерывных результатов

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

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

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

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

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

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

1.2.3 Обнаружение скрытых структур с помощью обучения без учителя

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

1.2.3.1 Поиск подгрупп с кластеризацией

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

1.2.3.2 Уменьшение размерности при сжатии данных

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

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

1.3 Введение в основную терминологию и обозначения

Набор данных Iris, состоящий из 150 образцов и 4 признаков, затем можно записать в виде матрицы 150 × 4:

1.4 Дорожная карта построения систем машинного обучения

1.4.1 Предварительная обработка – приведение данных в форму

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

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

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

1.4.2 Обучение и выбор прогнозной модели

Как мы увидим в последующих разделах, для решения различных проблемных задач было разработано множество различных алгоритмов машинного обучения. Важный момент, который можно резюмировать из знаменитой теоремы Дэвида Вулперта «Нет бесплатных обедов» .
в том, что мы не можем получить обучение «бесплатно» ( Отсутствие априорных различий между алгоритмами обучения
, Д. Х. Вулперт, 1996; Теоремы об отсутствии бесплатного обеда для оптимизации
, DH Wolpert и WG Macready, 1997). Интуитивно мы можем связать это понятие с популярной поговоркой: « Полагаю, это заманчиво, если единственный инструмент, который у вас есть, — это молоток, обращаться со всем, как если бы это был гвоздь
(Авраам Маслоу, 1966). Например, каждому алгоритму классификации присущи свои предвзятости, и ни одна модель классификации не будет иметь превосходства, если мы не сделаем никаких предположений относительно задачи. Поэтому на практике важно сравнить хотя бы несколько различных алгоритмов, чтобы обучить их и выбрать наиболее эффективную модель. Но прежде чем мы сможем сравнить разные модели, нам сначала нужно определиться с метрикой для измерения производительности. Одним из часто используемых показателей является точность классификации, которая определяется как доля правильно классифицированных экземпляров.

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

1.4.3 Оценка моделей и прогнозирование невидимых экземпляров данных

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

1.5 Использование Python для машинного обучения

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

Хотя производительность интерпретируемых языков, таких как Python, для задач с интенсивными вычислениями уступает языкам программирования более низкого уровня, библиотеки расширений, такие как NumPy
и SciPy
были разработаны на основе нижнего уровня Фортрана
и С
реализации для быстрых и векторизованных операций с многомерными массивами.

Для задач программирования машинного обучения мы в основном будем обращаться к scikit-learn
библиотека, которая на сегодняшний день является одной из самых популярных и доступных библиотек машинного обучения с открытым исходным кодом.

2 алгоритма обучения машинного обучения для классификации

В этом разделе мы будем использовать один из первых алгоритмически описанных алгоритмов машинного обучения для классификации, перцептрон
и адаптивные линейные *нейроны
. Мы начнем с пошаговой реализации перцептрона на Python и обучения его классификации различных видов цветов в наборе данных Iris. Это поможет нам понять концепцию алгоритмов машинного обучения для классификации и то, как их можно эффективно реализовать в Python. Обсуждение основ оптимизации с использованием адаптивных линейных нейронов затем заложит основу для использования более мощных классификаторов с помощью библиотеки машинного обучения scikit-learn в разделе 3.

• Формирование интуиции для алгоритмов машинного обучения
• Использование pandas, NumPy и matplotlib для чтения, обработки и визуализации данных
• Реализация алгоритмов линейной классификации на Python

2.1 Искусственные нейроны – краткий обзор ранней истории машинного обучения

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

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

Теперь, если активация конкретного образца, то есть выходной сигнал, превышает определенный порог, мы прогнозируем класс и класс, в противном случае в алгоритме перцептрона функция активации представляет собой простую ) функция единичного шага
, которую иногда также называют ступенчатой ​​функцией Хевисайда
:

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

1. Инициализируйте веса 0 или небольшими случайными числами.
2. Для каждой обучающей выборки выполните следующие шаги:
   

   1. Вычислите выходное значение.
   2. Обновите веса.

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

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

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

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

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

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

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

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

Теперь, прежде чем мы перейдем к реализации в следующем разделе, давайте подытожим то, что мы только что узнали, на простом рисунке, иллюстрирующем общую концепцию перцептрона:

На предыдущем рисунке показано, как персептрон получает входные данные выборки и объединяет их с весами для вычисления чистого входного значения. Чистый входной сигнал затем передается функции активации (здесь: функция единичного шага), которая генерирует двоичный выходной сигнал -1 или +1 — прогнозируемую метку класса выборки. На этапе обучения эти выходные данные используются для расчета ошибки прогноза и обновления весов.

2.2 Реализация алгоритма обучения перцептрона на Python

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

    

 
    """Perceptron classifier.

    Parameters
    ------------
    eta:float
    Learning rate (between 0.0 and 1.0)
    n_iter:int
    Passes over the training dataset.

    Attributes
    -------------
    w_: 1d-array
    Weights after fitting.
    errors_: list
    Numebr of misclassifications in every epoch.

    """

       
          
          

       
        

             # Add w_0
          

           
              
                 
                      
                    
                  
                    
            
         

      
        """Calculate net input"""
            

      
        """Return class label after unit step"""
              #analoge ? : in C++

  

Используя эту реализацию перцептрона, мы теперь можем инициализировать новый Perceptron
объекты с заданной скоростью обучения eta
и n_iter
, то есть количество эпох (проходит по обучающему набору). Через fit
метод, мы инициализируем веса в self.w_
к нулевому вектору, где обозначает количество измерений (признаков) в наборе данных, куда мы добавляем 1 для нулевого веса (то есть порога).

После инициализации весов, fit
Метод циклически перебирает все отдельные выборки в обучающем наборе и обновляет веса в соответствии с правилом обучения персептрона, которое мы обсуждали в предыдущем разделе. Метки классов прогнозируются по predict
метод, который также называется в fit
метод для прогнозирования метки класса для обновления веса, но прогноз также можно использовать для прогнозирования меток класса новых данных после того, как мы подогнали нашу модель. Кроме того, мы также собираем количество ошибочных классификаций в каждой эпохе в списке self.errors_.
чтобы позже мы могли проанализировать, насколько хорошо работал наш персептрон во время обучения. np.dot
функция, которая используется в net_input
Метод просто вычисляет скалярное произведение вектора.

2.2.1 Обучение модели перцептрона на наборе данных Iris

Чтобы протестировать нашу реализацию перцептрона, мы загрузим два класса цветов Setosa
и Версиколор
из набора данных Iris. Хотя правило перцептрона не ограничивается двумя измерениями, мы будем рассматривать только два признака : длину чашелистика .
и длина лепестка
для целей визуализации. Кроме того, мы выбрали только два класса цветов Setosa
и Versicolor
по практическим соображениям. Однако алгоритм перцептрона можно расширить до многоклассовой классификации, например, с помощью «Один против всех»

техника.

Во-первых, мы будем использовать библиотеку pandas для загрузки набора данных Iris непосредственно из UCI ​​
Репозиторий машинного обучения в объект DataFrame и распечатайте последние пять строк с помощью tail
метод проверки правильности загрузки данных:

Затем мы извлекаем первые 100 меток классов, которые соответствуют 50 Iris-Setosa
и 50 Ирис-Versicolor
цветы соответственно и преобразуем метки классов в две метки целочисленных классов 1
( Разноцветный
) и -1
( Сетоза
), который мы присваиваем вектору y
где значения
метод панды DataFrame
дает соответствующее представление NumPy. Аналогичным образом мы извлекаем первый столбец признаков ( длина чашелистика
) и третий столбец характеристик ( длина лепестка
) этих 100 обучающих выборок и назначаем их матрице признаков, которую мы можем визуализировать с помощью двумерной диаграммы рассеяния:

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

    
   
   
   

   
   
      
    

       
 

       

'Number of misclassifications'


  

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

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

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

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

2.3 Адаптивные линейные нейроны и конвергенция обучения

Ключевое отличие правила Адалины (также известного как Уидроу-Хоффа
Правило) и персептрона Розенблатта заключается в том, что веса обновляются на основе линейной функции активации, а не функции единичного шага, как в перцептроне. В Adaline эта линейная функция активации является просто тождественной функцией чистого входа, так что
.

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

2.3.1 Минимизация функций стоимости с градиентным спуском

Одним из ключевых компонентов алгоритмов контролируемого машинного обучения является определение целевой функции, которая должна быть оптимизирована в процессе обучения. Эта целевая функция часто является функцией затрат, которую мы хотим минимизировать. В случае с Adaline мы можем определить функцию стоимости J, чтобы узнать веса как сумму
Квадраты ошибок (SSE)
между рассчитанным результатом и истинной меткой класса

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

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

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

, чтобы мы могли записать обновление веса как:

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

Хотя правило обучения Adaline выглядит идентично правилу персептрона, with — это действительное число, а не целочисленная метка класса. Кроме того, обновление весов рассчитывается на основе всех выборок в обучающем наборе (вместо постепенного обновления весов после каждой выборки), поэтому этот подход также называется «пакетным» градиентным спуском.

2.3.2 Реализация адаптивного линейного нейрона в Python

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

«»»Классификатор перцептрона.

Параметры
————
эта: плавать
Скорость обучения (от 0,0 до 1,0)
n_iter:int
Передаёт набор обучающих данных.

Атрибуты
————-
w_: 1d-массив
Вес после примерки.
стоимость_: список
Количество неправильных классификаций в каждую эпоху.

«»»

# Добавить w_0

«»»Рассчитать чистый ввод»»»

«»»Вычислить линейную активацию»»»

«»»Вернуть метку класса после шага единицы»»»

#аналог ? : на C++

Вместо обновления весов после оценки каждой отдельной обучающей выборки, как в персептроне, мы вычисляем градиент на основе всего набора обучающих данных с помощью self.eta * errors.sum()
для нулевого веса и переходного отверстия self.eta * X.T.dot(errors)
для весов от 1 до где X.T.dot(errors)
представляет собой матрично-векторное умножение
между нашей матрицей признаков и вектором ошибок. Как и в предыдущей реализации перцептрона, мы собираем значения стоимости в список self.cost_.
чтобы проверить, сходился ли алгоритм после обучения.

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

    
   
   
   

   
   
      
    

 
      
       
              
     
   
 
   
 

      
     


'Adaline - Learning rate 0.01'
     


'Adaline - Learning rate 0.0001'


  

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

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

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

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

«Адалин — Скорость обучения 0,01»

«Адалин — Градиентный спуск»

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

2.3.3 Крупномасштабное машинное обучение и стохастический градиентный спуск

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

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

Мы обновляем веса постепенно для каждой обучающей выборки:

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

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

.

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

Компромисс между пакетным градиентным спуском и стохастическим градиентом.
спуск — это так называемое мини-пакетное обучение. Мини-пакетное обучение может быть
понимается как применение пакетного градиентного спуска к меньшим подмножествам
данные обучения — например, 50 выборок за раз. Преимущество
по пакетному градиентному спуску заключается в том, что сходимость достигается быстрее
мини-партиями из-за более частых обновлений веса.
Кроме того, мини-пакетное обучение позволяет нам заменить цикл for
по обучающим выборкам в Стохастический градиентный спуск (SGD)
к
векторизованные операции, которые могут еще больше улучшить вычислительные
эффективность нашего алгоритма обучения.

Поскольку мы уже реализовали правило обучения Adaline с использованием градиентного спуска, нам нужно всего лишь внести несколько корректировок, чтобы изменить алгоритм обучения для обновления весов с помощью стохастического градиентного спуска. Внутри fit
метод, теперь мы будем обновлять веса после каждой обучающей выборки. Кроме того, мы реализуем дополнительный partial_fit
метод, не требующий повторной инициализации весов, для онлайн-обучения. Чтобы проверить, сходится ли наш алгоритм после обучения, мы рассчитаем стоимость как среднюю стоимость обучающих выборок в каждую эпоху. Кроме того, мы добавим опцию к shuffle
данные обучения перед каждой эпохой, чтобы избежать циклов при оптимизации функции стоимости; через random_state
параметр, мы разрешаем указание случайного начального числа для согласованности:

«»»Классификатор перцептрона.

Параметры
————
эта: плавать
Скорость обучения (от 0,0 до 1,0)
n_iter:int
Передаёт набор обучающих данных.

Атрибуты
————-
w_: 1d-массив
Вес после примерки.
стоимость_: список
Количество неправильных классификаций в каждую эпоху.
перемешивание: bool (по умолчанию: True)
Перетасовывает данные обучения каждую эпоху
если True, чтобы предотвратить циклы.
Случайное_состояние: int (по умолчанию: нет)
Установить случайное состояние для перетасовки
и инициализация весов

«»»

«»»Подбор тренировочных данных без повторной инициализации весов.»»»

«»»Перемешать данные обучения»»»

«»»Инициализировать веса нулями»»»

«»»Примените правило обучения Adaline для обновления весов»»»

«»»Рассчитать чистый ввод»»»

«»»Вычислить линейную активацию»»»

«»»Вернуть метку класса после шага единицы»»»

#аналог ? : на C++

Затем мы можем использовать fit
метод тренировки AdalineSGD
классификатор и воспользуйтесь нашим plot_decision_regions
чтобы построить результаты нашего обучения:

«Адалин — Скорость обучения 0,01»

«Адалин — стохастический градиентный спуск»