Quels sont les algorithmes courants pour l'apprentissage supervisé ? Comment sont-ils appliqués ?

​Qu'est-ce que l'apprentissage supervisé ?

L'apprentissage supervisé est un sous-ensemble de l'apprentissage automatique. L'apprentissage supervisé étiquette les données d'entrée du modèle d'apprentissage automatique et les exerce. Par conséquent, le modèle supervisé peut prédire au maximum la sortie du modèle.

Le concept derrière l'apprentissage supervisé se retrouve également dans la vie réelle, comme les enseignants qui donnent des cours particuliers aux enfants. Supposons que l’enseignant veuille apprendre aux enfants à reconnaître les images de chats et de chiens. Il / elle encadrera l'enfant en lui montrant continuellement une image d'un chat ou d'un chien tout en l'informant si l'image est un chien ou un chat.

Le processus d'affichage et d'information des images peut être considéré comme des données d'étiquetage Au cours du processus de formation du modèle d'apprentissage automatique, il vous sera indiqué quelles données appartiennent à quelle catégorie.

A quoi sert l’apprentissage supervisé ? L’apprentissage supervisé peut être utilisé à la fois pour les problèmes de régression et de classification. Les modèles de classification permettent aux algorithmes de déterminer à quel groupe appartiennent les données données. Les exemples peuvent inclure Vrai/Faux, Chien/Chat, etc.

Étant donné que le modèle de régression peut prédire les valeurs futures sur la base de données historiques, il peut être utilisé pour prédire les salaires des employés ou les prix de vente de l'immobilier.

Dans cet article, nous énumérerons quelques algorithmes courants utilisés pour l'apprentissage supervisé, ainsi que des tutoriels pratiques sur ces algorithmes.

Régression linéaire

La régression linéaire est un algorithme d'apprentissage supervisé qui prédit une valeur de sortie en fonction d'une valeur d'entrée donnée. La régression linéaire est utilisée lorsque la variable cible (de sortie) renvoie une valeur continue.

Il existe deux principaux types d'algorithmes linéaires, la régression linéaire simple et la régression linéaire multiple.

La régression linéaire simple utilise une seule variable indépendante (d'entrée). Un exemple est de prédire l'âge d'un enfant en fonction de sa taille.

D'un autre côté, la régression linéaire multiple peut utiliser plusieurs variables indépendantes pour prédire ses résultats finaux. Un exemple consiste à prédire le prix d’une propriété donnée en fonction de son emplacement, de sa taille, de la demande, etc.

Voici la formule de régression linéaire

Pour l'exemple Python, nous utiliserons la régression linéaire pour prédire la valeur y par rapport à une valeur x donnée.

L'ensemble de données qui nous est fourni ne contient que deux colonnes : x et y. Notez que le résultat y renverra des valeurs continues.

Voici une capture d'écran de l'ensemble de données donné :

Exemple de modèle de régression linéaire utilisant Python

1 Importez les bibliothèques nécessaires

import numpy as np <br>import pandas as pd <br>import matplotlib.pyplot as plt <br>import seaborn as sns from sklearn <br>import linear_model from sklearn.model_selection <br>import train_test_split import os

2. Pour simplifier l'ensemble de données, nous avons pris un échantillon de 50 lignes de données et arrondi les valeurs des données à 2 chiffres significatifs.

Veuillez noter que vous devez importer l'ensemble de données donné avant de terminer cette étape.

df = pd.read_csv("../input/random-linear-regression/train.csv") <br>df=df.sample(50) df=round(df,2)

3. Filtrage des valeurs nulles et infinies

Si l'ensemble de données contient des valeurs nulles et infinies, des erreurs peuvent survenir. Par conséquent, nous utiliserons la fonction clean_dataset pour nettoyer l'ensemble de données de ces valeurs.

def clean_dataset(df): <br>assert isinstance(df, pd.DataFrame), "df needs to be a pd.DataFrame" <br>df.dropna(inplace=True) <br>indices_to_keep = ~df.isin([np.nan, np.inf, -np.inf]).any(1) <br>return df[indices_to_keep].astype(np.float64)<br>df=clean_dataset(df)

4. Sélectionnez nos valeurs dépendantes et indépendantes

Veuillez noter que nous convertissons les données au format ​

​

DataFrame. Le type de données ​​dataframe est une structure bidimensionnelle qui aligne nos données en lignes et en colonnes. 5. Divisez l'ensemble de données

Nous divisons l'ensemble de données en parties de formation et de test. La taille de l’ensemble de données de test a été choisie pour représenter 20 % de l’ensemble de données total.

Veuillez noter qu'en définissant random_state=1, chaque fois que le modèle est exécuté, la même répartition des données se produira, ce qui entraînera exactement les mêmes ensembles de données d'entraînement et de test.

Cela est utile dans les situations où vous souhaitez peaufiner davantage le modèle.

x_train,  x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=1)

6.建立线性回归模型

使用导入的线性回归模型，我们可以在模型中自由使用线性回归算法，绕过我们为给定模型获得的 x 和 y 训练变量。

lm=linear_model.LinearRegression() lm.fit(x_train,y_train)

7. 以分散的方式绘制我们的数据

df.plot(kind="scatter", x="x", y="y")

8. 绘制我们的线性回归线

plt.plot(X,lm.predict(X), color="red")

蓝点表示数据点，而红线是模型绘制的最佳拟合线性回归线。线性模型算法总是会尝试绘制最佳拟合线以尽可能准确地预测结果。

逻辑回归

与线性回归类似，​​逻辑回归​​根据输入变量预测输出值，两种算法的主要区别在于逻辑回归算法的输出是分类（离散）变量。

对于 Python的示例，会使用逻辑回归将“花”分成两个不同的类别/种类。在给定的数据集中会包括不同花的多个特征。

模型的目的是将给花识别为Iris-setosa、Iris-versicolor或 Iris-virginica 几个种类。

下面是给定数据集的截图：

使用 Python 的逻辑回归模型示例

1.导入必要的库

import numpy as np <br>import pandas as pd from sklearn.model_selection <br>import train_test_split import warnings warnings.filterwarnings('ignore')

2. 导入数据集

data = pd.read_csv('../input/iris-dataset-logistic-regression/iris.csv')

3. 选择我们依赖和独立的价值观

对于独立 value(x) ，将包括除类型列之外的所有可用列。至于我们的可靠值（y），将只包括类型列。

X = data[['x0','x1','x2','x3','x4']] <br>y = data[['type']]

4. 拆分数据集

将数据集分成两部分，80% 用于训练数据集，20% 用于测试数据集。

X_train,X_test,y_train,y_test = train_test_split(X,y, test_size=0.2, random_state=1)

5. 运行逻辑回归模型

从 linear_model 库中导入整个逻辑回归算法。然后我们可以将 X 和 y 训练数据拟合到逻辑模型中。

from sklearn.linear_model import LogisticRegression <br>model = LogisticRegression(random_state = 0) <br>model.fit(X_train, y_train)

6. 评估我们模型的性能

print(lm.score(x_test, y_test))

返回值为0.9845128775509371，这表明我们模型的高性能。

请注意，随着测试分数的增加，模型的性能也会增加。

7. 绘制图表

import matplotlib.pyplot as plt %matplotlib inline <br>plt.plot(range(len(X_test)), pred,'o',c='r')

输出图：

在逻辑图中，红点表示给定的数据点。这些点清楚地分为 3 类，Virginica、versicolor 和 setosa 花种。

使用这种技术，逻辑回归模型可以根据花在图表上的位置轻松对花类型进行分类。

支持向量机

​​支持向量机​​( SVM) 算法是另一个著名的监督机器学习模型，由 Vladimir Vapnik 创建，它能够解决分类和回归问题。实际上它更多地被用到解决分类问题。

SVM 算法能够将给定的数据点分成不同的组。算法在绘制出数据之后，可以绘制最合适的线将数据分成多个类别，从而分析数据之间的关系。

如下图所示，绘制的线将数据集完美地分成 2 个不同的组，蓝色和绿色。

SVM 模型可以根据图形的维度绘制直线或超平面。行只能用于二维数据集，这意味着只有 2 列的数据集。

如果是多个特征来预测数据集，就需要更高的维度。在数据集超过 2 维的情况下，支持向量机模型将绘制超平面。

在支持向量机 Python 的示例中，将对 3 种不同的花卉类型进行物种分类。我们的自变量包括花的所有特征，而因变量是花所属物种。

花卉品种包括Iris-setosa、 Iris-versicolor和Iris-virginica。

下面是数据集的截图：

使用 Python 的支持向量机模型示例

1.导入必要的库

import numpy as np <br>import pandas as pd from sklearn.model_selection <br>import train_test_split from sklearn.datasets <br>import load_iris

2. 读取给定的数据集

请注意，在执行此步骤之前，应该导入数据集。

data = pd.read_csv(‘../input/iris-flower-dataset/IRIS.csv’)

3. 将数据列拆分为因变量和自变量

将 X 值作为自变量，其中包含除物种列之外的所有列。

因变量y仅包含模型预测的物种列。

X = data.drop(‘species’, axis=1) y = data[‘species’]

4. 将数据集拆分为训练和测试数据集

将数据集分为两部分，其中我们将 80% 的数据放入训练数据集中，将 20% 放入测试数据集中。

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)

5.导入SVM并运行模型

导入了支持向量机算法。然后，使用上面步骤中收到的 X 和 y 训练数据集运行它。

from sklearn.svm import SVC <br>model = SVC( ) <br>model.fit(X_train, y_train)

6. 测试模型的性能

model.score(X_test, y_test)

为了评估模型的性能，将使用 score 函数。在第四步中创建的 X 和 y 测试值输入到 score 方法中。

返回值为0.9666666666667，这表明模型的高性能。

请注意，随着测试分数的增加，模型的性能也会增加。

Autres algorithmes d'apprentissage automatique supervisé populaires

Bien que les algorithmes linéaires, logistiques et SVM soient très fiables, il existe également willa mentionné certains algorithmes d'apprentissage automatique supervisé.

1. Décisionarbre

​​ L'algorithme d'arbre de décision​​ est un A utile modèle d'apprentissage automatique supervisé qui utilise une structure arborescente pour la prise de décision. Les arbres de décision sont souvent utilisés dans les problèmes de classification dans lesquels un modèle peut décider à quel groupe appartient un élément donné dans un ensemble de données.

Veuillez noter que le format arbre utilisé est un format arbre inversé.

2. Random Forest

est considéré comme un algorithme plus complexe, ​​ Algorithme de forêt aléatoire​ ​Atteignez son objectif ultime en construisant un grand nombre d'arbres de décision.

signifie construire plusieurs arbres de décision simultanément, chacun renvoyant ses propres résultats, qui sont ensuite combinés pour obtenir un meilleur résultat.

Pour les problèmes de classification, le modèle de forêt aléatoire générera plusieurs arbres de décision et classera un objet donné en fonction du groupe de classification prédit par la majorité des arbres.

Le modèle peut résoudre le problème de surapprentissage causé par un seul arbre. De plus, l'algorithme de forêt aléatoire peut également être utilisé pour la régression, bien qu'il puisse conduire à des résultats indésirables.

3. kRecent​​neighbour​​ (KNN) est une méthode d'apprentissage automatique supervisé qui regroupe toutes les données données dans des groupes distincts.

Ce regroupement est basé sur des caractéristiques communes entre différents individus. L'algorithme KNN peut être utilisé à la fois pour des problèmes de classification et de régression. L'exemple

classique de KNN consiste à classer les images d'animaux en différents groupes.

Résumé

Cet article a présenté l'apprentissage automatique supervisé et les deux types de problèmes qu'il peut résoudre , a expliqué le problème de classification et de régression, donne quelques exemples de chaque type de données de sortie.

explique en détail ce qu'est la régression linéaire et comment elle fonctionne, et fournit un exemple concret en Python que prédira en fonction de la valeur Y des variables X indépendantes.

Puis et ont introduit modèle de régression logistique , et donne un exemple de modèle de classification qui donnera Certaines catégories d'images sont types de fleurs spécifiques.

Pour l'algorithme de la machine à vecteurs de support, peut être utilisé pour prédire une espèce de fleur donnée de 3 espèces de fleurs différentes. Enfin répertorie d'autres algorithmes d'apprentissage automatique supervisé célèbres tels que l'arbre de décision, la forêt aléatoire et l'algorithme K le plus proche voisin.

Que vous lisiez ceci pour apprendre , pour le travail ou pour le plaisir, nous pensons que comprendre ces algorithmes est le point de départ Entrez dans la machine Un début dans le domaine de l'apprentissage.

Si vous êtes intéressé et souhaitez en savoir plus sur le domaine de l'apprentissage automatique, nous vous recommandons de vous plonger dans comment fonctionnent ces algorithmes et comment ajuster ces modèles pour améliorer encore leur performance.

Introduction du traducteur

Cui Hao, rédacteur de communauté 51CTO, architecte senior, a 18 ans d'expérience en développement de logiciels et en architecture, 10 ans d'expérience en architecture distribuée. Anciennement expert technique chez HP. Il est prêt à partager et a écrit de nombreux articles techniques populaires avec plus de 600 000 lectures. ​​Auteur de "Principes et pratique de l'architecture distribuée"​​.

Titre original : ​Algorithmes d'apprentissage supervisé primaires utilisés dans l'apprentissage automatique​, auteur : Kevin Vu

​

​

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!