Scikit-learn - это библиотека на Python, которая предоставляет множество алгоритмов неконтролируемого и контролируемого обучения. Он построен на некоторых технологиях, с которыми вы, возможно, уже знакомы, например, NumPy, pandas и Matplotlib!
Функции, предоставляемые scikit-learn, включают:
- Регрессия, включая линейную и логистическую регрессию
- Классификация, включая K-ближайших соседей
- Кластеризация, включая K-средние и K-средние ++
- Выбор модели
- Предварительная обработка, включая минимальную и максимальную нормализацию
В этой статье я объясню все алгоритмы машинного обучения с помощью scikit-learn, которые вам необходимо изучить как специалист по анализу данных.
Начнем с импорта библиотек:
%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.linear_model import LinearRegression
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
from scipy import stats
import pylab as plОценщик
Для объекта оценки scikit-learn с именем model доступны следующие методы:
Доступно во всех оценщиках
- model.fit (): соответствие тренировочным данным. Для приложений контролируемого обучения это принимает два аргумента: данные X и метки y (например, model.fit (X, y)). Для приложений неконтролируемого обучения это принимает только один аргумент, данные X (например, model.fit (X)).
Доступно в контролируемых оценщиках
- model.predict (): для обученной модели спрогнозируйте метку нового набора данных. Этот метод принимает один аргумент, новые данные X_new (например, model.predict (X_new)), и возвращает изученную метку для каждого объекта в массиве.
- model.predict_proba (): для задач классификации некоторые оценщики также предоставляют этот метод, который возвращает вероятность того, что новое наблюдение имеет каждую категориальную метку. В этом случае метка с наибольшей вероятностью возвращается с помощью model.predict (). model.score (): для задач классификации или регрессии большинство (все?) оценщиков реализуют метод оценки. Баллы находятся в диапазоне от 0 до 1, причем большее значение указывает на лучшее соответствие.
Доступно в неконтролируемых оценщиках
- model.predict (): прогнозирование меток в алгоритмах кластеризации. model.transform (): для неконтролируемой модели преобразовать новые данные в новую основу. Это также принимает один аргумент X_new и возвращает новое представление данных на основе неконтролируемой модели. model.fit_transform (): некоторые оценщики реализуют этот метод, который более эффективно выполняет подгонку и преобразование одних и тех же входных данных.
Давайте загрузим чтение набора данных
Это набор данных из 75 000 сортов домашнего пива более 176 различных стилей. Записи о пиве регистрируются пользователями и классифицируются по одному из 176 различных стилей. Эти рецепты содержат столько или меньше деталей, сколько предоставил пользователь, но есть как минимум 5 полезных столбцов, в которые были введены данные для каждого: исходная плотность, конечная плотность, ABV, IBU и цвет.
Вы можете скачать форму Kaggle, используя API Kaggle.
! kaggle datasets download -d jtrofe/beer-recipesРазархивируйте набор данных
! unzip beer-recipes.zipКодировать
file = open("recipeData.csv", encoding="latin1")
data_raw = pd.read_csv(file)
data_raw.head()
print(data_raw.shape)(73861, 23)data_raw.info()<class 'pandas.core.frame.DataFrame'> RangeIndex: 73861 entries, 0 to 73860 Data columns (total 23 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 BeerID 73861 non-null int64 1 Name 73860 non-null object 2 URL 73861 non-null object 3 Style 73265 non-null object 4 StyleID 73861 non-null int64 5 Size(L) 73861 non-null float64 6 OG 73861 non-null float64 7 FG 73861 non-null float64 8 ABV 73861 non-null float64 9 IBU 73861 non-null float64 10 Color 73861 non-null float64 11 BoilSize 73861 non-null float64 12 BoilTime 73861 non-null int64 13 BoilGravity 70871 non-null float64 14 Efficiency 73861 non-null float64 15 MashThickness 43997 non-null float64 16 SugarScale 73861 non-null object 17 BrewMethod 73861 non-null object 18 PitchRate 34609 non-null float64 19 PrimaryTemp 51199 non-null float64 20 PrimingMethod 6766 non-null object 21 PrimingAmount 4774 non-null object 22 UserId 23371 non-null float64 dtypes: float64(13), int64(3), object(7) memory usage: 13.0+ MB
ETL
Набор данных уже преобразован и очищен. Он сократился с 75 000 записей до выборки из 1000 строк.
data = pd.read_csv('MyData.csv')
data.head()
print(data.shape)(1000, 5)data = data[['Color', 'BoilGravity', 'IBU', 'ABV', 'Clase']]data.info()<class 'pandas.core.frame.DataFrame'> RangeIndex: 1000 entries, 0 to 999 Data columns (total 5 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Color 1000 non-null float64 1 BoilGravity 1000 non-null int64 2 IBU 1000 non-null float64 3 ABV 1000 non-null float64 4 Clase 1000 non-null object dtypes: float64(3), int64(1), object(1) memory usage: 39.2+ KB
Визуализация
Некоторое графическое представление информации и данных.
sns.FacetGrid(data,hue='Clase',size=5)\
.map(plt.scatter,'Color','IBU')\
.add_legend()
sns.pairplot(data,hue='Clase')
Подготовить тренировку и испытание
Scikit-learn предоставляет полезную функцию для разделения данных train_test_split, которая разделяет ваши данные на обучающий набор и тестовый набор.
Обучение и тестирование обычно составляют 70% для обучения и 30% для тестирования.
Учебный набор для подгонки модели Тестовый набор только для ознакомления
X = data.iloc[:, :-1].values # X -> Feature Variables
y = data.iloc[:, -1].values # y -> Target
# Splitting the data into Train and Test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0)Время работать
Алгоритм 1 - линейная регрессия
Он используется для оценки реальных значений (стоимость домов, количество звонков, общий объем продаж и т. Д.) На основе непрерывных переменных. Здесь мы устанавливаем взаимосвязь между независимыми и зависимыми переменными, подбирая лучшую линию. Эта линия наилучшего соответствия известна как линия регрессии и представлена линейным уравнением ** Y = a * X + b.
#converting object data type into int data type using labelEncoder for Linear reagration in this case XL = data.iloc[:, :-1].values # X -> Feature Variables yL = data.iloc[:, -1].values # y -> Target from sklearn.preprocessing import LabelEncoder le = LabelEncoder() Y_train= le.fit_transform(yL) print(Y_train) # this is Y_train categotical to numerical# This is only for Linear Regretion X_trainL, X_testL, y_trainL, y_testL = train_test_split(XL, Y_train, test_size = 0.3, random_state = 0)from sklearn.linear_model import LinearRegression modelLR = LinearRegression() modelLR.fit(X_trainL, y_trainL) Y_pred = modelLR.predict(X_testL)from sklearn import metrics #calculating the residuals print('y-intercept :' , modelLR.intercept_) print('beta coefficients :' , modelLR.coef_) print('Mean Abs Error MAE :' ,metrics.mean_absolute_error(y_testL,Y_pred)) print('Mean Sqrt Error MSE :' ,metrics.mean_squared_error(y_testL,Y_pred)) print('Root Mean Sqrt Error RMSE:' ,np.sqrt(metrics.mean_squared_error(y_testL,Y_pred))) print('r2 value :' ,metrics.r2_score(y_testL,Y_pred))y-intercept : 1.3387807147212312 beta coefficients : [ 0.0774304 -0.00204902 -0.00129162 -0.08929801] Mean Abs Error MAE : 0.4751251900979613 Mean Sqrt Error MSE : 0.34378571937495755 Root Mean Sqrt Error RMSE: 0.586332430771962 r2 value : 0.7081587758444602
Алгоритм 2 - дерево решений
Это один из моих любимых алгоритмов, и я использую его довольно часто. Это тип алгоритма обучения с учителем, который в основном используется для задач классификации. Удивительно, но это работает как для категориальных, так и для непрерывно зависимых переменных.
В этом алгоритме мы разбиваем популяцию на два или более однородных набора. Это делается на основе наиболее значимых атрибутов / независимых переменных, чтобы создать как можно более отдельные группы.
# Decision Tree's from sklearn.tree import DecisionTreeClassifier Model = DecisionTreeClassifier() Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.48 0.65 0.55 17 IPA 0.88 0.85 0.86 149 PALE 0.69 0.68 0.68 78 PORTER 0.48 0.50 0.49 20 STOUT 0.71 0.69 0.70 36 accuracy 0.75 300 macro avg 0.65 0.67 0.66 300 weighted avg 0.76 0.75 0.75 300 [[ 11 2 4 0 0] [ 3 126 20 0 0] [ 9 16 53 0 0] [ 0 0 0 10 10] [ 0 0 0 11 25]]Accuracy is 0.75
Алгоритм 3- RandomForest
Случайный лес - это товарный знак для обозначения совокупности деревьев решений. В Random Forest у нас есть набор деревьев решений (так называемый «лес»). Чтобы классифицировать новый объект на основе атрибутов, каждое дерево дает классификацию, и мы говорим, что дерево «голосует» за этот класс. Лес выбирает классификацию, имеющую наибольшее количество голосов (по всем деревьям в лесу).
from sklearn.ensemble import RandomForestClassifier Model=RandomForestClassifier(max_depth=2) Model.fit(X_train,y_train) y_pred=Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test,y_pred)) print(confusion_matrix(y_pred,y_test)) #Accuracy Score print('Accuracy is ',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.48 0.65 0.55 17 IPA 0.88 0.85 0.86 149 PALE 0.69 0.68 0.68 78 PORTER 0.48 0.50 0.49 20 STOUT 0.71 0.69 0.70 36 accuracy 0.75 300 macro avg 0.65 0.67 0.66 300 weighted avg 0.76 0.75 0.75 300 [[ 11 3 9 0 0] [ 2 126 16 0 0] [ 4 20 53 0 0] [ 0 0 0 10 11] [ 0 0 0 10 25]]Accuracy is 0.75
Алгоритм 4 - логистическая регрессия
Не запутайтесь по названию! Это классификация, а не алгоритм регрессии. Он используется для оценки дискретных значений (двоичных значений, таких как 0/1, да / нет, истина / ложь) на основе заданного набора независимых переменных.
Проще говоря, он предсказывает вероятность возникновения события, подгоняя данные под логическую функцию. Следовательно, это также известно как логическая регрессия. Поскольку он предсказывает вероятность, его выходные значения лежат между 0 и 1 (как и ожидалось).
# LogisticRegression from sklearn.linear_model import LogisticRegression Model = LogisticRegression() Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.45 0.59 0.51 17 IPA 0.78 0.91 0.84 149 PALE 0.69 0.44 0.54 78 PORTER 0.50 0.10 0.17 20 STOUT 0.66 0.97 0.79 36 accuracy 0.72 300 macro avg 0.62 0.60 0.57 300 weighted avg 0.71 0.72 0.69 300 [[ 10 0 7 0 0] [ 4 135 8 2 0] [ 8 36 34 0 0] [ 0 0 0 2 18] [ 0 1 0 0 35]]Accuracy is 0.72
Алгоритм 5- Ближайшие соседи
Его можно использовать как для задач классификации, так и для задач регрессии. Однако он более широко используется в задачах классификации в промышленности. K ближайших соседей - это простой алгоритм, который хранит все доступные случаи и классифицирует новые случаи большинством голосов своих k соседей. Случай, отнесенный к классу, наиболее распространен среди его K ближайших соседей, измеренных функцией расстояния.
# K-Nearest Neighbours from sklearn.neighbors import KNeighborsClassifier Model = KNeighborsClassifier(n_neighbors=8) Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.48 0.76 0.59 17 IPA 0.87 0.88 0.87 149 PALE 0.76 0.65 0.70 78 PORTER 0.65 0.55 0.59 20 STOUT 0.79 0.83 0.81 36 accuracy 0.79 300 macro avg 0.71 0.74 0.71 300 weighted avg 0.79 0.79 0.79 300 [[ 13 1 3 0 0] [ 5 131 13 0 0] [ 9 18 51 0 0] [ 0 1 0 11 8] [ 0 0 0 6 30]]Accuracy is 0.7866666666666666
Алгоритм 6 - наивный байесовский
Это метод классификации, основанный на теореме Байеса с предположением независимости между предикторами. Проще говоря, наивный байесовский классификатор предполагает, что наличие определенной функции в классе не связано с наличием какой-либо другой функции.
Например, фрукт может считаться яблоком, если он красный, круглый и имеет диаметр около 3 дюймов. Даже если эти характеристики зависят друг от друга или от наличия других характеристик, наивный байесовский классификатор будет рассматривать все эти свойства как независимые факторы, влияющие на вероятность того, что этот фрукт является яблоком.
# Naive Bayes from sklearn.naive_bayes import GaussianNB Model = GaussianNB() Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.52 0.82 0.64 17 IPA 0.92 0.81 0.86 149 PALE 0.66 0.71 0.68 78 PORTER 0.69 0.55 0.61 20 STOUT 0.79 0.92 0.85 36 accuracy 0.78 300 macro avg 0.71 0.76 0.73 300 weighted avg 0.80 0.78 0.78 300 [[ 14 1 2 0 0] [ 0 121 26 2 0] [ 13 10 55 0 0] [ 0 0 0 11 9] [ 0 0 0 3 33]]Accuracy is 0.78
Алгоритм 7 - машины опорных векторов
Это метод классификации. В этом алгоритме мы строим каждый элемент данных как точку в n-мерном пространстве (где n - количество имеющихся у вас функций), причем значение каждой функции является значением конкретной координаты.
Например, если бы у нас было только две характеристики, такие как рост и длина волос человека, мы сначала построили бы эти две переменные в двухмерном пространстве, где каждая точка имеет две координаты (эти координаты известны как опорные векторы).
# Support Vector Machine from sklearn.svm import SVC Model = SVC() Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.52 0.82 0.64 17 IPA 0.92 0.81 0.86 149 PALE 0.66 0.71 0.68 78 PORTER 0.69 0.55 0.61 20 STOUT 0.79 0.92 0.85 36 accuracy 0.78 300 macro avg 0.71 0.76 0.73 300 weighted avg 0.80 0.78 0.78 300 [[ 14 1 2 0 0] [ 0 121 26 2 0] [ 13 10 55 0 0] [ 0 0 0 11 9] [ 0 0 0 3 33]]Accuracy is 0.78
Алгоритм 8 - Классификатор соседей по радиусу
В scikit-learn RadiusNeighborsClassifier очень похож на KNeighborsClassifier за исключением двух параметров. Во-первых, в RadiusNeighborsClassifier нам нужно указать радиус фиксированной области, используемой, чтобы определить, является ли наблюдение соседом, используя радиус.
Если нет какой-либо существенной причины для установки некоторого значения радиуса, лучше всего рассматривать его как любой другой гиперпараметр и настраивать его во время выбора модели. Второй полезный параметр - outlier_label, который указывает, какую метку дать наблюдению, не имеющему наблюдений в пределах радиуса, - который сам по себе часто может быть полезным инструментом для выявления выбросов.
#Output from sklearn.neighbors import RadiusNeighborsClassifier Model=RadiusNeighborsClassifier(radius=18.0) Model.fit(X_train,y_train) y_pred=Model.predict(X_test)#summary of the predictions made by the classifier print(classification_report(y_test,y_pred)) print(confusion_matrix(y_test,y_pred)) #Accouracy score print('Accuracy is ', accuracy_score(y_test,y_pred))precision recall f1-score support ALE 0.44 0.41 0.42 17 IPA 0.87 0.88 0.88 149 PALE 0.71 0.72 0.71 78 PORTER 0.00 0.00 0.00 20 STOUT 0.63 0.92 0.75 36 accuracy 0.76 300 macro avg 0.53 0.59 0.55 300 weighted avg 0.72 0.76 0.73 300 [[ 7 0 10 0 0] [ 5 131 13 0 0] [ 4 18 56 0 0] [ 0 1 0 0 19] [ 0 0 0 3 33]]Accuracy is 0.7566666666666667
Алгоритм 9 - пассивно-агрессивный классификатор
Алгоритм PA - это алгоритм онлайн-обучения на основе маржи для двоичной классификации. В отличие от алгоритма PA, который является методом с жестким запасом, алгоритм PA-I является методом с мягким запасом и устойчив к шуму.
from sklearn.linear_model import PassiveAggressiveClassifier Model = PassiveAggressiveClassifier() Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.20 0.06 0.09 17 IPA 1.00 0.06 0.11 149 PALE 0.33 1.00 0.49 78 PORTER 0.00 0.00 0.00 20 STOUT 0.66 0.86 0.75 36 accuracy 0.40 300 macro avg 0.44 0.40 0.29 300 weighted avg 0.67 0.40 0.28 300 [[ 1 0 16 0 0] [ 4 9 136 0 0] [ 0 0 78 0 0] [ 0 0 4 0 16] [ 0 0 5 0 31]]Accuracy is 0.39666666666666667
Алгоритм 10 - BernoulliNB
Как и MultinomialNB, этот классификатор подходит для дискретных данных. Разница в том, что в то время как MultinomialNB работает с подсчетом вхождений, BernoulliNB предназначен для двоичных / логических функций.
# BernoulliNB from sklearn.naive_bayes import BernoulliNB Model = BernoulliNB() Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.00 0.00 0.00 17 IPA 0.50 1.00 0.66 149 PALE 0.00 0.00 0.00 78 PORTER 0.00 0.00 0.00 20 STOUT 0.00 0.00 0.00 36 accuracy 0.50 300 macro avg 0.10 0.20 0.13 300 weighted avg 0.25 0.50 0.33 300 [[ 0 17 0 0 0] [ 0 149 0 0 0] [ 0 78 0 0 0] [ 0 20 0 0 0] [ 0 36 0 0 0]]Accuracy is 0.49666666666666665
Алгоритм 11 - ExtraTreeClassifier
ExtraTreesClassifier - это метод ансамблевого обучения, в основе которого лежат деревья решений. ExtraTreesClassifier, как и RandomForest, рандомизирует определенные решения и подмножества данных, чтобы минимизировать чрезмерное обучение на основе данных и переобучение. Давайте посмотрим на некоторые методы ансамбля, упорядоченные от высокой к низкой дисперсии, заканчивая ExtraTreesClassifier.
# ExtraTreeClassifier from sklearn.tree import ExtraTreeClassifier Model = ExtraTreeClassifier() Model.fit(X_train, y_train) y_pred = Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test, y_pred)) print(confusion_matrix(y_test, y_pred)) # Accuracy score print('Accuracy is',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.39 0.71 0.50 17 IPA 0.86 0.81 0.83 149 PALE 0.60 0.55 0.57 78 PORTER 0.48 0.60 0.53 20 STOUT 0.75 0.67 0.71 36 accuracy 0.70 300 macro avg 0.61 0.67 0.63 300 weighted avg 0.72 0.70 0.71 300 [[ 12 0 5 0 0] [ 3 120 24 2 0] [ 16 19 43 0 0] [ 0 0 0 12 8] [ 0 1 0 11 24]]Accuracy is 0.7033333333333334
Алгоритм 12 - Классификатор упаковки
Классификатор пакетов - это метаоценка ансамбля, которая подбирает базовые классификаторы для каждого из случайных подмножеств исходного набора данных, а затем объединяет их индивидуальные прогнозы (путем голосования или усреднения) для формирования окончательного прогноза. Такая метаоценка обычно может использоваться как способ уменьшить дисперсию оценщика черного ящика (например, дерева решений), вводя рандомизацию в его процедуру построения и затем создавая из нее ансамбль.
from sklearn.ensemble import BaggingClassifier Model=BaggingClassifier() Model.fit(X_train,y_train) y_pred=Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test,y_pred)) print(confusion_matrix(y_pred,y_test)) #Accuracy Score print('Accuracy is ',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.45 0.59 0.51 17 IPA 0.87 0.89 0.88 149 PALE 0.69 0.62 0.65 78 PORTER 0.62 0.50 0.56 20 STOUT 0.75 0.83 0.79 36 accuracy 0.77 300 macro avg 0.68 0.68 0.68 300 weighted avg 0.77 0.77 0.77 300 [[ 10 0 12 0 0] [ 2 132 18 0 0] [ 5 17 48 0 0] [ 0 0 0 10 6] [ 0 0 0 10 30]]Accuracy is 0.7666666666666667
Алгоритм 13-классификатор AdaBoost
Классификатор AdaBoost - это метаоценка, которая начинается с подгонки классификатора к исходному набору данных, а затем подгоняет дополнительные копии классификатора к тому же набору данных, но при этом веса неправильно классифицированных экземпляров корректируются таким образом, что последующие классификаторы больше сосредотачиваются на сложных случаях.
from sklearn.ensemble import AdaBoostClassifier Model=AdaBoostClassifier() Model.fit(X_train,y_train) y_pred=Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test,y_pred)) print(confusion_matrix(y_pred,y_test)) #Accuracy Score print('Accuracy is ',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.40 0.35 0.38 17 IPA 0.98 0.34 0.51 149 PALE 0.41 0.94 0.57 78 PORTER 0.50 0.20 0.29 20 STOUT 0.67 0.89 0.76 36 accuracy 0.55 300 macro avg 0.59 0.54 0.50 300 weighted avg 0.73 0.55 0.53 300 [[ 6 5 4 0 0] [ 0 51 1 0 0] [11 93 73 0 0] [ 0 0 0 4 4] [ 0 0 0 16 32]]Accuracy is 0.5533333333333333
Алгоритм 14 - Классификатор повышения градиента
GBM - это алгоритм повышения, который используется, когда мы имеем дело с большим количеством данных для прогнозирования с высокой мощностью прогнозирования. Повышение на самом деле представляет собой совокупность алгоритмов обучения, которые объединяют предсказание нескольких базовых оценщиков с целью повышения надежности по сравнению с одним оценщиком. Он объединяет несколько слабых или средних предикторов для построения сильного предиктора.
from sklearn.ensemble import GradientBoostingClassifier Model=GradientBoostingClassifier() Model.fit(X_train,y_train) y_pred=Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test,y_pred)) print(confusion_matrix(y_pred,y_test)) #Accuracy Score print('Accuracy is ',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.48 0.59 0.53 17 IPA 0.88 0.90 0.89 149 PALE 0.70 0.64 0.67 78 PORTER 0.57 0.40 0.47 20 STOUT 0.71 0.83 0.77 36 accuracy 0.77 300 macro avg 0.67 0.67 0.67 300 weighted avg 0.77 0.77 0.77 300 [[ 10 0 11 0 0] [ 1 134 17 0 0] [ 6 15 50 0 0] [ 0 0 0 8 6] [ 0 0 0 12 30]]Accuracy is 0.7733333333333333
Алгоритм 15- линейный дискриминантный анализ.
Классификатор с линейной границей решения, созданный путем подбора условных плотностей классов к данным и с использованием правила Байеса.
Модель подбирает гауссову плотность для каждого класса, предполагая, что все классы имеют одну и ту же ковариационную матрицу.
Подобранную модель также можно использовать для уменьшения размерности входных данных, проецируя их в наиболее различимых направлениях.
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis Model=LinearDiscriminantAnalysis() Model.fit(X_train,y_train) y_pred=Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test,y_pred)) print(confusion_matrix(y_pred,y_test)) #Accuracy Score print('Accuracy is ',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.56 0.29 0.38 17 IPA 0.89 0.85 0.87 149 PALE 0.65 0.78 0.71 78 PORTER 0.69 0.45 0.55 20 STOUT 0.76 0.89 0.82 36 accuracy 0.78 300 macro avg 0.71 0.65 0.67 300 weighted avg 0.78 0.78 0.77 300 [[ 5 2 2 0 0] [ 0 126 15 1 0] [ 12 21 61 0 0] [ 0 0 0 9 4] [ 0 0 0 10 32]]Accuracy is 0.7766666666666666
Алгоритм 16- квадратичный дискриминантный анализ
Классификатор с квадратичной границей решения, созданный путем подбора условных плотностей классов к данным и с использованием правила Байеса.
Модель соответствует гауссовой плотности для каждого класса.
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis Model=QuadraticDiscriminantAnalysis() Model.fit(X_train,y_train) y_pred=Model.predict(X_test)# Summary of the predictions made by the classifier print(classification_report(y_test,y_pred)) print(confusion_matrix(y_pred,y_test)) #Accuracy Score print('accuracy is ',accuracy_score(y_pred,y_test))precision recall f1-score support ALE 0.61 0.82 0.70 17 IPA 0.93 0.85 0.89 149 PALE 0.72 0.76 0.74 78 PORTER 0.69 0.45 0.55 20 STOUT 0.76 0.94 0.84 36 accuracy 0.81 300 macro avg 0.74 0.77 0.74 300 weighted avg 0.82 0.81 0.81 300 [[ 14 0 9 0 0] [ 0 127 10 0 0] [ 3 20 59 0 0] [ 0 2 0 9 2] [ 0 0 0 11 34]]Accuracy is 0.81
Алгоритм 17- K- означает
Это тип неконтролируемого алгоритма, который решает проблему кластеризации. Его процедура следует простому и легкому способу классификации данного набора данных по определенному количеству кластеров (предположим, что кластеров k). Точки данных внутри кластера однородны и неоднородны по отношению к одноранговым группам.
Помните, как выявляли формы из чернильных кляксов? k означает, что в чем-то похожа эта деятельность. Вы смотрите на форму и распространение, чтобы определить, сколько разных кластеров / популяций присутствует.
x = data.iloc[:, [1, 2, 3]].values #Finding the optimum number of clusters for k-means classification from sklearn.cluster import KMeans wcss = [] for i in range(1, 11): kmeans = KMeans(n_clusters = i, init = 'k-means++', max_iter = 300, n_init = 10, random_state = 0) kmeans.fit(x) wcss.append(kmeans.inertia_)#Plotting the results onto a line graph, allowing us to observe 'The elbow' plt.plot(range(1, 11), wcss) plt.title('The elbow method') plt.xlabel('Number of clusters') plt.ylabel('WCSS') # within cluster sum of squares plt.show()
#Applying kmeans to the dataset / Creating the kmeans classifier
kmeans = KMeans(n_clusters = 5, init = 'k-means++', max_iter = 300, n_init = 10, random_state = 0)
y_kmeans = kmeans.fit_predict(x)
#Visualising the clusters
plt.scatter(x[y_kmeans == 0, 0], x[y_kmeans == 0, 1], s = 100, c = 'red', label = 'ALE')
plt.scatter(x[y_kmeans == 1, 0], x[y_kmeans == 1, 1], s = 100, c = 'blue', label = 'IPA')
plt.scatter(x[y_kmeans == 2, 0], x[y_kmeans == 2, 1], s = 100, c = 'yellow', label = 'PALE')
plt.scatter(x[y_kmeans == 3, 0], x[y_kmeans == 3, 1], s = 100, c = 'purple', label = 'PORTER')
plt.scatter(x[y_kmeans == 4, 0], x[y_kmeans == 4, 1], s = 100, c = 'black', label = 'STOUT')
#Plotting the centroids of the clusters
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:,1], s = 100, c = 'green', label = 'Centroids',marker='*')
plt.legend()
Заключение
Надеюсь, вам понравится эта статья о всех алгоритмах машинного обучения.
Я надеюсь, что это поможет тебе улучшить твои тренировки.
Ссылки: https://thecleverprogrammer.com/2020/06/05/all-machine-learning-algorithms-explained/
Никогда не сдавайтесь!
До встречи в Linkedin!
