Основы алгоритмов машинного обучения — с кодом Python и R

Беспилотные автомобили и роботы Google находятся под большим давлением, но реальное будущее компании — это машинное обучение, технология, которая делает компьютеры умнее и индивидуальнее. – Эрик Шмидт (председатель Google)

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

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

Кто может извлечь наибольшую пользу из этого руководства?

То, что я даю сегодня, вероятно, является самым ценным руководством, которое я когда-либо создавал.

Идея создания этого руководства состоит в том, чтобы упростить путешествие начинающих специалистов по данным и энтузиастов машинного обучения по всему миру. С помощью этого руководства я дам вам возможность изучить проблемы машинного обучения и извлечь пользу из опыта. Я хорошо разбираюсь в различных алгоритмах машинного обучения и запускаю их в коде R & Python. Этого должно быть достаточно, чтобы вы начали.

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

Вообще говоря, существует 3 типа алгоритмов машинного обучения.

1. Контролируемое обучение

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

2. Неконтролируемое обучение

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

3. Обучение с подкреплением:

Как это работает: с помощью этого алгоритма машины обучаются принимать конкретные решения.

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

Пример обучения с подкреплением: Марковский процесс принятия решений

Список распространенных алгоритмов машинного обучения

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

Линейная регрессия
логарифмическая регрессия шансов
Древо решений
SVM
Наивный Байес
KNN
кластеризация
случайный лес
алгоритм уменьшения размерности
Алгоритм повышения градиента

GBM (Машина повышения градиента)

XGBOST

Легкий ГБМ

способствовать росту

1. Линейная регрессия

Он используется для оценки фактической стоимости (стоимость дома, номер телефона, общий объем продаж и т. д.) на основе непрерывных переменных. Здесь мы строим оптимальную линию, чтобы установить связь между независимой переменной и зависимой переменной. Эта линия наилучшего соответствия называется линией регрессии и представлена линейным уравнением y=a*x+b.

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

В этом уравнении:

Y - зависимая переменная

а - наклон

Х - независимая переменная

б - перехват

Эти коэффициенты a и b получены на основе минимизации суммы квадратов разностей расстояний между точками данных и линией регрессии.

См. пример ниже. Здесь мы определили, что линия наилучшего соответствия имеет линейное уравнение y = 0,2811x + 13,9. Теперь, используя это уравнение, мы можем узнать вес и узнать рост человека.

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

Код Python

#Import Library
#Import other necessary libraries like pandas, numpy...
from sklearn import linear_model
#Load Train and Test datasets
#Identify feature and response variable(s) and values must be numeric and numpy arrays
x_train=input_variables_values_training_datasets
y_train=target_variables_values_training_datasets
x_test=input_variables_values_test_datasets
# Create linear regression object
linear = linear_model.LinearRegression()
# Train the model using the training sets and check score
linear.fit(x_train, y_train)
linear.score(x_train, y_train)
#Equation coefficient and Intercept
print('Coefficient: \n', linear.coef_)
print('Intercept: \n', linear.intercept_)
#Predict Output
predicted= linear.predict(x_test)

Код языка R

#Load Train and Test datasets
#Identify feature and response variable(s) and values must be numeric and numpy arrays
x_train <- input_variables_values_training_datasets
y_train <- target_variables_values_training_datasets
x_test <- input_variables_values_test_datasets
x <- cbind(x_train,y_train)
# Train the model using the training sets and check score
linear <- lm(y_train ~ ., data = x)
summary(linear)
#Predict Output
predicted= predict(linear,x_test)

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

Пусть вас не смущает его название! Это алгоритм классификации, а не регрессии. Он используется для оценки дискретных значений (двоичных значений, таких как 0/1, да/нет, правда/ложь) на основе заданного набора независимых переменных. Проще говоря, он предсказывает вероятность события, подгоняя данные к логит-функции. Следовательно, он также известен как логит-регрессия. Поскольку он предсказывает вероятности, его выходное значение находится в диапазоне от 0 до 1 (как и ожидалось).

Опять же, давайте разберемся с этим на простом примере.

Предположим, ваш друг дает вам решить головоломку. Есть только два финальных сценария — либо ты решишь это, либо нет. А теперь представьте, что вы решаете различные головоломки/викторины, чтобы понять, в каких предметах вы разбираетесь. Результаты этого исследования таковы — если вы получаете задачу 10-го класса на основе тригонометрии, у вас есть 70% шансов ее решить. С другой стороны, если это вопрос по истории пятого уровня, вероятность получить ответ составляет всего 30%. Это то, что дает вам логистическая регрессия.

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

odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence
ln(odds) = ln(p/(1-p))
logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk

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

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

Код Python

#Import Library
from sklearn.linear_model import LogisticRegression
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create logistic regression object
model = LogisticRegression()
# Train the model using the training sets and check score
model.fit(X, y)
model.score(X, y)
#Equation coefficient and Intercept
print('Coefficient: \n', model.coef_)
print('Intercept: \n', model.intercept_)
#Predict Output
predicted= model.predict(x_test)

Код языка R

x <- cbind(x_train,y_train)
# Train the model using the training sets and check score
logistic <- glm(y_train ~ ., data = x,family='binomial')
summary(logistic)
#Predict Output
predicted= predict(logistic,x_test)

Кроме того, чтобы улучшить модель, можно попробовать множество различных шагов:

Включить интерактивные элементы
удалить функции
метод регуляризации
Используйте нелинейную модель

3. Дерево решений

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

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

Лучший способ понять, как работают деревья решений, — сыграть в Jazzball, классическую игру Microsoft (см. ниже). По сути, у вас есть комната с движущимися стенами, и вам нужно создать стены так, чтобы шары были очищены от максимальной площади.

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

Дальнейшее чтение:Упрощенная версия алгоритма дерева решений

Код Python

#Import Library
#Import other necessary libraries like pandas, numpy...
from sklearn import tree
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create tree object 
model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini  
# model = tree.DecisionTreeRegressor() for regression
# Train the model using the training sets and check score
model.fit(X, y)
model.score(X, y)
#Predict Output
predicted= model.predict(x_test)

Код языка R

library(rpart)
x <- cbind(x_train,y_train)
# grow tree 
fit <- rpart(y_train ~ ., data = x,method="class")
summary(fit)
#Predict Output 
predicted= predict(fit,x_test)

4. Машина опорных векторов (SVM)

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

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

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

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

Более:Упрощенная версия машины опорных векторов

Думайте об этом алгоритме как об игре в джазбол в n-мерном пространстве, где корректировки в игре следующие:

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

Код Python

#Import Library
from sklearn import svm
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create SVM classification object 
model = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.
# Train the model using the training sets and check score
model.fit(X, y)
model.score(X, y)
#Predict Output
predicted= model.predict(x_test)

Код языка R

library(e1071)
x <- cbind(x_train,y_train)
# Fitting model
fit <-svm(y_train ~ ., data = x)
summary(fit)
#Predict Output 
predicted= predict(fit,x_test)

5. Наивный Байес

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

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

Теорема Байеса позволяет вычислить апостериорную вероятность p(C*x) P(C), P(X) и P(X,C). См. уравнение ниже:

это здесь,

P(C x) — апостериорная вероятность данного класса (цели) (атрибутов).
P(C) — априорная вероятность класса.
P(x,c) — вероятность предсказания данного класса.
P(x) — априорная вероятность предиктора.

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

Шаг 1. Преобразование набора данных в таблицу частот

Шаг 2: Создайте таблицу правдоподобия, найдя вероятность сомнительной вероятности = 0,29 и вероятность 0,64.

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

Вопрос: Правда ли, что игроки захотят играть, если будет солнечная погода?

Мы можем решить ее, используя описанный выше метод, поэтому P(Да | Солнечно) = P( Солнечно | Да) * P(Да) / P (Солнечно)

Здесь мы имеем P(Солнечно | Да) = 3/9 = 0,33, P(Солнечно) = 5/14 = 0,36, P(Да) = 9/14 = 0,64, что дает P(Да | Солнечно) = 0,33 * 0,64. / 0,36 = 0,60, с высокой вероятностью.

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

Код Python

#Import Library
from sklearn.naive_bayes import GaussianNB
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)

Код языка R

library(e1071)
x <- cbind(x_train,y_train)
# Fitting model
fit <-naiveBayes(y_train ~ ., data = x)
summary(fit)
#Predict Output 
predicted= predict(fit,x_test)

6. KNN (k-ближайших соседей)

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

Эти функции расстояния могут быть евклидовыми, манхэттенскими, расстояниями Минковского и Хэмминга. Первые три функции предназначены для непрерывных функций, а четвертая (Хемминга) — для категориальных переменных. Если k=1, случай просто присваивается классу ближайшего соседа. Иногда выбор K при моделировании KNN является проблемой.

Более:Представляем K-ближайших соседей: упрощенный.

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

Что следует учитывать перед выбором KNN:

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

Код Python

#Import Library
from sklearn.neighbors import KNeighborsClassifier
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create KNeighbors classifier object model 
KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)

R-код

library(knn)
x <- cbind(x_train,y_train)
# Fitting model
fit <-knn(y_train ~ ., data = x,k=5)
summary(fit)
#Predict Output 
predicted= predict(fit,x_test)

7. K-Means (алгоритм K-средних)

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

Помните, как вычисляли формы по чернильным пятнам? K означает какую-то подобную деятельность. Вы смотрите на форму и рассеиваетесь, чтобы понять, сколько существует разных кластеров/популяций!

Как k-средние формируют кластеры:

k-means выбирает K точек для каждого кластера, называемого центроидами.
Каждая точка данных образует кластер с ближайшим центроидом, кластер K.
Найдите центр тяжести каждого кластера на основе существующего членства в кластере. Здесь у нас есть новые центроиды.
Когда у нас есть новые центроиды, повторите шаги 2 и 3, чтобы найти ближайшее расстояние для каждой точки данных от новых центроидов и связать с новыми K кластерами. Этот процесс повторяется до тех пор, пока не произойдет сходимость, т. е. центр тяжести не изменится.

Как определить значение К:

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

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

Код Python

#Import Library
from sklearn.cluster import KMeans
#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset
# Create KNeighbors classifier object model 
k_means = KMeans(n_clusters=3, random_state=0)
# Train the model using the training sets and check score
model.fit(X)
#Predict Output
predicted= model.predict(x_test)

Код языка R

library(cluster)
fit <- kmeans(X, 3) # 5 cluster solution

8. Случайный лес

Случайный лес — это торговая марка ансамбля деревьев решений. В случайных лесах мы собираем деревья решений (называемые «лесами»). Чтобы классифицировать новые объекты на основе атрибутов, каждое дерево дает классификацию, и мы называем дерево «голосованием» за этот класс. Лес выбирает классификацию с наибольшим количеством голосов (из всех деревьев в лесу).

Каждое дерево сажают и выращивают следующим образом:

Если число случаев в обучающем наборе равно N, N случаев выбираются случайным образом, но заменяются. Этот образец будет учебным пособием по выращиванию деревьев.
Если имеется M входных переменных, задайте число m > M так, чтобы в каждом узле m переменных выбирались случайным образом из M, и для разделения узла использовалось наилучшее разделение по этим m. В процессе роста леса величина М остается неизменной.
Каждое дерево было выращено до максимально возможного размера без обрезки.

Код Python

#Import Library
from sklearn.ensemble import RandomForestClassifier
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create Random Forest object
model= RandomForestClassifier()
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)

Код языка R

library(randomForest)
x <- cbind(x_train,y_train)
# Fitting model
fit <- randomForest(Species ~ ., x,ntree=500)
summary(fit)
#Predict Output 
predicted= predict(fit,x_test)

9. Алгоритм уменьшения размерности

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

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

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

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

Код Python

#Import Library
from sklearn import decomposition
#Assumed you have training and test data set as train and test
# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)
# For Factor analysis
#fa= decomposition.FactorAnalysis()
# Reduced the dimension of training dataset using PCA
train_reduced = pca.fit_transform(train)
#Reduced the dimension of test dataset
test_reduced = pca.transform(test)
#For more detail on this, please refer  this link.

Код языка R

library(stats)
pca <- princomp(train, cor = TRUE)
train_reduced  <- predict(pca,train)
test_reduced  <- predict(pca,test)

10. Алгоритм повышения градиента

10.1 GBM

GBM (Gradient Boosting Machine) — это алгоритм повышения, используемый при обработке больших объемов данных, чтобы делать прогнозы с высокими прогнозами. Повышение на самом деле представляет собой набор алгоритмов обучения, которые объединяют прогнозы от нескольких базовых оценок, чтобы повысить надежность по сравнению с одной оценкой. Он объединяет несколько слабых или средних предикторов в один сильный предиктор. Эти алгоритмы повышения всегда хорошо показывают себя на соревнованиях по науке о данных, таких как Kaggle, AV Hackthon, CrowdAnalytix и т. д.

Дальнейшее чтение:Узнайте больше об алгоритмах повышения

Код Python

#Import Library
from sklearn.ensemble import GradientBoostingClassifier
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create Gradient Boosting Classifier object
model= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)

Код языка R

library(caret)
x <- cbind(x_train,y_train)
# Fitting model
fitControl <- trainControl( method = "repeatedcv", number = 4, repeats = 4)
fit <- train(y ~ ., data = x, method = "gbm", trControl = fitControl,verbose = FALSE)
predicted= predict(fit,x_test,type= "prob")[,2]

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

10.2 XGBOST

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

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

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

Одна из самых интересных особенностей XGBoost заключается в том, что он также известен как метод формального повышения. Это помогает уменьшить переоснащение при моделировании и обеспечивает расширенную поддержку различных языков, включая Scala, Java, R, Python, Julia и C++.

Поддерживается распределенное и расширенное обучение, включая множество компьютеров из кластеров GCE, AWS, Azure и Yarn. XGBoost также можно интегрировать со Spark, Flink и другими облачными системами потоковой передачи данных со встроенной перекрестной проверкой на каждой итерации процесса повышения.

Чтобы узнать больше о XGBoost и настройке параметров, посетитеwww..ticsvidhya.com/blog/2016/0….

Код Python:

from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
X = dataset[:,0:10]
Y = dataset[:,10:]
seed = 1

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=seed)

model = XGBClassifier()

model.fit(X_train, y_train)

#Make predictions for test data
y_pred = model.predict(X_test)

Код языка R

require(caret)

x <- cbind(x_train,y_train)

# Fitting model

TrainControl <- trainControl( method = "repeatedcv", number = 10, repeats = 4)

model<- train(y ~ ., data = x, method = "xgbLinear", trControl = TrainControl,verbose = FALSE)

OR 

model<- train(y ~ ., data = x, method = "xgbTree", trControl = TrainControl,verbose = FALSE)

predicted <- predict(model, x_test)

10.3 LightGBM

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

Более быстрое обучение и более высокая эффективность
низкое использование памяти
лучшая точность
Поддержка параллельного обучения GPU
Возможность обработки больших объемов данных

Этот фреймворк представляет собой быструю и эффективную фреймворк повышения градиента, основанный на алгоритме дерева решений для задач машинного обучения, таких как сортировка и классификация. Он был разработан в рамках проекта Microsoft Distributed Machine Learning Toolkit.

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

Кроме того, он очень быстрый, отсюда и слово «легкий».

См. эту статью, чтобы узнать больше о LightGBM:www..ticsvidhya.com/blog/2017/0…

Код Python

data = np.random.rand(500, 10) # 500 entities, each contains 10 features
label = np.random.randint(2, size=500) # binary target

train_data = lgb.Dataset(data, label=label)
test_data = train_data.create_valid('test.svm')

param = {'num_leaves':31, 'num_trees':100, 'objective':'binary'}
param['metric'] = 'auc'

num_round = 10
bst = lgb.train(param, train_data, num_round, valid_sets=[test_data])

bst.save_model('model.txt')

# 7 entities, each contains 10 features
data = np.random.rand(7, 10)
ypred = bst.predict(data)

Код языка R

library(RLightGBM)
data(example.binary)
#Parameters

num_iterations <- 100
config <- list(objective = "binary",  metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)

#Create data handle and booster
handle.data <- lgbm.data.create(x)

lgbm.data.setField(handle.data, "label", y)

handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))

#Train for num_iterations iterations and eval every 5 steps

lgbm.booster.train(handle.booster, num_iterations, 5)

#Predict
pred <- lgbm.booster.predict(handle.booster, x.test)

#Test accuracy
sum(y.test == (y.pred > 0.5)) / length(y.test)

#Save model (can be loaded again via lgbm.booster.load(filename))
lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")

Если вы знакомы с пакетом расширений Caret в R, это еще один способ реализации LightGBM.

require(caret)
require(RLightGBM)
data(iris)

model <-caretModel.LGBM()

fit <- train(Species ~ ., data = iris, method=model, verbosity = 0)
print(fit)
y.pred <- predict(fit, iris[,1:4])

library(Matrix)
model.sparse <- caretModel.LGBM.sparse()

#Generate a sparse matrix
mat <- Matrix(as.matrix(iris[,1:4]), sparse = T)
fit <- train(data.frame(idx = 1:nrow(iris)), iris$Species, method = model.sparse, matrix = mat, verbosity = 0)
print(fit)

10.4 CatBoost

CatBoost — это алгоритм машинного обучения с открытым исходным кодом от Яндекса, крупнейшей поисковой компании в России. Его можно легко комбинировать с фреймворками глубокого обучения, такими как Tensorflow от Google и Core ML от Apple.

Лучшее в CatBoost то, что он не требует обширного обучения данным, как другие модели машинного обучения, и может обрабатывать различные форматы данных, не нарушая его надежности.

Всегда проверяйте отсутствующие данные перед выполнением.

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

Узнайте больше о Catboost из этой статьи:Ву Ву-Дише SV ID HY A.com/B LG/2017/08…

Код Python

import pandas as pd
import numpy as np

from catboost import CatBoostRegressor

#Read training and testing files
train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")

#Imputing missing values for both train and test
train.fillna(-999, inplace=True)
test.fillna(-999,inplace=True)

#Creating a training set for modeling and validation set to check model performance
X = train.drop(['Item_Outlet_Sales'], axis=1)
y = train.Item_Outlet_Sales

from sklearn.model_selection import train_test_split

X_train, X_validation, y_train, y_validation = train_test_split(X, y, train_size=0.7, random_state=1234)
categorical_features_indices = np.where(X.dtypes != np.float)[0]

#importing library and building model
from catboost import CatBoostRegressormodel=CatBoostRegressor(iterations=50, depth=3, learning_rate=0.1, loss_function='RMSE')

model.fit(X_train, y_train,cat_features=categorical_features_indices,eval_set=(X_validation, y_validation),plot=True)

submission = pd.DataFrame()

submission['Item_Identifier'] = test['Item_Identifier']
submission['Outlet_Identifier'] = test['Outlet_Identifier']
submission['Item_Outlet_Sales'] = model.predict(test)

Код языка R

set.seed(1)

require(titanic)

require(caret)

require(catboost)

tt <- titanic::titanic_train[complete.cases(titanic::titanic_train),]

data <- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)

drop_columns = c("PassengerId", "Survived", "Name", "Ticket", "Cabin")

x <- data[,!(names(data) %in% drop_columns)]y <- data[,c("Survived")]

fit_control <- trainControl(method = "cv", number = 4,classProbs = TRUE)

grid <- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3,            rsm = 0.95, border_count = 64)

report <- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)

print(report)

importance <- varImp(report, scale = FALSE)

print(importance)

резюме

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

Оригинальная ссылка:Essentials of Machine Learning Algorithms (with Python and R Codes)

перевести:Сюй Дабай