7 типов классификации с использованием Python

Внутри Ай

7 типов классификации с использованием Python

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

Привет, как дела, я надеюсь, что это здорово ……….

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

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

Этот набор данных является общедоступным для исследования. Подробности описаны в [Moro et al., 2011]. [Moro et al., 2011] С. Моро, Р. Лауреано и П. Кортес. Использование интеллектуального анализа данных для прямого банковского маркетинга: применение методологии CRISP-DM.
В P. Novais et al. (ред.), Материалы Европейской конференции по моделированию и моделированию — ESM’2011, стр. 117–121, Гимарайнш, Португалия, октябрь 2011 г. EUROSIS.

Данные связаны с кампаниями прямого маркетинга португальского банковского учреждения.
Маркетинговые кампании основывались на телефонных звонках. Часто требовалось несколько контактов с одним и тем же клиентом,
чтобы узнать, будет ли (или нет) подписка на продукт (срочный банковский депозит).
Первоначальные владельцы набора данных :
Создатели: Пауло Кортес (Университет Минью) и Серхио Моро (ISCTE-IUL), 2012 г.

И он содержит атрибуты:

ID клиента, доход, возраст, кредит, дефолт

Давайте начнем с нашего часто используемого метода классификации:

1.) Логистическая регрессия, тогда мы будем использовать

2.) Кнн

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

4.) Ядро SVM

5.) Наивный байесовский метод

6.) Классификация дерева решений

7.) Классификация случайного леса

Какая-то еще классификация? Дайте мне знать в комментарии ниже.

#Logistic Regression
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values

Ну, пока здесь все так же, как и раньше, загрузите данные, затем разделите данные на X и Y, где Y — зависимая / целевая переменная, 4-й столбец (столбец невыполнения обязательств), а остальные от 0 до 3 — независимая переменная X.

Примечание: в индексе Python положение столбцов начинается с 0, а не с 1.

Затем мы разделим данные на наборы данных для обучения и тестирования. После того, как мы преобразуем все значения столбца в одно стандартное значение/диапазон, это уменьшит разброс, величину точек данных без потери исходного значения данных. ЗДОРОВО!

Это помогает алгоритму быстрее и эффективнее вычислять данные.

#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

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

#Fitting Logistic Regression to the Training set
from sklearn.linear_model import LogisticRegression
lr_model= LogisticRegression(random_state = 0)
lr_model.fit(X_train, y_train)
# Predicting the Test set results
y_pred = lr_model.predict(X_test)

ВЫПОЛНЕНО… !!! супер легко не так ли?

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

#We can also compare the actual versus predicted
df = pd.DataFrame({'Actual': y_test.flatten(), 'Predicted': y_pred.flatten()})
df

Fatten помогает представлять данные в виде одномерного массива, такого как список.

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

# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
cm

НИЦЦА.

Наша модель способна идентифицировать 0, то есть неплательщиков, которые на самом деле неплательщики 424 неплательщика из общего числа 500 (500 из общего числа 1997, потому что мы разделили набор данных на обучение и тестирование ~ 75% — 25%)

И 18 из 500 являются ложноотрицательными (FN), что означает, что 18 были неплательщиками, но прогнозировались как недефолтные. То же самое относится к 8 из 500 неплательщиков, но прогнозируется как неплательщики. И прогноз 50 относится к неплательщикам из 500, которые на самом деле являются неплательщиками.

Это действительно хорошая модель с высокой точностью, и ни одна модель не является точной на 100%, если это так, ТОГДА может возникнуть проблема смещения.

Хорошо, у нас есть еще одна метрика для оценки производительности модели с помощью использования metrics.accuracy_score.

#evaluation Metrics
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred))
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))

ОТЛИЧНО! У нас показатель точности модели 0,948, т. е. 95 %.

И сбалансированная оценка точности 0,858, т.е. 86%

И у нас есть еще одна точность

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

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

#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
# Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
lr_model.predict(new_data)
#if we wish to enter manually
lr_model.predict([[66952.7,28,8770.1]])

У нас есть вывод array([0], dtype=int64) класса «0». Готово… мы классифицировали, если доход, возраст, кредит = 66952,7, 28, 8770,1, кажется, не будет неплательщика (класс = '0').

БОНУС

Сохраните и загрузите модель.

#save the model in the disk
import pickle
# save the model to disk
filename = 'class_model.sav'
pickle.dump(lr_model, open(filename, 'wb'))
# load the model from disk
filename1 = 'class_model.sav'
loaded_model = pickle.load(open(filename1, 'rb'))
#another method using joblib
'''Pickled model as a file using joblib: Joblib is the replacement of pickle as
 it is more efficent on objects that carry large numpy arrays. 
'''
from sklearn.externals import joblib 
  
# Save the model as a pickle in a file 
joblib.dump(lr_model, 'classification.pkl') 
  
# Load the model from the file 
loaded_model2 = joblib.load('classification.pkl')  
  
# Use the loaded model to make predictions 
loaded_model2.predict(X_test)

Давайте соберем все части вместе

# Logistic Regression
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#---------------------------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
#Fitting Logistic Regression to the Training set
from sklearn.linear_model import LogisticRegression
lr_model= LogisticRegression(random_state = 0)
lr_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = lr_model.predict(X_test)
#We can also compare the actual versus predicted
df = pd.DataFrame({'Actual': y_test.flatten(), 'Predicted': y_pred.flatten()})
df
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
# Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
"""We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format else inverse transform will give back the original value"""
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
lr_model.predict(new_data)
#if we wish to enter manually
lr_model.predict([[66952.7,28,8770.1]])
#---------------------------------------
#save the model in the disk
import pickle
# save the model to disk
filename = 'class_model.sav'
pickle.dump(lr_model, open(filename, 'wb'))
# load the model from disk
filename1 = 'class_model.sav'
loaded_model = pickle.load(open(filename1, 'rb'))
#another method using joblib
'''Pickled model as a file using joblib: Joblib is the replacement of pickle as
 it is more efficent on objects that carry large numpy arrays. 
'''
from sklearn.externals import joblib 
  
# Save the model as a pickle in a file 
joblib.dump(lr_model, 'classification.pkl') 
  
# Load the model from the file 
loaded_model2 = joblib.load('classification.pkl')  
  
# Use the loaded model to make predictions 
loaded_model2.predict(X_test)

Поздравляем! Мы успешно завершили нашу первую модель классификации.

Далее КНН

Что такое КНН?

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

Классификация производится большинством голосов соседям (K).

Давайте начнем с того, как применять KNN для задач классификации.

#K-Nearest Neighbors (K-NN)
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#-------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

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

ТЕПЕРЬ мы подгоним KNN к нашему набору обучающих данных, где K ближайших соседей K = 3, метрика = Минковский, который помогает измерить трехмерное евклидово пространство, а p = 2 — это параметр мощности для метрики Минковского. Когда p = 1, это эквивалентно использованию manhattan_distance (l1) и euclidean_distance (l2) для p = 2.

# Fitting K-NN to the Training set
from sklearn.neighbors import KNeighborsClassifier
knn_model = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2)
knn_model.fit(X_train, y_train)

Вот и все….!

Пришло время прогнозировать с помощью тестового набора данных.

# Predicting the Test set results
y_pred = knn_model.predict(X_test)

Хорошо, давайте сравним наши предсказанные результаты с нашими первоначальными результатами.

#actual versus predicted
df = pd.DataFrame({'Actual': y_test.flatten(), 'Predicted': y_pred.flatten()})
df

ну, похоже, наша модель предсказывает очень хорошо….

Теперь давайте попробуем оценить нашу модель с помощью метрик оценки.

Во-первых, это матрица путаницы

# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

Ничего себе, он классифицирует истинно положительные и истинно отрицательные более точно, чем с помощью логистической регрессии.

#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))

НУ НУ НУ НУ

Даже показатель точности составляет 98%, а показатель сбалансированной точности 0,957, т.е. 96%.

И у нас есть еще одна точность

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

Теперь давайте предскажем с совершенно невидимыми случайными данными, если доход, возраст, кредит = 66952,7,28,8770,1

#if income, age, loan = 66952.7,28,8770.1
import numpy as np
#Create a numpy array
new_data = np.array([66952.7,28,8770.1])
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
knn_model.predict(new_data)
#if we wish to enter manually
knn_model.predict([[66952.7,28,8770.1]])

У нас есть вывод array([0], dtype=int64) класса «0». Готово… мы классифицировали, если доход, возраст, кредит = 66952,7, 28, 8770,1, кажется, будет неплательщиком (класс = '0') с моделью KNN

Давайте соберем все коды вместе

#K-Nearest Neighbors (K-NN)
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#------------------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
#Fitting K-NN to the Training set
from sklearn.neighbors import KNeighborsClassifier
knn_model = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2)
knn_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = knn_model.predict(X_test)
#Model Evaluation------------------------------------
#We can also compare the actual versus predicted
df = pd.DataFrame({'Actual': y_test.flatten(), 'Predicted': y_pred.flatten()})
df
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#---------------------------------------------------
#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
#Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
knn_model.predict(new_data)
#if we wish to enter manually
knn_model.predict([[66952.7,28,8770.1]])
#scaled version input data
knn_model.predict([[0.382027,-0.979416,1.45499]])

Поздравляем! Мы успешно завершили нашу модель KNN для классификации неплательщиков

Далее идет SVM, еще один мощный классификатор.

МАШИНА ОПОРНЫХ ВЕКТОРОВ

Что такое СВМ?

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

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

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

Давайте поймем это с помощью примера.

#SVM
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#--------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

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

Пришло время поместить SVM в обучающую выборку.

#Fitting SVM to the Training set
from sklearn.svm import SVC
svm_model = SVC(kernel = 'linear', random_state = 0)
svm_model.fit(X_train, y_train)

Теперь наша модель готова к прогнозированию с новыми данными.

#Predicting the Test set results
y_pred = svm_model.predict(X_test)

Давайте получим доступ к производительности нашей модели.

Во-первых, мы сравним прогнозируемые значения с фактическим результатом.

#We can also compare the actual versus predicted
df = pd.DataFrame({'Actual': y_test.flatten(), 'Predicted': y_pred.flatten()})
df

Вторая метрика производительности — это матрица путаницы.

# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

Он классифицирует истинно положительный и истинно отрицательный более точно, чем ложноположительный и ложноотрицательный.

Кроме того, мы можем использовать показатели оценки scikit sklearn для оценки оценки точности модели.

#evaluation Metrics
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred))
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))

Оценка точности составляет 95%, а сбалансированная оценка точности составляет 0,87, т.е. 87%.

И у нас есть еще одна точность

#if income, age, loan = 66952.7,28,8770.1
import numpy as np
# Create a numpy array
new_data = np.array([66952.7,28,8770.1])
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#---------------------------------------
svm_model.predict(new_data)
#if we wish to enter manually
svm_model.predict([[66952.7,28,8770.1]])

У нас есть вывод массива ([0], dtype=int64) класса «0». Готово… мы классифицировали, если доход, возраст, кредит = 66952,7, 28, 8770,1, похоже, не будет неплательщика (класс = '0') с моделью SVM.

Давайте соберем все коды вместе.

#SVM
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#-------------------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
#Fitting SVM to the Training set
from sklearn.svm import SVC
svm_model = SVC(kernel = 'linear', random_state = 0)
svm_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = svm_model.predict(X_test)
#We can also compare the actual versus predicted
df = pd.DataFrame({'Actual': y_test.flatten(), 'Predicted': y_pred.flatten()})
df
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#evaluation Metrics
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred))
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#if income, age, loan = 66952.7,28,8770.1
import numpy as np
#Create a numpy array
new_data = np.array([66952.7,28,8770.1])
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
svm_model.predict(new_data)
#if we wish to enter manually
svm_model.predict([[66952.7,28,8770.1]])

Поздравляем! Мы успешно завершили нашу модель SVM для классификации неплательщиков

Далее идет Kernel SVM, еще одна мощная SVM.

Что такое ядро SVM

Сложность Linear SVM растет с увеличением размера набора данных. Проще говоря, Kernel SVM ‘rbf’ преобразует сложные нелинейные данные в многомерное трехмерное пространство для разделения классов данных.

Обычно линейные и полиномиальные ядра требуют меньше времени и обеспечивают меньшую точность, чем rbf или ядра Гаусса.

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

Давайте. Сравните Linear svm с ядром Radial на основе svm

# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#-----------------------------------------------------------
# Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
#fearure scale
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

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

Теперь мы подгоним данные как в Linear, так и в Kernel 'rbf'svm, чтобы сравнить их оба. .

#Fitting SVM to the Training set
from sklearn.svm import SVC
svm_model = SVC(kernel = 'linear', random_state = 0)
svm_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = svm_model.predict(X_test)
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#-------------------------------------------------------
#Fitting Kernal SVM to the Training set
from sklearn.svm import SVC
Ksvm_model = SVC(kernel = 'rbf', random_state = 0)
Ksvm_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = Ksvm_model.predict(X_test)
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm1 = confusion_matrix(y_test, y_pred)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#Hence we noticed Kernal SVM perform better than SVM

Итак, что мы получили

Матрица путаницы Kernel SVM работает лучше при определении истинно положительных и истинно отрицательных, чем линейный SVM

Оценка точности нашей модели Kernel svm лучше, чем линейная svm.

Следовательно, Kernel SVM работает лучше, чем Linear SVM.

Наконец, с помощью модели мы можем предсказать любые новые входные данные.

#if income, age, loan = 66952.7,28,8770.1
import numpy as np
#Create a numpy array
new_data = np.array([66952.7,28,8770.1])
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
Ksvm_model.predict(new_data)
#if we wish to enter manually
Ksvm_model.predict([[66952.7,28,8770.1]])

У нас есть вывод array([0], dtype=int64) класса «0». Готово… мы классифицировали, если доход, возраст, кредит = 66952,7, 28, 8770,1, кажется, не будет неплательщиком (класс = '0') даже с моделью Kernel SVM.

Давайте соберем все коды вместе.

#Kernal SVM
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#-----------------------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
#fearure scale
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
#------------------------------------------------------
#Fitting SVM to the Training set
from sklearn.svm import SVC
svm_model = SVC(kernel = 'linear', random_state = 0)
svm_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = svm_model.predict(X_test)
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#---------------------------------------------------------
# Fitting Kernal SVM to the Training set
from sklearn.svm import SVC
Ksvm_model = SVC(kernel = 'rbf', random_state = 0)
Ksvm_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = Ksvm_model.predict(X_test)
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm1 = confusion_matrix(y_test, y_pred)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#Hence we noticed Kernal SVM performs better than SVM
#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
#Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
Ksvm_model.predict(new_data)
#if we wish to enter manually
Ksvm_model.predict([[66952.7,28,8770.1]])

Поздравляем! Мы успешно завершили нашу модель Kernel SVM для классификации неплательщиков.

Далее идет наивный байесовский классификатор.

Что такое Наивный Байес вкратце?

Наивные байесовские классификаторы — это семейство простых «вероятностных классификаторов», основанных на применении теоремы Байеса.

P(c|x) — апостериорная вероятность класса (цель) с учетом предиктора (атрибут).

P(c) — априорная вероятность класса.
P(x|c) — это вероятность, которая является вероятностью предиктора данного класса.
P(x) — априорная вероятность предиктора.

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

До: насколько вероятной была наша гипотеза до появления доказательств?

Апостериорная: насколько вероятна наша гипотеза с учетом наблюдаемых данных?

Предельно: насколько вероятны новые данные при всех возможных гипотезах?

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

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

Давайте посмотрим, как мы можем применить наивный байесовский метод для классификации неплательщиков банков.

#Naive Bayes
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#-----------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
#fearure scaling/Normalization
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

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

Давайте подгоним Наивный Байес к нашим данным.

# Fitting Naive Bayes to the Training set
from sklearn.naive_bayes import GaussianNB
NB_model = GaussianNB()
NB_model.fit(X_train, y_train)

Готово всего за 3 строчки кода, не так ли?

Время прогнозировать невидимые данные.

# Predicting the Test set results
y_pred2 = NB_model.predict(X_test)

Готово, наши прогнозируемые значения сохранены в y_pred2.

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

# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm2 = confusion_matrix(y_test, y_pred2)

Итак, мы видим, что он классифицирует Истинно положительные и Истинно отрицательные более точно, чем Ложноположительные и Ложноотрицательные.

Кроме того, мы можем использовать показатели оценки scikit sklearn для оценки оценки точности модели.

#evaluation Metrics
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred))
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))

Ну, мы получили показатель точности нашей модели 98%, это хорошая модель.

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

#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
# Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
NB_model.predict(new_data)
#if we wish to enter manually
NB_model.predict([[66952.7,28,8770.1]])

Давайте объединим все эти коды.

#Naive Bayes
# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#----------------------------------------------------------------
# Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
#fearure scaling/Normalization
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
#-------------------------------------------------------------
# Fitting Naive Bayes to the Training set
from sklearn.naive_bayes import GaussianNB
NB_model = GaussianNB()
NB_model.fit(X_train, y_train)
# Predicting the Test set results
y_pred2 = NB_model.predict(X_test)
# Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm2 = confusion_matrix(y_test, y_pred2)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
# Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
NB_model.predict(new_data)
#if we wish to enter manually
NB_model.predict([[66952.7,28,8770.1]])

Поздравляем! Мы успешно завершили нашу модель Наивного Байеса для классификации неплательщиков.

Далее идет дерево решений / классификатор на основе правил.

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

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

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

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

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

Decision Tree Classification
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#--------------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
#fearure scaling/Normalization
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

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

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

# Fitting Naive Bayes to the Training set
from sklearn.naive_bayes import GaussianNB
NB_model = GaussianNB()
NB_model.fit(X_train, y_train)
# Predicting the Test set results
y_pred2 = NB_model.predict(X_test)
#evaluation Metrics
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred2))
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred2))
print('Average Precision:',metrics.average_precision_score(y_test, y_pred2))
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm2 = confusion_matrix(y_test, y_pred2)
#Fitting Decision Tree Classification to the Training set
from sklearn.tree import DecisionTreeClassifier
dt_model = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
dt_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = dt_model.predict(X_test)
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#evaluation Metrics
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred))
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))

Итак, что мы получили

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

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

Следовательно, дерево решений работает лучше, чем наивный байесовский метод.

Наконец, с помощью модели мы можем предсказать любые новые входные данные.

#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
# Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
dt_model.predict(new_data)
#if we wish to enter manually
dt_model.predict([[66952.7,28,8770.1]])

Пришло время визуализировать дерево решений.

#import export_graphviz
 from sklearn.tree import export_graphviz# export the decision tree to a tree.dot file
#for visualizing the plot easily anywhere
 export_graphviz(dt_model, out_file ='e:/tree.dot',feature_names =['Pressure'])

Дерево, наконец, экспортировано, и мы можем визуализировать его с помощью http://www.webgraphviz.com/, скопировав данные из файла tree.dot.

Собрав все это вместе, код who выглядит примерно так.

#Decision Tree Classification 
#Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#----------------------------------------------------
#Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
#fearure scaling/Normalization
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
#---------------------------------------------------------
#Fitting Naive Bayes to the Training set
from sklearn.naive_bayes import GaussianNB
NB_model = GaussianNB()
NB_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred2 = NB_model.predict(X_test)
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm2 = confusion_matrix(y_test, y_pred2)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred2))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred2)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred2))
#if income, age, loan = 
NB_model.predict([[66952.7,18,8770.1]])
NB_model.predict([[0.382027,-0.979416,1.45499]])
#-----------------------------------------------------
# Fitting Decision Tree Classification to the Training set
from sklearn.tree import DecisionTreeClassifier
dt_model = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
dt_model.fit(X_train, y_train)
# Predicting the Test set results
y_pred = dt_model.predict(X_test)
# Making the Confusion Matrix 
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
from sklearn.tree import export_graphviz  
  # export the decision tree to a tree.dot file 
# for visualizing the plot easily anywhere 
export_graphviz(dt_model, out_file ='e:/tree.dot', 
               feature_names =['income','age','loan'])
"""
The tree is finally exported and we can visualized using  
http://www.webgraphviz.com/ by copying the data from the ‘tree.dot’ file."""
#if income, age, loan = 66952.7,28,8770.1
import numpy as np 
# Create a numpy array 
new_data = np.array([66952.7,28,8770.1]) 
new_data.dtype
new_data.shape
#We need to reshape to match the dimensions
new_data = new_data.reshape(-1,3)
new_data.shape
#------------------------------------
from sklearn.preprocessing import StandardScaler
sc= StandardScaler()
#scale the data
new_data = sc.fit_transform(new_data)
#We might see the scaled data as 0, 0, 0 but its not its 0.000000e+ and can be view by changing the format
#else inverse transform will give back the original value
inversed = sc.inverse_transform(new_data)
print(inversed)
#-------------------------------------
dt_model.predict(new_data)
#if we wish to enter manually
dt_model.predict([[66952.7,28,8770.1]])

Вот мы и закончили, как применять деревья решений для нелинейных данных.

СЛЕДУЮЩИЙ СЛУЧАЙНЫЙ ЛЕС

Что такое случайный лес?

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

Начнем с примера

#Random Forest Classification
# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the dataset
dataset = pd.read_csv('credit_data.csv', sep=",")
#drop the missing values
dataset = dataset.dropna()
X = dataset.iloc[:,1:4].values
y = dataset.iloc[:, 4].values
#---------------------------------------------------
# Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
#fearure scaling/Normalization
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

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

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

#Fitting Decision Tree Classification to the Training set
from sklearn.tree import DecisionTreeClassifier
dt_model = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
dt_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred = dt_model.predict(X_test)
#Making the Confusion Matrix 
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
 
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred))
#------------------------------------------------------------
#Fitting Random Forest Classification to the Training set
from sklearn.ensemble import RandomForestClassifier
rf_model = RandomForestClassifier(n_estimators = 500, criterion = 'entropy', random_state = 0)
rf_model.fit(X_train, y_train)
#Predicting the Test set results
y_pred2 = rf_model.predict(X_test)
#Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm2 = confusion_matrix(y_test, y_pred2)
#evaluation Metrics 
from sklearn import metrics
print('Accuracy Score:', metrics.accuracy_score(y_test, y_pred2))  
print('Balanced Accuracy Score:', metrics.balanced_accuracy_score(y_test, y_pred2)) 
print('Average Precision:',metrics.average_precision_score(y_test, y_pred2))

Вауууу ! у нас есть показатель точности модели 99%. Как насчет твоей?

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

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

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

Я также буду делать другую версию в R. Удачного дня. Поддерживать связь!

7 типов классификации с использованием Python

Внутри Ай