Touchons une partie de l'apprentissage automatique avec Python

Je me demande ce qu'est l'apprentissage automatique, et si je l'écris comme je peux y penser, cela ressemble à ceci.

--Catégorie --Revenir --La discrimination

Il y en a peut-être d'autres, mais je ne peux pas penser à eux. J'utilise les données d'iris quand je recommande un tutoriel ici en R, mais je me demande si c'est en Python. → Il semble y en avoir.

Apprentissage automatique avec R

Exemple de classification et de discrimination

Tout d'abord, essayez R. Faire un classificateur en R en utilisant SVM, NeuralNet, NaiveBayse, RandomForest, etc. n'est presque rien à penser. Chaque méthode de regroupement est utilisée pour créer un classificateur à l'aide de l'ensemble d'apprentissage et évaluer si l'ensemble de test peut être correctement classé par le classificateur.

Dans R, si vous faites des données (iris), vous pouvez utiliser les données de show, iris ou squid.

Il s'agit d'un tableau de données de tous les 150 échantillons avec des variétés d'iris (setosa, versicolor, virginica) comme variables explicatives, avec 萼 longueur, 萼 largeur, longueur de pétale et largeur de pétale comme variables explicatives.

Tout d'abord, utilisez sample () pour diviser aléatoirement la moitié dans un ensemble d'apprentissage et le reste dans un ensemble de test.

##Lecture des données d'iris
data(iris)
##Choisissez au hasard de faire un demi-ensemble d'entraînement
train_ids <- sample(nrow(iris), nrow(iris)*0.5)
##Créer un ensemble d'entraînement
iris.train <- iris[train_ids,]
##Utilisez l'autre moitié comme ensemble de test
iris.test  <- iris[-train_ids,]

À propos, les trois variétés d'iris, setosa, versicolor et virignica, ont les fleurs suivantes. Tout le monde est pareil! C'est un jeu de punition, comme distinguer cela par la forme des pétales.

###Exécution SVM
library(kernlab)
iris.svm <- ksvm(Species~., data=iris.train)
svm.predict <- predict(iris.svm, iris.test)
###Affichage des résultats
table(svm.predict, iris.test$Species)

###exécuter neuralnet
library(nnet)
iris.nnet<-nnet(Species ~ ., data = iris.train, size = 3)
nnet.predict <- predict(iris.nnet, iris.test, type="class")
###Affichage des résultats
table( nnet.predict,  iris.test$Species)

###courir bayes naïfs
library(e1071)
iris.nb <- naiveBayes(Species~., iris.train)
nbayes.predict <- predict(iris.nb, iris.test)
###Affichage des résultats
table(nbayes.predict, iris.test$Species)

###Exécution aléatoire de la forêt
library(randomForest)
iris.rf <- randomForest(Species~., iris.train)
rf.predict <- predict(iris.rf, iris.test)
###Affichage des résultats
table(rf.predict, iris.test$Species)

Lorsque vous l'essayez, vous pourrez l'identifier avec un taux de réponse correct d'environ 73/75, quelle que soit la méthode que vous utilisez. Ce n'est pas une centaine de plans, mais cela peut (ou non) être géré en ajustant les paramètres.

Maintenant, pour essayer la même chose en Python, utilisez scicit-learn. Plus de détails peuvent être trouvés dans didacticiel scikit-learn.

Identifié par Python

Essayez de pouvoir faire du SVM avec Python

En premier lieu, pourquoi faites-vous "ce que vous pourriez facilement faire avec R comme ci-dessus" avec Python, qui vous est inconnu? Je peux seulement dire que je veux l'essayer avec Python. S'il y a une montagne à Soko, je l'escaladerai, s'il y a une flaque d'eau, j'en serai accro, et s'il y a une table dressée, je la mangerai.

Si Anaconda est déjà installé, scikit-learn est déjà installé, alors importez-le. J'importe, mais le nom de la bibliothèque est sklearn. Iris peut également être chargé dans cette bibliothèque sous forme de jeux de données.

from sklearn import svm, datasets
iris = datasets.load_iris()

Quant au contenu, vous pouvez le dire en imprimant (iris.data) ou print (iris.target), mais iris.data a une variable explicative et iris.target a une variable objective. Divisez-le en un ensemble de données d'entraînement et un ensemble de données de test. Dans R, j'ai utilisé la fonction sample (), mais dans le cas de scikit-learn, il existe une méthode appelée train_test_split () dans sklearn.cross_varidation. Maintenant, comme je l'ai fait dans R, j'ai divisé la moitié en un ensemble d'entraînement (iris_data_train, iris_target_train) et un ensemble de test (iris_data_test, iris_target_test).

from sklearn import svm, datasets
from sklearn.cross_validation import train_test_split
import numpy as np

iris = datasets.load_iris()
iris_data_train, iris_data_test, iris_target_train, iris_target_test = train_test_split(iris.data, iris.target, test_size=0.5)

Créez un classificateur à l'aide de cet ensemble d'entraînement. Il y a plusieurs choses dans SVM, est-ce linéaire? Est-ce non linéaire? J'ai besoin de définir divers paramètres, mais c'est tout par défaut.

svc = svm.SVC()
svc.fit(iris_data_train, iris_target_train)
svc.predict(iris_data_test)

J'ai écrit fit () et predict () en deux lignes, mais je peux simplement l'initialiser, alimenter les données d'entraînement et alimenter les données de test, afin que je puisse l'écrire sur une ligne.

iris_predict = svm.SVC().fit(iris_data_train, iris_target_train).predict(iris_data_test)

Vous pouvez voir le taux de correspondance entre le résultat de ce svc.predict () (iris_predict) et iris_target_test. Dans R, il est affiché dans un format tabulaire comme table (svm.predict, iris.test $ Species), alors essayez la même chose. Cette table s'appelle confusion_matrix. Avec precision_score, vous pouvez rapidement obtenir le taux de réponse correct.

from sklearn.metrics import confusion_matrix, accuracy_score

print (confusion_matrix(iris_target_test, iris_predict))
print (accuracy_score(iris_target_test, iris_predict))

Selon le Document officiel, confusion_matrix () a le premier argument comme valeur vraie et le second argument comme identification. Il semble que ce soit une valeur discriminante par le navire, alors faites-la passer comme telle.

C'est simplement plus typé que R, mais j'en suis venu à obtenir des résultats similaires.

Selon le document ci-dessus, cela peut également être illustré sur la figure. Tout d'abord, normalisez chaque ligne de confusion_matrix afin qu'elle soit égale à 1. Je ne peux pas écrire cette formule moi-même.

cm = confusion_matrix(iris_target_test, iris_predict)
cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

En utilisant cette confusion_matrix normalisée, heatmap utilisant la fonction de matplotlib. Au fait, puisque svc.predict () est fait plusieurs fois et que le résultat est légèrement différent à chaque fois, le contenu de confusion_matrix est légèrement différent entre les chiffres ci-dessus et ci-dessous.

def plot_confusion_matrix(cm, title='Confusion matrix', cmap=plt.cm.Blues):
    ''' confusion_Fonction pour afficher la matrice sous forme de carte thermique
    Keyword arguments:
        cm -- confusion_matrix
        title --Titre de la figure
        cmap --Carte de couleurs à utiliser
        
    '''
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(iris.target_names))
    plt.xticks(tick_marks, iris.target_names, rotation=45)
    plt.yticks(tick_marks, iris.target_names)
    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

Cette fois, tout était par défaut, comme svc = svm.SVC (), mais bien sûr, vous devriez pouvoir utiliser différents noyaux pour la classification. La page Exemples du site officiel de scikit-learn contient diverses démos et tutoriels, donc si vous en avez besoin, voici quelques conseils. Je pense que je peux le trouver.

Comme je l'ai fait dans R, je me demande si NeuralNet est naiveBayes et randomForest, mais c'est probablement la même chose (je ne l'ai pas vérifié).

Cette conclusion

J'ai l'impression d'avoir touché à une partie de l'apprentissage automatique, mais à la fin je ne savais pas si l'iris était un spectacle, un écureuil ou un écureuil.

Postscript

Au départ, le titre était "Essayer de toucher l'apprentissage automatique avec Python", mais il a été dit que "le toucher est l'endroit le plus excitant, donc le titre ne convient pas", alors je l'ai corrigé.

Je pense personnellement que "faire un discriminateur avec SVM avec Python" est un point passionnant, mais il semble qu'il était égoïste. Je suis désolé de parler d'apprentissage automatique comme SVM. Je vais revenir.

Ce code

• https://github.com/fukuit/Python_SelfLearning/blob/master/ml_svm.py