scikit-learnCommencer avec scikit-learn


Remarques

scikit-learn est une bibliothèque open source polyvalente pour l'analyse de données écrite en python. Il est basé sur d'autres bibliothèques python: NumPy, SciPy et matplotlib

scikit-learn contient un certain nombre d'implémentations pour différents algorithmes populaires d'apprentissage automatique.

Installation de scikit-learn

La version stable actuelle de scikit-learn nécessite :

  • Python (> = 2.6 ou> = 3.3),
  • NumPy (> = 1.6.1),
  • SciPy (> = 0.9).

Pour la plupart l' installation pip gestionnaire de paquets python peut installer python et toutes ses dépendances:

pip install scikit-learn
 

Cependant, pour les systèmes Linux, il est recommandé d’utiliser le conda paquets conda pour éviter les processus de génération possibles.

conda install scikit-learn
 

Pour vérifier que vous avez scikit-learn , exécutez en shell:

python -c 'import sklearn; print(sklearn.__version__)'
 

Installation de Windows et Mac OSX:

Canopy et Anaconda proposent tous deux une version récente de scikit-learn , en plus d'un grand ensemble de bibliothèques scientifiques Python pour Windows, Mac OSX (également pertinentes pour Linux).

Créer des pipelines

La recherche de modèles dans les données passe souvent par une chaîne d'étapes de traitement des données, par exemple la sélection des fonctionnalités, la normalisation et la classification. Dans sklearn , un pipeline d'étapes est utilisé pour cela.

Par exemple, le code suivant montre un pipeline composé de deux étapes. Le premier met à l'échelle les entités et le second forme un classificateur sur le jeu de données augmenté résultant:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

pipeline = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=4))
 

Une fois le pipeline créé, vous pouvez l'utiliser comme une étape normale (en fonction de ses étapes spécifiques). Ici, par exemple, le pipeline se comporte comme un classificateur. Par conséquent, nous pouvons l'utiliser comme suit:

# fitting a classifier
pipeline.fit(X_train, y_train)
# getting predictions for the new data sample
pipeline.predict_proba(X_test)
 

Interfaces et conventions:

Différentes opérations avec des données sont effectuées à l'aide de classes spéciales.

La plupart des classes appartiennent à l'un des groupes suivants:

  • algorithmes de classification (dérivés de sklearn.base.ClassifierMixin ) pour résoudre les problèmes de classification
  • algorithmes de régression (dérivés de sklearn.base.RegressorMixin ) pour résoudre le problème de la reconstruction de variables continues (problème de régression)
  • Transformations de données (dérivées de sklearn.base.TransformerMixin ) qui prétraitent les données

Les données sont stockées dans numpy.array s (mais les autres objets de type pandas.DataFrame tels que pandas.DataFrame s sont acceptés si ceux-ci sont convertibles en numpy.array s)

Chaque objet dans les données est décrit par un ensemble de caractéristiques. La convention générale est que l’échantillon de données est représenté avec un tableau, où la première dimension est l’identifiant de l’échantillon de données, la seconde est l’identifiant de la caractéristique.

import numpy
data = numpy.arange(10).reshape(5, 2)
print(data)

Output:
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
 

Dans les conventions sklearn , le jeu de données ci-dessus contient 5 objets, chacun décrit par 2 entités.

Jeux de données d'échantillons

Pour faciliter les tests, sklearn fournit des jeux de données sklearn.datasets dans le module sklearn.datasets . Par exemple, chargez le jeu de données iris de Fisher:

import sklearn.datasets
iris_dataset = sklearn.datasets.load_iris()
iris_dataset.keys()
['target_names', 'data', 'target', 'DESCR', 'feature_names']
 

Vous pouvez lire la description complète, les noms des entités et les noms des classes ( target_names ). Ceux-ci sont stockés sous forme de chaînes.

Nous nous intéressons aux données et aux classes stockées dans target champs de data et target . Par convention, ceux-ci sont notés X et y

X, y = iris_dataset['data'], iris_dataset['target']
X.shape, y.shape
((150, 4), (150,))
 
numpy.unique(y)
array([0, 1, 2])
 

Les formes de X et y indiquent qu'il y a 150 échantillons avec 4 caractéristiques. Chaque échantillon appartient à l'une des classes suivantes: 0, 1 ou 2.

X et y peuvent maintenant être utilisés pour former un classificateur, en appelant la méthode fit() du classificateur.


Voici la liste complète des ensembles de données fournis par le module sklearn.datasets avec leur taille et leur utilisation prévue:

Charger avec La description Taille Usage
load_boston() Ensemble de données sur les prix de l'immobilier à Boston 506 régression
load_breast_cancer() Ensemble de données sur le cancer du sein du Wisconsin 569 classification (binaire)
load_diabetes() Ensemble de données sur le diabète 442 régression
load_digits(n_class) Jeu de données Digits 1797 classification
load_iris() Ensemble de données Iris 150 classification (multi-classes)
load_linnerud() Ensemble de données Linnerud 20 régression multivariée

Notez que (source: http://scikit-learn.org/stable/datasets/) :

Ces jeux de données sont utiles pour illustrer rapidement le comportement des différents algorithmes implémentés dans le scikit. Ils sont toutefois souvent trop petits pour être représentatifs des tâches d'apprentissage réel dans le monde réel.

En plus de ces jeux de données d'échantillons de jouets sklearn.datasets , sklearn.datasets fournit également des fonctions utilitaires pour charger des jeux de données externes:

  • load_mlcomp pour charger des exemples de jeux de données à partir du référentiel mlcomp.org (notez que les jeux de données doivent être téléchargés auparavant). Voici un exemple d'utilisation.
  • fetch_lfw_pairs et fetch_lfw_people pour le chargement du jeu de données de paires de visages étiquetés dans la nature (LFW) à partir de http://vis-www.cs.umass.edu/lfw/ , utilisé pour la vérification du visage (resp. reconnaissance du visage). Ce jeu de données est supérieur à 200 Mo. Voici un exemple d'utilisation.

Former un classificateur avec validation croisée

Utilisation du jeu de données iris:

import sklearn.datasets
iris_dataset = sklearn.datasets.load_iris()
X, y = iris_dataset['data'], iris_dataset['target']
 

Les données sont divisées en trains et ensembles de test. Pour ce faire, nous utilisons la fonction utilitaire train_test_split pour séparer de manière aléatoire X et y (vecteurs de données et cibles) avec l'option train_size=0.75 (les ensembles d'apprentissage contiennent 75% des données).

Les jeux de données d’entraînement sont introduits dans un classificateur de voisins les plus proches . L' fit de la méthode du classificateur adaptera le modèle aux données.

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.75) 
from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=3)
clf.fit(X_train, y_train)
 

Enfin, prédire la qualité sur l'échantillon de test:

clf.score(X_test, y_test) # Output: 0.94736842105263153
 

En utilisant une paire de trains et de jeux de tests, nous pouvons obtenir une estimation biaisée de la qualité du classificateur en raison du choix arbitraire de la division des données. En utilisant la validation croisée, nous pouvons adapter le classificateur à différents sous-ensembles train / test des données et effectuer une moyenne sur tous les résultats de précision. La fonction cross_val_score adapte un classificateur aux données d'entrée en utilisant une validation croisée. Il peut prendre en entrée le nombre de fractionnements (plis) à utiliser (5 dans l'exemple ci-dessous).

from sklearn.cross_validation import cross_val_score
scores = cross_val_score(clf, X, y, cv=5)
print(scores)
# Output: array([ 0.96666667,  0.96666667,  0.93333333,  0.96666667,  1.        ])
print "Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() / 2)
# Output: Accuracy: 0.97 (+/- 0.03)