Modèle, prédiction, solution

Vous êtes maintenant prêt à entraîner vos données d'entraînement, à créer un modèle et à faire des prédictions. Il existe plus de 60 algorithmes d'apprentissage automatique qui peuvent être utilisés pour créer des modèles.

En pratique, vous devez comprendre le type de problème et les exigences de la solution et choisir le bon algorithme. Le graphique montre quel type d'algorithme doit être sélectionné en fonction du type de problème à résoudre et du nombre d'éléments de données. C'est ouvert au public. Faisons bon usage de ces informations.

scikit-learn argorithm cheat sheet

Les problèmes de prédiction peuvent être divisés en deux catégories: la classification et la régression.

1, classification

La classification peut prédire en divisant les données en classes La régression vous permet de prédire les nombres à partir des données. Par exemple, sur le côté gauche de la figure ci-dessous, une ligne de classification est dessinée à partir des données et elle est divisée en classe A et classe B.

Étant donné que les nouvelles données ☆ appartiennent au côté de classe A, il peut être prédit qu'il s'agit de la classe A. Sur le côté droit de la figure ci-dessous, une ligne de régression est tracée à partir des données pour obtenir la valeur prédite des nouvelles données ☆. Ces mécanismes sont utilisés pour identifier si une image est un chien ou un chat, prédire si l'équipement se cassera ou non et prévoir les ventes. Il a été appliqué et déborde de nous.

Voici quelques algorithmes de classification et de régression typiques.

Régression logistique
k-NN ou k-voisins les plus proches
Machine de vecteur de soutien
Classificateur Naive Bayes
Arbre de décision
Forêt aléatoire
Perceptron
réseau neuronal

Voici un exemple de préparation de données.

import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline


#Apprentissage automatique
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import Perceptron
from sklearn.linear_model import SGDClassifier
from sklearn.tree import DecisionTreeClassifier


# 1. X_Pour le train, train à l'exclusion des survivants_Remplacez df.
X_train = train_df.drop("Survived", axis=1)

# 2. Y_le train ne contient que Survived_Remplacez df.
Y_train = train_df["Survived"]

# 3. X_Pour le test, test sans PassengerId_Remplacez df.
X_test  = test_df.drop("PassengerId", axis=1).copy()

# 4. X_train、Y_train、X_Affiche le nombre de lignes et de colonnes de test.
print(X_train.shape, Y_train.shape, X_test.shape)

Retour logistique

La régression logistique utilise une fonction logistique (fonction sigmoïde) pour classer les binômes. En d'autres termes, il est possible de classer si la variable objectif Survived est 0 ou 1 et de l'utiliser pour la prédiction. Utilisez des variables explicatives telles que Pclass et Age autres que Survived pour créer le modèle. La fonction sigmoïde a généralement la forme représentée sur la figure ci-dessous, et prend une valeur comprise entre 0 et 1.

Régression logistique avec python sklearn. ajuster et prédire, régulariser avec l'argument C

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
X_train_lr, X_test_lr, Y_train_lr, Y_test_lr = train_test_split(X_train, Y_train, test_size=0.2)


# 1.Données d'entraînement X_train_lr et Y_train_Créez un modèle de classification par régression logistique à l'aide de lr.
logreg = LogisticRegression()
logreg.fit(X_train_lr, Y_train_lr)

# 2.Données de test X_test_Appliquez le modèle créé à lr et la précision du modèle.
acc_log = round(logreg.score(X_test_lr, Y_test_lr) * 100, 2)

print(acc_log)

from sklearn.linear_model import LogisticRegression

# 1.Calculer le coefficient de régression partielle pour chaque entité
coeff_df = pd.DataFrame(train_df.columns.delete(0))
coeff_df.columns = ['Feature']
coeff_df["Partial regression coefficient"] = pd.Series(logreg.coef_[0])

coeff_df.sort_values(by="Partial regression coefficient", ascending=False)

Machine de vecteur de soutien

Support Vector Machine (SVM) est un algorithme de classification et de régression. L'apprentissage a lieu parce que les données sont converties de non-linéaires en linéaires à l'aide d'une méthode appelée méthode du noyau. Le temps de traitement est court.

Plus la largeur de la ligne de séparation (marge) est grande, moins il est probable qu'un surajustement se produise et plus le modèle sera généralisé. En revanche, plus la largeur est petite, plus il y a de chances qu'un surajustement se produise et le modèle ne s'intégrera que dans des données spécifiques. Si vous utilisez SVM, vous pouvez créer un modèle en ajustant plusieurs paramètres, dont la largeur. Le modèle a une précision de classification relativement élevée.

# 1.Créez un modèle de classification à l'aide de la fonction SVC et vérifiez la précision du modèle.
svc = SVC()
svc.fit(X_train, Y_train)

Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train) * 100, 2)

print(acc_svc)

# 2.Créez un modèle de classification avec la fonction LinearSVC et vérifiez la précision du modèle
linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)

Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train) * 100, 2)

print(acc_linear_svc)

k-Voisins les plus proches

La méthode k-Nearest Neighbours (ou k-NN en abrégé) est un algorithme de classification.

Les nouvelles données sont catégorisées par un vote majoritaire de données déjà classées. Par exemple, dans la figure ci-dessous, s'il y a 3 données (k = 3) qui prennent un vote majoritaire, les nouvelles données seront classées en rouge. De plus, s'il y a 5 données (k = 5) qui prennent un vote majoritaire, les nouvelles données seront classées en bleu.

# 1. k-Créez un modèle de classification par la méthode NN et vérifiez la précision du modèle.
knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)

Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train) * 100, 2)

print(acc_knn)

Classificateur Naive Bayes

Naive Bayes est un algorithme de classification. Il est souvent utilisé principalement pour la classification de documents et son application aux filtres anti-spam est bien connue. Naive Bayes utilise des probabilités conditionnelles, tout comme «naïf» signifie «simple» en japonais. Il peut être mis en œuvre de manière concise. Pensez maintenant à classer les articles dans les catégories A et B.

Supposons que vous ayez une matrice de document Word étiquetée. À partir de cette matrice de document Word Créez une distribution d'occurrence de mot pour chacune des catégories A et B. Vous pouvez voir que la forme de la distribution est différente pour chaque catégorie et les caractéristiques sont différentes.

Créez une distribution pour les articles sans étiquette de la même manière, en fonction de sa proximité avec la distribution (modèle) créée précédemment. Vous pouvez attribuer des catégories.

# 1.Créez un modèle de classification par Naive Bayes et vérifiez l'exactitude du modèle.
gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)

Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train) * 100, 2)

print(acc_gaussian)

perceptron

Perceptron est un algorithme de classification. Il a été créé en imitant la fonction des neurones (cellules nerveuses) dans le cerveau humain. Les données d'entrée sont pondérées et ajoutées, et la fonction d'activation est appliquée à la conversion et à la sortie.

En tant que fonction d'activation

Souvent utilisé par les fonctions pas à pas.

La fonction step convertit la valeur de sortie en 1 si la valeur d'entrée est égale ou supérieure à 0 et convertit la valeur de sortie en 0 si la valeur d'entrée est inférieure à 0. Lorsque la valeur du nœud est ●, la valeur de sortie est ▲, c'est-à-dire 1 si elle est convertie par la fonction pas à pas.

Vous pouvez créer un réseau de neurones en combinant plusieurs Perceptrons.

# 1.Créez un modèle de classification par Perceptron et vérifiez la précision du modèle.
perceptron = Perceptron()
perceptron.fit(X_train, Y_train)

Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train) * 100, 2)

print(acc_perceptron)

Méthode de descente de gradient probabiliste

En cours de modélisation avec Perceptron Le modèle est formé de sorte que l'erreur entre la sortie et la variable objective (bonne réponse) soit faible. À ce stade, le poids est mis à jour à l'aide de la méthode de descente de gradient afin que l'erreur devienne faible.

Le bas de la courbe d'erreur est la valeur optimale (solution optimale) du poids qui minimise l'erreur. À partir de la valeur initiale du poids ×, augmenter la valeur de poids et la mettre à jour donnera la valeur de poids optimale ●.

La quantité de mise à jour du poids peut être obtenue en calculant la pente entourée par le carré de la figure. Tracez une ligne tangente à la courbe d'erreur (ligne tangente) et calculez la pente (coefficient différentiel) en fonction de la variation de l'erreur et du poids.

Le poids est mis à jour afin que l'erreur devienne inférieure à une certaine valeur ou le nombre de fois spécifié est mis à jour. Dans la méthode de descente de gradient, la valeur optimale est recherchée en descendant vers le bas de la courbe. En particulier, lorsque les données d'apprentissage sont divisées en plusieurs parties et calculées plusieurs fois, on parle de méthode de descente de gradient stochastique.

# 1.Créez un modèle de classification par la méthode de descente de gradient probabiliste et vérifiez la précision du modèle.
sgd = SGDClassifier()
sgd.fit(X_train, Y_train)

Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train) * 100, 2)

print(acc_sgd)

Arbre de décision

L'arbre de décision est un algorithme de classification et de régression. Si vous utilisez un arbre de décision, les règles extraites des données sont représentées dans une structure arborescente. Il est connu comme un algorithme facile à utiliser car il est intuitif et facile à expliquer aux gens.

La variable objective de la figure est label et les variables explicatives sont de a1 à a4. L'arbre de décision est composé de nœuds.

Le nœud supérieur est appelé le "nœud racine de l'arbre" et le nœud final est appelé le "nœud feuille". La ramification de l'arbre de décision est une condition de la règle. Par exemple, si la valeur du nœud a3 dépasse 2,45 et la valeur du nœud a4 dépasse 1,75, Les fleurs d'Ayame sont classées comme "Iris-virginica".

De plus, les variables qui affectent la classification sont organisées dans l'ordre du nœud racine au nœud feuille. Plus le nœud de feuille est monochromatique, plus la pureté est élevée. Tenter d'augmenter la pureté complique les règles et améliore la précision du modèle, mais peut conduire à un ajustement excessif.

# 1.Créez un modèle de classification basé sur l'arbre de décision et vérifiez l'exactitude du modèle.
decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)

Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train) * 100, 2)

print(acc_decision_tree)

Forêt aléatoire

Random Forest est un algorithme de classification et de régression. Une des méthodes d'apprentissage d'ensemble (classificateurs composés en collectant plusieurs classificateurs) Les arbres sont rassemblés et appelés forêt car ils construisent un grand nombre d'arbres de décision (n_estimators = 100).

# 1.Créez un modèle de classification par forêt aléatoire et vérifiez l'exactitude du modèle.
random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)

Y_pred = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train) * 100, 2)

print(acc_random_forest)

Évaluation du modèle

Classez la précision de tous les modèles et choisissez le meilleur modèle pour la résolution de problèmes.

#Énumérez la précision de chaque modèle
models = pd.DataFrame({
    'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression', 
              'Random Forest',  
              'Linear SVC', 
              'Decision Tree'],
    'Score': [acc_svc, acc_knn, acc_log, 
              acc_random_forest,  
              acc_linear_svc, acc_decision_tree]})

models.sort_values(by='Score', ascending=False)

#Enregistrez le modèle de forêt aléatoire dans un fichier CSV.
submission = pd.DataFrame({
        "PassengerId": test_df["PassengerId"],
        "Survived": Y_pred
    })

submission.to_csv('./8010_titanic_data/submission.csv', index=False)

Python: prévision de survie des navires, partie 3