Explication détaillée de l'exploration du machine learning avec Python et Scikit-Learn

Cet article présente principalement le contenu pertinent de l'exploration de l'apprentissage automatique basé sur Python et Scikit-Learn. L'éditeur pense qu'il est plutôt bon. Je le partage ici avec tout le monde pour l'apprentissage et la référence par des amis dans le besoin.

Bonjour, %username% !

Je m'appelle Alex et j'ai de l'expérience en apprentissage automatique et en analyse de graphes de réseau (principalement théorique). Je développais également un produit big data pour un opérateur mobile russe. C’est la première fois que j’écris un article en ligne, alors ne commentez pas si vous ne l’aimez pas.

Aujourd'hui, de nombreuses personnes souhaitent développer des algorithmes efficaces et participer à des compétitions d'apprentissage automatique. Alors ils viennent me voir et me demandent : « Comment puis-je commencer ? ». Il y a quelque temps, j'ai dirigé le développement d'outils d'analyse de big data pour les médias et les réseaux sociaux dans une agence affiliée au gouvernement russe. Il me reste encore de la documentation que mon équipe utilise et que j'aimerais partager avec vous. La condition préalable est que le lecteur ait déjà une bonne connaissance des mathématiques et de l'apprentissage automatique (mon équipe est principalement composée de diplômés du MIPT (Université de physique et de technologie de Moscou) et de l'École d'analyse des données).

Cet article est une introduction à la science des données, un sujet devenu si populaire ces derniers temps. Il existe également un nombre croissant de concours d'apprentissage automatique (par exemple Kaggle, TudedIT) et leur financement est généralement important.

R et Python sont deux des outils les plus couramment utilisés par les data scientists. Chaque outil a ses avantages et ses inconvénients, mais Python a gagné dans tous les domaines ces derniers temps (juste mon humble avis, même si j'utilise les deux). Tout cela est dû à l'avènement de la bibliothèque Scikit-Learn, qui contient une documentation complète et de riches algorithmes d'apprentissage automatique.
Veuillez noter que nous aborderons principalement les algorithmes d'apprentissage automatique dans cet article. Il est généralement préférable d'utiliser le package Pandas pour effectuer une analyse des données de base, et il est facile de le faire vous-même. Alors concentrons-nous sur la mise en œuvre. Par souci de certitude, nous supposons qu'il existe une matrice caractéristique-objet en entrée, qui est stockée dans un fichier *.csv.

Chargement des données

Tout d'abord, les données doivent être chargées dans la mémoire avant de pouvoir traiter son opération. La bibliothèque Scikit-Learn utilise des tableaux NumPy dans son implémentation, nous utiliserons donc NumPy pour charger des fichiers *.csv. Téléchargeons l'un des ensembles de données du référentiel UCI Machine Learning.

import numpy as np
import urllib
# url with dataset
url = “http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data”
# download the file
raw_data = urllib.urlopen(url)
# load the CSV file as a numpy matrix
dataset = np.loadtxt(raw_data, delimiter=“,”)
# separate the data from the target attributes
X = dataset[:,0:7]
y = dataset[:,8]

Nous utiliserons cet ensemble de données dans tous les exemples ci-dessous, en d'autres termes, utiliserons le tableau de fonctionnalités X et la valeur de la variable cible y.

Normalisation des données

Nous connaissons tous la plupart des méthodes de gradient (presque tous les algorithmes d'apprentissage automatique sont basés sur celle-ci ) est sensible à la mise à l’échelle des données. Par conséquent, avant d’exécuter l’algorithme, nous devons effectuer une normalisation, ou ce qu’on appelle la normalisation. La normalisation consiste à remplacer les valeurs nominales de toutes les caractéristiques afin que chacune d'elles ait une valeur comprise entre 0 et 1. Pour la normalisation, cela inclut un prétraitement des données afin que la valeur de chaque caractéristique ait une dispersion de 0 et 1. La bibliothèque Scikit-Learn a fourni les fonctions correspondantes.

from sklearn
import metrics
from sklearn.ensemble
import ExtraTreesClassifier
model = ExtraTreesClassifier()
model.fit(X, y)# display the relative importance of each attribute
print(model.feature_importances_)

Sélection des fonctionnalités

Il ne fait aucun doute que la meilleure façon de résoudre un problème est ce qui compte, c'est la capacité à sélectionner des fonctionnalités de manière appropriée, voire à les créer. C’est ce qu’on appelle la sélection de fonctionnalités et l’ingénierie des fonctionnalités. Bien que l’ingénierie des fonctionnalités soit un processus plutôt créatif qui repose parfois davantage sur l’intuition et les connaissances professionnelles, il existe déjà de nombreux algorithmes destinés à être directement utilisés dans la sélection des fonctionnalités. Par exemple, un algorithme arborescent peut calculer le contenu informatif des fonctionnalités.

from sklearn
import metrics
from sklearn.ensemble
import ExtraTreesClassifier
model = ExtraTreesClassifier()
model.fit(X, y)# display the relative importance of each attribute
print(model.feature_importances_)

Toutes les autres méthodes sont basées sur une recherche efficace de sous-ensembles de fonctionnalités pour trouver le meilleur sous-ensemble, ce qui signifie que le modèle évolué est dans ce sous-ensemble L'ensemble a le meilleur qualité. L'élimination des fonctionnalités récursives (RFE) est l'un de ces algorithmes de recherche et est également fourni par la bibliothèque Scikit-Learn.

from sklearn.feature_selection
import RFE
from sklearn.linear_model
import LogisticRegression
model = LogisticRegression()# create the RFE model and select 3 attributes
rfe = RFE(model, 3)
rfe = rfe.fit(X, y)# summarize the selection of the attributes
print(rfe.support_)
print(rfe.ranking_)

Développement d'algorithme

Tout comme Ce que j'ai dit, c'est que la bibliothèque Scikit-Learn a implémenté tous les algorithmes de base d'apprentissage automatique. Permettez-moi d'en examiner quelques-uns.

Régression logistique

Dans la plupart des cas, elle est utilisée pour résoudre des problèmes de classification (classification binaire), mais de nombreuses classifications de classes (appelées méthodes un-à-plusieurs) s'applique également. L'avantage de cet algorithme est que pour chaque objet de sortie, il existe une probabilité d'une catégorie correspondante.

from sklearn
import metrics
from sklearn.linear_model
import LogisticRegression
model = LogisticRegression()
model.fit(X, y)
print(model)# make predictions
expected = y
predicted = model.predict(X)# summarize the fit of the model
print(metrics.classification_report(expected, predicted))
print(metrics.confusion_matrix(expected, predicted))

Naive Bayes

C'est aussi le plus célèbre des Machine Learning One des algorithmes, sa tâche principale est de restaurer la densité de distribution des données des échantillons d'apprentissage. Cette méthode fonctionne généralement bien sur les problèmes de classification multi-classes.

from sklearn
import metrics
from sklearn.naive_bayes
import GaussianNB
model = GaussianNB()
model.fit(X, y)
print(model)# make predictions
expected = y
predicted = model.predict(X)# summarize the fit of the model
print(metrics.classification_report(expected, predicted))
print(metrics.confusion_matrix(expected, predicted))

k-voisin le plus proche

kNN (k-voisin le plus proche) Les méthodes sont souvent utilisées dans le cadre d’un algorithme de classification plus complexe. Par exemple, nous pouvons utiliser sa valeur estimée comme caractéristique d’un objet. Parfois, un simple kNN

from sklearn
import metrics
from sklearn.neighbors
import KNeighborsClassifier# fit a k - nearest neighbor model to the data
model = KNeighborsClassifier()
model.fit(X, y)
print(model)# make predictions
expected = y
predicted = model.predict(X)# summarize the fit of the model
print(metrics.classification_report(expected, predicted))
print(metrics.confusion_matrix(expected, predicted))

arbre de décision

分类和回归树（CART）经常被用于这么一类问题，在这类问题中对象有可分类的特征且被用于回归和分类问题。决策树很适用于多类分类。

from sklearn
import metrics
from sklearn.tree
import DecisionTreeClassifier# fit a CART model to the data
model = DecisionTreeClassifier()
model.fit(X, y)
print(model)# make predictions
expected = y
predicted = model.predict(X)# summarize the fit of the model
print(metrics.classification_report(expected, predicted))
print(metrics.confusion_matrix(expected, predicted))

支持向量机

SVM（支持向量机）是最流行的机器学习算法之一，它主要用于分类问题。同样也用于逻辑回归，SVM在一对多方法的帮助下可以实现多类分类。

from sklearn import metrics
from sklearn.svm import SVC
# fit a SVM model to the data
model = SVC()
model.fit(X, y)
print(model)
# make predictions
expected = y
predicted = model.predict(X)
# summarize the fit of the model
print(metrics.classification_report(expected, predicted))
print(metrics.confusion_matrix(expected, predicted))

除了分类和回归问题，Scikit-Learn还有海量的更复杂的算法，包括了聚类， 以及建立混合算法的实现技术，如Bagging和Boosting。

如何优化算法的参数

在编写高效的算法的过程中最难的步骤之一就是正确参数的选择。一般来说如果有经验的话会容易些，但无论如何，我们都得寻找。幸运的是Scikit-Learn提供了很多函数来帮助解决这个问题。

作为一个例子，我们来看一下规则化参数的选择，在其中不少数值被相继搜索了：

import numpy as np
from sklearn.linear_model
import Ridge
from sklearn.grid_search
import GridSearchCV# prepare a range of alpha values to test
alphas = np.array([1, 0.1, 0.01, 0.001, 0.0001, 0])# create and fit a ridge regression model, testing each alpha
model = Ridge()
grid = GridSearchCV(estimator = model, param_grid = dict(alpha = alphas))
grid.fit(X, y)
print(grid)# summarize the results of the grid search
print(grid.best_score_)
print(grid.best_estimator_.alpha)

有时候随机地从既定的范围内选取一个参数更为高效，估计在这个参数下算法的质量，然后选出最好的。

import numpy as np
from scipy.stats
import uniform as sp_rand
from sklearn.linear_model
import Ridge
from sklearn.grid_search
import RandomizedSearchCV# prepare a uniform distribution to sample
for the alpha parameter
param_grid = {‘
  alpha': sp_rand()
}#
create and fit a ridge regression model, testing random alpha values
model = Ridge()
rsearch = RandomizedSearchCV(estimator = model, param_distributions = param_grid, n_iter = 100)
rsearch.fit(X, y)
print(rsearch)# summarize the results of the random parameter search
print(rsearch.best_score_)
print(rsearch.best_estimator_.alpha)

至此我们已经看了整个使用Scikit-Learn库的过程，除了将结果再输出到一个文件中。这个就作为你的一个练习吧，和R相比Python的一大优点就是它有很棒的文档说明。

总结

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!