Qu'est-ce que l'apprentissage supervisé (classification)?

Qu'est-ce que la «classification»?

L'apprentissage automatique est divisé en trois domaines principaux Parmi eux, cela correspond à 1-1.

1, apprentissage supervisé Apprenez le modèle à partir des données d'entraînement avec l'étiquette de réponse correcte Faites des prédictions pour les données inconnues. L'apprentissage supervisé est classé dans les deux catégories suivantes.

1-1, problème de classification Il apprend les données divisées par catégorie et prédit la catégorie (valeur discrète) des données inconnues. Ce contenu vous aidera à comprendre l'algorithme de ce problème de classification et à implémenter un problème simple. Des exemples d'applications pratiques incluent le jugement de spam par e-mail.

1-2, problème de retour (apprentissage enseigné (retour)) Contrairement au problème de classification, cela prédit des valeurs continues. Les prévisions de cours des actions sont classées ici.

2, apprentissage sans enseignant (apprentissage sans enseignant) Pour les données qui n'ont pas d'étiquette de réponse correcte ou dont la structure est inconnue Cela signifie que la machine trouve la structure et la relation des données. Les exemples incluent les tendances des clients de détail et le regroupement.

3, renforcer l'apprentissage Le but est d'améliorer les performances en fonction de l'interaction avec l'environnement. Fixez des récompenses pour les actions et entraînez-les à prendre des mesures qui profiteront à leurs objectifs en fonction de leur état. Un exemple est l'IA compétitive comme Go.

Classification binaire et multi-termes

Les problèmes de classification peuvent être largement divisés en problèmes de classification binaires et multi-termes.

Classification binaire (également appelée classification binaire ou classification à deux classes)

Les catégories (appelées classes) à classer sont deux problèmes de classification. Il ne peut être identifié que par «appartenant / n'appartenant pas» à l'un ou l'autre des groupes. Si une ligne droite peut faire la distinction entre les classes, on parle de classification linéaire, et sinon, on parle de classification non linéaire.

Classification multi-termes (également appelée classification multi-classes)

C'est un problème de classification avec trois classes ou plus. Cela ne peut pas être identifié simplement par «appartenir / n'appartenir» à aucun groupe. Dans de nombreux cas, il ne peut pas être identifié simplement par une ligne droite.

Flux de classification

L'apprentissage automatique comporte une série de flux, comme indiqué ci-dessous. Dans la section "2. Sélectionner un algorithme", vous sélectionnerez différents "algorithmes de classification".

Dans le modèle «d'apprentissage supervisé (classification)», l'algorithme de classification optimal est sélectionné et le modèle est créé en fonction de l'objectif. Un réglage est nécessaire pour des performances maximales.

Prétraitement des données Mise en forme et manipulation des données
Sélection de l'algorithme Sélectionnez un algorithme et créez un modèle
Apprentissage de modèles Sélection d'hyper paramètres à régler Réglage des paramètres
Prédiction du modèle (inférence) Vérification de l'exactitude du modèle à l'aide de données inconnues Incorporer dans les services WEB, etc., et exploiter réellement le modèle d'IA

Comment préparer les données (1)

Lors du déplacement du code et de l'apprentissage des différentes méthodes de classification, il est nécessaire de préparer des données qui peuvent être classifiées. Au niveau pratique, il est nécessaire d'obtenir une valeur réellement mesurée et de la façonner. Cette fois, je vais omettre cette partie et créer des données de classification fictives pour la pratique par moi-même. Je vais vous présenter comment obtenir des exemples de données.

Pour créer des données fictives adaptées à la classification

scikit-learn.du module jeux de données
make_classification()Est utilisé.

La classification de l'apprentissage supervisé nécessite des données et une étiquette indiquant à quelle classe les données appartiennent. Si vous utilisez make_classification (), vous pouvez définir n'importe quel nombre de données et le type d'étiquette comme arguments.

#Importation de module
from sklearn.datasets import make_classification
#Données X,Génération d'étiquette y
X, y = make_classification(n_samples=XX, n_classes=XX, n_features=XX, n_redundant=XX, random_state=XX

Chaque argument de la fonction ci-dessus est le suivant.

n_samples
#Nombre de données à préparer
n_classes
#Nombre de cours. S'il n'est pas spécifié, la valeur sera 2.
n_features
#Nombre d'entités de données
n_redundant
#Nombre de fonctionnalités (fonctionnalités supplémentaires) inutiles pour la classification
random_state
#Graine aléatoire (facteur qui détermine le modèle de nombres aléatoires)

Il y a d'autres arguments, mais dans ce contenu, nous allons créer les données qui les définissent. De plus, une "étiquette (y)" qui indique à quelle classe les données appartiennent est préparée, mais fondamentalement l'étiquette est préparée par une valeur entière. Par exemple, dans le cas d'une classification binaire, le libellé de chaque donnée est "0" ou "1".

Comment préparer les données (2)

La bibliothèque scikit-learn est principalement utilisée pour implémenter des algorithmes de classification.

Cependant, la bibliothèque scicit-learn a non seulement ces derniers, mais aussi le prétraitement des données et l'ajustement du modèle. Des fonctions d'évaluation sont également fournies.

Il existe également plusieurs ensembles de données disponibles pour tester et tester l'algorithme. Les données peuvent être appelées en spécifiant le module. Ici, nous allons introduire l'un d'entre eux, la méthode d'acquisition des données Iris.

Qu'est-ce que les données Iris Quatre grandeurs caractéristiques (unité: cm) de "longueur de morceau de rebut", "largeur de morceau de rebut", "longueur de pétale" et "largeur de pétale" d'un échantillon de 150 iris (un type de fleur). Et 3 types de variétés (0 ~ 2) sont stockés.

Ici, nous n'utiliserons que deux grandeurs de caractéristiques, «la longueur de l'épée» et «la longueur des pétales», dans le but de visualiser les données.

# scikit-apprendre l'importation de bibliothèque du module detaset
from sklearn import datasets
import numpy as np

#Obtenez des données
iris = datasets.load_iris()
#Stocke les 0e et 2e colonnes d'iris
X = iris.data[:, [0, 2]]
#Stocke les étiquettes de classe d'iris
y = iris.target

Également, pour évaluer les performances du modèle entraîné avec des données inconnues Divisez davantage l'ensemble de données en données d'entraînement et de test.

Utilisation de train_test_split () dans le module model_selection de scicit-learn comme suit: Les séquences X et y sont divisées aléatoirement en 30% de données de test et 70% de données d'entraînement.

from sklearn.model_selection import train_test_split

train_X, test_X, train_y, test_y = train_test_split(
    X, y, test_size=0.3, random_state=42)

Apprentissage et prédiction

Dans l'apprentissage automatique, il existe plusieurs algorithmes. Un aperçu d'une série d'étapes allant de l'apprentissage à partir des données de l'enseignant selon un algorithme à la prédiction d'une étiquette. Cela s'appelle un modèle.

Il est difficile de mettre en œuvre vous-même tous les modèles d'apprentissage automatique Il existe de nombreuses bibliothèques en Python spécialisées dans l'apprentissage automatique. Parmi eux, scikit-learn est une bibliothèque dans laquelle des modèles d'apprentissage automatique sont préparés à l'avance.

Voyons maintenant comment utiliser le classificateur de modèle fictif comme exemple.

#Importation de module
#Reportez-vous à différents modules pour chaque modèle(L'exemple suivant)
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC, SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier

#Construire un modèle
model = Classifier()
#Apprentissage de modèle
model.fit(train_X, train_y)
#Prédire les données par modèle
model.predict(test_X)

#Taux de précision du modèle
#Le taux de réponse correct est(Le nombre de données qui correspond à la classification prévue du modèle avec la classification réelle) ÷ (Nombre total de données)Est calculé par
model.score(test_X, test_y)

Lors de l'écriture de code d'apprentissage automatique réel

Classifier()La partie de sera remplacée par le modèle réel.

En utilisant scikit-learn, il est intéressant de pouvoir pratiquer l'apprentissage automatique assez simplement comme décrit ci-dessus.

Méthode principale

Retour logistique

La régression logistique est une méthode de classification des données en trouvant des limites de données linéairement séparables par entraînement.

Le graphique ci-dessus semble pouvoir faire une ligne droite pour identifier les couleurs.

Données pouvant être divisées en groupes de catégories de données par une ligne droite comme celle-ci

C'est ce qu'on appelle des données séparables linéairement.

La caractéristique est que la ligne de démarcation devient une ligne droite. Par conséquent, il est utilisé pour les données avec peu de classes telles que la classification binomiale. Il est également possible de calculer la probabilité que les données soient classées en classes. Il est principalement utilisé lorsque vous souhaitez connaître la probabilité de classification telle que «probabilité de précipitation des prévisions météorologiques» à partir de ces caractéristiques.

L'inconvénient est que les données d'apprentissage doivent être linéairement séparables avant de pouvoir être classées. Il ne convient pas non plus aux données clairsemées de grande dimension.

En outre, les limites apprises à partir des données d'entraînement passeront juste à côté des données à la limite de la classe. Un autre inconvénient est qu'il ne devient pas facilement une frontière généralisée (faible capacité de généralisation).

Le modèle de régression logistique est

scikit-apprendre la bibliothèque linéaire_Dans le sous-module modèle
LogisticRegression()Est défini comme.

Lors de l'entraînement avec un modèle de régression logistique, écrivez un code similaire au suivant pour appeler le modèle.

#Appeler le modèle du package
from sklearn.linear_model import LogisticRegression

#Construire un modèle
model = LogisticRegression()

#Former le modèle
# train_data_detail est une collection d'informations utilisée pour prédire la catégorie de données
# train_data_label est le label de la classe à laquelle appartiennent les données
model.fit(train_data_detail, train_data_label)

#Laissez le modèle prédire
model.predict(data_detail)

#Taux de réponse correct du résultat de la prédiction du modèle
model.score(data_detail, data_true_label)

Dans le travail de visualisation, utilisez le modèle entraîné Comment diviser les données en faisant des prédictions pour tous les points de tracé fin dans le graphique Il peut être montré par couleur.

Utilisez la bibliothèque matplotlib pour visualiser le graphique. Visualisez et comparez d'autres modèles de formation de la même manière.


#Tracez toutes les données sur un diagramme de dispersion et séparez les couleurs pour chaque étiquette
plt.scatter(X[:, 0], X[:, 1], c=y, marker=".",
            cmap=matplotlib.cm.get_cmap(name="cool"), alpha=1.0)
#Déterminez la plage du graphique
x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
#Graphique 0.Stocke les coordonnées de l'intersection lorsqu'elles sont séparées par 02
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, 0.02),
                       np.arange(x2_min, x2_max, 0.02))
#Tout xx1,Prédire avec un modèle d'entraînement pour xx2 paires
Z = model.predict(np.array([xx1.ravel(), xx2.ravel()]).T).reshape((xx1.shape))
#Coordonner(xx1, xx2)Dessiner Z sur
plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=matplotlib.cm.get_cmap(name="Wistia"))
#Spécifiez la plage, l'étiquette, le titre, la grille
plt.xlim(xx1.min(), xx1.max())
plt.ylim(xx2.min(), xx2.max())
plt.title("classification data using LogisticRegression")
plt.xlabel("Sepal length")
plt.ylabel("Petal length")
plt.grid(True)
plt.show()
np.La méthode meshgrid est x, y, ...Créez une matrice de coordonnées de n.

import numpy as np

#X dans la figure ci-dessous
x = np.array([1, 2, 3])

#Y dans la figure ci-dessous
y = np.array([4, 5])

x1, y1 = np.meshgrid(x,y)

print(x1)
print()
print(y1)
#production
[[1 2 3]
 [1 2 3]]

[[4 4 4]
 [5 5 5]]

SVM linéaire

SVM (Support Vector Machine) trouve les limites des données comme la régression logistique Il s'agit d'une méthode de classification des données. Sa plus grande caractéristique est un vecteur appelé vecteur de support.

Un vecteur de support est un groupe de données proche d'autres classes. En vous basant sur le vecteur de support, tracez une ligne de démarcation à la position où la distance est la plus grande. Les bordures sont dessinées pour maximiser la distance d'une classe à une autre (maximiser la marge)

Par rapport à la régression logistique, SVM trace la frontière de classification au point le plus éloigné entre les deux classes. Elle a tendance à être généralisée et la prévision de classification des données a tendance à s'améliorer. Une autre caractéristique est qu'il est facile de faire un chemin car il suffit de considérer le vecteur de support pour déterminer la ligne de démarcation.

Comme inconvénient (1) À mesure que la quantité de données augmente, la quantité de calcul augmente, de sorte que l'apprentissage et la prédiction ont tendance à être plus lents que les autres méthodes. (2) Comme pour la régression logistique, la classification ne peut être effectuée correctement que si les données d'entrée peuvent être séparées linéairement (un état dans lequel une surface de frontière droite peut être dessinée).

Un SVM qui trace une ligne droite et la classe est appelé SVM linéaire.

SVM linéaire, scicit-apprendre LinearSVC()Il peut être implémenté avec.

from sklearn.svm import LinearSVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

#Génération de données
X, y = make_classification(n_samples=100, n_features=2,
                           n_redundant=0, random_state=42)

#Divisez les données en données d'enseignants et en données que vous souhaitez prédire
train_X, test_X, train_y, test_y = train_test_split(X, y, random_state=42)

#Construire un modèle
model = LinearSVC()
#Apprentissage de modèle
model.fit(train_X, train_y)

#Taux de réponse correct de sortie
model.score(test_X, test_y)

Le taux de précision est pour test_X et test_y. Puisque le taux de réponse correct pour train_X et train_y n'est pas calculé Même si le taux de précision de sortie est de 100%, certains graphiques peuvent être mal classés.

La visualisation des limites peut être effectuée avec le code suivant, similaire à la méthode de régression logistique.

import matplotlib
import matplotlib.pyplot as plt
import numpy as np

#Ci-dessous le travail de visualisation
plt.scatter(X[:, 0], X[:, 1], c=y, marker=".",
            cmap=matplotlib.cm.get_cmap(name="cool"), alpha=1.0)

x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, 0.02),
                       np.arange(x2_min, x2_max, 0.02))
Z = model.predict(np.array([xx1.ravel(), xx2.ravel()]).T).reshape((xx1.shape))
plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=matplotlib.cm.get_cmap(name="Wistia"))
plt.xlim(xx1.min(), xx1.max())
plt.ylim(xx2.min(), xx2.max())
plt.title("classification data using LinearSVC")
plt.grid(True)
plt.show()

SVM non linéaire

Le SVM linéaire est un excellent modèle qui est facile à comprendre et a une grande généralité, mais il présente l'inconvénient de ne pas être utilisé à moins que les données d'entrée ne soient séparées linéairement.

Le SVM non linéaire est un modèle développé pour éliminer les lacunes du SVM.

Comme le montre la figure ci-dessus, en manipulant les données en effectuant un traitement mathématique selon une formule de conversion appelée fonction noyau. Les données d'entrée peuvent être séparables linéairement.

Un modèle qui effectue un tel traitement et utilise SVM est un SVM non linéaire.

L'opération par la fonction noyau est compliquée, mais vous n'avez pas à calculer l'opération. On l'appelle aussi une astuce du noyau car il est possible de classer si le produit interne après avoir manipulé les données est obtenu.

scikit-SVC dans le sous-module apprendre svm()Est utilisé.

import matplotlib
from sklearn.svm import SVC
from sklearn.datasets import make_gaussian_quantiles
import matplotlib.pyplot as plt

#Génération de données
#Puisque ces données ne sont pas séparables linéairement, préparez d'autres données
data, label = make_gaussian_quantiles(n_samples=1000, n_classes=2, n_features=2, random_state=42)

#Construire un modèle
#Utilisez SVC au lieu de LinearSVC pour classer les données séparables de manière non linéaire
model = SVC()
#Apprentissage de modèle
model.fit(data,label)

#Calcul du taux de réponse correcte
model.score(data,label)

Si cela est également émis de la même manière, ce sera comme suit

C'est le contraste entre non linéaire et linéaire.

Arbre de décision

L'arbre de décision est différent de la régression logistique et de la SVM introduites jusqu'à présent. Focus sur chacun des éléments de données (variables explicatives) C'est une méthode pour déterminer la classe à laquelle appartiennent les données en divisant les données à une certaine valeur dans l'élément.

Dans l'arbre de décision, vous pouvez voir dans quelle mesure chaque variable explicative affecte la variable objectif. Il se ramifie en répétant la division, mais on peut considérer que la variable qui est divisée en premier a une plus grande influence.

L'inconvénient est que je ne suis pas doué pour les données linéairement inséparables (Par exemple, dans les données 2D, la ligne de démarcation ne peut pas être tracée en diagonale), la formation est trop proche des données de l'enseignant (non généralisée).

scikit-DecisionTreeClassifier dans le sous-module de l'arbre d'apprentissage()Est utilisé.

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, random_state=42)

#Divisez en données d'entraînement et en données de test
train_X, test_X, train_y, test_y = train_test_split(X, y, random_state=42)

#Construire un modèle
model = DecisionTreeClassifier()

#Apprentissage de modèle
model.fit(train_X, train_y)

#Calcul du taux de réponse correcte
model.score(test_X, test_y)

Le résultat de la visualisation de la frontière de la même manière est le suivant.

Forêt aléatoire

Il s'agit d'une méthode permettant de créer plusieurs versions simplifiées de l'arbre de décision susmentionné et de décider du résultat de la classification à la majorité. Entraînez plusieurs classificateurs simples dans un classificateur C'est aussi un type d'apprentissage appelé apprentissage d'ensemble.

Alors que toutes les variables explicatives utilisées dans l'arbre de décision ont été utilisées, chaque arbre de décision de la forêt aléatoire Tente de déterminer la classe à laquelle appartiennent les données en utilisant seulement un petit nombre de variables explicatives déterminées au hasard. Ensuite, la classe avec le plus de sortie parmi les classes sorties de plusieurs arbres de décision simples est sortie en conséquence.

Une caractéristique des forêts aléatoires est que, comme un arbre décisionnel, les valeurs aberrantes sont moins susceptibles d'affecter les résultats. Il peut également être utilisé pour classer des ensembles de données avec des discriminants complexes qui ne sont pas linéairement séparables.

L'inconvénient est que, comme pour l'arbre de décision, si le nombre de données est petit par rapport au nombre de variables explicatives, la dichotomie ne peut pas être divisée et la précision de la prédiction diminuera.

Utilisez RandomForestClassifier () dans le sous-module d'ensemble de scikit-learn.

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, random_state=42)

#Divisez en données d'entraînement et en données de test
train_X, test_X, train_y, test_y = train_test_split(X, y, random_state=42)

#Construire un modèle
model = RandomForestClassifier()

#Apprentissage de modèle
model.fit(train_X, train_y)

#Calcul du taux de réponse correcte
model.score(test_X, test_y)

En ce qui concerne ce qui précède, le résultat de la visualisation de la frontière est le suivant. Vous pouvez voir qu'il a une limite similaire à l'arbre de décision. En effet, Random Forest fait l'apprentissage d'ensemble de l'algorithme d'arbre de décision (pour améliorer les performances de généralisation en fusionnant plusieurs apprenants appris individuellement).

k-NN

k-NN, également connue sous le nom de méthode k-voisinage, trouve des données similaires aux données prédictives C'est une méthode pour décider du résultat du classement par décision majoritaire.

Il s'agit d'une méthode d'apprentissage appelée apprentissage paresseux, caractérisée par un coût d'apprentissage (quantité de calcul nécessaire pour l'apprentissage) de 0.

Différent des méthodes introduites jusqu'à présent k-NN n'apprend pas à partir des données de l'enseignant, mais se réfère directement aux données de l'enseignant au moment de la prédiction pour prédire l'étiquette. La méthode de prédiction du résultat est la suivante.

Réorganisez les données de l'enseignant en fonction de la similitude avec les données utilisées pour la prédiction. 2, se référer à l'ensemble de données k dans le classificateur par ordre décroissant de similitude. 3, affichez la classe la plus courante parmi les classes auxquelles les données d'enseignant référencées appartiennent comme résultat de la prédiction.

Les caractéristiques de k-NN sont que le coût d'apprentissage est de 0 comme mentionné ci-dessus, que l'algorithme est relativement simple mais qu'il est facile d'obtenir une précision de prédiction élevée et qu'il est facile d'exprimer les limites de formes complexes. Peut être mentionné. Comme inconvénient

1, si le nombre de nombres naturels kk spécifié dans le classificateur est trop augmenté, la plage d'identification sera moyennée et la précision de la prédiction diminuera. 2, puisque le calcul est effectué à chaque fois que la prédiction est faite, la quantité de calcul augmente à mesure que la quantité de données d'enseignant et de données de prédiction augmente, ce qui entraîne un algorithme lent.

L'image ci-dessous montre la différence dans le processus de classification due à la différence du nombre de kk. Lorsque k = 3k = 3, les points gris devraient être bleu clair car il y a plus de points bleu clair autour, mais lorsque k = 7k = 7, il y a plus de points verts, donc ils sont verts. Cela se transforme en une prédiction que c'est un point.

scikit-KNeighborsClassifier dans l'apprentissage des voisins du sous-module()Est utilisé.

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, random_state=42)

#Divisez en données d'entraînement et en données de test
train_X, test_X, train_y, test_y = train_test_split(X, y, random_state=42)

#Construire un modèle
model = KNeighborsClassifier()
#Apprentissage de modèle
model.fit(train_X, train_y)

#Calcul du taux de réponse correcte
model.score(test_X, test_y)

Une visualisation des limites de ce modèle est, par exemple:

Python: apprentissage supervisé (classification)