Автор|Чэнь Лэйхуэй (Доу Мяо)

Введение

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

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

• Регрессия: предскажите значение, например прогноз осадков, цен на жилье и т. д. Более простые алгоритмы: Линейная регрессия

• Классификация: Предсказание метки, например предсказание «больной» или «здоровый», какое животное изображено на картинке и т. д. Более простые алгоритмы: логистическая регрессия, наивный байесовский алгоритм, K-ближайшие соседи (KNN)

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

2,неконтролируемое обучение(Unsupervised Learning, UL), такие алгоритмы работают, изучая базовую структуру данных из немаркированных обучающих данных. Кроме того, неконтролируемое обучение можно разделить на следующие три категории:

• Ассоциация: найти вероятность одновременного появления предметов в наборе, например, анализируя корзину для покупок в супермаркете, установлено, что пиво всегда покупают с подгузниками (история пива и подгузников), более простые алгоритмы: Априори

• Кластеризация: группирует данные таким образом, чтобы объекты внутри группы были более похожи, чем объекты между группами.Более простые алгоритмы: K-Means

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

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

выполнить

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

Linear Regression

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

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

# Linear Regression 一元回归
from sklearn import linear_model
from sklearn.metrics import mean_squared_error

# 1. 准备数据
lr_X_data, lr_y_data = datasets.make_regression(n_samples=500,n_features=1,n_targets=1,noise=2) # feature为1维度
# 2. 构造训练与测试集
lr_X_train, lr_X_test, lr_y_train, lr_y_test = train_test_split(lr_X_data, lr_y_data, test_size=0.3)
# 3. 训练模型
lr_model = linear_model.LinearRegression()
lr_model.fit(lr_X_train, lr_y_train)
# 4. 预测数据
lr_y_pred = lr_model.predict(lr_X_test)
# 5. 评估模型
lr_mse = mean_squared_error(lr_y_test, lr_y_pred)
print("mse:", lr_mse)
# 6. 可视化
plt.figure('Linear Regression')
plt.title('Linear Regression')
plt.scatter(lr_X_test, lr_y_test, color='lavender', marker='o')
plt.plot(lr_X_test, lr_y_pred, color='pink', linewidth=3)
plt.show()

# print info mse: 4.131366697554779

Logistic Regression

Хотя это говорит о регрессии, на самом деле это алгоритм бинарной классификации. Он подгоняет данные к логит-функции, поэтому он называется логит-регрессией. Проще говоря, на основе заданного набора переменных логистическая функция используется для прогнозирования вероятности этого события, что дает результат от 0 до 1. Ссылка на конкретный принцип:Объясните логистическую регрессию человеческими словами — упрощенные статьи, реализация кода приведена ниже.

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

# Logistic Regression 二分类
from sklearn import linear_model

# 1. 准备数据
np.random.seed(123)
logit_X_data = np.random.normal(size=1000)
logit_y_data = (logit_X_data>0).astype(np.float)
logit_X_data[logit_X_data>0]*=5
logit_X_data+=.4*np.random.normal(size=1000)
logit_X_data=logit_X_data[:,np.newaxis]
# 2. 构造训练与测试集
logit_X_train, logit_X_test, logit_y_train, logit_y_test = train_test_split(logit_X_data, logit_y_data, test_size=0.3)
# 3. 训练模型
logit_model=linear_model.LogisticRegression(C=1e4) #classifier
logit_model.fit(logit_X_train,logit_y_train)
# 4. 预测数据
logit_y_pred = logit_model.predict(logit_X_test)
# 5. 评估模型
logit_acc = logit_model.score(logit_X_test,logit_y_pred)
print("accuracy:", logit_acc)
# 5. 可视化
logit_X_view=np.linspace(-7,7,277)
logit_X_view = logit_X_view[:,np.newaxis]
def model(x):
    return 1/(1+np.exp(-x))
loss=model(logit_X_view*logit_model.coef_+logit_model.intercept_).ravel()
plt.figure('Logistic Regression')
plt.title('Logistic Regression')
plt.scatter(logit_X_train.ravel(), logit_y_train, color='lavender',zorder=17)
plt.plot(logit_X_view, loss, color='pink',linewidth=3)

lr_model=linear_model.LinearRegression()
lr_model.fit(logit_X_train,logit_y_train)
plt.plot(logit_X_view, lr_model.predict(logit_X_view), color='blue', linewidth=3)
plt.legend(('Logistic Regression','Linear Regression'),loc='lower right',fontsize='small')

# print info accuracy: 1.0

Naive Bayes

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

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# Naive Bayes 任务为分类, n_classes=4
import sklearn.naive_bayes as nb
# 1. 准备数据
nb_X_train, nb_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 构造训练与测试集
l, r = nb_X_train[:, 0].min() - 1, nb_X_train[:, 0].max() + 1
b, t = nb_X_train[:, 1].min() - 1, nb_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
nb_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 训练模型
nb_model = nb.GaussianNB()
nb_model.fit(nb_X_train, nb_y_train)
# 4. 预测数据
nb_y_pred = nb_model.predict(nb_X_test)
# 5. 可视化
grid_z = nb_y_pred.reshape(grid_x.shape)
plt.figure('Naive Bayes')
plt.title('Naive Bayes')
plt.pcolormesh(grid_x, grid_y, grid_z, cmap='Blues')
plt.scatter(nb_X_train[:, 0], nb_X_train[:, 1], s=30, c=nb_y_train, cmap='pink')
plt.show()

K-Nearest Neighbors

Это алгоритм машинного обучения для классификации и регрессии (в основном для классификации). Он учитывает различные центроиды и использует функцию Евклида для сравнения расстояний. Затем результаты анализируются, и каждая точка сортируется по группам, чтобы оптимизировать ее для размещения со всеми ближайшими точками. Он использует большинство голосов k ближайших соседей, чтобы делать прогнозы классификации данных. Конкретная оригинальная ссылка:Краткий обзор принципов метода K-ближайших соседей (KNN) - Лю Цзяньпин Пинар, реализация кода приведена ниже.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# Naive Bayes 任务为分类, n_classes=4
import sklearn.naive_bayes as nb
# 1. 准备数据
nb_X_train, nb_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 构造训练与测试集
l, r = nb_X_train[:, 0].min() - 1, nb_X_train[:, 0].max() + 1
b, t = nb_X_train[:, 1].min() - 1, nb_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
nb_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 训练模型
nb_model = nb.GaussianNB()
nb_model.fit(nb_X_train, nb_y_train)
# 4. 预测数据
nb_y_pred = nb_model.predict(nb_X_test)
# 5. 可视化
grid_z = nb_y_pred.reshape(grid_x.shape)
plt.figure('Naive Bayes')
plt.title('Naive Bayes')
plt.pcolormesh(grid_x, grid_y, grid_z, cmap='Blues')
plt.scatter(nb_X_train[:, 0], nb_X_train[:, 1], s=30, c=nb_y_train, cmap='pink')
plt.show()

Decision Tree

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

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# K-Nearest Neighbors 任务为分类, n_classes=4
from sklearn.neighbors import KNeighborsClassifier
# 1. 准备数据
knn_X_train, knn_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 构造训练与测试集
l, r = knn_X_train[:, 0].min() - 1, knn_X_train[:, 0].max() + 1
b, t = knn_X_train[:, 1].min() - 1, knn_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
knn_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 训练模型
knn_model = KNeighborsClassifier(n_neighbors=5)
knn_model.fit(knn_X_train, knn_y_train)
# 4. 预测数据
knn_y_pred = knn_model.predict(knn_X_test)
# 5. 可视化
grid_z = knn_y_pred.reshape(grid_x.shape)
plt.figure('K-Nearest Neighbors')
plt.title('K-Nearest Neighbors')
plt.pcolormesh(grid_x, grid_y, grid_z, cmap='Blues')
plt.scatter(knn_X_train[:, 0], knn_X_train[:, 1], s=30, c=knn_y_train, cmap='pink')
plt.show()

Random Forest

Случайный лес — это набор деревьев решений. Случайно выбранные точки данных строят деревья, случайно выбранные подмножества объектов разбиваются, и каждое дерево обеспечивает классификацию. Классификация с наибольшим количеством голосов побеждает в лесу и является окончательной классификацией точек данных. Конкретная оригинальная ссылка:Эксклюзив | Статья для понимания интерпретации и реализации случайных лесов - статья Института науки о данных Университета Цинхуа - Чжиху, реализация кода приведена ниже.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# Decision Tree
from sklearn.tree import DecisionTreeClassifier
# 1. 准备数据
dt_X_train, dt_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 构造训练与测试集
l, r = dt_X_train[:, 0].min() - 1, dt_X_train[:, 0].max() + 1
b, t = dt_X_train[:, 1].min() - 1, dt_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
dt_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 训练模型
dt_model = DecisionTreeClassifier(max_depth=4)
dt_model.fit(dt_X_train, dt_y_train)
# 4. 预测数据
dt_y_pred = dt_model.predict(dt_X_test)
# 5. 可视化
grid_z = dt_y_pred.reshape(grid_x.shape)
plt.figure('Decision Tree')
plt.title('Decision Tree')
plt.pcolormesh(grid_x, grid_y, grid_z, cmap='Blues')
plt.scatter(dt_X_train[:, 0], dt_X_train[:, 1], s=30, c=dt_y_train, cmap='pink')
plt.show()

Support Vector Machines

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

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# SVM
from sklearn import svm
# 1. 准备数据
svm_X_train, svm_y_train = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1, n_classes=4)
# 2. 构造训练与测试集
l, r = svm_X_train[:, 0].min() - 1, svm_X_train[:, 0].max() + 1
b, t = svm_X_train[:, 1].min() - 1,svm_X_train[:, 1].max() + 1
n = 1000
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
svm_X_test = np.column_stack((grid_x.ravel(), grid_y.ravel()))
# 3. 训练模型
# svm_model = RandomForestClassifier(max_depth=4)
svm_model = svm.SVC(kernel='rbf', gamma=1, C=0.0001).fit(svm_X_train, svm_y_train)
svm_model.fit(svm_X_train, svm_y_train)
# 4. 预测数据
svm_y_pred = svm_model.predict(svm_X_test)
# 5. 可视化
grid_z = svm_y_pred.reshape(grid_x.shape)
plt.figure('SVM')
plt.title('SVM')
plt.pcolormesh(grid_x, grid_y, grid_z, cmap='Blues')
plt.scatter(svm_X_train[:, 0], svm_X_train[:, 1], s=30, c=svm_y_train, cmap='pink')
plt.show()

K-Means

Разделите данные на K кластеров, чтобы каждая точка данных принадлежала кластеру, соответствующему ближайшему среднему (т. е. центру кластера, центроиду). Наконец, объекты данных с более высоким сходством делятся на один и тот же кластер, а объекты данных с более высоким несходством делятся на разные кластеры. Ссылка на конкретный принцип:Объяснить быструю кластеризацию kmeans человеческими словами, реализация кода приведена ниже.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets.samples_generator import make_blobs

# K-means 任务为聚类 n_classes=5
from sklearn.cluster import KMeans

# 1. 准备数据
kmeans_X_data, kmeans_y_data = make_blobs(n_samples=500, centers=5, cluster_std=0.60, random_state=0)
# 2. 训练模型
kmeans_model = KMeans(n_clusters=5)
kmeans_model.fit(kmeans_X_data)
# 3. 预测模型
kmeans_y_pred = kmeans_model.predict(kmeans_X_data)
# 4. 可视化
plt.figure('K-Means')
plt.title('K-Means')
plt.scatter(kmeans_X_data[:,0], kmeans_X_data[:, 1], s=50)
plt.scatter(kmeans_X_data[:, 0], kmeans_X_data[:, 1], c=kmeans_y_pred, s=50, cmap='viridis')
centers = kmeans_model.cluster_centers_
plt.scatter(centers[:,0], centers[:, 1], c='red', s=80, marker='x')
plt.show()

PCA

Обычно используемый метод уменьшения размерности, как следует из названия, PCA помогает нам найти основные компоненты данных.Главные компоненты в основном представляют собой линейно некоррелированные векторы, а выбранные k основных компонентов используются для представления данных для достижения цели размерности. снижение. Ссылка на конкретный принцип:Как доступно объяснить, что такое анализ главных компонентов PCA? - Ответ студентки Ма - Зная, реализация кода приведена ниже.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# PCA
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris

# 1. 准备数据
pca_data=load_iris()
pca_X_data=pca_data.data
pca_y_data=pca_data.target
# 2. 训练模型, 维度为2
pca_model=PCA(n_components=2)  
# 3. 降维
reduced_X=pca_model.fit_transform(pca_X_data)
# 4. 可视化
red_x,red_y=[],[]
blue_x,blue_y=[],[]
green_x,green_y=[],[]

for i in range(len(reduced_X)):
 if pca_y_data[i] ==0:
  red_x.append(reduced_X[i][0])
  red_y.append(reduced_X[i][1])
 elif pca_y_data[i]==1:
  blue_x.append(reduced_X[i][0])
  blue_y.append(reduced_X[i][1])
 else:
  green_x.append(reduced_X[i][0])
  green_y.append(reduced_X[i][1])

plt.figure('PCA')
plt.title('PCA')
plt.scatter(red_x,red_y,c='r')
plt.scatter(blue_x,blue_y,c='b')
plt.scatter(green_x,green_y,c='g')
plt.show()

Суммировать

На данный момент была дана реализация 9 распространенных алгоритмов машинного обучения, и субъект может лучше понять и ознакомиться с алгоритмами на некоторых практических примерах. Overseas Kaggle и Alibaba Cloud Tianchi — хорошие способы получить проектный опыт.