Dieser Artikel stellt hauptsächlich die relevanten Inhalte der maschinellen Lernforschung basierend auf Python und Scikit-Learn vor. Der Herausgeber findet, dass er hier mit allen zum Lernen und Nachschlagen für bedürftige Freunde geteilt wird.
Hallo, %username%!
Mein Name ist Alex und ich habe Erfahrung im maschinellen Lernen und der Analyse von Netzwerkgraphen (hauptsächlich Theorie). Außerdem habe ich ein Big-Data-Produkt für einen russischen Mobilfunkbetreiber entwickelt. Dies ist das erste Mal, dass ich einen Artikel online schreibe. Kommentieren Sie also nicht, wenn er Ihnen nicht gefällt.
Heutzutage möchten viele Menschen effiziente Algorithmen entwickeln und an Wettbewerben für maschinelles Lernen teilnehmen. Also kommen sie zu mir und fragen: „Wie fange ich an?“ Vor einiger Zeit leitete ich in einer der russischen Regierung angeschlossenen Agentur die Entwicklung von Big-Data-Analysetools für Medien und soziale Netzwerke. Ich habe noch einige Dokumentationen, die mein Team verwendet und die ich gerne mit Ihnen teilen würde. Voraussetzung ist, dass der Leser bereits über gute Kenntnisse in Mathematik und maschinellem Lernen verfügt (mein Team besteht hauptsächlich aus Absolventen des MIPT (Moskauer Universität für Physik und Technologie) und der School of Data Analysis).
Dieser Artikel ist eine Einführung in die Datenwissenschaft, ein Thema, das in letzter Zeit so populär geworden ist. Es gibt auch immer mehr Wettbewerbe für maschinelles Lernen (z. B. Kaggle, TudedIT), und ihre Finanzierung ist in der Regel beträchtlich.
R und Python sind zwei der am häufigsten verwendeten Tools, die Datenwissenschaftlern zur Verfügung stehen. Jedes Tool hat seine Vor- und Nachteile, aber Python hat in letzter Zeit in jeder Hinsicht gewonnen (nur meine bescheidene Meinung, obwohl ich beide verwende). All dies geschah aufgrund der Einführung der Scikit-Learn-Bibliothek, die eine vollständige Dokumentation und umfangreiche Algorithmen für maschinelles Lernen enthält.
Bitte beachten Sie, dass wir in diesem Artikel hauptsächlich Algorithmen für maschinelles Lernen besprechen. Normalerweise ist es besser, das Pandas-Paket für die Stammdatenanalyse zu verwenden, und es ist einfach, dies selbst durchzuführen. Konzentrieren wir uns also auf die Umsetzung. Der Sicherheit halber gehen wir davon aus, dass als Eingabe eine Feature-Objekt-Matrix vorliegt, die in einer *.csv-Datei gespeichert ist.
Daten laden
Zunächst müssen die Daten in den Speicher geladen werden bevor es seine Operation verarbeiten kann. Die Scikit-Learn-Bibliothek verwendet NumPy-Arrays in ihrer Implementierung, daher werden wir NumPy zum Laden von *.csv-Dateien verwenden. Laden wir einen der Datensätze aus dem UCI Machine Learning Repository herunter.
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]
Wir werden diesen Datensatz in allen folgenden Beispielen verwenden, mit anderen Worten, das X-Feature-Array und den Wert der y-Zielvariablen verwenden.
Datennormalisierung
Wir alle kennen die meisten Gradientenmethoden (fast alle Algorithmen für maschinelles Lernen basieren darauf). ) reagiert empfindlich auf die Datenskalierung. Daher sollten wir vor dem Ausführen des Algorithmus eine Normalisierung oder sogenannte Normalisierung durchführen. Bei der Standardisierung werden die Nominalwerte aller Merkmale so ersetzt, dass jedes von ihnen einen Wert zwischen 0 und 1 hat. Zur Normalisierung gehört die Vorverarbeitung der Daten, sodass der Wert jedes Merkmals eine Streuung von 0 und 1 aufweist. Die Scikit-Learn-Bibliothek stellt dafür entsprechende Funktionen bereit.
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_)
Funktionsauswahl
Es besteht kein Zweifel, dass dies der beste Weg ist Um ein Problem zu lösen, kommt es auf die Fähigkeit an, Merkmale entsprechend auszuwählen oder sogar zu erstellen. Dies wird als Feature-Auswahl und Feature-Engineering bezeichnet. Obwohl Feature Engineering ein eher kreativer Prozess ist, der manchmal mehr auf Intuition und Fachwissen angewiesen ist, gibt es bereits viele Algorithmen für den direkten Einsatz bei der Feature-Auswahl. Beispielsweise kann ein Baumalgorithmus den Informationsgehalt von Features berechnen.
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_)
Alle anderen Methoden basieren auf der effizienten Suche nach Feature-Teilmengen, um die beste Teilmenge zu finden, was bedeutet, dass das entwickelte Modell in dieser Teilmenge die beste Menge hat Qualität. Recursive Feature Elimination (RFE) ist einer dieser Suchalgorithmen und wird auch von der Scikit-Learn-Bibliothek bereitgestellt.
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_)
Entwicklung eines Algorithmus
Genau wie Was ich gesagt habe ist, dass die Scikit-Learn-Bibliothek alle grundlegenden Algorithmen für maschinelles Lernen implementiert hat. Lassen Sie mich einen Blick auf einige davon werfen.
Logistische Regression
In den meisten Fällen wird es zur Lösung von Klassifizierungsproblemen (binäre Klassifizierung) verwendet, aber viele Klassifizierung von Klassen (sog. One-to-many-Methoden) gilt ebenfalls. Der Vorteil dieses Algorithmus besteht darin, dass für jedes Ausgabeobjekt eine Wahrscheinlichkeit einer entsprechenden Kategorie besteht.
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
Es ist auch das berühmteste maschinelle Lernen Die Hauptaufgabe der Algorithmen besteht darin, die Datenverteilungsdichte von Trainingsstichproben wiederherzustellen. Diese Methode eignet sich normalerweise gut für Klassifizierungsprobleme mit mehreren Klassen.
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-nächster Nachbar
kNN (k-nächster Nachbar) Methoden werden häufig als Teil eines komplexeren Klassifizierungsalgorithmus verwendet. Beispielsweise können wir seinen geschätzten Wert als Merkmal eines Objekts verwenden. Manchmal ein einfacher 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))
Entscheidungsbaum
分类和回归树（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的一大优点就是它有很棒的文档说明。
总结
Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung der Erforschung maschinellen Lernens mit Python und Scikit-Learn. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
