Викиконспекты - Вклад участника [ru]

Примеры кода на Scala

2019-01-28T14:53:01Z

Alexey Katsman: /* Долгая краткосрочная память */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>

===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов (SVM)]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Scala

2019-01-28T14:52:45Z

Alexey Katsman: /* Метод опорных векторов */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]][на 15.01.19 не создан].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>
===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов (SVM)]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Scala

2019-01-28T14:52:19Z

Alexey Katsman: /* EM-алгоритм */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]][на 15.01.19 не создан].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>
===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов]][на 15.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Scala

2019-01-28T14:52:08Z

Alexey Katsman: /* Байесовская классификация */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]][на 15.01.19 не создан].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>
===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов]][на 15.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 28.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Scala

2019-01-28T14:51:52Z

Alexey Katsman: /* Рекуррентные нейронные сети */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]][на 15.01.19 не создан].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>
===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов]][на 15.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Scala

2019-01-28T14:51:36Z

Alexey Katsman: /* Логистическая регрессия */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}[на 5.01.19 не создан]

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]][на 15.01.19 не создан].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>
===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов]][на 15.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Scala

2019-01-28T14:51:26Z

Alexey Katsman: /* Вариации регрессии */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}[на 5.01.19 не создан]

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}[на 5.01.19 не создан]

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]][на 15.01.19 не создан].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>
===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов]][на 15.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Scala

2019-01-28T14:51:13Z

Alexey Katsman: /* Линейная регрессия */

[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]

==Популярные библиотеки==
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировть данными и позволяет реализовавать матричные и веторные операции, решать задачи оптимизации, обрабатывать сигналы устройств.
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста.
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого.
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala.
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.

==Примеры кода==
===Линейная регрессия===
{{main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:
'''val '''training = spark.read.format("libsvm")
.load("linear_regression.txt")
'''val '''lr = '''new '''LinearRegression()
.setMaxIter(10)
.setRegParam(0.3)
.setElasticNetParam(0.8)
'''val '''lrModel = lr.fit(training)
Вывод итоговых параметров модели:
println(lrModel.coefficients)
println(lrModel.intercept)
'''val '''trainingSummary = lrModel.summary
println(trainingSummary.totalIterations)
println(trainingSummary.objectiveHistory.mkString(","))
trainingSummary.residuals.show()
println(trainingSummary.rootMeanSquaredError)
println(trainingSummary.r2)

===Вариации регрессии===
{{main|Вариации регрессии}}[на 5.01.19 не создан]

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}

'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Double'''] = data.y()
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)
'''val '''lassoRegression: LASSO = lasso(x, y, 10)
println(ridgeRegression)
println(lassoRegression)

===Логистическая регрессия===
{{main|Логистическая регрессия}}[на 5.01.19 не создан]

Sbt зависимость:
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics
'''import '''org.apache.spark.mllib.regression.LabeledPoint
'''import '''org.apache.spark.mllib.util.MLUtils

'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
'''val '''training = splits(0).cache()
'''val '''test = splits(1)
'''val '''model = '''new '''LogisticRegressionWithLBFGS()
.setNumClasses(10)
.run(training)

'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =>
'''val '''prediction = model.predict(features)
(prediction, label)
}
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)
'''val '''accuracy = metrics.accuracy
println(accuracy)

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}

Sbt зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}
'''import '''smile.data.{AttributeDataset, NumericAttribute}
'''import '''smile.read
'''import '''smile.classification.mlp
'''import '''smile.plot.plot

'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = data.x()
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)
plot(x, y, mlpModel)

===Рекуррентные нейронные сети===
{{main|Рекуррентные нейронные сети}}[на 5.01.19 не создан]

Пример кода, с использованием билиотеки DeepLearning.scala
// Задание слоёв
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {
'''val '''exp_x = hyperparameters.exp(x)
'''val '''exp_nx = hyperparameters.exp(-x)
(exp_x - exp_nx) / (exp_x + exp_nx)
}
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)
'''val '''yraw = why.dot(hnext) + by
'''val '''yraw_exp = hyperparameters.exp(yraw)
'''val '''prob = yraw_exp / yraw_exp.sum
'''val '''loss = -hyperparameters.log((prob * y).sum)
(loss, prob, hnext)
}

// Определение структуры
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector
type WithHiddenLayer[A] = (A, INDArrayLayer)
type Batch = IndexedSeq[(Char, Char)]
type Losses = Vector['''Double''']
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {
batch '''match '''{
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =>
(bstate, xy) '''match '''{
'''case '''((tot, localhprev), (x, y)) => {
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{
'''case '''(localloss, _, localhnext) => {
(tot + localloss, localhnext)
}
}
}
}
}
}
}

// Определение одного шага обучения
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)
'''def '''singleRound(initprevloss: Losses): Future[Losses] =
(batches.foldLeftM((initprevloss, initH)) {
(bstate: WithHiddenLayer[Losses], batch: Batch) =>
bstate '''match '''{
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{
'''case '''(bloss, hnext) => bloss.train.map {
(blossval: '''Double''') => {
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001
(loss_seq, hnext)
}
}
}
}
}).map {
(fstate: WithHiddenLayer[Losses]) =>
fstate '''match '''{
'''case '''(floss, _) => floss
}
}
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {
(ploss: Losses, round: '''Int''') => {
singleRound(ploss)
}
}

// Обучение сети
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)
'''val '''losses = unsafePerformFuture(allRounds)

===Долгая краткосрочная память===
Освновная статья: [[Долгая краткосрочная память]][на 15.01.19 не создан].

[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref>
===Обработка естественного языка===
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].

===Метрический классификатор и метод ближайших соседей===
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].

===Метод опорных векторов===
Освновная статья: [[Метод опорных векторов]][на 15.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, SVM)

===Дерево решений и случайный лес===
Освновная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].

===Байесовская классификация===
Освновная статья: [[Байесовская классификация]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:
// Создание модели
'''val '''bayes = '''new '''BayesClassifier[String, String]()
// Задание соотвествия категория - слово
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)
// Тестовые примеры
'''val '''unknownText1 = "I use git".split(" ")
'''val '''unknownText2 = "Today's weather is snow".split(" ")
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")
// Классификация
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) // technology
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) // weather
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) // government

===EM-алгоритм===
Освновная статья: [[EM-алгоритм]][на 7.01.19 не создан].

SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:
'''import '''smile.clustering._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)
'''val '''y = kMeans.getClusterLabel
plot(x, y, '.', Palette.COLORS)

===Бустинг, AdaBoost===
Освновная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].

===Уменьшение размерности===
Освновная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:50:50Z

Alexey Katsman: /* См. также */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) [на 28.01.19 не создан]}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм|l1=EM-алгоритм[на 28.01.19 не создан]}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn|l1=Уменьшение размерности: пример через scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]][на 28.01.19 не создан]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 28.01.19 не создан]
*[[:Примеры кода на Java|Примеры кода на Java]][на 28.01.19 не создан]

==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:50:39Z

Alexey Katsman: /* Библиотеки для градиентного бустинга */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) [на 28.01.19 не создан]}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм|l1=EM-алгоритм[на 28.01.19 не создан]}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn|l1=Уменьшение размерности: пример через scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]][на 28.01.19 не создан]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:50:17Z

Alexey Katsman: /* Уменьшение размерности */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) [на 28.01.19 не создан]}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм|l1=EM-алгоритм[на 28.01.19 не создан]}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn|l1=Уменьшение размерности: пример через scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:49:50Z

Alexey Katsman: /* EM-алгоритм */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) [на 28.01.19 не создан]}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм|l1=EM-алгоритм[на 28.01.19 не создан]}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:49:31Z

Alexey Katsman: /* Метод опорных векторов (SVM) */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) [на 28.01.19 не создан]}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:49:19Z

Alexey Katsman: /* Метод опорных векторов (SVM) */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM)[на 28.01.19 не создан]}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:48:53Z

Alexey Katsman: /* Обработка естественного языка */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:48:35Z

Alexey Katsman: /* Дерево решений и случайный лес */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:48:15Z

Alexey Katsman: /* Метрический классификатор и метод ближайших соседей */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)}}
====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:47:39Z

Alexey Katsman: /* Линейная регрессия */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)}}
====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)}}
====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-01-28T14:47:15Z

Alexey Katsman: /* Описание */

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] (и ее модификаций Лассо, гребневой регрессии), [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]
====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)}}
====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)}}
====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц, вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>.
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib.
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff.
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA.
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python.
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм.
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net.
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]
*[[:Примеры кода на Java|Примеры кода на Java]]
==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Уменьшение размерности

2019-01-28T14:46:11Z

Alexey Katsman:

Под '''уменьшением размерности''' (англ. ''dimensionality reduction'') в машинном обучении подразумевается уменьшение числа признаков набора данных. Наличие в нем признаков избыточных, неинформативных или слабо информативных может понизить эффективность модели, а после такого преобразования она упрощается, и соответственно уменьшается размер набора данных в памяти и ускоряется работа алгоритмов ML на нем. Уменьшение размерности может быть осуществлено методами выбора признаков (англ. ''feature selection'') или выделения признаков (англ. ''feature extraction'').
==Выбор признаков==
Методы '''выбора признаков''' оставляют некоторое подмножество исходного набора признаков, избавляясь от признаков избыточных и слабо информативных. Основные преимущества этого класса алгоритмов:
*Уменьшение вероятности [[переобучение|переобучения]]
*Увеличение точности предсказания модели
*Сокращение времени обучения
*Увеличивается семантическое понимание модели

Все методы выбора признаков можно разделить на 5 типов, которые отличаются алгоритмами выбора лишних признаков.
===Фильтры===
'''Фильтры''' (англ. ''filter methods'') измеряют релевантность признаков на основе функции $\mu$, и затем решают по правилу $\kappa$, какие признаки оставить в результирующем множестве.

Фильтры могут быть:
*Одномерные (англ. ''univariate'') {{---}} функция $\mu$ определяет релевантность одного признака по отношению к выходным меткам. В таком случае, обычно, измеряют "качество" каждого признака и удаляют худшие.
*Многомерные (англ. ''multivariate'') {{---}} функция $\mu$ определяет релевантность некоторого подмножества исходного множества признаков относительно выходных меток.

Распространенными вариантами для $\mu$ являются:
*Коэффициент ранговой корреляции Спирмена <ref>[https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient Определение коэффициента ранговой корреляции Спирмена]</ref>(англ. ''Spearman's rank correlation coefficient''): $p(x, y)=\displaystyle \frac{\sum_{i, j}(x_{ij}-\bar{x_j})(y_i-\bar{y})}{\sqrt{\sum_{i, j}(x_{ij}-\bar{x_j})^2\sum_i(y_i-\bar{y})^2}}$;
*Information gain<ref>[https://en.wikipedia.org/wiki/Information_gain_in_decision_trees Определение information gain]</ref>: $IG(x, y)=\displaystyle -\sum_{i=1}^kp(c_i)\log_2{(p(c_i))}+\sum_{i=1}^{n}p(t_i)\sum_{j=1}^kp(c_j|t_i)log_2{(p(c_j|t_i))}$, и другие.

Преимуществом группы фильтров является простота вычисления релевантности признаков в наборе данных, но недостатком в таком подходе является игнорирование возможных зависимостей между признаками.
===Оберточные методы===
[[File:Feature_selection_wrapper_rus.png|450px|thumb|right|Процесс работы оберточных методов]]
'''Оберточные методы''' (англ. ''wrapper methods'') находят подмножество искомых признаков последовательно, используя некоторый классификатор как источник оценки качества выбранных признаков, т.е. этот процесс является циклическим и продолжается до тех пор, пока не будут достигнуты заданные условия останова. Оберточные методы учитывают зависимости между признаками, что является преимуществом по сравнению с фильтрами, к тому же показывают большую точность, но вычисления занимают длительное время, и повышается риск [[переобучение|переобучения]].

Существует несколько типов оберточных методов: детерминированные, которые изменяют множество признаков по определенному правилу, а также рандомизированные, которые используют генетические алгоритмы для выбора искомого подмножества признаков. Среди детерминированных алгоритмов самыми простыми являются:
*SFS (Sequential Forward Selection) {{---}} жадный алгоритм, который начинает с пустого множества признаков, на каждом шаге добавляя лучший из еще не выбранных признаков в результирующее множество
*SBS (Sequential Backward Selection) {{---}} алгоритм обратный SFS, который начинает с изначального множества признаков, и удаляет по одному или несколько худших признаков на каждом шаге

Популярным оберточным методом является SVM-RFE (SVM-based Recursive Feature Elimination), который иногда также обозначается как встроенный <ref>[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117/ C. Embedded method]</ref>. Этот метод использует как классификатор [[Метод опорных векторов (SVM)| SVM]][на 28.01.19 не создан] и работает итеративно: начиная с полного множества признаков обучает классификатор, ранжирует признаки по весам, которые им присвоил классификатор, убирает какое-то число признаков и повторяет процесс с оставшегося подмножества фичей, если не было достигнуто их требуемое количество. Таким образом, этот метод очень похож на встроенный, потому что непосредственно использует знание того, как устроен классификатор.

===Встроенные методы===
[[File:Feature_selection_embedded_rus.png|450px|thumb|right|Процесс работы встроенных методов]]
Группа '''встроенных методов''' (англ. ''embedded methods'') очень похожа на оберточные методы, но для выбора признаков используется непосредственно структуру некоторого классификатора. В оберточных методах классификатор служит только для оценки работы на данном множестве признаков, тогда как встроенные методы используют какую-то информацию о признаках, которую классификаторы присваивают во время обучения.

Одним из примеров встроенного метода является реализация на [[Дерево решений и случайный лес| случайном лесе]]: каждому дереву на вход подаются случайное подмножество данных из датасета с каким-то случайным набор признаков, в процессе обучения каждое из деревьев решений производит "голосование" за релевантность его признаков, эти данные агрегируются, и на выходе получаются значения важности каждого признака набора данных. Дальнейший выбор нужных нам признаков уже зависит от выбранного критерия отбора.

Встроенные методы используют преимущества оберточных методов и являются более эффективными, при этом на отбор тратится меньше времени, уменьшается риск [[переобучение|переобучения]], но т.к. полученный набор признаков был отобран на основе знаний о классификаторе, то есть вероятность, что для другого классификатора это множество признаков уже не будет настолько же релевантным.

===Другие методы===
[[File:Feature_selection_ensemble_rus.png|thumb|Один из примеров процесса работы ансамблевых методов]]
Есть и другие методы выбора признаков: '''гибридные''' (англ. ''hybrid methods'') и '''ансамблевые''' (англ. ''ensemble methods''). '''Гибридные методы''' комбинируют несколько разных методов выбора признаков, например некоторое множество фильтров, а потом запускают оберточный или встроенный метод. Таким образом, гибридные методы сочетают в себе преимущества сразу нескольких методов, и на практике повышают эффективность выбора признаков.

'''Ансамблевые методы''' применяются больше для наборов данных с очень большим числом признаков. В данном подходе для начального множества признаков создается несколько подмножеств признаков, и эти группы каким-то образом объединяются, чтобы получить набор самых релевантных признаков. Это довольно гибкая группа методов, т.к. для нее можно применять различные способы выбора признаков и объединения их подмножеств.

<div style="clear:{{{1|both}}};"></div>

===Примеры кода scikit-learn===
Пример кода, реализующего функцию оценки фильтра на основе коэффициента ранговой корреляции:
# Импорт библиотек
import pandas as pd
import numpy as np

# Вспомогательная функция для расчета корреляции
def correlation(X, Y):
return np.cov(X, Y) / np.sqrt(np.var(X) * np.var(Y))

# Сам фильтр на основе метрики ранговой корреляции
# Аргументы X -- значения объектов датасета для какой-то фичи, Y -- метки этих объектов
def measure_spearmans(X, Y):
xr = pd.Series(X).rank()
yr = pd.Series(Y).rank()
return correlation(xr, yr)

Пример кода, реализующего SVM-RFE wrapper:
# Импорт библиотек
import numpy as np
import pandas as pd
from sklearn import svm

# X -- наш датасет, Y -- массив меток
# N -- число признаков, которые хотим оставить, step -- сколько фичей удаляется на каждой итерации
# Возвращает массив из булевых переменных размерностью 1x[число признаков], показывающий, отбрасываем признак или нет
def RFE(X, Y, N, step = 10):
# cache_size нужен, если набор данных большой, иначе можно опустить
clfRFE = svm.SVC(kernel='linear', cache_size=1024)
featureCount = X.shape[1]
featureList = np.arange(0, featureCount )
included = np.full(featureCount, True)
curCount = featureCount
while curCount > N:
actualFeatures = featureList[included]
Xnew = X[:, actualFeatures]

clfRFE.fit(Xnew, Y)
curStep = min(step, curCount - N)
elim = np.argsort(np.abs(clfRFE.coef_[0]))[:curStep]
included[actualFeatures[elim]] = False
curCount -= curStep
return included
==Выделение признаков==
Другим способом уменьшить размерность входных данных является выделение признаков. Эти методы каким-то образом составляют из уже исходных признаков новые, все также полностью описывающие пространство набора данных, но уменьшая его размерность и теряя в репрезентативности данных, т.к. становится непонятно, за что отвечают новые признаки.
Все методы feature extraction можно разделить на '''линейные''' и '''нелинейные'''.

Одним из самых известных методов '''линейного''' выделения признаков является [[Метод главных компонент (PCA)| PCA]][на 28.01.19 не создан] (Principal Component Analysis, рус. ''метод главных компонент''). Основной идеей этого метода является поиск такой гиперплоскости, на которую при ортогональной проекции всех признаков максимизируется дисперсия. Данное преобразование может быть произведено с помощью сингулярного разложения матриц и создает проекцию только на линейные многомерные плоскости, поэтому и метод находится в категории линейных.

К '''нелинейным''' методам, например, могут быть отнесены методы отображающие исходное пространство признаков на нелинейные поверхности или топологические многообразия. Одним из таких алгоритмов является [[Стохастическое вложение соседей с t-распределением |t-SNE]][на 28.01.19 не создан] (t-distributed Stochastic Neighbor Embedding, рус. ''стохастическое вложение соседей с t-распределением''). Данный метод состоит из двух шагов: изначально строится распределение вероятностей по всем парам точек набора данных, каждая условная вероятность $p_{j|i}$ которого означает насколько точка $X_j$ близка к точке $X_i$ при гауссовом распределении вокруг $X_i$. Данное распределение как метрику похожести использует евклидово расстояние. Алгоритм старается получить отображение из точек размерности $\mathbb{R}^k$ в меньшую размерность $\mathbb{R}^d$, для этого вводится еще одно распределение, описывающее насколько точки из нового пространства похожи друг на друга, но используя при этом t-распределение Стьюдента с одной степенью свободы. Как метрику похожести двух распределений используется дивергенция Кульбака-Лейблера<ref>[https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence Дивергенция Кульбака-Лейблера]</ref>, и чтобы найти точки новой размерности $d$ запускается градиентный спуск для минимизации этой величины.
===Пример кода scikit-learn===
Пример выделения признаков с помощью PCA в scikit-learn:
# Импорт библиотек
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split

X = ... # загрузка X
Y = ... # загрузка Y
# Разделение данных на train и test
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y)

clf = ... # берем какой-то классификатор
# Обучаем PCA для выделения 5 признаков
pca = PCA(n_components=5)
pca.fit(Xtrain)
# Изменяем наши наборы данных под выбранные признаки
Xtrain = pca.transform(Xtrain)
Xtest = pca.transform(Xtest)
# Обучаем классификатор и проверяем точность его работы
clf.fit(Xtrain, Ytrain)
print ("Score: %.6f" % clf.score(Xtest, Ytest))

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример уменьшение размерности используя smile.feature.GAFeatureSelection<ref>[https://haifengl.github.io/smile/feature.html#genetic-algorithm-feature-selection Smile, Genetic Algorithm Based Feature Selection]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.feature.GAFeatureSelection
'''import '''smile.read
'''import '''smile.validation.Accuracy

// Загрузка данных
'''val '''data = read.arff("data/weka/segment-test.arff", 19)
'''val '''(x, y) = data.unzipInt
'''val '''trainer = '''new '''GradientTreeBoost.Trainer(100)
'''val '''measure = '''new '''Accuracy
// Cоздание генетического алгоритма и его настройка.
'''val '''selector = '''new '''GAFeatureSelection
// Размер популяции - 50, количество поколений - 20 
// Каждая возращаемая BitString содержит фичи и их качество.
'''val '''result = selector.learn(50, 20, trainer, measure, x, y, 5)
result.foreach { bits =>
print(100*bits.fitness)
println(bits.bits.mkString(" "))
}

==См. также==
*[[Переобучение]]
*[[Метод опорных векторов (SVM)| SVM]][на 28.01.19 не создан]
*[[Дерево решений и случайный лес| Случайный лес]]
*[[Метод главных компонент (PCA)| PCA]][на 28.01.19 не создан]
*[[Стохастическое вложение соседей с t-распределением |t-SNE]][на 28.01.19 не создан]
==Примечания==
<references/>
==Источники информации==
#[http://research.cs.tamu.edu/prism/lectures/pr/pr_l11.pdf Sequential feature selection] {{---}} курс ML Texas A&M University
#[https://en.wikipedia.org/wiki/Feature_selection Feature selection] {{---}} статья про Feature Selection в Wikipedia
#[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117 Публикация про feature selection]
#[https://towardsdatascience.com/feature-selection-using-random-forest-26d7b747597f Embedded random forest]

[[Категория: Машинное обучение]]
[[Категория: Уменьшение размерности]]

Распознавание речи

2019-01-28T14:44:58Z

Alexey Katsman: /* См. также */

'''Распознавание речи'''(Speech Recognition) - процесс преобразования речевого сигнала в цифровую информацию.

Задачей распознавания является сопоставление набору акустических признаков речевого сигнала или наблюдений
<math>X(x_1 ,...,x_n)</math> последовательности слов
<math>W(w_1 ,...,w_k)</math>, имеющих наибольшую вероятность правдоподобия среди всех кандидатов. Для этого используется формула Байеса:

<center><math>W = argmax \left[\frac{P(W)*P(X|W)}{P(X)}\right]</math></center>

Причем, в процессе распознавания вероятность уже полученных признаков Р(Х) не подлежит оптимизации и знаменатель в формуле не испльзуется:

<center><math>W = argmax[P(W)*P(X|W)]</math></center>

==Классификация систем распознавания речи==

Системы распознавания речи классифицируются<ref>''Федосин С.А., Еремин А. Ю.'' Классификация систем распознавания речи. — Саранск. : МГУ им. Н.П. Огарева, 2009. — С. 3.</ref>:
* по размеру словаря (ограниченный набор слов, словарь большого размера);
* по зависимости от диктора (дикторозависимые и дикторонезависимые системы);
* по типу речи (слитная или раздельная речь);
* по назначению (системы диктовки, командные системы);
* по используемому алгоритму (нейронные сети, скрытые Марковские модели, динамическое программирование);
* по типу структурной единицы (фразы, слова, фонемы, дифоны, аллофоны);
* по принципу выделения структурных единиц (распознавание по шаблону, выделение лексических элементов).

==Структура систем распознавания речи==

Системы распознавания речи впервые появились в 1952 году. С тех пор методы распознавания не раз менялись.
Ранее использовались такие методы и алгоритмы, как:
* Динамическое программирование (Dynamic Time Warping) - временные динамические алгоритмы, выполняющие классификацию на основе сравнения с эталоном.
* Методы дискриминантного анализа, основанные на Байесовской дискриминации (Bayesian discrimination).
* Скрытые Марковские Модели (Hidden Markov Model).
* Нейронные сети (Neural Networks).
В настоящее время, перечисленные выше методы как правило комбинируются. Их сочетание позволяет получить более высокое качество распознавания, чем использование каждой модели отдельно.

Системы распознавания речи имеют следующие основные модули:
* Акустическая модель
* Языковая модель
* Декодер

===Акустическая модель===

''Акустическая модель'' — это функция, принимающая на вход небольшой участок акустического сигнала (кадр или frame) и выдающая распределение вероятностей различных фонем на этом кадре. Таким образом, акустическая модель дает нам возможность по звуку восстановить, что было произнесено — с той или иной степенью уверенности. 
''Фонема'' - элементарная единица человеческой речи. 

===Языковая модель===

''Языковая модель'' - позволяет узнать, какие последовательности слов в языке более вероятны, а какие менее.
Здесь в самом простом случае требуется предсказать следующее слово по известным предыдущим словам. В традиционных системах применялись модели типа N-грамм, в которых на основе большого количества текстов оценивались распределения вероятности появления слова в зависимости от N предшествующих слов. Для получения надежных оценок распределений параметр N должен быть достаточно мал: одно, два или три слова — модели униграмм, биграмм или триграмм соответственно. Внедрение языковой модели в систему распознавания речи позволило значительно повысить качество распознавания за счет учета контекста.

===Декодер===

В ходе работы системы автоматического распознавания речи задача распознавания сводится к определению наиболее вероятной последовательности слов, соответствующих содержанию речевого сигнала. Наиболее вероятный кандидат должен определяться с учетом как акустической, так и лингвистической информации. Это означает, что необходимо производить эффективный поиск среди возможных кандидатов с учетом различной вероятностной информации. При распознавании слитной речи число таких кандидатов огромно, и даже использование самых простых моделей приводит к серьезным проблемам, связанным с быстродействием и памятью систем. Как результат, эта задача выносится в отдельный модуль системы автоматического распознавания речи, называемый декодером.
Декодер должен определять наиболее грамматически вероятную гипотезу для неизвестного высказывания – то есть определять наиболее вероятный путь по сети распознавания, состоящей из моделей слов (которые, в свою очередь, формируются из моделей отдельных фонов). Правдоподобие (likelihood) гипотезы определяется двумя факторами, а именно вероятностями последовательности фонов, приписываемыми акустической моделью, и вероятностями следования слов друг за другом, определяемыми моделью языка.

Рассмотрим математическую основу декодеров. 
Отбрасывая несущественный на этапе распознавания знаменатель, запишем:

<center><math>W = argmax [P(W)P(XW)]</math></center>

где <math>X = x_1^T = x_1 ,..., x_N</math> – последовательность векторов признаков входного сигнала, <math>W = w_1^n = w_1 ,..., w_n</math> – последовательность слов, принадлежащих словарю размером <math>N_W</math>. Первый множитель P(W) описывает вклад лингвистического модуля, второй P(X|W) – лексического, фонетического и акустического источников знаний. В соответствии с концепцией марковских цепей, второй множитель представляет собой сумму вероятностей всех возможных последовательностей состояний, что приводит к уравнению:

<center><math>W = argmax [P(W)\sum_{S_1^T} P(x_1^T, s_1^T | w_1^N)]</math></center>

где <math>s_1^T</math> – одна из последовательностей состояний, порождаемых последовательностью слов <math>w_1^n</math>. На практике применяется критерий Витерби<ref>''Тампель И.Б, Карпов А.А.'' Автоматическое распознавание речи. — СПб. : Университет ИТМО, 2016. — С. 113.</ref>. – ищется последовательность состояний, дающая максимальный вклад в сумму:

<center><math>W = argmax[P(W)^aMax[P(x_1^T, s_1^T | w_1^N)]]</math></center>

Различают систему раннего и систему позднего предсказания. В первой выполняется предсказание для акустической и языковой модели независимо, а затем оба предсказания поступают в декодер. При позднем предсказании, вычисленные признаки речи в акустической и языковой моделях без предсказания поступают в декодер и уже на основе их совместного декодирования выполняется предсказание.

Этапы распознавания:
# Обработка речи начинается с оценки качества речевого сигнала. На этом этапе определяется уровень помех и искажений.
# Результат оценки поступает в модуль акустической адаптации, который управляет модулем расчета параметров речи, необходимых для распознавания.
# В сигнале выделяются участки, содержащие речь, и происходит оценка параметров речи. Происходит выделение фонетических и просодических вероятностных характеристик для синтаксического, семантического и прагматического анализа. (Оценка информации о части речи, форме слова и статистические связи между словами.)
# Далее параметры речи поступают в основной блок системы распознавания — декодер. Это компонент, который сопоставляет входной речевой поток с информацией, хранящейся в акустических и языковых моделях, и определяет наиболее вероятную последовательность слов, которая и является конечным результатом распознавания.

==Признаки==

Признаки речевых событий, используемые при распознавании речи:
* Спектр Фурье
* Спектр Фурье в шкале мел
* Коэффициенты линейного предсказания
* Кепстр

'''Спектр Фурье'''

Спектр Фурье получают, используя алгоритм БПФ (Быстрого Преобразования Фурье) с длиной окна равной 2-4 периода основного тона, что составляет около 20 мс. При частоте квантования 10-16 кГц выбирается окно 256 отсчетов.

Для ослабления искажений сигнала, вызванных применением к непрерывному сигналу конечного окна анализа, чаще всего используется окно Хэмминга по формуле:

<center><math>S'(n) = [0.54 - 0.46cos\left(\frac{2\pi n}{N-1}\right)]*S(n)</math></center>

где n = 1..N, N – размерность окна, S(n) – отсчеты речевого сигнала.

'''Спектр Фурье в шкале мел'''

К каждому кадру, полученного Фурье спектра применяется блок мел-фильтров — треугольных пересекающихся фильтров, расположенных наиболее плотно в области нижних частот. Количество фильтров — 26. Для расчета фильтров выбирается верхняя и нижняя частота. Затем осуществляется переход от частотной шкалы к мел-шкале по формуле:

<center><math>M(f) = 1127*ln\left(1 + \frac{f}{700}\right)</math></center>

На мел-шкале выбираются линейно расположенные точки (28 точек для 26 фильтров), после чего, производится обратный переход в частотную область.

'''Коэффициенты линейного предсказания'''

Модель линейного предсказания речи предполагает, что передаточная функция голосового тракта представляется полюсным фильтром с передаточной
функцией:

<center><math>H(z) = \frac{1}{\sum_{i=0}^p a_i z^{-i}}</math></center>

где p – число полюсов и <math>a_0 = 1</math>;
Фильтр с такой передаточной функцией позволяет описать поведение сглаженного спектра речевого сигнала с хорошей точностью, за исключением назализованных звуков. Коэффициенты фильтра {<math>a_i</math>} – выбираются путем минимизации среднеквадратичной ошибки предсказания, просуммированной на окне анализа.

'''Кепстр'''

Кепстр (''cepstrum'') сигнала на основе спектра Фурье вычисляется путем применения косинусного Фурье преобразования к логарифму спектра:

<center><math>c_j = \sqrt{\frac{2}{N}}\sum_{i=0}^{N-1} \left[s_icos\left(\frac{\pi(j+1)(i+0.5)}{N}\right)\right] = \sum_{i=0}^{N-1} C_{j,i}s_i</math></center>

где <math>s_i</math> – логарифм спектра, N – количество отсчётов спектра, <math>C_{i,j}</math> – унитарная матрица косинусного преобразования.

Кепстральные коэффициенты, полученные приведённым способом из ''мел'' спектра Фурье, широко используются для распознавания с помощью марковских моделей и носят название MFCC (Mel-frequency cepstral coefficients).

==Показатели оценки качества распознавания речи==

Существуют различные по сложности и прикладному значению задачи распознавания: изолированных слов (команд); ключевых слов в потоке речи; связанной речи (тщательное проговаривание текста с паузами между словами); слитной речи (разделяют диктовку в узкой тематической области, и спонтанную речь, например, в диалоге между людьми).

Оценка системы, распознающей отдельные команды, не представляет каких-либо трудностей – количество неправильно распознанных команд делится на общее количество испытаний и получается процент ошибки. Для систем, распознающих слитную речь, ситуация не столь проста.

Основными показателями качества распознавания слитной речи являются:
* процент правильно распознанных слов (WRR - Word Recognition Rate);
* процент неправильно распознанных слов (WER - Word Error Rate);
* процент неправильно распознанных предложений/фраз (SER - Sentence Error Rate);

Поскольку с развитием речевых технологий показатель WER все более приближается к нулю, то значение улучшения WER более наглядно, чем улучшение точности распознавания слов.

<center><math>WER = \frac{S+D+I}{T} * 100%</math></center>

где T - количество слов в распознаваемой фразе,
S - количество замененных слов,
D - количество удаленных слов,
I - количество вставленных слов.
Показатель WER может быть больше 100%.

Другим важным критерием оценки систем распознавания слитной речи является - скорость обработки речи. Она вычисляется с помощью показателя скорости (Real-Time Factor, Speed Factor):

<center><math>RTF = \frac{T_{proc}}{T_{signal}}</math></center>

<math>T_{signal}</math> - длительность обрабатываемого аудиосигнала; 
<math>T_{proc}</math> - время, необходимое для обработки сигнала. 
Если <math>RTF \leqslant 1.0</math> - то распознавание речи ведется в режиме реального времени.

==Применение==

Системы распознавания речи начали развиваться как специальные сервисы для людей с ограниченными возможностями, но также нашли применение в различных сферах бизнеса, таких как:
* Телефония: системы голосового самообслуживания;
* "Умный дом": голосовой интерфейс управления;
* Роботы: голосовой интерфейс электронных роботов;
* РС, ноутбуки, телефоны: голосовой ввод команд, диктовка текста;
* Автомобили: голосовое управление в салоне автомобиля.

Основные отрасли применения:
* Голосовое управление
* Голосовые команды
* Голосовой ввод текста
* Голосовой поиск

==См. также==
* [[Байесовская классификация]][на 28.01.19 не создан]
* [https://ru.wikipedia.org/wiki/Распознавание_образов Распознавание образов]
* [https://habr.com/company/yandex/blog/198556/ Распознавание речи от Яндекса]
* [https://ru.wikipedia.org/wiki/Субвокальное_распознавание Субвокальное распознавание]

== Примечания ==
<references />

==Источники информации==
# [https://ru.wikipedia.org/wiki/Speech_recognition] - статья на Википедии
# Тампель И.Б, Карпов А.А. Автоматическое распознавание речи. Учебное пособие. — СПб: Университет ИТМО, 2016. — 138 с.
# [http://fetmag.mrsu.ru/2010-2/pdf/SpeechRecognition.pdf] - статья "Классификация систем распознавания речи".
# [https://moluch.ru/archive/147/41443/] - статья "Выделение границ фонем речевого сигнала с помощью мел-частотных спектральных коэффициентов".

Вариационный автокодировщик

2019-01-28T14:44:23Z

Alexey Katsman:

'''Вариационный автокодировщик''' (англ. ''Variational Autoencoder'', ''VAE'') {{---}} это [[автокодировщик]][на 28.01.19 не создан] (a.k.a. генеративная модель, которая учится отображать объекты в заданное скрытое пространство (и обратно)) основанный на вариационном выводе.

== Предпосылки ==
При попытке использования обыкновенного автокодировщика для генерации новых объектов (желательно из того же априорного распределения, что и датасет) возникает следующая проблема. Случайной величиной с каким распределением проинициализировать скрытые векторы, для того, чтобы картинка, после применения декодера, стала похожа на картинки из датасета, но при этом не совпадала ни с одной из них? Ответ на этот вопрос не ясен, в связи с тем, что обыкновенный автокодировщик не может ничего утверждать про распределение скрытого вектора и даже про его область определения. В частности, область определения может быть даже дискретной.

Вариационный автокодировщик в свою очередь предлагает пользователю самому определить распределение скрытого вектора.

== Описание ==
'''Порождающее моделирование''' (англ. ''Generative modelling'') {{---}} область машинного обучения, имеющая дело с распределением <math>P(X)</math>, определенном на датасете <math>X</math> из пространства (возможно многомерного) <math>\Chi</math>. Так, например, популярные задачи генерации картинок имеют дело с огромным количеством измерений (пикселей).

Также как и в обыкновенных кодировщиках у нас имеется скрытое вероятностное пространство <math>Z</math> соответствующее случайной величине <math>(z, P(z))</math> (распределенной как-нибудь фиксированно, здесь <math>\sim N(0, 1)</math>). И мы хотим иметь декодер <math>f(z, \theta) \colon Z \times \Theta \to \Chi </math>. При этом мы хотим найти такие <math>\theta</math>, чтобы после разыгрывания <math>z</math> по <math>P(z)</math> мы получили "что-то похожее" на элементы <math>X</math>.

Вообще, для любого <math>x \in X</math> мы хотим считать <math>P(x) = \int P(x|z; \theta)P(z)dz</math>, здесь мы заменили <math>f(z, \theta)</math> на <math>P(x|z; \theta)</math>, чтобы явно показать зависимость между <math>x</math> и <math>z</math> и после этого применить формулу полной вероятности. Обычно <math>P(x|z; \theta)</math> около нуля почти для всех пар <math>(x, z)</math>. Основная идея в том, что мы хотим теперь генерировать <math>z</math>, который бы давали что-то около <math>x</math> и только их суммировать в <math>P(x)</math>. Для этого нам требуется ввести еще одно распределение <math>Q(z|X)</math>, которое будет получать <math>x</math> и говорить распределение на <math>z</math> которое наиболее вероятно будет генерировать нам такой <math>x</math>. Теперь нам нужно как-то сделать похожими распределения <math>E_{z\sim Q}P(X|z)</math> и <math>P(X)</math>.

Рассмотрим следующую дивергенцию Кульбака-Лейблера.
:<math>D[Q(z)||P(z|X)] = E_{z∼Q} [log Q(z|X) − log P(z|X)]</math>

Распишем <math>P(z|X)</math> как <math>P(X|z) * P(z) / P(X)</math>.
:<math>D[Q(z)||P(z|X)] = E_{z∼Q} [log Q(z) − log P(X|z) - log P(z)] + log P(X)</math>

Что эквивалентно:
:<math>logP(x) - D[Q(z)||P(z|X)] = E_{z∼Q}[log P(X|z)] - D[Q(z)||P(z)]</math>

Рассмотрим эту штуку для <math>Q(z|X)</math>, тогда:
:<math>logP(x) - D[Q(z|X)||P(z|X)] = E_{z∼Q}[log P(X|z)] - D[Q(z|X)||P(z)]</math>

Посмотрим, на это равенство. Правую часть мы можем оптимизировать градиентным спуском (пусть пока и не совсем понятно как).
В левой же части первое слагаемое -- то, что мы хотим максимизировать. В то же время <math>D[Q(z|X)||P(z|X)]</math> мы хотим минимизировать. Если у нас <math>Q(z|X)</math> -- достаточно сильная модель, то в какой-то модель она будет хорошо матчить <math>P(z|X)</math>, а значит их дивергенция Кульбака-Лейблера будет почти 0. А значит на это слагаемое можно забить. И стараться максимизировать правую часть. В качестве бонуса мы еще получили более "поддатливую" <math>P(z|X)</math>, вместо нее можно смотреть на <math>Q(z|X)</math>.

Теперь разберемся как оптимизировать правую часть. Сначала нужно определиться с моделью для <math>Q(z|X)</math>. Обычно ее берут равной <math>N(z|\mu(X, \theta), \sigma(X, \theta))</math>. Где <math>\mu</math> и <math>\sigma</math> какие-то детерминированные функции на X с обучаемыми параметрами <math>\theta</math>, которые мы впредь будем опускать). Ага, нейронки.

Нетрудно проверить, что для дивергенция Кульбака-Лейблера двух нормальных распределений имеет следующий вид.
:<math>D_{K}[N(\mu_1, \Sigma_0)||N(\mu_1, \Sigma_0)]</math>, KLD есть <math>\frac{1}{2} (tr(\Sigma_1^{-1}\Sigma_0) + (\mu_1 - \mu_0)^T\Sigma_1^{-1}(\mu_1 - \mu_0) - k + log(\frac{det\Sigma_1}{det\Sigma_0})) </math>.

Это значит, что
:<math>D[Q(z|X)||P(z)] = D[N(\mu(X), \Sigma(X))||N(0, I)] = \frac12 (tr(\Sigma(X)) + \mu(X)^T\mu(X) - k - log(det\Sigma(X)))</math>.
Теперь здесь
можно считать градиенты, для BackPropagation. С первым слагаемым в правой части все немного сложнее. <math>E_{z∼Q}[log P(X|z)]</math> мы можем считать методом Монте-Карло(МК), но тогда такая штука (из-за того, что переменные спрятаны в распределении, из которого мы генерируем себе выборку, для МК) не является гладкой относительно них, а значит непонятно, как проталкивать через это градиент. Для того, чтобы все-таки можно было протолкнуть градиент, применяется так называемый reparametrization trick, который базируется на простой формуле <math>N(\Sigma(X), \mu(X)) = \mu(X) + \Sigma^{\frac12}(X) * N(0, I) </math>.

:<math>E_{z∼Q}[log P(X|z)] = E_{\epsilon \sim N(0, I)}[log P(X = f(\mu(X) + \Sigma^{\frac12}(X) * \epsilon), \theta)]</math>.
В такой форме мы уже можем использовать BackPropagation для переменных из функций <math>\Sigma</math> и <math>\mu</math>.

Следующая картинка лучше поможет осознать структуру VAE и, в частности, зачем нужен (и как работает) reparametrization trick.

На левой части диаграмма без использования reparameterization trick.
На правой части диаграмма с использованием reparameterization trick.

[[Файл:VAE.PNG]]

взято из https://arxiv.org/pdf/1606.05908.pdf

== Пример реализации ==
Ниже приведена реализация частного случая VAE на языке Python с использованием библиотеки Pytorch.
Эта реализация работает с датасетом MNIST.
Размерность скрытого слоя {{---}} 2.
Координаты в нем считаются независимыми (из-за этого, например, матрица <math>\Sigma</math> диагональная, и формула для расчета KLD немного другая).

class VariationalAutoencoder(nn.Module):
def __init__(self):
super().__init__()
self.mu = nn.Linear(32, 2)
self.gamma = nn.Linear(32, 2)
self.encoder = nn.Sequential(nn.Linear(784, 32), nn.ReLU(True))
self.decoder = nn.Sequential(nn.Linear(2, 32), nn.ReLU(True), nn.Linear(32, 784), nn.Sigmoid())

def forward(self, x):
mu, gamma = self.encode(x)
encoding = self.reparameterize(mu, gamma)
x = self.decoder(encoding)
return x, mu, gamma

def reparameterize(self, mu, gamma):
if self.training:
sigma = torch.exp(0.5*gamma)
std_z = Variable(torch.from_numpy(np.random.normal(0, 1, size=sigma.size())).float())
encoding = std_z.mul(sigma).add(mu)
return encoding
else:
return mu

def encode(self, x):
x = self.encoder(x)
mu = self.mu(x)
gamma = self.gamma(x)
return mu, gamma

def decode(self, x):
return self.decoder(x)

def latent(self, x):
mu, gamma = self.encode(x)
encoding = self.reparameterize(mu, gamma)
return encoding

def loss_function(input, output, mu, gamma, batch_size=batch_size):
BCE = F.binary_cross_entropy(output, input)
KLD = -0.5*torch.sum(1 + gamma - mu.pow(2) - gamma.exp())
KLD /= batch_size*784
return BCE + KLD

== Применение ==
Область применения вариационных автокодировщиков совпадает с областью применения обыкновенных автокодировщиков. А именно:
* Каскадное обучение глубоких сетей (хотя сейчас применяется все реже, в связи с появлением новых методов инициализации весов)
* Уменьшение шума в данных
* Уменьшение размерности данных (иногда работает лучше, чем [[метод главных компонент]][на 28.01.19 не создан])

Благодаря тому, что пользователь сам устанавливает нужное распределение скрытого вектора, вариационный кодировщик хорошо подходит для генерации новых объектов (например, картинок). Для этого достаточно разыграть скрытый вектор согласно его распределению и скормить ее в декодер. Получится объект из того же распределения, что и датасет.

== См. также ==
*[[:Автокодировщик|Автокодировщик]][на 28.01.19 не создан]
*[[:Generative Adversarial Nets (GAN)|Порождающие состязательные сети]]

== Примечания ==
*[https://habr.com/ru/post/429276/ Вариационные автокодировщики: теория и рабочий код]
*[https://jaan.io/what-is-variational-autoencoder-vae-tutorial/ Tutorial - What is a variational autoencoder?]
*[https://towardsdatascience.com/intuitively-understanding-variational-autoencoders-1bfe67eb5daf Intuitively Understanding Variational Autoencoders]

== Источники информации ==
*[https://arxiv.org/abs/1606.05908 Tutorial on Variational Autoencoders]
*Datalore презентация Дениса Степанова

[[Категория: Машинное обучение]]
[[Категория: Порождающие модели]]

Generative Adversarial Nets (GAN)

2019-01-28T14:43:58Z

Alexey Katsman: /* См. также */

[[File:Арх_ган.png|450px|thumb|Оригинальная архитектура GAN]]

'''Порождающие состязательные сети''' (англ. ''Generative Adversarial Nets, GAN'') $-$ это алгоритм машинного обучения, входящий в семейство [[:Порождающие модели|порождающих моделей]][на 28.01.19 не создан] и построенный на комбинации из двух нейронных сетей, одна из которых генерирует образцы, другая пытается отличить настоящие образцы от сгенерированных. Впервые такие сети были представлены Иэном Гудфеллоу в 2014 году.

==Постановка задачи и метод==
Имеется множество образцов <tex>X</tex> из распределения <tex>p_{data}</tex>, заданного на <tex> \mathbb R^n </tex>, а также некоторое пространство латентных факторов <tex>Z</tex> из распределения <tex>p_{z}</tex>, например, случайные вектора из равномерного распределения <tex> \mathbb U^t(0,1) </tex>.

Рассмотрим две нейронные сети: первая $-$ ''генератор'' <tex> G: Z \rightarrow \mathbb R^n </tex> с параметрами <tex>\theta</tex>, цель которой сгенерировать похожий образец из <tex>p_{data}</tex>, и вторая $-$ ''дискриминатор'' <tex>D: \mathbb R^n \rightarrow \mathbb [0,1] </tex> с параметрами <tex>\gamma</tex>, цель которой выдавать максимальную оценку на образцах из <tex>X</tex> и минимальную на сгенерированных образцах из <tex>G</tex>. Распределение, порождаемое генератором будем обозначать <tex>p_{gen}</tex>. Так же заметим, что в текущем изложении не принципиальны архитектуры нейронных сетей, поэтому можно считать, что параметры <tex>\theta</tex> и <tex>\gamma</tex> являются просто параметрами многослойных персептронов.

В качестве примера можно рассматривать генерацию реалистичных фотографий: в этом случае, входом для генератора может быть случайный многомерный шум, а выходом генератора (и входом для дискриминатора) RGB-изображение; выходом же для дискриминатора будет вероятность, что фотография настоящая, т.е число от 0 до 1.

Наша задача выучить распределение <tex>p_{gen}</tex> так, чтобы оно как можно лучше описывало <tex>p_{data}</tex>. Зададим функцию ошибки для получившейся модели. Со стороны дискриминатора мы хотим распознавать образцы из <tex>X</tex> как правильные, т.е в сторону единицы, и образцы из <tex>G</tex> как неправильные, т.е в сторону нуля, таким образом нужно максимизировать следующую величину:

<center> <tex>\mathop{E}\limits_{x \sim p_{data}}[logD(x)] + \mathop{E}\limits_{x \sim p_{gen}}[log(1-D(x))]</tex>, где <tex>\mathop{E}\limits_{x \sim p_{gen}}[log(1-D(x))] = \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z))]</tex> </center>

Со стороны же генератора требуется научиться "обманывать" дискриминатор, т.е минимизировать по <tex>p_{gen}</tex> второе слагаемое предыдущего выражения. Другими словами, <tex>G</tex> и <tex>D</tex> играют в так называемую ''минимаксную игру'', решая следующую задачу оптимизации:

<center> <tex> \min\limits_{G}\max\limits_{D} \mathop{E}\limits_{x \sim p_{data}}[logD(x)] + \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z))] </tex> </center>

Теоретическое обоснование того, что такой метод заставляет <tex>p_{gen}</tex> сходится к <tex>p_{data}</tex> описано в исходной статье. <ref> [https://arxiv.org/pdf/1406.2661.pdf Ian J. Goodfellow {{---}} Generative Adversarial Nets]</ref>

==Оригинальный алгоритм обучения GAN==
[[File:Обучение_ган.png|450px|thumb|right|Визуализация генерирования фотографии с помощью DCGAN по одному и тому же шуму в зависимости от итерации обучения. Источник: https://arxiv.org/pdf/1701.07875.pdf]]

В процессе обучения требуется делать два шага оптимизации поочередно: сначала обновлять веса генератора <tex>\theta</tex> при фиксированном <tex>\gamma</tex>, а затем веса дискриминатора <tex>\gamma</tex> при фиксированном <tex>\theta</tex>. На практике дискриминатор обновляется <tex>k</tex> раз вместо одного; <tex>k</tex> является гиперпараметром.

// num_iteration {{---}} число итераций обучения 
'''function''' GAN:
'''for''' i = 1..num_iteration '''do'''
'''for''' j = 1..k '''do'''
$z$ = getBatchFromNoisePrior($p_z$) //Получаем мини-батч $\{z_1, . . . , z_m\}$ из распределения $p_z$ 
$x$ = getBatchFromDataGeneratingDistibution($p_{data}$) //Получаем мини-батч $\{x_1, . . . , x_m\}$ из распределения $p_{data}$ 
<tex>d_w \leftarrow \mathop{\nabla}_{\gamma} { \frac{1}{m} \sum_{t = 1}^m \limits} [logD(x_t)] + [log(1-D(G(z_t))] </tex> //Обновляем дискриминатор в сторону возрастания его градиента 
'''end''' '''for'''
$z$ = getBatchFromNoisePrior($p_z$) //Получаем мини-батч $\{z_1, . . . , z_m\}$ из распределения $p_z$ 
<tex>g_w \leftarrow \mathop{\nabla}_{\theta} { \frac{1}{m} \sum_{t = 1}^m \limits} [log(1-D(G(z_t))] </tex> //Обновляем генератор в сторону убывания его градиента 
'''end''' '''for'''
Обновления на основе градиента могут быть сделаны любым стандартным способом, например, в оригинальной статье использовался [[:Cтохастический градиентный спуск|стохастический градиентный спуск]][на 28.01.19 не создан] с импульсом.

==Улучшение обучения GAN==

Большинство GAN'ов подвержено следующим проблемам:
* Несходимость (non-convergence): параметры модели дестабилизируются и не сходятся,
* Схлопывание мод распределения (mode collapse): генератор коллапсирует, т.е выдает ограниченное количество разных образцов,
* Исчезающий градиент (diminished gradient): дискриминатор становится слишком "сильным", а градиент генератора исчезает и обучение не происходит,
* Высокая чувствительность к гиперпараметрам.

Универсального подхода к их решению нет, но существуют практические советы<ref> [https://github.com/soumith/ganhacks How to Train a GAN? Tips and tricks to make GANs work]</ref>, которые могут помочь. Основными из них являются:
# Нормализация данных. Все признаки в диапазоне $[-1; 1]$.
# Замена функции ошибки для $G$ с $\min log (1-D)$ на $\max log D$, потому что исходный вариант имеет маленький градиент на раннем этапе обучения и большой градиент при сходимости, а предложенный наоборот.
# Сэмплирование из многомерного нормального распределения вместо равномерного.
# Использовать нормализационные слои (например, batch normalization или layer normalization) в $G$ и $D$.
# Использовать метки для данных, если они имеются, т.е обучать дискриминатор еще и классифицировать образцы.

==Применение==

[[File:прогресс_ганов.jpg|450px|thumb|right|Прогресс в генерации фотографий с помощью GAN. Источник: https://twitter.com/goodfellow_ian]]

Чаще всего GAN'ы используются для генерации реалистичных фотографий. Серьезные улучшения в этом направлении были сделаны следующими работами:

* Auxiliary GAN<ref> [https://arxiv.org/pdf/1610.09585.pdf Augustus Odena {{---}} Conditional Image Synthesis with Auxiliary Classifier GANs]</ref>: вариант GAN-архитектуры, использующий метки данных.
* SN-GAN<ref> [https://arxiv.org/pdf/1802.05957.pdf Takeru Miyato {{---}} SPECTRAL NORMALIZATION FOR GENERATIVE ADVERSARIAL NETWORKS]</ref>: GAN с новым подходом решения проблемы нестабильного обучения через спектральную нормализацию.
* SAGAN<ref> [https://arxiv.org/pdf/1805.08318.pdf Han Zhang {{---}} Self-Attention Generative Adversarial Networks]</ref>: GAN, основанный на механизме внимания.
* BigGAN<ref> [https://arxiv.org/pdf/1809.11096.pdf Andrew Brock {{---}} LARGE SCALE GAN TRAINING FOR HIGH FIDELITY NATURAL IMAGE SYNTHESIS]</ref>: GAN с ортогональной регуляризацией, позволившей разрешить проблему коллапсирования при долгом обучении.

Кроме простой генерации изображений, существуют достаточно необычные применения, дающие впечатляющие результаты не только на картинках, но и на звуке:

* CycleGAN<ref> [https://junyanz.github.io/CycleGAN/ Jun-Yan Zhu & Taesung Park {{---}} Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks]</ref>: меняет изображения c одного домена на другой, например, лошадей на зебр,
* SRGAN<ref> [https://arxiv.org/abs/1609.04802 Christian Ledig {{---}} Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network]</ref>: создает изображения с высоким разрешением из более низкого разрешения,
* Pix2Pix<ref> [https://phillipi.github.io/pix2pix/ Phillip Isola {{---}} Image-to-Image Translation with Conditional Adversarial Nets]</ref>: создает изображения по семантической окраске,
* StackGAN<ref> [https://arxiv.org/abs/1612.03242 Han Zhang {{---}} StackGAN: Text to Photo-realistic Image Synthesis with Stacked Generative Adversarial Networks]</ref>: создает изображения по заданному тексту,
* MidiNet<ref> [https://arxiv.org/abs/1703.10847 Li-Chia Yang {{---}} MIDINET: A CONVOLUTIONAL GENERATIVE ADVERSARIAL NETWORK FOR SYMBOLIC-DOMAIN MUSIC GENERATION]</ref>: генерирует последовательность нот, таким образом, создает мелодию.

==CGAN (Conditional Generative Adversarial Nets)==

[[File:CGAN_architecture.png|450px|thumb|Архитектура CGAN. Источник: https://arxiv.org/pdf/1411.1784.pdf]]

'''Условные порождающие состязательные сети''' (англ. ''Conditional Generative Adversarial Nets, CGAN'') $-$ это модифицированная версия алгоритма GAN, которая позволяет
генерировать объекты с дополнительными условиями '''y'''. '''y''' может быть любой дополнительной информацией, например, меткой класса или данными из других моделей. Добавление данных условий в существующую архитектуру осуществляется с помощью расширения вектором '''y''' входных данных генератора и дискриминатора.

В таком случае задача оптимизации будет выглядеть следующим образом:

<center> <tex> \min\limits_{G}\max\limits_{D} \mathop{E}\limits_{x \sim p_{data}}[logD(x|y)] + \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z|y))] </tex> </center>

В качестве примера использования данного алгоритма можно рассмотреть задачу генерации рукописных цифр. ''CGAN'' был натренирован на датасете ''MNIST'' с метками классов представленных в виде ''one-hot'' векторов.

[[File:CGAN_generated.png|450px|thumb|Цифры, сгенерированные с помощью CGAN. Источник: https://arxiv.org/pdf/1411.1784.pdf]]

==DCGAN (Deep Convolutional Generative Adversarial Nets)==

[[File:DCGAN_generator.png|450px|thumb|Архитектура генератора в DCGAN. Источник: https://arxiv.org/pdf/1511.06434.pdf]]

'''DCGAN''' $-$ модификация алгоритма ''GAN'', основными архитектурными изменениями которой являются:
* Замена всех пулинговых слоев на страйдинговые свертки (''strided convolutions'') в дискриминаторе и частично-страйдинговые свертки (''fractional-strided''
''convolutions'') в генераторе.
* Использование батчинговой нормализации для генератора и дискриминатора.
* Удаление всех полносвязных скрытых уровней для более глубоких архитектур.
* Использование ''ReLU'' в качестве функции активации в генераторе для всех слоев, кроме последнего, где используется ''tanh''.
* Использование ''LeakyReLU'' в качестве функции активации в дискриминаторе для всех слоев.

Помимо задачи генерации объектов, данный алгоритм хорошо показывает себя в качестве ''feature extractor'''а.
Данный алгоритм был натренирован на датасете ''Imagenet-1k'', после чего были использованы значения со сверточных слоев дискриминатора, подвергнутые ''max-pooling'''у, чтобы образовать матрицы
<tex> 4 \times 4 </tex> и получить общий вектор признаков на их основе. ''L2-SVM'' с данным ''feature extractor'''ом на датасете ''CIFAR-10'' превосходит по точности решения, основанные на алгоритме
''K-Means''. Более подробно об этом вы можете прочитать в статье. <ref> [https://arxiv.org/pdf/1511.06434.pdf Alec Radford, Luke Metz, Soumith Chintala {{---}} Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks]</ref>

==См. также==
*[[:Порождающие модели|Порождающие модели]][на 28.01.19 не создан]
*[[:Variational autoencoder (VAE)|Variational autoencoder (VAE)]][на 28.01.19 не создан]

==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 348-360.
* [https://medium.com/@jonathan_hui/gan-why-it-is-so-hard-to-train-generative-advisory-networks-819a86b3750b Medium | GAN — Why it is so hard to train Generative Adversarial Networks! ]
* [https://arxiv.org/pdf/1411.1784.pdf CGAN Paper]
* [https://arxiv.org/pdf/1511.06434.pdf DCGAN Paper]
[[Категория: Машинное обучение]]
[[Категория: Порождающие модели]]

Generative Adversarial Nets (GAN)

2019-01-28T14:43:41Z

Alexey Katsman:

[[File:Арх_ган.png|450px|thumb|Оригинальная архитектура GAN]]

'''Порождающие состязательные сети''' (англ. ''Generative Adversarial Nets, GAN'') $-$ это алгоритм машинного обучения, входящий в семейство [[:Порождающие модели|порождающих моделей]][на 28.01.19 не создан] и построенный на комбинации из двух нейронных сетей, одна из которых генерирует образцы, другая пытается отличить настоящие образцы от сгенерированных. Впервые такие сети были представлены Иэном Гудфеллоу в 2014 году.

==Постановка задачи и метод==
Имеется множество образцов <tex>X</tex> из распределения <tex>p_{data}</tex>, заданного на <tex> \mathbb R^n </tex>, а также некоторое пространство латентных факторов <tex>Z</tex> из распределения <tex>p_{z}</tex>, например, случайные вектора из равномерного распределения <tex> \mathbb U^t(0,1) </tex>.

Рассмотрим две нейронные сети: первая $-$ ''генератор'' <tex> G: Z \rightarrow \mathbb R^n </tex> с параметрами <tex>\theta</tex>, цель которой сгенерировать похожий образец из <tex>p_{data}</tex>, и вторая $-$ ''дискриминатор'' <tex>D: \mathbb R^n \rightarrow \mathbb [0,1] </tex> с параметрами <tex>\gamma</tex>, цель которой выдавать максимальную оценку на образцах из <tex>X</tex> и минимальную на сгенерированных образцах из <tex>G</tex>. Распределение, порождаемое генератором будем обозначать <tex>p_{gen}</tex>. Так же заметим, что в текущем изложении не принципиальны архитектуры нейронных сетей, поэтому можно считать, что параметры <tex>\theta</tex> и <tex>\gamma</tex> являются просто параметрами многослойных персептронов.

В качестве примера можно рассматривать генерацию реалистичных фотографий: в этом случае, входом для генератора может быть случайный многомерный шум, а выходом генератора (и входом для дискриминатора) RGB-изображение; выходом же для дискриминатора будет вероятность, что фотография настоящая, т.е число от 0 до 1.

Наша задача выучить распределение <tex>p_{gen}</tex> так, чтобы оно как можно лучше описывало <tex>p_{data}</tex>. Зададим функцию ошибки для получившейся модели. Со стороны дискриминатора мы хотим распознавать образцы из <tex>X</tex> как правильные, т.е в сторону единицы, и образцы из <tex>G</tex> как неправильные, т.е в сторону нуля, таким образом нужно максимизировать следующую величину:

<center> <tex>\mathop{E}\limits_{x \sim p_{data}}[logD(x)] + \mathop{E}\limits_{x \sim p_{gen}}[log(1-D(x))]</tex>, где <tex>\mathop{E}\limits_{x \sim p_{gen}}[log(1-D(x))] = \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z))]</tex> </center>

Со стороны же генератора требуется научиться "обманывать" дискриминатор, т.е минимизировать по <tex>p_{gen}</tex> второе слагаемое предыдущего выражения. Другими словами, <tex>G</tex> и <tex>D</tex> играют в так называемую ''минимаксную игру'', решая следующую задачу оптимизации:

<center> <tex> \min\limits_{G}\max\limits_{D} \mathop{E}\limits_{x \sim p_{data}}[logD(x)] + \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z))] </tex> </center>

Теоретическое обоснование того, что такой метод заставляет <tex>p_{gen}</tex> сходится к <tex>p_{data}</tex> описано в исходной статье. <ref> [https://arxiv.org/pdf/1406.2661.pdf Ian J. Goodfellow {{---}} Generative Adversarial Nets]</ref>

==Оригинальный алгоритм обучения GAN==
[[File:Обучение_ган.png|450px|thumb|right|Визуализация генерирования фотографии с помощью DCGAN по одному и тому же шуму в зависимости от итерации обучения. Источник: https://arxiv.org/pdf/1701.07875.pdf]]

В процессе обучения требуется делать два шага оптимизации поочередно: сначала обновлять веса генератора <tex>\theta</tex> при фиксированном <tex>\gamma</tex>, а затем веса дискриминатора <tex>\gamma</tex> при фиксированном <tex>\theta</tex>. На практике дискриминатор обновляется <tex>k</tex> раз вместо одного; <tex>k</tex> является гиперпараметром.

// num_iteration {{---}} число итераций обучения 
'''function''' GAN:
'''for''' i = 1..num_iteration '''do'''
'''for''' j = 1..k '''do'''
$z$ = getBatchFromNoisePrior($p_z$) //Получаем мини-батч $\{z_1, . . . , z_m\}$ из распределения $p_z$ 
$x$ = getBatchFromDataGeneratingDistibution($p_{data}$) //Получаем мини-батч $\{x_1, . . . , x_m\}$ из распределения $p_{data}$ 
<tex>d_w \leftarrow \mathop{\nabla}_{\gamma} { \frac{1}{m} \sum_{t = 1}^m \limits} [logD(x_t)] + [log(1-D(G(z_t))] </tex> //Обновляем дискриминатор в сторону возрастания его градиента 
'''end''' '''for'''
$z$ = getBatchFromNoisePrior($p_z$) //Получаем мини-батч $\{z_1, . . . , z_m\}$ из распределения $p_z$ 
<tex>g_w \leftarrow \mathop{\nabla}_{\theta} { \frac{1}{m} \sum_{t = 1}^m \limits} [log(1-D(G(z_t))] </tex> //Обновляем генератор в сторону убывания его градиента 
'''end''' '''for'''
Обновления на основе градиента могут быть сделаны любым стандартным способом, например, в оригинальной статье использовался [[:Cтохастический градиентный спуск|стохастический градиентный спуск]][на 28.01.19 не создан] с импульсом.

==Улучшение обучения GAN==

Большинство GAN'ов подвержено следующим проблемам:
* Несходимость (non-convergence): параметры модели дестабилизируются и не сходятся,
* Схлопывание мод распределения (mode collapse): генератор коллапсирует, т.е выдает ограниченное количество разных образцов,
* Исчезающий градиент (diminished gradient): дискриминатор становится слишком "сильным", а градиент генератора исчезает и обучение не происходит,
* Высокая чувствительность к гиперпараметрам.

Универсального подхода к их решению нет, но существуют практические советы<ref> [https://github.com/soumith/ganhacks How to Train a GAN? Tips and tricks to make GANs work]</ref>, которые могут помочь. Основными из них являются:
# Нормализация данных. Все признаки в диапазоне $[-1; 1]$.
# Замена функции ошибки для $G$ с $\min log (1-D)$ на $\max log D$, потому что исходный вариант имеет маленький градиент на раннем этапе обучения и большой градиент при сходимости, а предложенный наоборот.
# Сэмплирование из многомерного нормального распределения вместо равномерного.
# Использовать нормализационные слои (например, batch normalization или layer normalization) в $G$ и $D$.
# Использовать метки для данных, если они имеются, т.е обучать дискриминатор еще и классифицировать образцы.

==Применение==

[[File:прогресс_ганов.jpg|450px|thumb|right|Прогресс в генерации фотографий с помощью GAN. Источник: https://twitter.com/goodfellow_ian]]

Чаще всего GAN'ы используются для генерации реалистичных фотографий. Серьезные улучшения в этом направлении были сделаны следующими работами:

* Auxiliary GAN<ref> [https://arxiv.org/pdf/1610.09585.pdf Augustus Odena {{---}} Conditional Image Synthesis with Auxiliary Classifier GANs]</ref>: вариант GAN-архитектуры, использующий метки данных.
* SN-GAN<ref> [https://arxiv.org/pdf/1802.05957.pdf Takeru Miyato {{---}} SPECTRAL NORMALIZATION FOR GENERATIVE ADVERSARIAL NETWORKS]</ref>: GAN с новым подходом решения проблемы нестабильного обучения через спектральную нормализацию.
* SAGAN<ref> [https://arxiv.org/pdf/1805.08318.pdf Han Zhang {{---}} Self-Attention Generative Adversarial Networks]</ref>: GAN, основанный на механизме внимания.
* BigGAN<ref> [https://arxiv.org/pdf/1809.11096.pdf Andrew Brock {{---}} LARGE SCALE GAN TRAINING FOR HIGH FIDELITY NATURAL IMAGE SYNTHESIS]</ref>: GAN с ортогональной регуляризацией, позволившей разрешить проблему коллапсирования при долгом обучении.

Кроме простой генерации изображений, существуют достаточно необычные применения, дающие впечатляющие результаты не только на картинках, но и на звуке:

* CycleGAN<ref> [https://junyanz.github.io/CycleGAN/ Jun-Yan Zhu & Taesung Park {{---}} Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks]</ref>: меняет изображения c одного домена на другой, например, лошадей на зебр,
* SRGAN<ref> [https://arxiv.org/abs/1609.04802 Christian Ledig {{---}} Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network]</ref>: создает изображения с высоким разрешением из более низкого разрешения,
* Pix2Pix<ref> [https://phillipi.github.io/pix2pix/ Phillip Isola {{---}} Image-to-Image Translation with Conditional Adversarial Nets]</ref>: создает изображения по семантической окраске,
* StackGAN<ref> [https://arxiv.org/abs/1612.03242 Han Zhang {{---}} StackGAN: Text to Photo-realistic Image Synthesis with Stacked Generative Adversarial Networks]</ref>: создает изображения по заданному тексту,
* MidiNet<ref> [https://arxiv.org/abs/1703.10847 Li-Chia Yang {{---}} MIDINET: A CONVOLUTIONAL GENERATIVE ADVERSARIAL NETWORK FOR SYMBOLIC-DOMAIN MUSIC GENERATION]</ref>: генерирует последовательность нот, таким образом, создает мелодию.

==CGAN (Conditional Generative Adversarial Nets)==

[[File:CGAN_architecture.png|450px|thumb|Архитектура CGAN. Источник: https://arxiv.org/pdf/1411.1784.pdf]]

'''Условные порождающие состязательные сети''' (англ. ''Conditional Generative Adversarial Nets, CGAN'') $-$ это модифицированная версия алгоритма GAN, которая позволяет
генерировать объекты с дополнительными условиями '''y'''. '''y''' может быть любой дополнительной информацией, например, меткой класса или данными из других моделей. Добавление данных условий в существующую архитектуру осуществляется с помощью расширения вектором '''y''' входных данных генератора и дискриминатора.

В таком случае задача оптимизации будет выглядеть следующим образом:

<center> <tex> \min\limits_{G}\max\limits_{D} \mathop{E}\limits_{x \sim p_{data}}[logD(x|y)] + \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z|y))] </tex> </center>

В качестве примера использования данного алгоритма можно рассмотреть задачу генерации рукописных цифр. ''CGAN'' был натренирован на датасете ''MNIST'' с метками классов представленных в виде ''one-hot'' векторов.

[[File:CGAN_generated.png|450px|thumb|Цифры, сгенерированные с помощью CGAN. Источник: https://arxiv.org/pdf/1411.1784.pdf]]

==DCGAN (Deep Convolutional Generative Adversarial Nets)==

[[File:DCGAN_generator.png|450px|thumb|Архитектура генератора в DCGAN. Источник: https://arxiv.org/pdf/1511.06434.pdf]]

'''DCGAN''' $-$ модификация алгоритма ''GAN'', основными архитектурными изменениями которой являются:
* Замена всех пулинговых слоев на страйдинговые свертки (''strided convolutions'') в дискриминаторе и частично-страйдинговые свертки (''fractional-strided''
''convolutions'') в генераторе.
* Использование батчинговой нормализации для генератора и дискриминатора.
* Удаление всех полносвязных скрытых уровней для более глубоких архитектур.
* Использование ''ReLU'' в качестве функции активации в генераторе для всех слоев, кроме последнего, где используется ''tanh''.
* Использование ''LeakyReLU'' в качестве функции активации в дискриминаторе для всех слоев.

Помимо задачи генерации объектов, данный алгоритм хорошо показывает себя в качестве ''feature extractor'''а.
Данный алгоритм был натренирован на датасете ''Imagenet-1k'', после чего были использованы значения со сверточных слоев дискриминатора, подвергнутые ''max-pooling'''у, чтобы образовать матрицы
<tex> 4 \times 4 </tex> и получить общий вектор признаков на их основе. ''L2-SVM'' с данным ''feature extractor'''ом на датасете ''CIFAR-10'' превосходит по точности решения, основанные на алгоритме
''K-Means''. Более подробно об этом вы можете прочитать в статье. <ref> [https://arxiv.org/pdf/1511.06434.pdf Alec Radford, Luke Metz, Soumith Chintala {{---}} Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks]</ref>

==См. также==
*[[:Порождающие модели|Порождающие модели]]
*[[:Variational autoencoder (VAE)|Variational autoencoder (VAE)]]
==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 348-360.
* [https://medium.com/@jonathan_hui/gan-why-it-is-so-hard-to-train-generative-advisory-networks-819a86b3750b Medium | GAN — Why it is so hard to train Generative Adversarial Networks! ]
* [https://arxiv.org/pdf/1411.1784.pdf CGAN Paper]
* [https://arxiv.org/pdf/1511.06434.pdf DCGAN Paper]
[[Категория: Машинное обучение]]
[[Категория: Порождающие модели]]

Сверточные нейронные сети

2019-01-28T14:43:16Z

Alexey Katsman: /* См. также */

'''Сверточная нейронная сеть''' (англ. ''convolutional neural network'', ''CNN'') {{---}} специальная архитектура нейронных сетей, предложенная Яном Лекуном<ref name=LeNet5>[http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf Yann LeCun — Gradient-Based Learning Applied to Document Recognition, 1998]</ref>, изначально нацеленная на эффективное распознавание изображений.

== Свертка ==
[[Файл:Convolution_example.png|upright=1.0|thumb|[https://arxiv.org/abs/1603.07285 Пример свертки двух матриц размера 5x5 и 3x3]]]
'''Свертка''' (англ. ''convolution'') {{---}} операция над парой матриц <math>A</math> (размера <math>n_x\times n_y</math>) и <math>B</math> (размера <math>m_x \times m_y</math>), результатом которой является матрица <math>C = A * B</math> размера <math>(n_x-m_x+1)\times (n_y-m_y+1)</math>.
Каждый элемент результата вычисляется как скалярное произведение матрицы <math>B</math> и некоторой подматрицы <math>A</math> такого же размера (подматрица определяется положением элемента в результате).
То есть, <math>C_{i,j} = \sum_{u = 0}^{m_x-1}\sum_{v = 0}^{m_y - 1}A_{i+u,j+v}B_{u,v}</math>. На изображении справа можно видеть, как матрица <math>B</math> «двигается» по матрице <math>A</math>, и в каждом положении считается скалярное произведение матрицы <math>B</math> и той части матрицы <math>A</math>, на которую она сейчас наложена. Получившееся число записывается в соответствующий элемент результата.

Логический смысл свертки такой {{---}} чем больше величина элемента свертки, тем больше эта часть матрицы <math>A</math> была похожа на матрицу <math>B</math> (похожа в смысле скалярного произведения). Поэтому матрицу <math>A</math> называют ''изображением'', а матрицу <math>B</math> {{---}} ''фильтром'' или ''образцом''.

== Структура сверточной нейронной сети ==
В сверточной нейронной сети выходы промежуточных слоев образуют матрицу (изображение) или набор матриц (несколько слоёв изображения). Так, например, на вход сверточной нейронной сети можно подавать три слоя изображения (R-, G-, B-каналы изображения). Основными видами слоев в сверточной нейронной сети являются сверточные слои (англ. ''convolutional layer''), пулинговые слои (англ. ''pooling layer'') и [[:Нейронные_сети,_перцептрон|полносвязные слои]] (англ. ''fully-connected layer'').

=== Сверточный слой ===
[[Файл:Padding.png|upright=1.0|thumb|[https://arxiv.org/abs/1603.07285 Пример свертки двух матриц с дополнением нулями и сдвигом 2]]]
[[Файл:Convolution-operation-on-volume5.png|upright=1.0|thumb|[http://www.machinelearning.ru/wiki/images/1/1b/DL16_lecture_3.pdf Пример свертки с трехмерным ядром]]]
Сверточный слой нейронной сети представляет из себя применение операции свертки к выходам с предыдущего слоя, где веса ядра свертки являются обучаемыми параметрами. Еще один обучаемый вес используется в качестве константного сдвига (англ. ''bias''). При этом есть несколько важных деталей:

* В одном сверточном слое может быть несколько сверток. В этом случае для каждой свертки на выходе получится своё изображение. Например, если вход имел размерность <math>w\times h</math>, а в слое было <math>n</math> сверток с ядром размерности <math>k_x\times k_y</math>, то выход будет иметь размерность <math>n\times(w - k_x + 1)\times(h - k_y + 1)</math>.

* Ядра свертки могут быть трёхмерными. Свертка трехмерного входа с трехмерным ядром происходит аналогично, просто скалярное произведение считается еще и по всем слоям изображения. Например, для усреднения информации о цветах исходного изображения, на первом слое можно использовать свертку размерности <math>3\times w \times h</math>. На выходе такого слоя будет уже одно изображение (вместо трёх).

* Можно заметить, что применение операции свертки уменьшает изображение. Также пиксели, которые находятся на границе изображения учавствуют в меньшем количестве сверток, чем внутренние. В связи с этим в сверточных слоях используется дополнение изображения (англ. ''padding''). Выходы с предыдущего слоя дополняются пикселями так, чтобы после свертки сохранился размер изображения. Такие свертки называют ''одинаковыми'' (англ. ''same convolution''), а свертки без дополнения изображения называются ''правильными'' (англ. ''valid convolution''). Среди способов, которыми можно заполнить новые пиксели, можно выделить следующие:
** ''zero shift'': <code>00[ABC]00</code>
** ''border extension'': <code>AA[ABC]CC</code>
** ''mirror shift'': <code>BA[ABC]CB</code>
** ''cyclic shift'': <code>BC[ABC]AB</code>

* Еще одним параметром сверточного слоя является ''сдвиг'' (англ. ''stride''). Хоть обычно свертка применяется подряд для каждого пикселя, иногда используется сдвиг, отличный от единицы {{---}} скалярное произведение считается не со всеми возможными положениями ядра, а только с положениями, кратными некоторому сдвигу <math>s</math>. Тогда, если если вход имел размерность <math>w\times h</math>, а ядро свертки имело размерность <math>k_x\times k_y</math> и использовался сдвиг <math>s</math>, то выход будет иметь размерность <math>\lfloor\frac{w - k_x}{s} + 1\rfloor\times\lfloor\frac{h - k_y}{s} + 1\rfloor</math>.

=== Пулинговый слой ===
[[Файл:Maxpool.jpeg|upright=1.0|thumb|[https://www.slideshare.net/YUNGKUEICHEN/convolutional-neural-network-cnn-image-recognition Пример операции пулинга с функцией максимума]]]
Пулинговый слой призван снижать размерность изображения. Исходное изображение делится на блоки размером <math>w\times h</math> и для каждого блока вычисляется некоторая функция. Чаще всего используется функция максимума (англ. ''max pooling'') или (взвешенного) среднего (англ. ''(weighted) average pooling''). Обучаемых параметров у этого слоя нет. Основные цели пулингового слоя:
* уменьшение изображения, чтобы последующие свертки оперировали над большей областью исходного изображения;
* увеличение инвариантности выхода сети по отношению к малому переносу входа;
* ускорение вычислений.

=== Inception module ===
[[Файл:Inception.png|upright=1.0|thumb|[https://arxiv.org/abs/1409.4842 Inception module]]]
[[Файл:Inception_red.png|upright=1.0|thumb|[https://arxiv.org/pdf/1409.4842.pdf Inception module с сокращением размерностей]]]
''Inception module'' {{---}} это специальный слой нейронной сети, который был предложен в работе<ref name=GoogLeNet>[https://arxiv.org/pdf/1409.4842.pdf Going deeper with convolutions]</ref>, в которой была представлена сеть GoogLeNet. Основная цель этого модуля заключается в следующем. Авторы предположили, что каждый элемент предыдущего слоя соответствует определенной области исходного изображения. Каждая свертка по таким элементам будет увеличивать область исходного изображения, пока элементы на последних слоях не будут соответствовать всему изображению целиком. Однако, если с какого-то момента все свертки станут размером <math>1\times 1</math>, то не найдется элементов, которые покрывали бы все исходное изображение, поэтому было бы невозможно находить большие признаки на изображении. Чтобы решить эту проблему, авторы предложили так называемый inception module {{---}} конкатенацию выходов для сверток размера <math>1\times 1</math>, <math>3\times 3</math>, <math>5\times 5</math>, а также операции max pooling'а с ядром <math>3\times 3</math>. К сожалению, подобный наивный подход (англ. ''naive inception module'') приводит к резкому увеличению слоев изображения, что не позволяет построить с его использованием глубокую нейронную сеть. Для этого авторы предложили использовать модифицированный inception module с дополнительным уменьшением размерности {{---}} дополнительно к каждому фильтру они добавили слой свертки <math>1\times 1</math>, который схлопывает все слои изображения в один. Это позволяет сохранить малое число слоев, с сохранением полезной информации о изображении.

=== Residual block ===
[[Файл:Residual.png|upright=1.0|thumb|[https://arxiv.org/pdf/1512.03385.pdf Устройство residual block]]]
Двумя серьезными проблемами в обучении глубоких нейронных сетей являются исчезающий градиент (англ. ''vanishing gradient'') и взрывающийся градиент (англ. ''exploding gradient''). Они возникают из-за того, что при дифференцировании по цепному правилу, до глубоких слоев нейронной сети доходит очень маленькая величина градиента (из-за многократного домножения на небольшие величины на предыдущих слоях). Для борьбы с этой проблемой был предложен так называемый ''residual block''<ref name=ResNet>[https://arxiv.org/pdf/1512.03385.pdf Deep residual learning for image recognition]</ref>. Идея заключается в том, чтобы взять пару слоёв (например, сверточных), и добавить дополнительную связь, которая проходит мимо этих слоёв. Пусть <math>z^{(k)}</math> {{---}} выход <math>k</math>-ого слоя до применения функции активации, а <math>a^{(k)}</math> {{---}} выход после. Тогда residual block будет выполнять следующее преобразование: <math>a^{(k + 2)} = g(z^{(k + 2)} + a^{(k)})</math>, где <math>g</math> {{---}} функция активации.

На самом деле, такая нейронная сеть обучается предсказывать функцию <math>\mathcal{F}(x) - x</math>, вместо функции <math>\mathcal{F}(x)</math>, которую изначально нужно было предсказывать. Для компенсации этой разницы и вводится это замыкающее соединение (англ. ''shortcut connection''), которое добавляет недостающий <math>x</math> к функции. Предположение авторов, которые предложили residual block, заключалось в том, что такую разностную функцию будет проще обучать, чем исходную. Если рассматривать крайние случаи, то если <math>\mathcal{F}(x) = x</math>, такую сеть обучить нулю всегда возможно, в отличие от обучения множества нелинейных слоёв линейному преобразованию.

== Известные архитектуры сверточных нейронных сетей ==
=== LeNet-5 ===
[[Файл:Lenet5.png|upright=1.0|thumb|[http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf Архитектура LeNet-5]]]
Нейронная сеть, предложенная Яном Лекуном<ref name=LeNet5/>, для распознавания рукописных цифр MNIST.

=== AlexNet ===
[[Файл:Alexnet.png|upright=1.0|thumb|[https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf Архитектура AlexNet]]]
Победитель соревнования ImageNet 2012-ого года, набравший точность 84.6%<ref name=AlexNet>[https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf ImageNet Classification with Deep Convolutional Neural Networks]</ref>. Была реализована с использованием CUDA для повышения производительности. Состоит из двух отдельных частей, которые слабо взаимодействуют друг с другом, что позволяет исполнять их параллельно на разных GPU с минимальным обменом данными.

=== VGG ===
Семейство архитектур нейронных сетей, которое включает в себя, в частности, VGG-11, VGG-13, VGG-16 и VGG-19<ref name=VGG>[https://arxiv.org/pdf/1409.1556.pdf Very Deep Convolutional Networks for Large-Scale Image Recognition]</ref>. Победитель соревнования ImageNet 2013-ого года (VGG-16), набравший точность 92.7%. Одной из отличительных особенностей является использование ядер свертки небольшого размера (3x3, в отличие от больших ядер размера 7x7 или 11x11).

=== GoogLeNet ===
Также известный как ''inception network'' {{---}} победитель соревнования ImageNet 2014-ого года, набравший 93.3% точности<ref name=GoogLeNet/>. Состоит в основном из inception модулей. В сумме содержит 22 слоя с настраиваемыми параметрами (+5 пулинговых слоев).

=== ResNet ===
Победитель соревнования ImageNet 2015-ого года. Сеть-победитель содержала более 150 слоёв<ref name=ResNet/> и набрала 96.43% точности.

=== Сравнение известных нейронных сетей ===
[[Файл:Net-comparison.png|border|1000px]]

== Примеры кода ==
===Scala===
Пример кода с библиотекой DeepLearning.scala<ref>[https://deeplearning.thoughtworks.school/index.html DeepLearning.scala]</ref>
// Загрузка датасета
val cifar10 = Cifar10.load().blockingAwait
// Определение слоёв
def myNeuralNetwork(input: INDArray): INDArrayLayer = {
val cnnLayer = maxPool(relu(conv2d(input.reshape(input.shape()(0), Cifar10.NumberOfChannels, PixelHeight, PixelWidth), cnnWeight, cnnBias, (KernelHeight, KernelWidth), (Stride, Stride), (Padding, Padding))), (PoolSize, PoolSize))
val affineRuleOfCnnLayer = relu(affine(cnnLayer.reshape(input.shape()(0), NumFilters * (PixelHeight / PoolSize) * (PixelWidth / PoolSize)), affineWeight, affineBias))
val affineOfaffineRuleOfCnnLayer = affine(affineRuleOfCnnLayer.reshape(input.shape()(0), HiddenDim), affineLastWeight, affineLastBias)
val softmaxValue = softmax(affineOfaffineRuleOfCnnLayer)
softmaxValue
}
// Определение функции потерь
def lossFunction(input: INDArray, expectOutput: INDArray): DoubleLayer = {
val probabilities = myNeuralNetwork(input)
-(hyperparameters.log(probabilities) * expectOutput).mean
}

class Trainer(batchSize: Int, numberOfEpoches: Int = 5) {
import scalaz.std.anyVal._
import scalaz.syntax.all._
@volatile
private var isShuttingDown: Boolean = false
private val lossBuffer = scala.collection.mutable.Buffer.empty[Double]
def plotLoss(): Unit = Seq(Scatter(lossBuffer.indices, lossBuffer)).plot(title = "loss by time")
def interrupt(): Unit = isShuttingDown = true
def startTrain(): Unit = {
@monadic[Future]
def trainTask: Future[Unit] = {
isShuttingDown = false
var epoch = 0

while (epoch < numberOfEpoches && !isShuttingDown) {
val cifar10 = Cifar10.load().blockingAwait
val iterator = cifar10.epoch(batchSize).zipWithIndex
while (iterator.hasNext && !isShuttingDown) {
val (Cifar10.Batch(labels, batch), i) = iterator.next()
val loss = lossFunction(batch, labels).train.each
lossBuffer += loss
hyperparameters.logger.info(s"epoch=epoch iteration=i batchSize=batchSize loss=loss")
}
epoch += 1
}
hyperparameters.logger.info("Done")
}
trainTask.onComplete { tryUnit: scala.util.Try[Unit] => tryUnit.get }
}
}

==См. также==
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан]

==Примечания==
<references/>

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]
[[Категория: Сверточные нейронные сети]]

Рекуррентные нейронные сети

2019-01-28T14:42:44Z

Alexey Katsman: /* См. также */

'''Рекуррентная нейронная сеть''' (англ. ''recurrent neural network'', ''RNN'') {{---}} вид [[:Нейронные_сети,_перцептрон|нейронных сетей]], где связи между элементами образуют направленную последовательность.

== Описание ==
[[File:RNN.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ RNN и ее развернутое представление]]]
[[File:RNN_layer.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоя рекуррентной сети]]]
Рекуррентные нейронные сети {{---}} сети с циклами, которые хорошо подходят для обработки последовательностей.
[[File:RNN_BP.jpg|450px|thumb|RNN с задержкой на скрытом слое]]
[[File:RNN_BPTT.jpg|450px|thumb|Развертка RNN]]
Обучение RNN аналогично обучению обычной нейронной сети. Мы также используем [[:Обратное_распространение_ошибки|алгоритм обратного распространения ошибки (backpropagation)]][на 28.01.19 не создан], но с небольшим изменением. Поскольку одни и те же параметры используются на всех временных этапах в сети, градиент на каждом выходе зависит не только от расчетов текущего шага, но и от предыдущих временных шагов. Например, чтобы вычислить градиент для четвертого элемента последовательности, нам нужно было бы «распространить ошибку» на 3 шага и суммировать градиенты. Этот алгоритм называется «алгоритмом обратного распространения ошибки сквозь время» (англ. Backpropagation Through Time, BPTT).<ref name=BPTT_1>[http://andrew.gibiansky.com/blog/machine-learning/recurrent-neural-networks/ Backpropagation Through Time]</ref><ref name=BPTT_2>[http://www.wildml.com/2015/10/recurrent-neural-networks-tutorial-part-3-backpropagation-through-time-and-vanishing-gradients/ Backpropagation Through Time]</ref>

Алгоритм обратного распространения ошибки сквозь время:

[[File:RNN_BPTT_GRAD.png|400px|frameless]]

== Области и примеры применения ==
Используются, когда важно соблюдать последовательность, когда важен порядок поступающих объектов.
* Обработка текста на естественном языке
** Анализ текста
** Автоматический перевод
* Обработка аудио
** Автоматическое распознавание речи
* Обработка видео
** Прогнозирование следующего кадра на основе предыдущих
** Распознавание эмоций
* Обработка изображений
** Прогнозирование следующего пикселя на основе окружения
** Генерация описания изображений

== Виды RNN ==
=== Один к одному ===
{|
|-
|[[File:RNN_OTO.jpg|100px|left]]
|Архитектура по сути является обычной нейронной сетью.
|}

=== Один ко многим ===
{|
|-
|[[File:RNN_OTM.jpg|100px|left]]
|Один вход ко многим выходам может применяться, например, для генерации аудиозаписи. На вход подаем жанр музыки, который хотим получить, на выходе получаем последовательность аудиозаписи.
|}

=== Многие к одному ===
{|
|-
|[[File:RNN_MTO.jpg|100px|left]]
|Много входов и один выход может применяться, если мы хотим оценить тональность рецензии. На вход подаем слова рецензии, на выходе получаем оценку ее тональности: позитивная рецензия или негативная.
|}

=== Многие ко многим ===
{|
|-
|[[File:RNN_MTM1.jpg|100px|left]]
|Данную архитектуру можно использовать для перевода текста с одного языка на другой.
|-
|[[File:RNN_MTM2.jpg|100px|left]]
|Такой вариант подойдет для определения для классификации каждого слова в предложении в зависимости от контекста.
|}

== Архитектуры ==
=== Полностью рекуррентная сеть ===
Это базовая архитектура, разработанная в 1980-х. Сеть строится из узлов, каждый из которых соединён со всеми другими узлами. У каждого нейрона порог активации меняется со временем и является вещественным числом. Каждое соединение имеет переменный вещественный вес. Узлы разделяются на входные, выходные и скрытые.

=== Рекурсивная сеть ===
[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан] представляют собой более общий случай рекуррентных сетей, когда сигнал в сети проходит через структуру в виде дерева (обычно бинарные деревья). Те же самые матрицы весов используются рекурсивно по всему графу в соответствии с его топологией.

=== Нейронная сеть Хопфилда ===
Тип рекуррентной сети, когда все соединения симметричны. Изобретена Джоном Хопфилдом в 1982 году и гарантируется, что динамика такой сети сходится к одному из положений равновесия.

=== Двунаправленная ассоциативная память (BAM) ===
Вариацией сети Хопфилда является двунаправленная ассоциативная память (BAM). BAM имеет два слоя, каждый из которых может выступать в качестве входного, находить (вспоминать) ассоциацию и генерировать результат для другого слоя.
[[File:Elman_RNN.jpg|450px|thumb|Сеть Элмана]]

=== Сеть Элмана ===
Нейронная сеть Элмана состоит из трёх слоев: x, y, z (см рис. Сеть Элмана). Дополнительно к сети добавлен набор «контекстных блоков»: u (см рис. Сеть Элмана). Средний (скрытый) слой соединён с контекстными блоками с фиксированным весом, равным единице. С каждым шагом времени на вход поступает информация, которая проходит прямой ход к выходному слою в соответствии с правилами обучения. Фиксированные обратные связи сохраняют предыдущие значения скрытого слоя в контекстных блоках (до того как скрытый слой поменяет значение в процессе обучения). Таким способом сеть сохраняет своё состояние, что может использоваться в предсказании последовательностей, выходя за пределы мощности многослойного перцептрона.

<math>h_t = \sigma_h(W_h x_t + U_h h_{t-1} + b_h)</math>

<math>y_t = \sigma_y(W_y h_t + b_y)</math>

Обозначения переменных и функций:
* <math>x_t</math>: вектор входного слоя
* <math>h_t</math>: вектор скрытого слоя
* <math>y_t</math>: вектор выходного слоя
* <math>W, U, b</math>: матрица и вектор параметров
* <math>\sigma_h, \sigma_y</math>: функция активации

=== Сеть Джордана ===
Нейронная сеть Джордана подобна сети Элмана, но контекстные блоки связаны не со скрытым слоем, а с выходным слоем. Контекстные блоки таким образом сохраняют своё состояние. Они обладают рекуррентной связью с собой.

<math>h_t = \sigma_h(W_h x_t + U_h y_{t-1} + b_h)</math>

<math>y_t = \sigma_y(W_y h_t + b_y)</math>

=== Эхо-сети ===
Эхо-сеть (англ. Echo State Network, ESN) характеризуется одним скрытым слоем (который называется резервуаром) со случайными редкими связями между нейронами. При этом связи внутри резервуара фиксированы, но связи с выходным слоем подлежат обучению. Состояние резервуара (state) вычисляется через предыдущие состояния резервуара, а также предыдущие состояния входного и выходного сигналов. Так как эхо-сети обладают только одним скрытым слоем, они обладают достаточно низкой вычислительной сложностью.

=== Нейронный компрессор истории ===
Нейронный компрессор исторических данных {{---}} это блок, позволяющий в сжатом виде хранить существенные исторические особенности процесса, который является своего рода стеком рекуррентной нейронной сети, формируемым в процессе самообучения.
[[File:LSTM.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоев рекуррентной сети долго-краткосрочной памяти]]]

=== Сети долго-краткосрочной памяти ===
[[:Долгая_краткосрочная_память|Сеть долго-краткосрочной памяти]] (англ. Long short-term memory, LSTM) является самой популярной архитектурой рекуррентной нейронной сети на текущий момент, такая архитектура способна запоминать данные на долгое время.<ref name=LSTM>[https://www.bioinf.jku.at/publications/older/2604.pdf Sepp Hochreiter, Jurgen Schmidhuber. Long short-term memory (1997). Neural Computation.]</ref>

=== Управляемые рекуррентные блоки ===
Управляемые рекуррентные блоки (англ. Gated Recurrent Units, GRU) {{---}} обладает меньшим количеством параметров, чем у LSTM, и в ней отсутствует выходное управление. При этом производительность в моделях речевого сигнала или полифонической музыки оказалась сопоставимой с LSTM.

== Пример кода ==
Пример кода на Python с использованием библиотеки Keras.<ref name=KerasRNN>[https://keras.io/layers/recurrent/ Keras RNN]</ref>

# Импорты
'''import''' numpy '''as''' np
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Activation, Embedding
'''from''' keras.layers '''import''' LSTM
'''from''' keras.datasets '''import''' imdb

# Устанавливаем seed для обеспечения повторяемости результатов
np.random.seed(42)

# Указываем количество слов из частотного словаря, которое будет использоваться (отсортированы по частоте использования)
max_features = 5000

# Загружаем данные (датасет IMDB содержит 25000 рецензий на фильмы с правильным ответом для обучения и 25000 рецензий на фильмы с правильным ответом для тестирования)
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words = max_features)

# Устанавливаем максимальную длину рецензий в словах, чтобы они все были одной длины
maxlen = 80

# Заполняем короткие рецензии пробелами, а длинные обрезаем
X_train = sequence.pad_sequences(X_train, maxlen = maxlen)
X_test = sequence.pad_sequences(X_test, maxlen = maxlen)

# Создаем модель последовательной сети
model = Sequential()
# Добавляем слой для векторного представления слов (5000 слов, каждое представлено вектором из 32 чисел, отключаем входной сигнал с вероятностью 20% для предотвращения переобучения)
model.add(Embedding(max_features, 32, dropout = 0.2))
# Добавляем слой долго-краткосрочной памяти (100 элементов для долговременного хранения информации, отключаем входной сигнал с вероятностью 20%, отключаем рекуррентный сигнал с вероятностью 20%)
model.add(LSTM(100, dropout_W = 0.2, dropout_U = 0.2))
# Добавляем полносвязный слой из 1 элемента для классификации, в качестве функции активации будем использовать сигмоидальную функцию
model.add(Dense(1, activation = 'sigmoid'))

# Компилируем модель нейронной сети
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])

# Обучаем нейронную сеть (данные для обучения, ответы к данным для обучения, количество рецензий после анализа которого будут изменены веса, число эпох обучения, тестовые данные, показывать progress bar или нет)
model.fit(X_train, y_train,
batch_size = 64,
nb_epoch = 7,
validation_data = (X_test, y_test),
verbose = 1)

# Проверяем качество обучения на тестовых данных (если есть данные, которые не участвовали в обучении, лучше использовать их, но в нашем случае таковых нет)
scores = model.evaluate(X_test, y_test, batch_size = 64)
print('Точность на тестовых данных: %.2f%%' % (scores[1] * 100))

==См. также==
*[[:Сверточные_нейронные_сети|Сверточные нейронные сети]]
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан]

==Примечания==
<references/>

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]
[[Категория: Рекуррентные нейронные сети]]

Рекуррентные нейронные сети

2019-01-28T14:42:30Z

Alexey Katsman: /* Рекурсивная сеть */

'''Рекуррентная нейронная сеть''' (англ. ''recurrent neural network'', ''RNN'') {{---}} вид [[:Нейронные_сети,_перцептрон|нейронных сетей]], где связи между элементами образуют направленную последовательность.

== Описание ==
[[File:RNN.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ RNN и ее развернутое представление]]]
[[File:RNN_layer.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоя рекуррентной сети]]]
Рекуррентные нейронные сети {{---}} сети с циклами, которые хорошо подходят для обработки последовательностей.
[[File:RNN_BP.jpg|450px|thumb|RNN с задержкой на скрытом слое]]
[[File:RNN_BPTT.jpg|450px|thumb|Развертка RNN]]
Обучение RNN аналогично обучению обычной нейронной сети. Мы также используем [[:Обратное_распространение_ошибки|алгоритм обратного распространения ошибки (backpropagation)]][на 28.01.19 не создан], но с небольшим изменением. Поскольку одни и те же параметры используются на всех временных этапах в сети, градиент на каждом выходе зависит не только от расчетов текущего шага, но и от предыдущих временных шагов. Например, чтобы вычислить градиент для четвертого элемента последовательности, нам нужно было бы «распространить ошибку» на 3 шага и суммировать градиенты. Этот алгоритм называется «алгоритмом обратного распространения ошибки сквозь время» (англ. Backpropagation Through Time, BPTT).<ref name=BPTT_1>[http://andrew.gibiansky.com/blog/machine-learning/recurrent-neural-networks/ Backpropagation Through Time]</ref><ref name=BPTT_2>[http://www.wildml.com/2015/10/recurrent-neural-networks-tutorial-part-3-backpropagation-through-time-and-vanishing-gradients/ Backpropagation Through Time]</ref>

Алгоритм обратного распространения ошибки сквозь время:

[[File:RNN_BPTT_GRAD.png|400px|frameless]]

== Области и примеры применения ==
Используются, когда важно соблюдать последовательность, когда важен порядок поступающих объектов.
* Обработка текста на естественном языке
** Анализ текста
** Автоматический перевод
* Обработка аудио
** Автоматическое распознавание речи
* Обработка видео
** Прогнозирование следующего кадра на основе предыдущих
** Распознавание эмоций
* Обработка изображений
** Прогнозирование следующего пикселя на основе окружения
** Генерация описания изображений

== Виды RNN ==
=== Один к одному ===
{|
|-
|[[File:RNN_OTO.jpg|100px|left]]
|Архитектура по сути является обычной нейронной сетью.
|}

=== Один ко многим ===
{|
|-
|[[File:RNN_OTM.jpg|100px|left]]
|Один вход ко многим выходам может применяться, например, для генерации аудиозаписи. На вход подаем жанр музыки, который хотим получить, на выходе получаем последовательность аудиозаписи.
|}

=== Многие к одному ===
{|
|-
|[[File:RNN_MTO.jpg|100px|left]]
|Много входов и один выход может применяться, если мы хотим оценить тональность рецензии. На вход подаем слова рецензии, на выходе получаем оценку ее тональности: позитивная рецензия или негативная.
|}

=== Многие ко многим ===
{|
|-
|[[File:RNN_MTM1.jpg|100px|left]]
|Данную архитектуру можно использовать для перевода текста с одного языка на другой.
|-
|[[File:RNN_MTM2.jpg|100px|left]]
|Такой вариант подойдет для определения для классификации каждого слова в предложении в зависимости от контекста.
|}

== Архитектуры ==
=== Полностью рекуррентная сеть ===
Это базовая архитектура, разработанная в 1980-х. Сеть строится из узлов, каждый из которых соединён со всеми другими узлами. У каждого нейрона порог активации меняется со временем и является вещественным числом. Каждое соединение имеет переменный вещественный вес. Узлы разделяются на входные, выходные и скрытые.

=== Рекурсивная сеть ===
[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан] представляют собой более общий случай рекуррентных сетей, когда сигнал в сети проходит через структуру в виде дерева (обычно бинарные деревья). Те же самые матрицы весов используются рекурсивно по всему графу в соответствии с его топологией.

=== Нейронная сеть Хопфилда ===
Тип рекуррентной сети, когда все соединения симметричны. Изобретена Джоном Хопфилдом в 1982 году и гарантируется, что динамика такой сети сходится к одному из положений равновесия.

=== Двунаправленная ассоциативная память (BAM) ===
Вариацией сети Хопфилда является двунаправленная ассоциативная память (BAM). BAM имеет два слоя, каждый из которых может выступать в качестве входного, находить (вспоминать) ассоциацию и генерировать результат для другого слоя.
[[File:Elman_RNN.jpg|450px|thumb|Сеть Элмана]]

=== Сеть Элмана ===
Нейронная сеть Элмана состоит из трёх слоев: x, y, z (см рис. Сеть Элмана). Дополнительно к сети добавлен набор «контекстных блоков»: u (см рис. Сеть Элмана). Средний (скрытый) слой соединён с контекстными блоками с фиксированным весом, равным единице. С каждым шагом времени на вход поступает информация, которая проходит прямой ход к выходному слою в соответствии с правилами обучения. Фиксированные обратные связи сохраняют предыдущие значения скрытого слоя в контекстных блоках (до того как скрытый слой поменяет значение в процессе обучения). Таким способом сеть сохраняет своё состояние, что может использоваться в предсказании последовательностей, выходя за пределы мощности многослойного перцептрона.

<math>h_t = \sigma_h(W_h x_t + U_h h_{t-1} + b_h)</math>

<math>y_t = \sigma_y(W_y h_t + b_y)</math>

Обозначения переменных и функций:
* <math>x_t</math>: вектор входного слоя
* <math>h_t</math>: вектор скрытого слоя
* <math>y_t</math>: вектор выходного слоя
* <math>W, U, b</math>: матрица и вектор параметров
* <math>\sigma_h, \sigma_y</math>: функция активации

=== Сеть Джордана ===
Нейронная сеть Джордана подобна сети Элмана, но контекстные блоки связаны не со скрытым слоем, а с выходным слоем. Контекстные блоки таким образом сохраняют своё состояние. Они обладают рекуррентной связью с собой.

<math>h_t = \sigma_h(W_h x_t + U_h y_{t-1} + b_h)</math>

<math>y_t = \sigma_y(W_y h_t + b_y)</math>

=== Эхо-сети ===
Эхо-сеть (англ. Echo State Network, ESN) характеризуется одним скрытым слоем (который называется резервуаром) со случайными редкими связями между нейронами. При этом связи внутри резервуара фиксированы, но связи с выходным слоем подлежат обучению. Состояние резервуара (state) вычисляется через предыдущие состояния резервуара, а также предыдущие состояния входного и выходного сигналов. Так как эхо-сети обладают только одним скрытым слоем, они обладают достаточно низкой вычислительной сложностью.

=== Нейронный компрессор истории ===
Нейронный компрессор исторических данных {{---}} это блок, позволяющий в сжатом виде хранить существенные исторические особенности процесса, который является своего рода стеком рекуррентной нейронной сети, формируемым в процессе самообучения.
[[File:LSTM.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоев рекуррентной сети долго-краткосрочной памяти]]]

=== Сети долго-краткосрочной памяти ===
[[:Долгая_краткосрочная_память|Сеть долго-краткосрочной памяти]] (англ. Long short-term memory, LSTM) является самой популярной архитектурой рекуррентной нейронной сети на текущий момент, такая архитектура способна запоминать данные на долгое время.<ref name=LSTM>[https://www.bioinf.jku.at/publications/older/2604.pdf Sepp Hochreiter, Jurgen Schmidhuber. Long short-term memory (1997). Neural Computation.]</ref>

=== Управляемые рекуррентные блоки ===
Управляемые рекуррентные блоки (англ. Gated Recurrent Units, GRU) {{---}} обладает меньшим количеством параметров, чем у LSTM, и в ней отсутствует выходное управление. При этом производительность в моделях речевого сигнала или полифонической музыки оказалась сопоставимой с LSTM.

== Пример кода ==
Пример кода на Python с использованием библиотеки Keras.<ref name=KerasRNN>[https://keras.io/layers/recurrent/ Keras RNN]</ref>

# Импорты
'''import''' numpy '''as''' np
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Activation, Embedding
'''from''' keras.layers '''import''' LSTM
'''from''' keras.datasets '''import''' imdb

# Устанавливаем seed для обеспечения повторяемости результатов
np.random.seed(42)

# Указываем количество слов из частотного словаря, которое будет использоваться (отсортированы по частоте использования)
max_features = 5000

# Загружаем данные (датасет IMDB содержит 25000 рецензий на фильмы с правильным ответом для обучения и 25000 рецензий на фильмы с правильным ответом для тестирования)
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words = max_features)

# Устанавливаем максимальную длину рецензий в словах, чтобы они все были одной длины
maxlen = 80

# Заполняем короткие рецензии пробелами, а длинные обрезаем
X_train = sequence.pad_sequences(X_train, maxlen = maxlen)
X_test = sequence.pad_sequences(X_test, maxlen = maxlen)

# Создаем модель последовательной сети
model = Sequential()
# Добавляем слой для векторного представления слов (5000 слов, каждое представлено вектором из 32 чисел, отключаем входной сигнал с вероятностью 20% для предотвращения переобучения)
model.add(Embedding(max_features, 32, dropout = 0.2))
# Добавляем слой долго-краткосрочной памяти (100 элементов для долговременного хранения информации, отключаем входной сигнал с вероятностью 20%, отключаем рекуррентный сигнал с вероятностью 20%)
model.add(LSTM(100, dropout_W = 0.2, dropout_U = 0.2))
# Добавляем полносвязный слой из 1 элемента для классификации, в качестве функции активации будем использовать сигмоидальную функцию
model.add(Dense(1, activation = 'sigmoid'))

# Компилируем модель нейронной сети
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])

# Обучаем нейронную сеть (данные для обучения, ответы к данным для обучения, количество рецензий после анализа которого будут изменены веса, число эпох обучения, тестовые данные, показывать progress bar или нет)
model.fit(X_train, y_train,
batch_size = 64,
nb_epoch = 7,
validation_data = (X_test, y_test),
verbose = 1)

# Проверяем качество обучения на тестовых данных (если есть данные, которые не участвовали в обучении, лучше использовать их, но в нашем случае таковых нет)
scores = model.evaluate(X_test, y_test, batch_size = 64)
print('Точность на тестовых данных: %.2f%%' % (scores[1] * 100))

==См. также==
*[[:Сверточные_нейронные_сети|Сверточные нейронные сети]]
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]

==Примечания==
<references/>

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]
[[Категория: Рекуррентные нейронные сети]]

Рекуррентные нейронные сети

2019-01-28T14:42:15Z

Alexey Katsman: /* Описание */

'''Рекуррентная нейронная сеть''' (англ. ''recurrent neural network'', ''RNN'') {{---}} вид [[:Нейронные_сети,_перцептрон|нейронных сетей]], где связи между элементами образуют направленную последовательность.

== Описание ==
[[File:RNN.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ RNN и ее развернутое представление]]]
[[File:RNN_layer.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоя рекуррентной сети]]]
Рекуррентные нейронные сети {{---}} сети с циклами, которые хорошо подходят для обработки последовательностей.
[[File:RNN_BP.jpg|450px|thumb|RNN с задержкой на скрытом слое]]
[[File:RNN_BPTT.jpg|450px|thumb|Развертка RNN]]
Обучение RNN аналогично обучению обычной нейронной сети. Мы также используем [[:Обратное_распространение_ошибки|алгоритм обратного распространения ошибки (backpropagation)]][на 28.01.19 не создан], но с небольшим изменением. Поскольку одни и те же параметры используются на всех временных этапах в сети, градиент на каждом выходе зависит не только от расчетов текущего шага, но и от предыдущих временных шагов. Например, чтобы вычислить градиент для четвертого элемента последовательности, нам нужно было бы «распространить ошибку» на 3 шага и суммировать градиенты. Этот алгоритм называется «алгоритмом обратного распространения ошибки сквозь время» (англ. Backpropagation Through Time, BPTT).<ref name=BPTT_1>[http://andrew.gibiansky.com/blog/machine-learning/recurrent-neural-networks/ Backpropagation Through Time]</ref><ref name=BPTT_2>[http://www.wildml.com/2015/10/recurrent-neural-networks-tutorial-part-3-backpropagation-through-time-and-vanishing-gradients/ Backpropagation Through Time]</ref>

Алгоритм обратного распространения ошибки сквозь время:

[[File:RNN_BPTT_GRAD.png|400px|frameless]]

== Области и примеры применения ==
Используются, когда важно соблюдать последовательность, когда важен порядок поступающих объектов.
* Обработка текста на естественном языке
** Анализ текста
** Автоматический перевод
* Обработка аудио
** Автоматическое распознавание речи
* Обработка видео
** Прогнозирование следующего кадра на основе предыдущих
** Распознавание эмоций
* Обработка изображений
** Прогнозирование следующего пикселя на основе окружения
** Генерация описания изображений

== Виды RNN ==
=== Один к одному ===
{|
|-
|[[File:RNN_OTO.jpg|100px|left]]
|Архитектура по сути является обычной нейронной сетью.
|}

=== Один ко многим ===
{|
|-
|[[File:RNN_OTM.jpg|100px|left]]
|Один вход ко многим выходам может применяться, например, для генерации аудиозаписи. На вход подаем жанр музыки, который хотим получить, на выходе получаем последовательность аудиозаписи.
|}

=== Многие к одному ===
{|
|-
|[[File:RNN_MTO.jpg|100px|left]]
|Много входов и один выход может применяться, если мы хотим оценить тональность рецензии. На вход подаем слова рецензии, на выходе получаем оценку ее тональности: позитивная рецензия или негативная.
|}

=== Многие ко многим ===
{|
|-
|[[File:RNN_MTM1.jpg|100px|left]]
|Данную архитектуру можно использовать для перевода текста с одного языка на другой.
|-
|[[File:RNN_MTM2.jpg|100px|left]]
|Такой вариант подойдет для определения для классификации каждого слова в предложении в зависимости от контекста.
|}

== Архитектуры ==
=== Полностью рекуррентная сеть ===
Это базовая архитектура, разработанная в 1980-х. Сеть строится из узлов, каждый из которых соединён со всеми другими узлами. У каждого нейрона порог активации меняется со временем и является вещественным числом. Каждое соединение имеет переменный вещественный вес. Узлы разделяются на входные, выходные и скрытые.

=== Рекурсивная сеть ===
[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]] представляют собой более общий случай рекуррентных сетей, когда сигнал в сети проходит через структуру в виде дерева (обычно бинарные деревья). Те же самые матрицы весов используются рекурсивно по всему графу в соответствии с его топологией.

=== Нейронная сеть Хопфилда ===
Тип рекуррентной сети, когда все соединения симметричны. Изобретена Джоном Хопфилдом в 1982 году и гарантируется, что динамика такой сети сходится к одному из положений равновесия.

=== Двунаправленная ассоциативная память (BAM) ===
Вариацией сети Хопфилда является двунаправленная ассоциативная память (BAM). BAM имеет два слоя, каждый из которых может выступать в качестве входного, находить (вспоминать) ассоциацию и генерировать результат для другого слоя.
[[File:Elman_RNN.jpg|450px|thumb|Сеть Элмана]]

=== Сеть Элмана ===
Нейронная сеть Элмана состоит из трёх слоев: x, y, z (см рис. Сеть Элмана). Дополнительно к сети добавлен набор «контекстных блоков»: u (см рис. Сеть Элмана). Средний (скрытый) слой соединён с контекстными блоками с фиксированным весом, равным единице. С каждым шагом времени на вход поступает информация, которая проходит прямой ход к выходному слою в соответствии с правилами обучения. Фиксированные обратные связи сохраняют предыдущие значения скрытого слоя в контекстных блоках (до того как скрытый слой поменяет значение в процессе обучения). Таким способом сеть сохраняет своё состояние, что может использоваться в предсказании последовательностей, выходя за пределы мощности многослойного перцептрона.

<math>h_t = \sigma_h(W_h x_t + U_h h_{t-1} + b_h)</math>

<math>y_t = \sigma_y(W_y h_t + b_y)</math>

Обозначения переменных и функций:
* <math>x_t</math>: вектор входного слоя
* <math>h_t</math>: вектор скрытого слоя
* <math>y_t</math>: вектор выходного слоя
* <math>W, U, b</math>: матрица и вектор параметров
* <math>\sigma_h, \sigma_y</math>: функция активации

=== Сеть Джордана ===
Нейронная сеть Джордана подобна сети Элмана, но контекстные блоки связаны не со скрытым слоем, а с выходным слоем. Контекстные блоки таким образом сохраняют своё состояние. Они обладают рекуррентной связью с собой.

<math>h_t = \sigma_h(W_h x_t + U_h y_{t-1} + b_h)</math>

<math>y_t = \sigma_y(W_y h_t + b_y)</math>

=== Эхо-сети ===
Эхо-сеть (англ. Echo State Network, ESN) характеризуется одним скрытым слоем (который называется резервуаром) со случайными редкими связями между нейронами. При этом связи внутри резервуара фиксированы, но связи с выходным слоем подлежат обучению. Состояние резервуара (state) вычисляется через предыдущие состояния резервуара, а также предыдущие состояния входного и выходного сигналов. Так как эхо-сети обладают только одним скрытым слоем, они обладают достаточно низкой вычислительной сложностью.

=== Нейронный компрессор истории ===
Нейронный компрессор исторических данных {{---}} это блок, позволяющий в сжатом виде хранить существенные исторические особенности процесса, который является своего рода стеком рекуррентной нейронной сети, формируемым в процессе самообучения.
[[File:LSTM.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоев рекуррентной сети долго-краткосрочной памяти]]]

=== Сети долго-краткосрочной памяти ===
[[:Долгая_краткосрочная_память|Сеть долго-краткосрочной памяти]] (англ. Long short-term memory, LSTM) является самой популярной архитектурой рекуррентной нейронной сети на текущий момент, такая архитектура способна запоминать данные на долгое время.<ref name=LSTM>[https://www.bioinf.jku.at/publications/older/2604.pdf Sepp Hochreiter, Jurgen Schmidhuber. Long short-term memory (1997). Neural Computation.]</ref>

=== Управляемые рекуррентные блоки ===
Управляемые рекуррентные блоки (англ. Gated Recurrent Units, GRU) {{---}} обладает меньшим количеством параметров, чем у LSTM, и в ней отсутствует выходное управление. При этом производительность в моделях речевого сигнала или полифонической музыки оказалась сопоставимой с LSTM.

== Пример кода ==
Пример кода на Python с использованием библиотеки Keras.<ref name=KerasRNN>[https://keras.io/layers/recurrent/ Keras RNN]</ref>

# Импорты
'''import''' numpy '''as''' np
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Activation, Embedding
'''from''' keras.layers '''import''' LSTM
'''from''' keras.datasets '''import''' imdb

# Устанавливаем seed для обеспечения повторяемости результатов
np.random.seed(42)

# Указываем количество слов из частотного словаря, которое будет использоваться (отсортированы по частоте использования)
max_features = 5000

# Загружаем данные (датасет IMDB содержит 25000 рецензий на фильмы с правильным ответом для обучения и 25000 рецензий на фильмы с правильным ответом для тестирования)
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words = max_features)

# Устанавливаем максимальную длину рецензий в словах, чтобы они все были одной длины
maxlen = 80

# Заполняем короткие рецензии пробелами, а длинные обрезаем
X_train = sequence.pad_sequences(X_train, maxlen = maxlen)
X_test = sequence.pad_sequences(X_test, maxlen = maxlen)

# Создаем модель последовательной сети
model = Sequential()
# Добавляем слой для векторного представления слов (5000 слов, каждое представлено вектором из 32 чисел, отключаем входной сигнал с вероятностью 20% для предотвращения переобучения)
model.add(Embedding(max_features, 32, dropout = 0.2))
# Добавляем слой долго-краткосрочной памяти (100 элементов для долговременного хранения информации, отключаем входной сигнал с вероятностью 20%, отключаем рекуррентный сигнал с вероятностью 20%)
model.add(LSTM(100, dropout_W = 0.2, dropout_U = 0.2))
# Добавляем полносвязный слой из 1 элемента для классификации, в качестве функции активации будем использовать сигмоидальную функцию
model.add(Dense(1, activation = 'sigmoid'))

# Компилируем модель нейронной сети
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])

# Обучаем нейронную сеть (данные для обучения, ответы к данным для обучения, количество рецензий после анализа которого будут изменены веса, число эпох обучения, тестовые данные, показывать progress bar или нет)
model.fit(X_train, y_train,
batch_size = 64,
nb_epoch = 7,
validation_data = (X_test, y_test),
verbose = 1)

# Проверяем качество обучения на тестовых данных (если есть данные, которые не участвовали в обучении, лучше использовать их, но в нашем случае таковых нет)
scores = model.evaluate(X_test, y_test, batch_size = 64)
print('Точность на тестовых данных: %.2f%%' % (scores[1] * 100))

==См. также==
*[[:Сверточные_нейронные_сети|Сверточные нейронные сети]]
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]

==Примечания==
<references/>

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]
[[Категория: Рекуррентные нейронные сети]]

Batch-normalization

2019-01-28T14:41:16Z

Alexey Katsman: /* Модификации */

'''Пакетная нормализация''' (англ. batch-normalization) {{---}} это метод, который позволяет повысить производительность и стабилизировать работу [[Нейронные сети, перцептрон | искусственных нейронных сетей]]. Суть данного метода заключается в том, что некоторым слоям нейронной сети на вход подаются данные, предварительно обработанные и имеющие нулевое [[Математическое ожидание случайной величины|математическое ожидание]] и единичную [[Дисперсия случайной величины|дисперсию]]. Впервые данный метод был представлен в <ref>[https://arxiv.org/pdf/1502.03167.pdf Ioffe S., Szegedy C. {{---}} Batch normalization: Accelerating deep network training by reducing internal covariate shift, 2016]</ref>.

==Идея==
Нормализация входного слоя нейронной сети обычно выполняется путем масштабирования данных, подаваемых в функции активации. Например, когда есть признаки со значениями от <tex>0</tex> до <tex>1</tex> и некоторые признаки со значениями от <tex>1</tex> до <tex>1000</tex>, то их необходимо нормализовать, чтобы ускорить обучение. Нормализацию данных можно выполнить и в скрытых слоях нейронных сетей, что и делает метод пакетной нормализации.
===Пакет===
Предварительно, напомним, что такое '''пакет''' (англ. batch). Возможны два подхода к реализации алгоритма градиентного спуска для обучения нейросетевых моделей: стохастический и пакетный<ref>[http://www.machinelearning.ru/wiki/index.php?title=Метод_стохастического_градиента Метод стохастического градиента]</ref>.
* [[Стохастический градиентный спуск|Стохастический градиентный спуск]] (англ. stochastic gradient descent) {{---}} реализация, в которой на каждой итерации алгоритма из обучающей выборки каким-то (случайным) образом выбирается только один объект.
* Пакетный (батч) (англ. batch gradient descent) {{---}} реализация градиентного спуска, когда на каждой итерации обучающая выборка просматривается целиком, и только после этого изменяются веса модели.

Также существует "золотая середина" между стохастическим градиентным спуском и пакетным градиентным спуском {{---}} когда просматривается только некоторое подмножество обучающей выборки фиксированного размера (англ. batch-size). В таком случае такие подмножества принято называть мини-пакетом (англ. mini-batch). Здесь и далее, мини-пакеты будем также называть пакетом.

===Ковариантный сдвиг===
[[Файл:covariate-shift1.png|600px|thumb|Рисунок 1. Верхние две строки роз показывают первое подмножество данных, а нижние две строки показывают другое подмножество. Два подмножества имеют разные пропорции изображения роз. На графиках показано распределение двух классов в пространстве объектов с использованием красных и зеленых точек. Синяя линия показывает границу между двумя классами. Иллюстрация из [https://www.learnopencv.com/batch-normalization-in-deep-networks/ статьи].]]
Пакетная нормализация уменьшает величину, на которую смещаются значения узлов в скрытых слоях (т.н. '''[[Ковариация случайных величин|ковариантный]] сдвиг''' (англ. covariance shift)).

Ковариантный сдвиг {{---}} это ситуация, когда распределения значений признаков в обучающей и тестовой выборке имеют разные параметры (математическое ожидание, дисперсия и т.д.). Ковариантность в данном случае относится к значениям признаков.

Проиллюстрируем ковариантный сдвиг примером.
Пусть есть [[Глубокое обучение|глубокая нейронная сеть]], которая обучена определять находится ли на изображении роза.
И нейронная сеть была обучена на изображениях только красных роз.
Теперь, если попытаться использовать обученную модель для обнаружения роз различных цветов, то, очевидно, точность работы модели будет неудовлетворительной.
Это происходит из-за того, что обучающая и тестовая выборки содержат изображения красных роз и роз различных цветов в разных пропорциях.
Другими словами, если модель обучена отображению из множества <tex>X</tex> в множество <tex>Y</tex> и если пропорция элементов в <tex>X</tex> изменяется, то появляется необходимость обучить модель заново, чтобы "выровнять" пропорции элементов в <tex>X</tex> и <tex>Y</tex>.
Когда пакеты содержат изображения разных классов, распределенные в одинаковой пропорции на всем множестве, то ковариантный сдвиг незначителен.
Однако, когда пакеты выбираются только из одного или двух подмножеств (в данном случае, красные розы и розы различных цветов), то ковариантный сдвиг возрастает.
Это довольно сильно замедляет процесс обучения модели. На Рисунке 1 изображена разница в пропорциях.

Простой способ решить проблему ковариантного сдвига для входного слоя {{---}} это случайным образом перемешать данные перед созданием пакетов.
Но для скрытых слоев нейронной сети такой метод не подходит, так как распределение входных данных для каждого узла скрытых слоев изменяется каждый раз, когда происходит обновление параметров в предыдущем слое.
Эта проблема называется '''внутренним ковариантным сдвигом''' (англ. internal covariate shift).
Для решения данной проблемы часто приходится использовать низкий [[Стохастический градиентный спуск|темп обучения]] (англ. learning rate) и методы [[wikipedia:ru:Регуляризация_(математика)|регуляризации]] при обучении модели.
Другим способом устранения внутреннего ковариантного сдвига является метод пакетной нормализации.

===Свойства пакетной нормализации===
Кроме того, использование пакетной нормализации обладает еще несколькими дополнительными полезными свойствами:
* достигается более быстрая сходимость моделей, несмотря на выполнение дополнительных вычислений;
* пакетная нормализация позволяет каждому слою сети обучатся более независимо от других слоев;
* становится возможным использование более высокого темпа обучения, так как пакетная нормализация гарантирует, что выходы узлов нейронной сети не будут иметь слишком больших или малых значений;
* пакетная нормализация в каком-то смысле также является механизмом регуляризации: данный метод привносит в выходы узлов скрытых слоев некоторый шум, аналогично методу [[Практики реализации нейронных сетей#Dropout|dropout]];
* модели становятся менее чувствительны к начальной инициализации весов.

==Описание метода==
Опишем устройство метода пакетной нормализации. Пусть на вход некоторому слою нейронной сети поступает вектор размерности <tex>d</tex>: <tex>x = (x^{(1)}, \ldots, x^{(d)})</tex>. Нормализуем данный вектор по каждой размерности <tex>k</tex>:

<tex>\hat{x}^{(k)} = \displaystyle \frac{x^{(k)} - E(x^{(k)})}{\sqrt{D(x^{(k)})}}</tex>,

где математическое ожидание и дисперсия считаются по всей обучающей выборке. Такая нормализация входа слоя нейронной сети может изменить представление данных в слое. Чтобы избежать данной проблемы, вводятся два параметра сжатия и сдвига нормализованной величины для каждого <tex>x^{(k)}</tex>: <tex>\gamma^{(k)}</tex>, <tex>\beta^{(k)}</tex> {{---}} которые действуют следующим образом:

<tex>y^{(k)} = \gamma^{(k)} \hat{x}^{(k)} + \beta^{(k)}</tex>.

Данные параметры настраиваются в процессе обучения вместе с остальными [[Модель_алгоритма_и_ее_выбор|параметрами модели]].

Пусть обучение модели производится с помощью пакетов <tex>B</tex> размера <tex>m</tex>: <tex>B = \{x_{1},\ldots, x_{m}\}</tex>. Здесь нормализация применяется к каждому элементу входа с номером <tex>k</tex> отдельно, поэтому в <tex>x^{(k)}</tex> индекс опускается для ясности изложения. Пусть были получены нормализованные значения пакета <tex>\hat{x}_{1},\ldots, \hat{x}_{m}</tex>. После применения операций сжатия и сдвига были получены <tex>y_{1},\ldots, y_{m}</tex>. Обозначим данную функцию пакетной нормализации следующим образом:

<tex>BN_{\gamma, \beta}: \{x_{1},\ldots, x_{m}\} \rightarrow \{y_{1},\ldots, y_{m}\}</tex>

Тогда алгоритм пакетной нормализации можно представить так:

'''Вход''': значения <tex>x</tex> из пакета <tex>B = \{x_{1},\ldots, x_{m}\}</tex>; настраиваемые параметры <tex>\gamma, \beta</tex>; константа <tex>\epsilon</tex> для вычислительной устойчивости.
'''Выход''': <tex>\{y_{i} = BN_{\gamma, \beta}(x_{i})\}</tex>
<tex>\mu_{B} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} x_{i}</tex> // математическое ожидание пакета
<tex>\sigma_{B}^{2} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} (x_{i} - \mu_{B})^{2}</tex> // дисперсия пакета
<tex>\hat{x}_{i} = \displaystyle \frac{x_{i} - \mu_{B}}{\sqrt{\sigma_{B}^{2} + \epsilon}}</tex> // нормализация
<tex>y_{i} = \gamma \hat{x}_{i} + \beta \equiv BN_{\gamma, \beta}(x_{i}) </tex> // сжатие и сдвиг

Заметим, что если <tex>\beta=\mu_{B}</tex> и <tex>\gamma=\sqrt{\sigma_{B}^{2} + \epsilon}</tex>, то <tex>y_{i}</tex> равен <tex>x_{i}</tex>, то есть <tex>BN_{\gamma, \beta}(\cdot)</tex> является тождественным отображением.
Таким образом, использование пакетной нормализации не может привести к снижению точности, поскольку оптимизатор просто может использовать нормализацию как тождественное отображение.

==Обучение нейронных сетей с пакетной нормализацией==
[[Файл:BNcircuit.png|700px|thumb|Рисунок 2. [[Настройка_глубокой_сети#Граф вычислений|Граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки. Слева-направо черными стрелками показана работа алгоритма в прямом направлении. А справа-налево красными стрелками {{---}} в обратном направлении, где вычисляется градиент функции потерь. Здесь <tex>N=m</tex> и <tex>D=d</tex>. Иллюстрация из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи].]]

Для обучения нейронных сетей необходимо вычислять [[wikipedia:ru:Градиент|градиент]] [[wikipedia:en:Loss_function|функции потерь]] <tex>l</tex>. В случае использования метода пакетной нормализации градиент вычисляется следующим образом:

<tex>\displaystyle \frac{\partial l}{\partial \hat{x}_{i}} = \frac{\partial l}{\partial y_{i}} \cdot \gamma</tex> <tex> (1)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \sigma_{B}^{2}} = \sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot (x_{i} - \mu_{B}) \cdot \frac{-1}{2}(\sigma_{B}^{2} + \epsilon)^{-3/2}</tex> <tex> (2)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \mu_{B}} = \left(\sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{-1}{\sqrt{\sigma_{B}^{2} + \epsilon}}\right) + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{\sum_{i=1}^{m}-2(x_{i}-\mu_{B})}{m}</tex> <tex> (3)</tex>

<tex>\displaystyle \frac{\partial l}{\partial x_{i}} = \frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{1}{\sqrt{\sigma_{B}^{2} + \epsilon}} + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{2(x_{i}-\mu_{B})}{m} + \frac{\partial l}{\partial \mu_{B}} \cdot \frac{1}{m}</tex> <tex> (4)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \gamma} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}} \cdot \hat{x}_{i}</tex> <tex> (5)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \beta} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}}</tex> <tex> (6)</tex>

На Рисунке 2 изображен [[Настройка_глубокой_сети#Граф вычислений|граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки.

В прямом направлении, как и описано в алгоритме метода, из входа <tex>x</tex> вычисляется среднее значение по каждой размерности признакового пространства. Затем полученный вектор средних значение вычитается из каждого элемента обучающей выборки. Далее вычисляется дисперсия, и с помощью нее вычисляется знаменатель для нормализации. Затем полученное значение инвертируется и умножается на разницу входа <tex>x</tex> и средних значений. В конце применяются параметры <tex>\gamma</tex> и <tex>\beta</tex>.

В обратном направлении вычисляются производные необходимых функций. В следующей таблице подробнее изображены шаги вычисления градиента функции потерь (иллюстрации из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи], здесь <tex>N=m</tex> и <tex>D=d</tex>):

{| cellpadding = "20" class = "wikitable"
! Шаг !! Изображение !! Описание
|-
| style = "text-align: center" | 1
|[[Файл:step9.png|300px]]
|Сначала вычисляется производная по параметру <tex>\beta</tex>, как в уравнении <tex>(6)</tex>, так как к нему применяется только операции суммирования. И значение градиента выхода передается без изменений.
|-
| style = "text-align: center" | 2
|[[Файл:step8.png|300px]]
|Далее, пользуясь правилом вычисления производной при умножении, как в уравнении <tex>(5)</tex>, вычисляется градиент по параметру <tex>\gamma</tex>. Градиент выхода умножается на данную константу, получая уравнение <tex>(1)</tex>, и передается в следующий узел.
|-
| style = "text-align: center" | 3
|[[Файл:step7.png|300px]]
|Данный шаг вычисляется аналогично предыдущему, применяя правило вычисления производной при умножении.
|-
| style = "text-align: center" | 4
|[[Файл:step6.png|300px]]
|Пользуясь производной обратной величины, вычисляем следующий узел графа.
|-
| style = "text-align: center" | 5
|[[Файл:step5.png|300px]]
|Вычисляем производную квадратного корня с добавлением <tex>\epsilon</tex>.
|-
| style = "text-align: center" | 6
|[[Файл:step4.png|300px]]
|Вычисляем производную суммы по всем компонентам входного вектора, получая матрицу.
|-
| style = "text-align: center" | 7
|[[Файл:step3.png|300px]]
|Получаем производную квадрата входящей функции.
|-
| style = "text-align: center" | 8
|[[Файл:step2.png|300px]]
|На данном шаге в одном узле сходятся ветки, поэтому полученные производные просто складываются, получая уравнение <tex>(2)</tex> для производной по дисперсии.
|-
| style = "text-align: center" | 9
|[[Файл:step1.png|300px]]
|Аналогично шагу 6 вычисляем матрицу по сумме для производной по математическому ожиданию, получая формулу <tex>(3)</tex>.
|-
| style = "text-align: center" | 10
|[[Файл:step0.png|300px]]
|В начальной вершине получаем уравнение <tex>(4)</tex>, складывая входящие производные.
|}

==Пакетная нормализация в [[Сверточные нейронные сети | свёрточных сетях]]==
Пакетная нормализация может быть применена к любой функции активации. Рассмотрим подробнее случай аффинного преобразования с некоторой нелинейной функцией:

<tex>z = g(Wu + b)</tex>,

где <tex>W</tex> и <tex>b</tex> {{---}} настраиваемые параметры модели, а <tex>g(\cdot)</tex> {{---}} некоторая нелинейная функция, например [[Практики реализации нейронных сетей#Sigmoid function|cигмоида]] или [[Практики реализации нейронных сетей#Rectified Linear Units (ReLU)|ReLU]]. Данной функцией можно описать как обычные, так и сверточные слои нейронных сетей. Пакетная нормализация применяется сразу перед функцией <tex>g(\cdot)</tex> к <tex>x = Wu + b</tex>. Параметр <tex>b</tex> может быть опущен, так как в дальнейших вычислениях его роль будет играть параметр <tex>\beta</tex>. Поэтому <tex>z = g(Wu + b)</tex> может быть записано так:

<tex>z = g(BN(Wu))</tex>,

где <tex>BN</tex> применяется отдельно к каждой размерности <tex>x=Wu</tex> с отдельной парой параметров <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> для каждой размерности.

В случае свёрточных сетей, дополнительно необходима нормализация, чтобы удовлетворить свойство свёрточных сетей, что различные элементы в разных местах одной карты признаков (образ операции свёртки, англ. feature map) должны быть нормализованы одинаково. Чтобы этого добиться, нормализация выполняется совместно над всеми значениями в пакете. Пусть <tex>B</tex> {{---}} множество всех значений в карте признаков по всему пакету и всем точкам в карте признаков. Тогда для пакета размера <tex>m</tex> и карты признаков размера <tex>p \times q</tex> размер <tex>B</tex> равен <tex>m'=|B|=m \cdot pq</tex>. Тогда параметры <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> настраиваются для каждой карты признаков отдельно.

==Пример==
[[File:bn_exp_1.png|300px|thumb|Рисунок 3. Точность распознавания в зависимости от итерации обучения. Оранжевая кривая изображает результаты для модели с использованием пакетной нормализации, синяя кривая {{---}} без. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]
[[File:bn_exp_2.png|300px|thumb|Рисунок 4. Точность распознавания в зависимости от итерации обучения c использованием сигмоиды в качетсве функции активации. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]

Приведем пример демонстрирующий работу пакетной нормализации.
Рассмотрим задачу распознавания рукописных цифр на известном датасете MNIST <ref>[http://yann.lecun.com/exdb/mnist/ Датасет MNIST]</ref>.
Для решения задачи будет использоваться обычная нейронная сеть с <tex>3</tex> скрытыми полносвязными слоями по <tex>100</tex> узлов в каждом.
Функция активации {{---}} ReLU.
Выходной слой содержит <tex>10</tex> узлов.
Размер пакета равен <tex>60</tex>.
Сравниваются две одинаковые модели, но в первой перед каждым скрытым слоем используется пакетная нормализация, а во второй {{---}} нет.
Темп обучения равен <tex>0.01</tex>.
Веса инициализированы значениями с малой дисперсией.

На Рисунке 3 изображены два графика, показывающие разницу между моделями.
Как видно, обе модели достигли высокой точности, но модель с использованием пакетной нормализации достигла точности более <tex>90\%</tex> быстрее, почти сразу, и достигла максимума, примерно, уже на <tex>10000</tex> итераций. Однако, модель без пакетной нормализации достигла скорости обучения примерно <tex>510</tex> пакетов в секунду, а модель с использованием пакетной нормализации {{---}} <tex>270</tex>.
Однако, как можно видеть, пакетная нормализация позволяет выполнить меньшее количество итераций и, в итоге, сойтись за меньшее время.

На Рисунке 4 изображен график, сравнивающий точно такие же модели, но с использованием сигмоиды в качестве функции активации.
Такая конфигурация моделей требует большего времени, чтобы начать обучение.
В итоге, модель обучается, но на это потребовалось более <tex>45000</tex> итераций, чтобы получить точность более <tex>80\%</tex>.
При использовании пакетной нормализации получилось достичь точность более <tex>90\%</tex> примерно за <tex>1000</tex> итераций.

==Реализации==
Механизм пакетной нормализации реализован практически во всех современных инструментариях для машинного обучения, таких как: TensorFlow <ref>[https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization TensorFlow]</ref>, Keras <ref>[https://keras.io/layers/normalization/ Keras]</ref>, CNTK <ref>[https://docs.microsoft.com/en-us/cognitive-toolkit/BatchNormalization CNTK]</ref>, Theano <ref>[http://deeplearning.net/software/theano/library/tensor/nnet/bn.html Theano]</ref>, PyTorch <ref>[https://pytorch.org/docs/stable/_modules/torch/nn/modules/batchnorm.html PyTorch]</ref> и т.д.

Приведем пример<ref>[https://towardsdatascience.com/batch-normalization-theory-and-how-to-use-it-with-tensorflow-1892ca0173ad Batch normalization: theory and how to use it with Tensorflow]</ref> применения пакетной нормализации с использованием библиотеки TensorFlow на языке программирования Python <ref>[https://www.python.org/ Язык программирования Python]</ref>:

'''import''' tensorflow '''as''' tf
# ...
is_train = tf.placeholder(tf.bool, name="is_train");
# ...
x_norm = tf.layers.batch_normalization(x, training=is_train)
# ...
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
'''with''' tf.control_dependencies(update_ops):
train_op = optimizer.minimize(loss)

==Модификации==
Существует несколько модификаций и вариаций метода пакетной нормализации:
# Тим Койманс<ref>[https://arxiv.org/pdf/1603.09025.pdf Cooijmans T. {{---}} Recurrent batch normalization, 2016]</ref> в 2016 г. предложил способ применения пакетной нормализации к [[Рекуррентные нейронные сети|рекуррентным нейронным сетям]].
# Расширение метода пакетной нормализации было предложено Ликси Хуангом<ref>[https://arxiv.org/pdf/1804.08450.pdf Huang L. {{---}} Decorrelated Batch Normalization, 2018]</ref> в 2018 г. Метод получил название декоррелированная пакетная нормализация (англ. Decorrelated Batch Normalization). В данном методе кроме операций масштабирования и сдвига была предложено использование специальной функции затирания данных.
# Джимми Лей Ба<ref>[https://arxiv.org/pdf/1607.06450.pdf Ba J. L., Kiros J. R., Hinton G. E. {{---}} Layer normalization, 2016]</ref> в 2016 г. предложил метод нормализации слоев (англ. Layer Normalization), который решает проблему выбора размера пакета.
# В работе Сергея Иоффе<ref>[https://arxiv.org/pdf/1702.03275.pdf Ioffe S. {{---}} Batch renormalization: Towards reducing minibatch dependence in batch-normalized models, 2017]</ref> в 2017 г. было представлено расширение метода пакетной нормализации: пакетная ренормализация (англ. Batch Renormalization). Данный метод улучшает пакетную нормализацию, когда размер пакетов мал и не состоит из независимых данных.
# Метод потоковой нормализации (англ. Streaming Normalization) был предложен Кифэном Ляо<ref>[https://arxiv.org/pdf/1610.06160.pdf Liao Q., Kawaguchi K., Poggio T. {{---}} Streaming normalization: Towards simpler and more biologically-plausible normalizations for online and recurrent learning, 2016]</ref> в 2016 г. Данный метод убирает два ограничения пакетной нормализации: использование при [[wikipedia:ru:Онлайновое_обучение_машин|online-обучении]] и использование в рекуррентных нейронных сетях.

==См. также==
*[[:Глубокое обучение|Глубокое обучение]]
*[[:Практики реализации нейронных сетей|Практики реализации нейронных сетей]]
*[[:Настройка глубокой сети|Настройка глубокой сети]]

== Примечания ==
<references/>

== Источники информации==
* [https://arxiv.org/pdf/1502.03167.pdf Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift]
* [https://towardsdatascience.com/batch-normalization-in-neural-networks-1ac91516821c Glossary of Deep Learning: Batch Normalisation]
* [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html Understanding the backward pass through Batch Normalization Layer]
* [https://medium.com/@SeoJaeDuk/deeper-understanding-of-batch-normalization-with-interactive-code-in-tensorflow-manual-back-1d50d6903d35 Deeper Understanding of Batch Normalization with Interactive Code in Tensorflow]
* [https://www.learnopencv.com/batch-normalization-in-deep-networks/ Batch Normalization in Deep Networks]
* [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb Batch Normalization {{---}} Lesson]
[[Категория: Машинное обучение]]

Batch-normalization

2019-01-28T14:40:56Z

Alexey Katsman: /* Ковариантный сдвиг */

'''Пакетная нормализация''' (англ. batch-normalization) {{---}} это метод, который позволяет повысить производительность и стабилизировать работу [[Нейронные сети, перцептрон | искусственных нейронных сетей]]. Суть данного метода заключается в том, что некоторым слоям нейронной сети на вход подаются данные, предварительно обработанные и имеющие нулевое [[Математическое ожидание случайной величины|математическое ожидание]] и единичную [[Дисперсия случайной величины|дисперсию]]. Впервые данный метод был представлен в <ref>[https://arxiv.org/pdf/1502.03167.pdf Ioffe S., Szegedy C. {{---}} Batch normalization: Accelerating deep network training by reducing internal covariate shift, 2016]</ref>.

==Идея==
Нормализация входного слоя нейронной сети обычно выполняется путем масштабирования данных, подаваемых в функции активации. Например, когда есть признаки со значениями от <tex>0</tex> до <tex>1</tex> и некоторые признаки со значениями от <tex>1</tex> до <tex>1000</tex>, то их необходимо нормализовать, чтобы ускорить обучение. Нормализацию данных можно выполнить и в скрытых слоях нейронных сетей, что и делает метод пакетной нормализации.
===Пакет===
Предварительно, напомним, что такое '''пакет''' (англ. batch). Возможны два подхода к реализации алгоритма градиентного спуска для обучения нейросетевых моделей: стохастический и пакетный<ref>[http://www.machinelearning.ru/wiki/index.php?title=Метод_стохастического_градиента Метод стохастического градиента]</ref>.
* [[Стохастический градиентный спуск|Стохастический градиентный спуск]] (англ. stochastic gradient descent) {{---}} реализация, в которой на каждой итерации алгоритма из обучающей выборки каким-то (случайным) образом выбирается только один объект.
* Пакетный (батч) (англ. batch gradient descent) {{---}} реализация градиентного спуска, когда на каждой итерации обучающая выборка просматривается целиком, и только после этого изменяются веса модели.

Также существует "золотая середина" между стохастическим градиентным спуском и пакетным градиентным спуском {{---}} когда просматривается только некоторое подмножество обучающей выборки фиксированного размера (англ. batch-size). В таком случае такие подмножества принято называть мини-пакетом (англ. mini-batch). Здесь и далее, мини-пакеты будем также называть пакетом.

===Ковариантный сдвиг===
[[Файл:covariate-shift1.png|600px|thumb|Рисунок 1. Верхние две строки роз показывают первое подмножество данных, а нижние две строки показывают другое подмножество. Два подмножества имеют разные пропорции изображения роз. На графиках показано распределение двух классов в пространстве объектов с использованием красных и зеленых точек. Синяя линия показывает границу между двумя классами. Иллюстрация из [https://www.learnopencv.com/batch-normalization-in-deep-networks/ статьи].]]
Пакетная нормализация уменьшает величину, на которую смещаются значения узлов в скрытых слоях (т.н. '''[[Ковариация случайных величин|ковариантный]] сдвиг''' (англ. covariance shift)).

Ковариантный сдвиг {{---}} это ситуация, когда распределения значений признаков в обучающей и тестовой выборке имеют разные параметры (математическое ожидание, дисперсия и т.д.). Ковариантность в данном случае относится к значениям признаков.

Проиллюстрируем ковариантный сдвиг примером.
Пусть есть [[Глубокое обучение|глубокая нейронная сеть]], которая обучена определять находится ли на изображении роза.
И нейронная сеть была обучена на изображениях только красных роз.
Теперь, если попытаться использовать обученную модель для обнаружения роз различных цветов, то, очевидно, точность работы модели будет неудовлетворительной.
Это происходит из-за того, что обучающая и тестовая выборки содержат изображения красных роз и роз различных цветов в разных пропорциях.
Другими словами, если модель обучена отображению из множества <tex>X</tex> в множество <tex>Y</tex> и если пропорция элементов в <tex>X</tex> изменяется, то появляется необходимость обучить модель заново, чтобы "выровнять" пропорции элементов в <tex>X</tex> и <tex>Y</tex>.
Когда пакеты содержат изображения разных классов, распределенные в одинаковой пропорции на всем множестве, то ковариантный сдвиг незначителен.
Однако, когда пакеты выбираются только из одного или двух подмножеств (в данном случае, красные розы и розы различных цветов), то ковариантный сдвиг возрастает.
Это довольно сильно замедляет процесс обучения модели. На Рисунке 1 изображена разница в пропорциях.

Простой способ решить проблему ковариантного сдвига для входного слоя {{---}} это случайным образом перемешать данные перед созданием пакетов.
Но для скрытых слоев нейронной сети такой метод не подходит, так как распределение входных данных для каждого узла скрытых слоев изменяется каждый раз, когда происходит обновление параметров в предыдущем слое.
Эта проблема называется '''внутренним ковариантным сдвигом''' (англ. internal covariate shift).
Для решения данной проблемы часто приходится использовать низкий [[Стохастический градиентный спуск|темп обучения]] (англ. learning rate) и методы [[wikipedia:ru:Регуляризация_(математика)|регуляризации]] при обучении модели.
Другим способом устранения внутреннего ковариантного сдвига является метод пакетной нормализации.

===Свойства пакетной нормализации===
Кроме того, использование пакетной нормализации обладает еще несколькими дополнительными полезными свойствами:
* достигается более быстрая сходимость моделей, несмотря на выполнение дополнительных вычислений;
* пакетная нормализация позволяет каждому слою сети обучатся более независимо от других слоев;
* становится возможным использование более высокого темпа обучения, так как пакетная нормализация гарантирует, что выходы узлов нейронной сети не будут иметь слишком больших или малых значений;
* пакетная нормализация в каком-то смысле также является механизмом регуляризации: данный метод привносит в выходы узлов скрытых слоев некоторый шум, аналогично методу [[Практики реализации нейронных сетей#Dropout|dropout]];
* модели становятся менее чувствительны к начальной инициализации весов.

==Описание метода==
Опишем устройство метода пакетной нормализации. Пусть на вход некоторому слою нейронной сети поступает вектор размерности <tex>d</tex>: <tex>x = (x^{(1)}, \ldots, x^{(d)})</tex>. Нормализуем данный вектор по каждой размерности <tex>k</tex>:

<tex>\hat{x}^{(k)} = \displaystyle \frac{x^{(k)} - E(x^{(k)})}{\sqrt{D(x^{(k)})}}</tex>,

где математическое ожидание и дисперсия считаются по всей обучающей выборке. Такая нормализация входа слоя нейронной сети может изменить представление данных в слое. Чтобы избежать данной проблемы, вводятся два параметра сжатия и сдвига нормализованной величины для каждого <tex>x^{(k)}</tex>: <tex>\gamma^{(k)}</tex>, <tex>\beta^{(k)}</tex> {{---}} которые действуют следующим образом:

<tex>y^{(k)} = \gamma^{(k)} \hat{x}^{(k)} + \beta^{(k)}</tex>.

Данные параметры настраиваются в процессе обучения вместе с остальными [[Модель_алгоритма_и_ее_выбор|параметрами модели]].

Пусть обучение модели производится с помощью пакетов <tex>B</tex> размера <tex>m</tex>: <tex>B = \{x_{1},\ldots, x_{m}\}</tex>. Здесь нормализация применяется к каждому элементу входа с номером <tex>k</tex> отдельно, поэтому в <tex>x^{(k)}</tex> индекс опускается для ясности изложения. Пусть были получены нормализованные значения пакета <tex>\hat{x}_{1},\ldots, \hat{x}_{m}</tex>. После применения операций сжатия и сдвига были получены <tex>y_{1},\ldots, y_{m}</tex>. Обозначим данную функцию пакетной нормализации следующим образом:

<tex>BN_{\gamma, \beta}: \{x_{1},\ldots, x_{m}\} \rightarrow \{y_{1},\ldots, y_{m}\}</tex>

Тогда алгоритм пакетной нормализации можно представить так:

'''Вход''': значения <tex>x</tex> из пакета <tex>B = \{x_{1},\ldots, x_{m}\}</tex>; настраиваемые параметры <tex>\gamma, \beta</tex>; константа <tex>\epsilon</tex> для вычислительной устойчивости.
'''Выход''': <tex>\{y_{i} = BN_{\gamma, \beta}(x_{i})\}</tex>
<tex>\mu_{B} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} x_{i}</tex> // математическое ожидание пакета
<tex>\sigma_{B}^{2} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} (x_{i} - \mu_{B})^{2}</tex> // дисперсия пакета
<tex>\hat{x}_{i} = \displaystyle \frac{x_{i} - \mu_{B}}{\sqrt{\sigma_{B}^{2} + \epsilon}}</tex> // нормализация
<tex>y_{i} = \gamma \hat{x}_{i} + \beta \equiv BN_{\gamma, \beta}(x_{i}) </tex> // сжатие и сдвиг

Заметим, что если <tex>\beta=\mu_{B}</tex> и <tex>\gamma=\sqrt{\sigma_{B}^{2} + \epsilon}</tex>, то <tex>y_{i}</tex> равен <tex>x_{i}</tex>, то есть <tex>BN_{\gamma, \beta}(\cdot)</tex> является тождественным отображением.
Таким образом, использование пакетной нормализации не может привести к снижению точности, поскольку оптимизатор просто может использовать нормализацию как тождественное отображение.

==Обучение нейронных сетей с пакетной нормализацией==
[[Файл:BNcircuit.png|700px|thumb|Рисунок 2. [[Настройка_глубокой_сети#Граф вычислений|Граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки. Слева-направо черными стрелками показана работа алгоритма в прямом направлении. А справа-налево красными стрелками {{---}} в обратном направлении, где вычисляется градиент функции потерь. Здесь <tex>N=m</tex> и <tex>D=d</tex>. Иллюстрация из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи].]]

Для обучения нейронных сетей необходимо вычислять [[wikipedia:ru:Градиент|градиент]] [[wikipedia:en:Loss_function|функции потерь]] <tex>l</tex>. В случае использования метода пакетной нормализации градиент вычисляется следующим образом:

<tex>\displaystyle \frac{\partial l}{\partial \hat{x}_{i}} = \frac{\partial l}{\partial y_{i}} \cdot \gamma</tex> <tex> (1)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \sigma_{B}^{2}} = \sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot (x_{i} - \mu_{B}) \cdot \frac{-1}{2}(\sigma_{B}^{2} + \epsilon)^{-3/2}</tex> <tex> (2)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \mu_{B}} = \left(\sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{-1}{\sqrt{\sigma_{B}^{2} + \epsilon}}\right) + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{\sum_{i=1}^{m}-2(x_{i}-\mu_{B})}{m}</tex> <tex> (3)</tex>

<tex>\displaystyle \frac{\partial l}{\partial x_{i}} = \frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{1}{\sqrt{\sigma_{B}^{2} + \epsilon}} + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{2(x_{i}-\mu_{B})}{m} + \frac{\partial l}{\partial \mu_{B}} \cdot \frac{1}{m}</tex> <tex> (4)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \gamma} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}} \cdot \hat{x}_{i}</tex> <tex> (5)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \beta} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}}</tex> <tex> (6)</tex>

На Рисунке 2 изображен [[Настройка_глубокой_сети#Граф вычислений|граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки.

В прямом направлении, как и описано в алгоритме метода, из входа <tex>x</tex> вычисляется среднее значение по каждой размерности признакового пространства. Затем полученный вектор средних значение вычитается из каждого элемента обучающей выборки. Далее вычисляется дисперсия, и с помощью нее вычисляется знаменатель для нормализации. Затем полученное значение инвертируется и умножается на разницу входа <tex>x</tex> и средних значений. В конце применяются параметры <tex>\gamma</tex> и <tex>\beta</tex>.

В обратном направлении вычисляются производные необходимых функций. В следующей таблице подробнее изображены шаги вычисления градиента функции потерь (иллюстрации из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи], здесь <tex>N=m</tex> и <tex>D=d</tex>):

{| cellpadding = "20" class = "wikitable"
! Шаг !! Изображение !! Описание
|-
| style = "text-align: center" | 1
|[[Файл:step9.png|300px]]
|Сначала вычисляется производная по параметру <tex>\beta</tex>, как в уравнении <tex>(6)</tex>, так как к нему применяется только операции суммирования. И значение градиента выхода передается без изменений.
|-
| style = "text-align: center" | 2
|[[Файл:step8.png|300px]]
|Далее, пользуясь правилом вычисления производной при умножении, как в уравнении <tex>(5)</tex>, вычисляется градиент по параметру <tex>\gamma</tex>. Градиент выхода умножается на данную константу, получая уравнение <tex>(1)</tex>, и передается в следующий узел.
|-
| style = "text-align: center" | 3
|[[Файл:step7.png|300px]]
|Данный шаг вычисляется аналогично предыдущему, применяя правило вычисления производной при умножении.
|-
| style = "text-align: center" | 4
|[[Файл:step6.png|300px]]
|Пользуясь производной обратной величины, вычисляем следующий узел графа.
|-
| style = "text-align: center" | 5
|[[Файл:step5.png|300px]]
|Вычисляем производную квадратного корня с добавлением <tex>\epsilon</tex>.
|-
| style = "text-align: center" | 6
|[[Файл:step4.png|300px]]
|Вычисляем производную суммы по всем компонентам входного вектора, получая матрицу.
|-
| style = "text-align: center" | 7
|[[Файл:step3.png|300px]]
|Получаем производную квадрата входящей функции.
|-
| style = "text-align: center" | 8
|[[Файл:step2.png|300px]]
|На данном шаге в одном узле сходятся ветки, поэтому полученные производные просто складываются, получая уравнение <tex>(2)</tex> для производной по дисперсии.
|-
| style = "text-align: center" | 9
|[[Файл:step1.png|300px]]
|Аналогично шагу 6 вычисляем матрицу по сумме для производной по математическому ожиданию, получая формулу <tex>(3)</tex>.
|-
| style = "text-align: center" | 10
|[[Файл:step0.png|300px]]
|В начальной вершине получаем уравнение <tex>(4)</tex>, складывая входящие производные.
|}

==Пакетная нормализация в [[Сверточные нейронные сети | свёрточных сетях]]==
Пакетная нормализация может быть применена к любой функции активации. Рассмотрим подробнее случай аффинного преобразования с некоторой нелинейной функцией:

<tex>z = g(Wu + b)</tex>,

где <tex>W</tex> и <tex>b</tex> {{---}} настраиваемые параметры модели, а <tex>g(\cdot)</tex> {{---}} некоторая нелинейная функция, например [[Практики реализации нейронных сетей#Sigmoid function|cигмоида]] или [[Практики реализации нейронных сетей#Rectified Linear Units (ReLU)|ReLU]]. Данной функцией можно описать как обычные, так и сверточные слои нейронных сетей. Пакетная нормализация применяется сразу перед функцией <tex>g(\cdot)</tex> к <tex>x = Wu + b</tex>. Параметр <tex>b</tex> может быть опущен, так как в дальнейших вычислениях его роль будет играть параметр <tex>\beta</tex>. Поэтому <tex>z = g(Wu + b)</tex> может быть записано так:

<tex>z = g(BN(Wu))</tex>,

где <tex>BN</tex> применяется отдельно к каждой размерности <tex>x=Wu</tex> с отдельной парой параметров <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> для каждой размерности.

В случае свёрточных сетей, дополнительно необходима нормализация, чтобы удовлетворить свойство свёрточных сетей, что различные элементы в разных местах одной карты признаков (образ операции свёртки, англ. feature map) должны быть нормализованы одинаково. Чтобы этого добиться, нормализация выполняется совместно над всеми значениями в пакете. Пусть <tex>B</tex> {{---}} множество всех значений в карте признаков по всему пакету и всем точкам в карте признаков. Тогда для пакета размера <tex>m</tex> и карты признаков размера <tex>p \times q</tex> размер <tex>B</tex> равен <tex>m'=|B|=m \cdot pq</tex>. Тогда параметры <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> настраиваются для каждой карты признаков отдельно.

==Пример==
[[File:bn_exp_1.png|300px|thumb|Рисунок 3. Точность распознавания в зависимости от итерации обучения. Оранжевая кривая изображает результаты для модели с использованием пакетной нормализации, синяя кривая {{---}} без. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]
[[File:bn_exp_2.png|300px|thumb|Рисунок 4. Точность распознавания в зависимости от итерации обучения c использованием сигмоиды в качетсве функции активации. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]

Приведем пример демонстрирующий работу пакетной нормализации.
Рассмотрим задачу распознавания рукописных цифр на известном датасете MNIST <ref>[http://yann.lecun.com/exdb/mnist/ Датасет MNIST]</ref>.
Для решения задачи будет использоваться обычная нейронная сеть с <tex>3</tex> скрытыми полносвязными слоями по <tex>100</tex> узлов в каждом.
Функция активации {{---}} ReLU.
Выходной слой содержит <tex>10</tex> узлов.
Размер пакета равен <tex>60</tex>.
Сравниваются две одинаковые модели, но в первой перед каждым скрытым слоем используется пакетная нормализация, а во второй {{---}} нет.
Темп обучения равен <tex>0.01</tex>.
Веса инициализированы значениями с малой дисперсией.

На Рисунке 3 изображены два графика, показывающие разницу между моделями.
Как видно, обе модели достигли высокой точности, но модель с использованием пакетной нормализации достигла точности более <tex>90\%</tex> быстрее, почти сразу, и достигла максимума, примерно, уже на <tex>10000</tex> итераций. Однако, модель без пакетной нормализации достигла скорости обучения примерно <tex>510</tex> пакетов в секунду, а модель с использованием пакетной нормализации {{---}} <tex>270</tex>.
Однако, как можно видеть, пакетная нормализация позволяет выполнить меньшее количество итераций и, в итоге, сойтись за меньшее время.

На Рисунке 4 изображен график, сравнивающий точно такие же модели, но с использованием сигмоиды в качестве функции активации.
Такая конфигурация моделей требует большего времени, чтобы начать обучение.
В итоге, модель обучается, но на это потребовалось более <tex>45000</tex> итераций, чтобы получить точность более <tex>80\%</tex>.
При использовании пакетной нормализации получилось достичь точность более <tex>90\%</tex> примерно за <tex>1000</tex> итераций.

==Реализации==
Механизм пакетной нормализации реализован практически во всех современных инструментариях для машинного обучения, таких как: TensorFlow <ref>[https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization TensorFlow]</ref>, Keras <ref>[https://keras.io/layers/normalization/ Keras]</ref>, CNTK <ref>[https://docs.microsoft.com/en-us/cognitive-toolkit/BatchNormalization CNTK]</ref>, Theano <ref>[http://deeplearning.net/software/theano/library/tensor/nnet/bn.html Theano]</ref>, PyTorch <ref>[https://pytorch.org/docs/stable/_modules/torch/nn/modules/batchnorm.html PyTorch]</ref> и т.д.

Приведем пример<ref>[https://towardsdatascience.com/batch-normalization-theory-and-how-to-use-it-with-tensorflow-1892ca0173ad Batch normalization: theory and how to use it with Tensorflow]</ref> применения пакетной нормализации с использованием библиотеки TensorFlow на языке программирования Python <ref>[https://www.python.org/ Язык программирования Python]</ref>:

'''import''' tensorflow '''as''' tf
# ...
is_train = tf.placeholder(tf.bool, name="is_train");
# ...
x_norm = tf.layers.batch_normalization(x, training=is_train)
# ...
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
'''with''' tf.control_dependencies(update_ops):
train_op = optimizer.minimize(loss)

==Модификации==
Существует несколько модификаций и вариаций метода пакетной нормализации:
# Тим Койманс<ref>[https://arxiv.org/pdf/1603.09025.pdf Cooijmans T. {{---}} Recurrent batch normalization, 2016]</ref> в 2016 г. предложил способ применения пакетной нормализации к [[Рекуррентные нейронные сети|рекуррентным нейронным сетям]][на 10.01.18 не создан].
# Расширение метода пакетной нормализации было предложено Ликси Хуангом<ref>[https://arxiv.org/pdf/1804.08450.pdf Huang L. {{---}} Decorrelated Batch Normalization, 2018]</ref> в 2018 г. Метод получил название декоррелированная пакетная нормализация (англ. Decorrelated Batch Normalization). В данном методе кроме операций масштабирования и сдвига была предложено использование специальной функции затирания данных.
# Джимми Лей Ба<ref>[https://arxiv.org/pdf/1607.06450.pdf Ba J. L., Kiros J. R., Hinton G. E. {{---}} Layer normalization, 2016]</ref> в 2016 г. предложил метод нормализации слоев (англ. Layer Normalization), который решает проблему выбора размера пакета.
# В работе Сергея Иоффе<ref>[https://arxiv.org/pdf/1702.03275.pdf Ioffe S. {{---}} Batch renormalization: Towards reducing minibatch dependence in batch-normalized models, 2017]</ref> в 2017 г. было представлено расширение метода пакетной нормализации: пакетная ренормализация (англ. Batch Renormalization). Данный метод улучшает пакетную нормализацию, когда размер пакетов мал и не состоит из независимых данных.
# Метод потоковой нормализации (англ. Streaming Normalization) был предложен Кифэном Ляо<ref>[https://arxiv.org/pdf/1610.06160.pdf Liao Q., Kawaguchi K., Poggio T. {{---}} Streaming normalization: Towards simpler and more biologically-plausible normalizations for online and recurrent learning, 2016]</ref> в 2016 г. Данный метод убирает два ограничения пакетной нормализации: использование при [[wikipedia:ru:Онлайновое_обучение_машин|online-обучении]] и использование в рекуррентных нейронных сетях.

==См. также==
*[[:Глубокое обучение|Глубокое обучение]]
*[[:Практики реализации нейронных сетей|Практики реализации нейронных сетей]]
*[[:Настройка глубокой сети|Настройка глубокой сети]]

== Примечания ==
<references/>

== Источники информации==
* [https://arxiv.org/pdf/1502.03167.pdf Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift]
* [https://towardsdatascience.com/batch-normalization-in-neural-networks-1ac91516821c Glossary of Deep Learning: Batch Normalisation]
* [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html Understanding the backward pass through Batch Normalization Layer]
* [https://medium.com/@SeoJaeDuk/deeper-understanding-of-batch-normalization-with-interactive-code-in-tensorflow-manual-back-1d50d6903d35 Deeper Understanding of Batch Normalization with Interactive Code in Tensorflow]
* [https://www.learnopencv.com/batch-normalization-in-deep-networks/ Batch Normalization in Deep Networks]
* [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb Batch Normalization {{---}} Lesson]
[[Категория: Машинное обучение]]

Batch-normalization

2019-01-28T14:40:39Z

Alexey Katsman: /* Пакет */

'''Пакетная нормализация''' (англ. batch-normalization) {{---}} это метод, который позволяет повысить производительность и стабилизировать работу [[Нейронные сети, перцептрон | искусственных нейронных сетей]]. Суть данного метода заключается в том, что некоторым слоям нейронной сети на вход подаются данные, предварительно обработанные и имеющие нулевое [[Математическое ожидание случайной величины|математическое ожидание]] и единичную [[Дисперсия случайной величины|дисперсию]]. Впервые данный метод был представлен в <ref>[https://arxiv.org/pdf/1502.03167.pdf Ioffe S., Szegedy C. {{---}} Batch normalization: Accelerating deep network training by reducing internal covariate shift, 2016]</ref>.

==Идея==
Нормализация входного слоя нейронной сети обычно выполняется путем масштабирования данных, подаваемых в функции активации. Например, когда есть признаки со значениями от <tex>0</tex> до <tex>1</tex> и некоторые признаки со значениями от <tex>1</tex> до <tex>1000</tex>, то их необходимо нормализовать, чтобы ускорить обучение. Нормализацию данных можно выполнить и в скрытых слоях нейронных сетей, что и делает метод пакетной нормализации.
===Пакет===
Предварительно, напомним, что такое '''пакет''' (англ. batch). Возможны два подхода к реализации алгоритма градиентного спуска для обучения нейросетевых моделей: стохастический и пакетный<ref>[http://www.machinelearning.ru/wiki/index.php?title=Метод_стохастического_градиента Метод стохастического градиента]</ref>.
* [[Стохастический градиентный спуск|Стохастический градиентный спуск]] (англ. stochastic gradient descent) {{---}} реализация, в которой на каждой итерации алгоритма из обучающей выборки каким-то (случайным) образом выбирается только один объект.
* Пакетный (батч) (англ. batch gradient descent) {{---}} реализация градиентного спуска, когда на каждой итерации обучающая выборка просматривается целиком, и только после этого изменяются веса модели.

Также существует "золотая середина" между стохастическим градиентным спуском и пакетным градиентным спуском {{---}} когда просматривается только некоторое подмножество обучающей выборки фиксированного размера (англ. batch-size). В таком случае такие подмножества принято называть мини-пакетом (англ. mini-batch). Здесь и далее, мини-пакеты будем также называть пакетом.

===Ковариантный сдвиг===
[[Файл:covariate-shift1.png|600px|thumb|Рисунок 1. Верхние две строки роз показывают первое подмножество данных, а нижние две строки показывают другое подмножество. Два подмножества имеют разные пропорции изображения роз. На графиках показано распределение двух классов в пространстве объектов с использованием красных и зеленых точек. Синяя линия показывает границу между двумя классами. Иллюстрация из [https://www.learnopencv.com/batch-normalization-in-deep-networks/ статьи].]]
Пакетная нормализация уменьшает величину, на которую смещаются значения узлов в скрытых слоях (т.н. '''[[Ковариация случайных величин|ковариантный]] сдвиг''' (англ. covariance shift)).

Ковариантный сдвиг {{---}} это ситуация, когда распределения значений признаков в обучающей и тестовой выборке имеют разные параметры (математическое ожидание, дисперсия и т.д.). Ковариантность в данном случае относится к значениям признаков.

Проиллюстрируем ковариантный сдвиг примером.
Пусть есть [[Глубокое обучение|глубокая нейронная сеть]], которая обучена определять находится ли на изображении роза.
И нейронная сеть была обучена на изображениях только красных роз.
Теперь, если попытаться использовать обученную модель для обнаружения роз различных цветов, то, очевидно, точность работы модели будет неудовлетворительной.
Это происходит из-за того, что обучающая и тестовая выборки содержат изображения красных роз и роз различных цветов в разных пропорциях.
Другими словами, если модель обучена отображению из множества <tex>X</tex> в множество <tex>Y</tex> и если пропорция элементов в <tex>X</tex> изменяется, то появляется необходимость обучить модель заново, чтобы "выровнять" пропорции элементов в <tex>X</tex> и <tex>Y</tex>.
Когда пакеты содержат изображения разных классов, распределенные в одинаковой пропорции на всем множестве, то ковариантный сдвиг незначителен.
Однако, когда пакеты выбираются только из одного или двух подмножеств (в данном случае, красные розы и розы различных цветов), то ковариантный сдвиг возрастает.
Это довольно сильно замедляет процесс обучения модели. На Рисунке 1 изображена разница в пропорциях.

Простой способ решить проблему ковариантного сдвига для входного слоя {{---}} это случайным образом перемешать данные перед созданием пакетов.
Но для скрытых слоев нейронной сети такой метод не подходит, так как распределение входных данных для каждого узла скрытых слоев изменяется каждый раз, когда происходит обновление параметров в предыдущем слое.
Эта проблема называется '''внутренним ковариантным сдвигом''' (англ. internal covariate shift).
Для решения данной проблемы часто приходится использовать низкий [[Стохастический градиентный спуск|темп обучения]][на 10.01.18 не создано] (англ. learning rate) и методы [[wikipedia:ru:Регуляризация_(математика)|регуляризации]] при обучении модели.
Другим способом устранения внутреннего ковариантного сдвига является метод пакетной нормализации.

===Свойства пакетной нормализации===
Кроме того, использование пакетной нормализации обладает еще несколькими дополнительными полезными свойствами:
* достигается более быстрая сходимость моделей, несмотря на выполнение дополнительных вычислений;
* пакетная нормализация позволяет каждому слою сети обучатся более независимо от других слоев;
* становится возможным использование более высокого темпа обучения, так как пакетная нормализация гарантирует, что выходы узлов нейронной сети не будут иметь слишком больших или малых значений;
* пакетная нормализация в каком-то смысле также является механизмом регуляризации: данный метод привносит в выходы узлов скрытых слоев некоторый шум, аналогично методу [[Практики реализации нейронных сетей#Dropout|dropout]];
* модели становятся менее чувствительны к начальной инициализации весов.

==Описание метода==
Опишем устройство метода пакетной нормализации. Пусть на вход некоторому слою нейронной сети поступает вектор размерности <tex>d</tex>: <tex>x = (x^{(1)}, \ldots, x^{(d)})</tex>. Нормализуем данный вектор по каждой размерности <tex>k</tex>:

<tex>\hat{x}^{(k)} = \displaystyle \frac{x^{(k)} - E(x^{(k)})}{\sqrt{D(x^{(k)})}}</tex>,

где математическое ожидание и дисперсия считаются по всей обучающей выборке. Такая нормализация входа слоя нейронной сети может изменить представление данных в слое. Чтобы избежать данной проблемы, вводятся два параметра сжатия и сдвига нормализованной величины для каждого <tex>x^{(k)}</tex>: <tex>\gamma^{(k)}</tex>, <tex>\beta^{(k)}</tex> {{---}} которые действуют следующим образом:

<tex>y^{(k)} = \gamma^{(k)} \hat{x}^{(k)} + \beta^{(k)}</tex>.

Данные параметры настраиваются в процессе обучения вместе с остальными [[Модель_алгоритма_и_ее_выбор|параметрами модели]].

Пусть обучение модели производится с помощью пакетов <tex>B</tex> размера <tex>m</tex>: <tex>B = \{x_{1},\ldots, x_{m}\}</tex>. Здесь нормализация применяется к каждому элементу входа с номером <tex>k</tex> отдельно, поэтому в <tex>x^{(k)}</tex> индекс опускается для ясности изложения. Пусть были получены нормализованные значения пакета <tex>\hat{x}_{1},\ldots, \hat{x}_{m}</tex>. После применения операций сжатия и сдвига были получены <tex>y_{1},\ldots, y_{m}</tex>. Обозначим данную функцию пакетной нормализации следующим образом:

<tex>BN_{\gamma, \beta}: \{x_{1},\ldots, x_{m}\} \rightarrow \{y_{1},\ldots, y_{m}\}</tex>

Тогда алгоритм пакетной нормализации можно представить так:

'''Вход''': значения <tex>x</tex> из пакета <tex>B = \{x_{1},\ldots, x_{m}\}</tex>; настраиваемые параметры <tex>\gamma, \beta</tex>; константа <tex>\epsilon</tex> для вычислительной устойчивости.
'''Выход''': <tex>\{y_{i} = BN_{\gamma, \beta}(x_{i})\}</tex>
<tex>\mu_{B} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} x_{i}</tex> // математическое ожидание пакета
<tex>\sigma_{B}^{2} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} (x_{i} - \mu_{B})^{2}</tex> // дисперсия пакета
<tex>\hat{x}_{i} = \displaystyle \frac{x_{i} - \mu_{B}}{\sqrt{\sigma_{B}^{2} + \epsilon}}</tex> // нормализация
<tex>y_{i} = \gamma \hat{x}_{i} + \beta \equiv BN_{\gamma, \beta}(x_{i}) </tex> // сжатие и сдвиг

Заметим, что если <tex>\beta=\mu_{B}</tex> и <tex>\gamma=\sqrt{\sigma_{B}^{2} + \epsilon}</tex>, то <tex>y_{i}</tex> равен <tex>x_{i}</tex>, то есть <tex>BN_{\gamma, \beta}(\cdot)</tex> является тождественным отображением.
Таким образом, использование пакетной нормализации не может привести к снижению точности, поскольку оптимизатор просто может использовать нормализацию как тождественное отображение.

==Обучение нейронных сетей с пакетной нормализацией==
[[Файл:BNcircuit.png|700px|thumb|Рисунок 2. [[Настройка_глубокой_сети#Граф вычислений|Граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки. Слева-направо черными стрелками показана работа алгоритма в прямом направлении. А справа-налево красными стрелками {{---}} в обратном направлении, где вычисляется градиент функции потерь. Здесь <tex>N=m</tex> и <tex>D=d</tex>. Иллюстрация из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи].]]

Для обучения нейронных сетей необходимо вычислять [[wikipedia:ru:Градиент|градиент]] [[wikipedia:en:Loss_function|функции потерь]] <tex>l</tex>. В случае использования метода пакетной нормализации градиент вычисляется следующим образом:

<tex>\displaystyle \frac{\partial l}{\partial \hat{x}_{i}} = \frac{\partial l}{\partial y_{i}} \cdot \gamma</tex> <tex> (1)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \sigma_{B}^{2}} = \sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot (x_{i} - \mu_{B}) \cdot \frac{-1}{2}(\sigma_{B}^{2} + \epsilon)^{-3/2}</tex> <tex> (2)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \mu_{B}} = \left(\sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{-1}{\sqrt{\sigma_{B}^{2} + \epsilon}}\right) + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{\sum_{i=1}^{m}-2(x_{i}-\mu_{B})}{m}</tex> <tex> (3)</tex>

<tex>\displaystyle \frac{\partial l}{\partial x_{i}} = \frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{1}{\sqrt{\sigma_{B}^{2} + \epsilon}} + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{2(x_{i}-\mu_{B})}{m} + \frac{\partial l}{\partial \mu_{B}} \cdot \frac{1}{m}</tex> <tex> (4)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \gamma} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}} \cdot \hat{x}_{i}</tex> <tex> (5)</tex>

<tex>\displaystyle \frac{\partial l}{\partial \beta} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}}</tex> <tex> (6)</tex>

На Рисунке 2 изображен [[Настройка_глубокой_сети#Граф вычислений|граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки.

В прямом направлении, как и описано в алгоритме метода, из входа <tex>x</tex> вычисляется среднее значение по каждой размерности признакового пространства. Затем полученный вектор средних значение вычитается из каждого элемента обучающей выборки. Далее вычисляется дисперсия, и с помощью нее вычисляется знаменатель для нормализации. Затем полученное значение инвертируется и умножается на разницу входа <tex>x</tex> и средних значений. В конце применяются параметры <tex>\gamma</tex> и <tex>\beta</tex>.

В обратном направлении вычисляются производные необходимых функций. В следующей таблице подробнее изображены шаги вычисления градиента функции потерь (иллюстрации из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи], здесь <tex>N=m</tex> и <tex>D=d</tex>):

{| cellpadding = "20" class = "wikitable"
! Шаг !! Изображение !! Описание
|-
| style = "text-align: center" | 1
|[[Файл:step9.png|300px]]
|Сначала вычисляется производная по параметру <tex>\beta</tex>, как в уравнении <tex>(6)</tex>, так как к нему применяется только операции суммирования. И значение градиента выхода передается без изменений.
|-
| style = "text-align: center" | 2
|[[Файл:step8.png|300px]]
|Далее, пользуясь правилом вычисления производной при умножении, как в уравнении <tex>(5)</tex>, вычисляется градиент по параметру <tex>\gamma</tex>. Градиент выхода умножается на данную константу, получая уравнение <tex>(1)</tex>, и передается в следующий узел.
|-
| style = "text-align: center" | 3
|[[Файл:step7.png|300px]]
|Данный шаг вычисляется аналогично предыдущему, применяя правило вычисления производной при умножении.
|-
| style = "text-align: center" | 4
|[[Файл:step6.png|300px]]
|Пользуясь производной обратной величины, вычисляем следующий узел графа.
|-
| style = "text-align: center" | 5
|[[Файл:step5.png|300px]]
|Вычисляем производную квадратного корня с добавлением <tex>\epsilon</tex>.
|-
| style = "text-align: center" | 6
|[[Файл:step4.png|300px]]
|Вычисляем производную суммы по всем компонентам входного вектора, получая матрицу.
|-
| style = "text-align: center" | 7
|[[Файл:step3.png|300px]]
|Получаем производную квадрата входящей функции.
|-
| style = "text-align: center" | 8
|[[Файл:step2.png|300px]]
|На данном шаге в одном узле сходятся ветки, поэтому полученные производные просто складываются, получая уравнение <tex>(2)</tex> для производной по дисперсии.
|-
| style = "text-align: center" | 9
|[[Файл:step1.png|300px]]
|Аналогично шагу 6 вычисляем матрицу по сумме для производной по математическому ожиданию, получая формулу <tex>(3)</tex>.
|-
| style = "text-align: center" | 10
|[[Файл:step0.png|300px]]
|В начальной вершине получаем уравнение <tex>(4)</tex>, складывая входящие производные.
|}

==Пакетная нормализация в [[Сверточные нейронные сети | свёрточных сетях]]==
Пакетная нормализация может быть применена к любой функции активации. Рассмотрим подробнее случай аффинного преобразования с некоторой нелинейной функцией:

<tex>z = g(Wu + b)</tex>,

где <tex>W</tex> и <tex>b</tex> {{---}} настраиваемые параметры модели, а <tex>g(\cdot)</tex> {{---}} некоторая нелинейная функция, например [[Практики реализации нейронных сетей#Sigmoid function|cигмоида]] или [[Практики реализации нейронных сетей#Rectified Linear Units (ReLU)|ReLU]]. Данной функцией можно описать как обычные, так и сверточные слои нейронных сетей. Пакетная нормализация применяется сразу перед функцией <tex>g(\cdot)</tex> к <tex>x = Wu + b</tex>. Параметр <tex>b</tex> может быть опущен, так как в дальнейших вычислениях его роль будет играть параметр <tex>\beta</tex>. Поэтому <tex>z = g(Wu + b)</tex> может быть записано так:

<tex>z = g(BN(Wu))</tex>,

где <tex>BN</tex> применяется отдельно к каждой размерности <tex>x=Wu</tex> с отдельной парой параметров <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> для каждой размерности.

В случае свёрточных сетей, дополнительно необходима нормализация, чтобы удовлетворить свойство свёрточных сетей, что различные элементы в разных местах одной карты признаков (образ операции свёртки, англ. feature map) должны быть нормализованы одинаково. Чтобы этого добиться, нормализация выполняется совместно над всеми значениями в пакете. Пусть <tex>B</tex> {{---}} множество всех значений в карте признаков по всему пакету и всем точкам в карте признаков. Тогда для пакета размера <tex>m</tex> и карты признаков размера <tex>p \times q</tex> размер <tex>B</tex> равен <tex>m'=|B|=m \cdot pq</tex>. Тогда параметры <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> настраиваются для каждой карты признаков отдельно.

==Пример==
[[File:bn_exp_1.png|300px|thumb|Рисунок 3. Точность распознавания в зависимости от итерации обучения. Оранжевая кривая изображает результаты для модели с использованием пакетной нормализации, синяя кривая {{---}} без. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]
[[File:bn_exp_2.png|300px|thumb|Рисунок 4. Точность распознавания в зависимости от итерации обучения c использованием сигмоиды в качетсве функции активации. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]

Приведем пример демонстрирующий работу пакетной нормализации.
Рассмотрим задачу распознавания рукописных цифр на известном датасете MNIST <ref>[http://yann.lecun.com/exdb/mnist/ Датасет MNIST]</ref>.
Для решения задачи будет использоваться обычная нейронная сеть с <tex>3</tex> скрытыми полносвязными слоями по <tex>100</tex> узлов в каждом.
Функция активации {{---}} ReLU.
Выходной слой содержит <tex>10</tex> узлов.
Размер пакета равен <tex>60</tex>.
Сравниваются две одинаковые модели, но в первой перед каждым скрытым слоем используется пакетная нормализация, а во второй {{---}} нет.
Темп обучения равен <tex>0.01</tex>.
Веса инициализированы значениями с малой дисперсией.

На Рисунке 3 изображены два графика, показывающие разницу между моделями.
Как видно, обе модели достигли высокой точности, но модель с использованием пакетной нормализации достигла точности более <tex>90\%</tex> быстрее, почти сразу, и достигла максимума, примерно, уже на <tex>10000</tex> итераций. Однако, модель без пакетной нормализации достигла скорости обучения примерно <tex>510</tex> пакетов в секунду, а модель с использованием пакетной нормализации {{---}} <tex>270</tex>.
Однако, как можно видеть, пакетная нормализация позволяет выполнить меньшее количество итераций и, в итоге, сойтись за меньшее время.

На Рисунке 4 изображен график, сравнивающий точно такие же модели, но с использованием сигмоиды в качестве функции активации.
Такая конфигурация моделей требует большего времени, чтобы начать обучение.
В итоге, модель обучается, но на это потребовалось более <tex>45000</tex> итераций, чтобы получить точность более <tex>80\%</tex>.
При использовании пакетной нормализации получилось достичь точность более <tex>90\%</tex> примерно за <tex>1000</tex> итераций.

==Реализации==
Механизм пакетной нормализации реализован практически во всех современных инструментариях для машинного обучения, таких как: TensorFlow <ref>[https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization TensorFlow]</ref>, Keras <ref>[https://keras.io/layers/normalization/ Keras]</ref>, CNTK <ref>[https://docs.microsoft.com/en-us/cognitive-toolkit/BatchNormalization CNTK]</ref>, Theano <ref>[http://deeplearning.net/software/theano/library/tensor/nnet/bn.html Theano]</ref>, PyTorch <ref>[https://pytorch.org/docs/stable/_modules/torch/nn/modules/batchnorm.html PyTorch]</ref> и т.д.

Приведем пример<ref>[https://towardsdatascience.com/batch-normalization-theory-and-how-to-use-it-with-tensorflow-1892ca0173ad Batch normalization: theory and how to use it with Tensorflow]</ref> применения пакетной нормализации с использованием библиотеки TensorFlow на языке программирования Python <ref>[https://www.python.org/ Язык программирования Python]</ref>:

'''import''' tensorflow '''as''' tf
# ...
is_train = tf.placeholder(tf.bool, name="is_train");
# ...
x_norm = tf.layers.batch_normalization(x, training=is_train)
# ...
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
'''with''' tf.control_dependencies(update_ops):
train_op = optimizer.minimize(loss)

==Модификации==
Существует несколько модификаций и вариаций метода пакетной нормализации:
# Тим Койманс<ref>[https://arxiv.org/pdf/1603.09025.pdf Cooijmans T. {{---}} Recurrent batch normalization, 2016]</ref> в 2016 г. предложил способ применения пакетной нормализации к [[Рекуррентные нейронные сети|рекуррентным нейронным сетям]][на 10.01.18 не создан].
# Расширение метода пакетной нормализации было предложено Ликси Хуангом<ref>[https://arxiv.org/pdf/1804.08450.pdf Huang L. {{---}} Decorrelated Batch Normalization, 2018]</ref> в 2018 г. Метод получил название декоррелированная пакетная нормализация (англ. Decorrelated Batch Normalization). В данном методе кроме операций масштабирования и сдвига была предложено использование специальной функции затирания данных.
# Джимми Лей Ба<ref>[https://arxiv.org/pdf/1607.06450.pdf Ba J. L., Kiros J. R., Hinton G. E. {{---}} Layer normalization, 2016]</ref> в 2016 г. предложил метод нормализации слоев (англ. Layer Normalization), который решает проблему выбора размера пакета.
# В работе Сергея Иоффе<ref>[https://arxiv.org/pdf/1702.03275.pdf Ioffe S. {{---}} Batch renormalization: Towards reducing minibatch dependence in batch-normalized models, 2017]</ref> в 2017 г. было представлено расширение метода пакетной нормализации: пакетная ренормализация (англ. Batch Renormalization). Данный метод улучшает пакетную нормализацию, когда размер пакетов мал и не состоит из независимых данных.
# Метод потоковой нормализации (англ. Streaming Normalization) был предложен Кифэном Ляо<ref>[https://arxiv.org/pdf/1610.06160.pdf Liao Q., Kawaguchi K., Poggio T. {{---}} Streaming normalization: Towards simpler and more biologically-plausible normalizations for online and recurrent learning, 2016]</ref> в 2016 г. Данный метод убирает два ограничения пакетной нормализации: использование при [[wikipedia:ru:Онлайновое_обучение_машин|online-обучении]] и использование в рекуррентных нейронных сетях.

==См. также==
*[[:Глубокое обучение|Глубокое обучение]]
*[[:Практики реализации нейронных сетей|Практики реализации нейронных сетей]]
*[[:Настройка глубокой сети|Настройка глубокой сети]]

== Примечания ==
<references/>

== Источники информации==
* [https://arxiv.org/pdf/1502.03167.pdf Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift]
* [https://towardsdatascience.com/batch-normalization-in-neural-networks-1ac91516821c Glossary of Deep Learning: Batch Normalisation]
* [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html Understanding the backward pass through Batch Normalization Layer]
* [https://medium.com/@SeoJaeDuk/deeper-understanding-of-batch-normalization-with-interactive-code-in-tensorflow-manual-back-1d50d6903d35 Deeper Understanding of Batch Normalization with Interactive Code in Tensorflow]
* [https://www.learnopencv.com/batch-normalization-in-deep-networks/ Batch Normalization in Deep Networks]
* [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb Batch Normalization {{---}} Lesson]
[[Категория: Машинное обучение]]

Настройка глубокой сети

2019-01-28T14:40:10Z

Alexey Katsman: /* См.также */

[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокая сеть] состоит из нескольких слоев, где каждый слой организован таким образом, что каждый нейрон в одном слое получает свою копию всех выходных данных предыдущего слоя. Эта модель идеально подходит для определенных типов задач, например, обучение на ограниченном количество более или менее неструктурированных параметров. Существует множество способов изменения параметров (весов) в такой модели, когда ей на вход поступают необработанные данные.

== Инициализация сети ==

Принцип выбора начальных значений весов для слоев, составляющих модель очень важен: установка всех весов в 0 будет серьезным препятствием для обучения, так как ни один из весов изначально не будет активен. Присваивать весам значения из интервала ±1 — тоже обычно не лучший вариант — на самом деле, иногда (в зависимости от задачи и сложности модели) от правильной инициализации модели может зависеть, достигнет она высочайшей производительности или вообще не будет сходиться. Даже если задача не предполагает такой крайности, удачно выбранный способ инициализации весов может значительно влиять на способность модели к обучению, так как он предустанавливает параметры модели с учетом функции потерь<ref>[https://habr.com/company/wunderfund/blog/315476/ Тонкая настройка нейронной сети, Habr]</ref>.

Всегда можно выбрать случайно начальное приближение, но лучше выбирать определённым образом, ниже приведены самые распространённые из них.

Метод инициализации Завьера (Xavier) (иногда — метод Glorot’а)<ref>[http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf Understanding the difficulty of training deep feedforward neural networks]</ref>. Основная идея этого метода — упростить прохождение сигнала через слой во время как прямого, так и обратного распространения ошибки для линейной функции активации (этот метод также хорошо работает для сигмоидной функции, так как участок, где она ненасыщена, также имеет линейный характер). При вычислении весов этот метод опирается на вероятностное распределение (равномерное или нормальное) с дисперсией, равной <tex>\mathrm{Var}(W) = {2 \over{n_{in} + n_{out}}}</tex>, где <tex>n_{in}</tex> и <tex>n_{out}</tex> — количества нейронов в предыдущем и последующем слоях соответственно.

Метод инициализации Ге (He) — это вариация метода Завьера, больше подходящая функции активации ReLU, компенсирующая тот факт, что эта функция возвращает нуль для половины области определения. А именно, в этом случае <tex>\mathrm{Var}(W) = {2 \over{n_{in}}}</tex><ref>[https://arxiv.org/pdf/1502.01852.pdf Delving Deep into Rectifiers]</ref>.

== Граф вычислений ==
Глубокие сети являются особенной формой графа вычиcлений.
[[Файл: Graph_comp.png|800px|thumb|Рис.1. Граф вычислений для функции <tex>f(a,b)=(a+b)*(b+1)</tex>]]
Граф вычислений — это ориентированный граф, узлы которого соответствуют операциям или переменным. Переменные могут передавать свое значение в операции, а операции могут передавать свои результаты в другие операции. Таким образом, каждый узел в графе определяет функцию переменных.

Значения, которые вводятся в узлы и выходят из узлов, называются тензорами (т.е. многомерными массивами). На рисунке 1 представлен граф вычислений для функции <tex>f(a,b)=(a+b)*(b+1)</tex>. В нейронах сетях функций имеют больше аргументов и сложнее, но смысл операций остаётся прежним.

Процесс передачи значений от входных нейронов к выходным называется прямым распространеним (от англ. Forward pass). После чего мы вычисляем ошибку обработанных сетью данных на выходном нейроне и, основываясь на её значении, делаем обратную передачу (Back propagation)<ref>[https://en.wikipedia.org/wiki/Backpropagation Backpropagation, Wikipedia]</ref>. Back propagation заключается в том, чтобы последовательно менять веса нейронной сети, начиная с весов выходного нейрона. Значения весов будут меняться в сторону уменьшения ошибки.

[[Файл: Graph_compilation.jpg|400px|thumb|Рис.2. Граф вычислений для функции <tex>f(x,y,z)=(x+y)*z</tex>. Зелёные цифры — значения вычислений по ходу выполнения операций графа, красные — значения производной выходной функции по текущей переменной в точке <tex>(x_0=-2, y_0=5, z_0=-4)</tex>]]

Преимуществом такого представления функции является простота вычисления производных. Используя следующие правила вычисления частных производных: <tex>q=x+y:\frac{\partial q}{\partial x}=1, \frac{\partial q}{\partial y}=1;</tex>
<tex>q=xy:\frac{\partial q}{\partial x}=y, \frac{\partial q}{\partial y}=x;</tex>
<tex>\frac{\partial f}{\partial x}=\frac{\partial f}{\partial q}\frac{\partial q}{\partial y}</tex>.

Рассмотрим граф вычислений на рисунке 2 с поданными на вход значениями <tex>(x_0=-2, y_0=5, z_0=-4)</tex>. Подсчёт производных по графу вычислений производим от значения функции к значениям независимых переменных-входов.
#<tex>\frac{\partial f}{\partial f} = 1</tex>
#<tex>\frac{\partial f}{\partial q} = z_0 = -4</tex>, <tex>\frac{\partial f}{\partial z} = q_0 = 3</tex>
#<tex>\frac{\partial f}{\partial x} = \frac{\partial f}{\partial q}\frac{\partial q}{\partial x} = -4</tex>, <tex>\frac{\partial f}{\partial y} = \frac{\partial f}{\partial q}\frac{\partial q}{\partial y} = -4</tex>

[[Файл: Schematic-diagram-of-a-general-back-propagation-neural-network.png|400px|thumb|Рис.3. Архитекутра нейронной сети: <tex>x_{N_i}</tex> — входные значения, <tex>y_{N_i}</tex> — выходные с сети значения, <tex>w</tex> — матрица весов, изменяющая с помощью линейной комбинации значения предыдущего слоя]]

Зная производные, можно искать матрицы весов <tex>w</tex> (числа, на которые умножаются входные для этого слоя значения) с помощью градиентного спуска сдвигаемся
в сторону градиента (при максимизации) или обратную ему
(при минимизации) <tex>w:=w-\eta\nabla_w f</tex>, или его модификаций<ref>[http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D1%81%D0%BF%D1%83%D1%81%D0%BA%D0%B0 Метод градиентного спуска]</ref>.

== Способы настройки параметров ==
[[File:basins.png|450px|thumb|right|Рисунок 4. Сравение мотификаций метода градиентного спуска на ландшафте "бассейны и стены".]]
[[File:wolby.png|450px|thumb|right|Рисунок 5. Сравение мотификаций метода градиентного спуска на "шатком" ландшафте.]]
Ниже представлены различные вариации градиентного спуска (более подробное сравнение, применительно к данной задаче <ref>[https://habr.com/post/318970/ Методы оптимизации нейронных сетей, Habr]</ref>). Градиентный спуск — итеративный алгоритм поиска минимума или максимума функции, метриками качества алгоритма этого семейства методов являются скорость сходимости и сходимость в глобальный оптимум. Методы имеют различные преимущества на различных функциях. Так например на рисунке 4 из локального минимума методы adam и nag не могут достигнуть глобального, а в случае "шаткого" ландшафта (рисунок 5) эти методы сходятся быстрее.

* Стохастический градиентный спуск<ref>[http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%81%D1%82%D0%BE%D1%85%D0%B0%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%B0 Метод стохастического градиента]</ref> заключается в том, что алгоритм делает шаг постоянной величины в направлении, указанном градиентом в текущей точке: <tex>w^{(0)}</tex> — начальные весы сети, <tex>w^{(k+1)}=w^{(k)}-\mu\frac{\partial L(w^{(k)})}{\partial w}</tex>;

* Модификация Momentum <ref>[https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Momentum Momentum, Wikipedia]</ref> запоминает скорость на предыдущем шаге и добавляет в <tex>\alpha</tex> раз меньшую величину на следующем шаге: <tex> \Delta w:=\alpha \Delta w-\eta \nabla Q_{i}(w)</tex>, <tex> w:=w+\Delta w</tex> или <tex> w:=w-\eta \nabla Q_{i}(w)+\alpha \Delta w</tex>;

* NAG (Nesterov accelerated gradient)<ref>[https://jlmelville.github.io/mize/nesterov.html#nag Nesterov accelerated gradient]</ref> добавляет к методу Momentum идею "заглядывания вперёд", используя производную не в текущей точке, а в следующей (если бы мы продолжали двигаться в этом же направлении без измений): <tex> w^{(k+1)} = w^{(k)}-v^{(k)}; v^{(k+1)}=\gamma v^{(k)}+\mu\frac{\partial L(w^{(k)}-v^{(k)})}{\partial w}</tex>

*Adagrad имеет преимущество в плане обучения нейронных сетей в предположении, что процесс обучения должен сходится (т.е. не нужно сильно менять веса сети, когда мы уже немного научились). В процессе обучения после каждого прецендента алгоритм будет уменьшать шаг за счёт суммы квадратов координат градиента предыдущих итераций<ref>[http://akyrillidis.github.io/notes/AdaGrad AdaGrad]</ref>: <tex>g_{i,(k)}=\frac{\partial L(w_i^{(k)})}{\partial w_i}, w_i^{(k+1)}=w_i^{(k)}-\frac{\mu}{\sqrt{G^{(k)}_i,i+\epsilon}}g_{i,(k)}</tex>, где G — диагональная матрица, элементы которой, суммы квадратов координат градиента к k-ой итерации алгоритма;

*RMSProp<ref>[https://towardsdatascience.com/a-look-at-gradient-descent-and-rmsprop-optimizers-f77d483ef08b RMSProp]</ref> основан на идее Adagrad'a, но с учётом того элементы матрицы G могут быть большими величинами и начать препятствовать обучению. Для этого RMSProp делит шаг не на полную сумму градиентов, а на скользящую, т.е. <tex>E^{(k)}[g_i^2] = \gamma E^{(k-1)}[g_i^2]+(1-\gamma)g^2_{i, (k)}</tex>, обновление весов осталось таким же как в Adagrad : <tex> w^{(k+1)}_i = w_i^{(k)}-\frac{\mu}{\sqrt{E^{(k)}[g_i^2]+\epsilon}}g_{i, (k)}</tex>;

*Adadelta<ref>[https://arxiv.org/abs/1212.5701 Adadelta]</ref> устраняет "нефизичность" методов Adagrad и RMSProp, добавка с градиентом в которых не имеет размерности весов(точнее вообще безразмерна). Умножение этого слагаемого на любую величину правильной размерности — не самая хорошая идея. Используем разложение ряда Тейлора в точке с большим числом членов, тогда появится матрица Q вторых производных:<tex>w^{(k+1)}=w^{(k)}-\mu(Q''(w^{(k)})^{-1}Q'(w^{(k)}</tex>, рассчёт которой повлечёт за собой дополнительные затраты на её расчёт (сами градиенты мы получаем сразу при обратном распространии ошибки), поэтому вместо неё можно брать приближение (из сложных выводов получаем необходимиый множитель <tex>RMS^{(k-1)}[\delta w_i]</tex>, однако в данном случае знание предыдущей скорости не довляет алгоритму "инерции" методов Momentum и NAG): <tex>w^{(k+1)}=w^{(k)}-\frac{RMS^{(k-1)}[\delta w_i]}{RMS^{(k)}[g_i]}g_i^{(k)}</tex>, где <tex>RMS^{(k)}[x_i]=\sqrt{E^{(k)}[x^2_i]+\epsilon}</tex>;

*Adam<ref>[https://arxiv.org/pdf/1412.6980.pdf Adam]</ref> сочетает в себе преимущества Nag и Adadelta над обычным градиентным спуском: <tex> w^{(k+1)}_i = w_i^{(k)}-\frac{\mu}{\sqrt{\hat{b}^2_{(k)}+\epsilon}}\hat{m}_{(k)}</tex>, где <tex>\hat{m}_{(k)}=\frac{\gamma_1 E^{(k-1)}[g_i]+(1-\gamma_1)g_{i,(k)}}{1-\gamma_1^k}</tex> и <tex>\hat{b}^2_{(k)}= \frac{\gamma_2 E^{(k-1)}[g^2_i]+(1-\gamma_2)g:2_{i,(k)}}{1-\gamma_2^k}</tex>.

==См.также==
* [[Глубокое обучение]]
* [[Стохастический градиентный спуск]]

==Примечания==
<references/>

==Источники информации==

#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%28%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2%29 Курс лекций по машинному обучению] {{---}} Воронцов К.В.
# Riedmiller, M., & Braun, H. (1993). A direct adaptive method for faster backpropagation learning: The RPROP algorithm. In Neural Networks, 1993., IEEE International Conference on (pp. 586-591). IEEE.

[[Категория: Машинное обучение]]
[[Категория: Глубокое обучение]]

Глубокое обучение

2019-01-28T14:39:45Z

Alexey Katsman: /* См. также */

[[Файл:Ml_areas.jpg|thumb|250px|Глубокое обучение как часть машинного обучения.]]

'''Глубокое обучение''' (англ. deep learning) {{---}} совокупность широкого семейства методов машинного обучения, основанных на имитации работы человеческого мозга в процессе обработки данных и создания паттернов, используемых для принятия решений<ref>[https://www.investopedia.com/terms/d/deep-learning.asp Deep Learning, Investopedia]</ref>. Как правило, глубокое обучение предназначено для работы с большими объемами данных и использует сложные алгоритмы для обучения модели<ref>[https://www.quora.com/What-is-the-difference-between-Neural-Networks-and-Deep-Learning The difference between neural networks and deep learning]</ref>. На больших датасетах глубокое обучение показывает более высокую точность результатов в сравнении с традиционным машинным обучением. Зависимость производительности (качества результатов) от объема данных представлена на рисунке ниже.

{|align="center"
|-valign="top"
|[[Файл:Perfm_data.jpg|border|450px|thumb|left|Зависимость производительности от объема данных.]]
|}

Несмотря на то, что данный раздел машинного обучения появился еще в 1980-х, до недавнего времени его применение было сильно ограничено из-за недостака вычислительных мощностей существовавших компьютеров. Ситуация изменилась только в середине 2000-х.

На создание моделей глубокого обучения оказали влияние некоторые процессы и паттерны, происходящие в биологических нейронных системах. Несмотря на это, данные модели во многом отличаются от биологического мозга (и в структуре и в функциях), что делает невозможным использование теорем и доказательств, применяющихся в нейробиологии.

== История ==
* 1943 {{---}} Искусственный нейрон Маккаллока — Питтса<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref> {{---}} узел искусственной нейронной сети, являющийся упрощённой моделью естественного нейрона.
* 1949 {{---}} Принцип обучения нейронов Хебба<ref>[https://en.wikipedia.org/wiki/Hebbian_theory Hebbian theory, Wikipedia]</ref> {{---}} изначально наблюдаемая причинно-следственная связь между активациями пре- и постсинаптического нейрона имеет тенденцию к усилению.
* 1957 {{---}} Модель перцептрона предложена Фрэнком Розенблаттом<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref> {{---}} математическая или компьютерная модель восприятия информации мозгом.
* 1960 {{---}} Дельта-правило обучения перцептрона<ref>[https://en.wikipedia.org/wiki/Delta_rule Delta rule, Wikipedia]</ref> {{---}} метод обучения перцептрона по принципу градиентного спуска по поверхности ошибки.
* 1969 {{---}} Выход книги Марвина Минска и Сеймура Паперта "Перцептроны"<ref>[https://en.wikipedia.org/wiki/Perceptrons_(book) Perceptrons book, WIkipedia]</ref>. В данной книге математически показаны ограничения перцептронов.
* 1974 {{---}} Метод обратного распространения ошибки впервые предложен А. И. Галушкиным и Дж. Вербосом<ref>[https://en.wikipedia.org/wiki/Backpropagation Backpropagation, Wikipedia]</ref> {{---}} метод вычисления градиента, который используется при обновлении весов многослойного перцептрона.
* 1980 {{---}} Первая свёрточная нейронная сеть предложена Кунихико Фукусимой<ref>[https://en.wikipedia.org/wiki/Convolutional_neural_network Convolutional_neural_network, Wikipedia]</ref> {{---}} специальная архитектура искусственных нейронных сетей использующая некоторые особенности зрительной коры.
* 1982 {{---}} Рекуррентные нейронные сети предложены Д. Хопфилдом {{---}} вид нейронных сетей, где связи между элементами образуют направленную последовательность.
* 1991 {{---}} Проблема "исчезающего" градиента была сформулирована С. Хочрейтом. Проблема "исчезающего" градиента заключается в быстрой потере информации с течением времени.
* 1997 {{---}} Долгая краткосрочная память предложена С. Хочрейтом и Ю. Шмидхубером<ref>[https://en.wikipedia.org/wiki/Long_short-term_memory Long short-term memory, Wikipedia]</ref>. В отличие от традиционных рекуррентных нейронных сетей, LSTM-сеть хорошо приспособлена к обучению на задачах классификации, обработки и прогнозирования временных рядов в случаях, когда важные события разделены временными промежутками с неопределённой продолжительностью и границами.
* 1998 {{---}} Градиентный спуск для сверточных нейронных сетей предложен Я. Лекуном.
* 2006 {{---}} Публикации Г. Хинтона, С. Осиндера и Я. Теха об обучении сетей глубокого доверия. Данные публикации, а также их активное освещение в средствах массовой информации смогли привлечь внимание ученых и разработчиков со всего мира к глубоким сетям.
* 2012 {{---}} Предложение дропаута Г. Хинтоном, А. Крижевски и И. Шутковичем<ref>[https://en.wikipedia.org/wiki/Dropout_(neural_networks) Dropout, Wikipedia]</ref>. Дропаут (от англ. dropout) {{---}} метод регуляризации искусственных нейронных сетей, предназначен для предотвращения переобучения сети.
* 2012 {{---}} Нейронные сети побеждают в ImageNet Challenge<ref>[https://en.wikipedia.org/wiki/ImageNet#ImageNet_Challenge ImageNet Challenge, Wikipedia]</ref>. Данное событие ознаменовало начало эры нейронных сетей и глубокого обучения.
* 2014 {{---}} Группа исследователей под руководством Зеппа Хохрейтера использовала глубокое обучение для определения токсичного воздействия лекарств и бытовых средств на окружающую среду. Данна работа была отмечена первым местом на соревновании "Tox21 Data Challenge"<ref>[https://tripod.nih.gov/tox21/challenge/leaderboard.jsp Tox21 Data Challenge Winners]</ref>.
* 2016 {{---}} Программа для игры в го Google AlphaGo выиграла со счётом 4:1 у Ли Седоля, лучшего международного игрока в эту игру. AlphaGo, разработанная DeepMind, использует глубокое обучение с помощью многоуровневых нейронных сетей.
* 2018 {{---}} Глубокое обучение впервые используется для планирования лучевой терапии<ref>[https://aapm.onlinelibrary.wiley.com/doi/abs/10.1002/mp.13271 Automatic treatment planning based on three‐dimensional dose distribution predicted from deep learning technique]</ref>.

В настоящее время глубокое обучение используется [[Глубокое обучение#Применения | во многих сферах]].

== Определение ==
'''Глубокое обучение''' {{---}} это класс алгоритмов машинного обучения, который:

* Использует многослойную систему нелинейных фильтров для извлечения признаков с преобразованиями. Каждый последующий слой получает на входе выходные данные предыдущего слоя.
* Может сочетать алгоритмы [[Обучение с учителем | обучения с учителем]][на 28.01.19 не создан] (пример {{---}} классификация) и [[Обучение без учителя | без учителя ]][на 28.01.19 не создан] (пример {{---}} анализ образца).
* Формирует в процессе обучения слои выявления признаков на нескольких уровнях представлений, которые соответствуют различным уровням абстракции; при этом признаки организованы иерархически {{---}} признаки более высокого уровня являются производными от признаков более низкого уровня.
{|align="center"
|-valign="top"
|[[Файл:Network_dif.png|border|550px|thumb|left|Глубокие и неглубокие нейронные сети.]]
|}

== Применения ==
* Распознавание речи<ref>[https://en.wikipedia.org/wiki/Speech_recognition Speech recognition, Wikipedia]</ref>. Все основные коммерческие системы распознавания речи (например, Microsoft Cortana, Xbox, Skype Translator, Amazon Alexa, Google Now, Apple Siri, Baidu и iFlyTek) основаны на глубоком обучении.
* [[:Задача нахождения объектов на изображении | Компьютерное зрение]][на 28.01.19 не создан]. На сегодняшний день системы распознавания образов основанные на глубоком обучении уже умеют давать более точные результаты, чем человеческий глаз<ref>[https://www.sciencedirect.com/science/article/pii/S0893608012000524 Multi-column deep neural network for traffic sign classification]</ref>.
* Обработка естественного языка<ref>[https://en.wikipedia.org/wiki/Natural_language_processing Natural language processing, Wikipedia]</ref>. Нейронные сети использовались для реализации языковых моделей еще с начала 2000-х годов. Изобретение LSTM помогло улучшить машинный перевод и языковое моделирование<ref>[https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf Sequence to Sequence Learning with Neural Networks]</ref>.
* Обнаружение новых лекарственных препаратов. К примеру, нейронная сеть AtomNet использовалась для прогнозирования новых биомолекул {{---}} кандидатов для лечения таких заболевания, как вирус Эбола и рассеянный склероз.
* Рекомендательные системы<ref>[https://en.wikipedia.org/wiki/Recommender_system Recommender system, Wikipedia]</ref>. На сегодняшний день глубокое обучение применяется для изучения пользовательских предпочтений во многих доменах.
* Предсказание генномных онтологий в биоинформатике<ref>[https://en.wikipedia.org/wiki/Deep_learning#Bioinformatics Deep learning in bioinformatics, Wikipedia]</ref>.

Полный список возможных применений глубокого обучения<ref>[https://en.wikipedia.org/wiki/Deep_learning#Applications Applications of deep learning, Wikipedia]</ref>.

== Transfer learning ==
[[Файл:Transfer.jpeg|border|450px|thumb|Transfer learning. Иллюстрация из [https://habr.com/company/binarydistrict/blog/428255/ статьи] на habr.com.]]
'''Transfer learning''' - это применение к решению задачи знаний, извлеченных нейронной сетью при решении другой задачи.

Глубокие нейронные сети требуют больших объемов данных для сходимости обучения. Поэтому часто встречается ситуация, когда для решаемой задачи недостаточно данных для того, чтобы хорошо натренировать все слои нейросети. Для решения этой проблемы и используется '''transfer learning'''<ref>[https://habr.com/company/binarydistrict/blog/428255/ Transfer Learning: как быстро обучить нейросеть на своих данных, habr.com]</ref>.

Чаще всего '''transfer learning''' выглядит следующим образом: к натренированной на определенную задачу нейросети добавляется еще несколько скрытый слоев, которые позволяют использовать уже полученные знания для решения более конкретной задачи. Например, знания, полученные при обучении распознаванию различных предметов, могут применяться при решении задачи распознавания еды.
<div style="clear:{{{1|both}}};"></div>

== Фреймворки для глубокого обучения ==
* TensorFlow<ref>[https://en.wikipedia.org/wiki/TensorFlow TensorFlow, Wikipedia]</ref>
* Microsoft Cognitive Toolkit<ref>[https://en.wikipedia.org/wiki/Microsoft_Cognitive_Toolkit Microsoft Cognitive Toolkit, Wikipedia]</ref>
* Wolfram Mathematica<ref>[https://en.wikipedia.org/wiki/Wolfram_Mathematica Wolfram Mathematica, Wikipedia]</ref>
* Keras<ref>[https://en.wikipedia.org/wiki/Keras Keras, Wikipedia]</ref>
* Deeplearning4j<ref>[https://en.wikipedia.org/wiki/Deeplearning4j Deeplearning4j, Wikipedia]</ref>
* Caffe<ref>[https://en.wikipedia.org/wiki/Caffe_(software) Caffe, Wikipedia]</ref>
* Torch/PyTorch<ref>[https://habr.com/post/334380 PyTorch — ваш новый фреймворк глубокого обучения, habr]</ref>
* MXNet<ref>[https://mxnet.apache.org MXNet, official site]</ref>
* Chainer<ref>[https://chainer.org Chainer, official site]</ref>
Сопоставление фреймворков, библиотек и отдельных программ для глубокого обучения<ref>[https://en.wikipedia.org/wiki/Comparison_of_deep_learning_software Comparison of deep learning software, Wikipedia]</ref>.

== См. также ==
* [[:Нейронные сети, перцептрон]]
* [[:Сверточные нейронные сети]]
* [[:Рекуррентные нейронные сети]]
* [[:Обучение с подкреплением]]

== Примечания ==
<references/>

== Источники информации ==
* [https://en.wikipedia.org/wiki/Deep_learning Deep learning, Wikipedia]
* [https://ru.wikipedia.org/wiki/Глубокое_обучение Глубокое обучение, Wikipedia]
* [http://www.deeplearningbook.org/ Deep Learning Book, MIT]
* [https://towardsdatascience.com/multi-layer-neural-networks-with-sigmoid-function-deep-learning-for-rookies-2-bf464f09eb7f Multi-Layer Neural Networks with Sigmoid Function, Towards Data Science]
* [https://www.kaggle.com/dansbecker/rectified-linear-units-relu-in-deep-learning Rectified Linear Units (ReLU) in Deep Learning, Kaggle]

Глубокое обучение

2019-01-28T14:39:27Z

Alexey Katsman: /* Применения */

[[Файл:Ml_areas.jpg|thumb|250px|Глубокое обучение как часть машинного обучения.]]

'''Глубокое обучение''' (англ. deep learning) {{---}} совокупность широкого семейства методов машинного обучения, основанных на имитации работы человеческого мозга в процессе обработки данных и создания паттернов, используемых для принятия решений<ref>[https://www.investopedia.com/terms/d/deep-learning.asp Deep Learning, Investopedia]</ref>. Как правило, глубокое обучение предназначено для работы с большими объемами данных и использует сложные алгоритмы для обучения модели<ref>[https://www.quora.com/What-is-the-difference-between-Neural-Networks-and-Deep-Learning The difference between neural networks and deep learning]</ref>. На больших датасетах глубокое обучение показывает более высокую точность результатов в сравнении с традиционным машинным обучением. Зависимость производительности (качества результатов) от объема данных представлена на рисунке ниже.

{|align="center"
|-valign="top"
|[[Файл:Perfm_data.jpg|border|450px|thumb|left|Зависимость производительности от объема данных.]]
|}

Несмотря на то, что данный раздел машинного обучения появился еще в 1980-х, до недавнего времени его применение было сильно ограничено из-за недостака вычислительных мощностей существовавших компьютеров. Ситуация изменилась только в середине 2000-х.

На создание моделей глубокого обучения оказали влияние некоторые процессы и паттерны, происходящие в биологических нейронных системах. Несмотря на это, данные модели во многом отличаются от биологического мозга (и в структуре и в функциях), что делает невозможным использование теорем и доказательств, применяющихся в нейробиологии.

== История ==
* 1943 {{---}} Искусственный нейрон Маккаллока — Питтса<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref> {{---}} узел искусственной нейронной сети, являющийся упрощённой моделью естественного нейрона.
* 1949 {{---}} Принцип обучения нейронов Хебба<ref>[https://en.wikipedia.org/wiki/Hebbian_theory Hebbian theory, Wikipedia]</ref> {{---}} изначально наблюдаемая причинно-следственная связь между активациями пре- и постсинаптического нейрона имеет тенденцию к усилению.
* 1957 {{---}} Модель перцептрона предложена Фрэнком Розенблаттом<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref> {{---}} математическая или компьютерная модель восприятия информации мозгом.
* 1960 {{---}} Дельта-правило обучения перцептрона<ref>[https://en.wikipedia.org/wiki/Delta_rule Delta rule, Wikipedia]</ref> {{---}} метод обучения перцептрона по принципу градиентного спуска по поверхности ошибки.
* 1969 {{---}} Выход книги Марвина Минска и Сеймура Паперта "Перцептроны"<ref>[https://en.wikipedia.org/wiki/Perceptrons_(book) Perceptrons book, WIkipedia]</ref>. В данной книге математически показаны ограничения перцептронов.
* 1974 {{---}} Метод обратного распространения ошибки впервые предложен А. И. Галушкиным и Дж. Вербосом<ref>[https://en.wikipedia.org/wiki/Backpropagation Backpropagation, Wikipedia]</ref> {{---}} метод вычисления градиента, который используется при обновлении весов многослойного перцептрона.
* 1980 {{---}} Первая свёрточная нейронная сеть предложена Кунихико Фукусимой<ref>[https://en.wikipedia.org/wiki/Convolutional_neural_network Convolutional_neural_network, Wikipedia]</ref> {{---}} специальная архитектура искусственных нейронных сетей использующая некоторые особенности зрительной коры.
* 1982 {{---}} Рекуррентные нейронные сети предложены Д. Хопфилдом {{---}} вид нейронных сетей, где связи между элементами образуют направленную последовательность.
* 1991 {{---}} Проблема "исчезающего" градиента была сформулирована С. Хочрейтом. Проблема "исчезающего" градиента заключается в быстрой потере информации с течением времени.
* 1997 {{---}} Долгая краткосрочная память предложена С. Хочрейтом и Ю. Шмидхубером<ref>[https://en.wikipedia.org/wiki/Long_short-term_memory Long short-term memory, Wikipedia]</ref>. В отличие от традиционных рекуррентных нейронных сетей, LSTM-сеть хорошо приспособлена к обучению на задачах классификации, обработки и прогнозирования временных рядов в случаях, когда важные события разделены временными промежутками с неопределённой продолжительностью и границами.
* 1998 {{---}} Градиентный спуск для сверточных нейронных сетей предложен Я. Лекуном.
* 2006 {{---}} Публикации Г. Хинтона, С. Осиндера и Я. Теха об обучении сетей глубокого доверия. Данные публикации, а также их активное освещение в средствах массовой информации смогли привлечь внимание ученых и разработчиков со всего мира к глубоким сетям.
* 2012 {{---}} Предложение дропаута Г. Хинтоном, А. Крижевски и И. Шутковичем<ref>[https://en.wikipedia.org/wiki/Dropout_(neural_networks) Dropout, Wikipedia]</ref>. Дропаут (от англ. dropout) {{---}} метод регуляризации искусственных нейронных сетей, предназначен для предотвращения переобучения сети.
* 2012 {{---}} Нейронные сети побеждают в ImageNet Challenge<ref>[https://en.wikipedia.org/wiki/ImageNet#ImageNet_Challenge ImageNet Challenge, Wikipedia]</ref>. Данное событие ознаменовало начало эры нейронных сетей и глубокого обучения.
* 2014 {{---}} Группа исследователей под руководством Зеппа Хохрейтера использовала глубокое обучение для определения токсичного воздействия лекарств и бытовых средств на окружающую среду. Данна работа была отмечена первым местом на соревновании "Tox21 Data Challenge"<ref>[https://tripod.nih.gov/tox21/challenge/leaderboard.jsp Tox21 Data Challenge Winners]</ref>.
* 2016 {{---}} Программа для игры в го Google AlphaGo выиграла со счётом 4:1 у Ли Седоля, лучшего международного игрока в эту игру. AlphaGo, разработанная DeepMind, использует глубокое обучение с помощью многоуровневых нейронных сетей.
* 2018 {{---}} Глубокое обучение впервые используется для планирования лучевой терапии<ref>[https://aapm.onlinelibrary.wiley.com/doi/abs/10.1002/mp.13271 Automatic treatment planning based on three‐dimensional dose distribution predicted from deep learning technique]</ref>.

В настоящее время глубокое обучение используется [[Глубокое обучение#Применения | во многих сферах]].

== Определение ==
'''Глубокое обучение''' {{---}} это класс алгоритмов машинного обучения, который:

* Использует многослойную систему нелинейных фильтров для извлечения признаков с преобразованиями. Каждый последующий слой получает на входе выходные данные предыдущего слоя.
* Может сочетать алгоритмы [[Обучение с учителем | обучения с учителем]][на 28.01.19 не создан] (пример {{---}} классификация) и [[Обучение без учителя | без учителя ]][на 28.01.19 не создан] (пример {{---}} анализ образца).
* Формирует в процессе обучения слои выявления признаков на нескольких уровнях представлений, которые соответствуют различным уровням абстракции; при этом признаки организованы иерархически {{---}} признаки более высокого уровня являются производными от признаков более низкого уровня.
{|align="center"
|-valign="top"
|[[Файл:Network_dif.png|border|550px|thumb|left|Глубокие и неглубокие нейронные сети.]]
|}

== Применения ==
* Распознавание речи<ref>[https://en.wikipedia.org/wiki/Speech_recognition Speech recognition, Wikipedia]</ref>. Все основные коммерческие системы распознавания речи (например, Microsoft Cortana, Xbox, Skype Translator, Amazon Alexa, Google Now, Apple Siri, Baidu и iFlyTek) основаны на глубоком обучении.
* [[:Задача нахождения объектов на изображении | Компьютерное зрение]][на 28.01.19 не создан]. На сегодняшний день системы распознавания образов основанные на глубоком обучении уже умеют давать более точные результаты, чем человеческий глаз<ref>[https://www.sciencedirect.com/science/article/pii/S0893608012000524 Multi-column deep neural network for traffic sign classification]</ref>.
* Обработка естественного языка<ref>[https://en.wikipedia.org/wiki/Natural_language_processing Natural language processing, Wikipedia]</ref>. Нейронные сети использовались для реализации языковых моделей еще с начала 2000-х годов. Изобретение LSTM помогло улучшить машинный перевод и языковое моделирование<ref>[https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf Sequence to Sequence Learning with Neural Networks]</ref>.
* Обнаружение новых лекарственных препаратов. К примеру, нейронная сеть AtomNet использовалась для прогнозирования новых биомолекул {{---}} кандидатов для лечения таких заболевания, как вирус Эбола и рассеянный склероз.
* Рекомендательные системы<ref>[https://en.wikipedia.org/wiki/Recommender_system Recommender system, Wikipedia]</ref>. На сегодняшний день глубокое обучение применяется для изучения пользовательских предпочтений во многих доменах.
* Предсказание генномных онтологий в биоинформатике<ref>[https://en.wikipedia.org/wiki/Deep_learning#Bioinformatics Deep learning in bioinformatics, Wikipedia]</ref>.

Полный список возможных применений глубокого обучения<ref>[https://en.wikipedia.org/wiki/Deep_learning#Applications Applications of deep learning, Wikipedia]</ref>.

== Transfer learning ==
[[Файл:Transfer.jpeg|border|450px|thumb|Transfer learning. Иллюстрация из [https://habr.com/company/binarydistrict/blog/428255/ статьи] на habr.com.]]
'''Transfer learning''' - это применение к решению задачи знаний, извлеченных нейронной сетью при решении другой задачи.

Глубокие нейронные сети требуют больших объемов данных для сходимости обучения. Поэтому часто встречается ситуация, когда для решаемой задачи недостаточно данных для того, чтобы хорошо натренировать все слои нейросети. Для решения этой проблемы и используется '''transfer learning'''<ref>[https://habr.com/company/binarydistrict/blog/428255/ Transfer Learning: как быстро обучить нейросеть на своих данных, habr.com]</ref>.

Чаще всего '''transfer learning''' выглядит следующим образом: к натренированной на определенную задачу нейросети добавляется еще несколько скрытый слоев, которые позволяют использовать уже полученные знания для решения более конкретной задачи. Например, знания, полученные при обучении распознаванию различных предметов, могут применяться при решении задачи распознавания еды.
<div style="clear:{{{1|both}}};"></div>

== Фреймворки для глубокого обучения ==
* TensorFlow<ref>[https://en.wikipedia.org/wiki/TensorFlow TensorFlow, Wikipedia]</ref>
* Microsoft Cognitive Toolkit<ref>[https://en.wikipedia.org/wiki/Microsoft_Cognitive_Toolkit Microsoft Cognitive Toolkit, Wikipedia]</ref>
* Wolfram Mathematica<ref>[https://en.wikipedia.org/wiki/Wolfram_Mathematica Wolfram Mathematica, Wikipedia]</ref>
* Keras<ref>[https://en.wikipedia.org/wiki/Keras Keras, Wikipedia]</ref>
* Deeplearning4j<ref>[https://en.wikipedia.org/wiki/Deeplearning4j Deeplearning4j, Wikipedia]</ref>
* Caffe<ref>[https://en.wikipedia.org/wiki/Caffe_(software) Caffe, Wikipedia]</ref>
* Torch/PyTorch<ref>[https://habr.com/post/334380 PyTorch — ваш новый фреймворк глубокого обучения, habr]</ref>
* MXNet<ref>[https://mxnet.apache.org MXNet, official site]</ref>
* Chainer<ref>[https://chainer.org Chainer, official site]</ref>
Сопоставление фреймворков, библиотек и отдельных программ для глубокого обучения<ref>[https://en.wikipedia.org/wiki/Comparison_of_deep_learning_software Comparison of deep learning software, Wikipedia]</ref>.

== См. также ==
* [[:Нейронные сети, перцептрон]][на 06.12.18 не создан]
* [[:Сверточные нейронные сети]]
* [[:Рекуррентные нейронные сети]][на 06.12.18 не создан]
* [[:Обучение с подкреплением]][на 06.12.18 не создан]

== Примечания ==
<references/>

== Источники информации ==
* [https://en.wikipedia.org/wiki/Deep_learning Deep learning, Wikipedia]
* [https://ru.wikipedia.org/wiki/Глубокое_обучение Глубокое обучение, Wikipedia]
* [http://www.deeplearningbook.org/ Deep Learning Book, MIT]
* [https://towardsdatascience.com/multi-layer-neural-networks-with-sigmoid-function-deep-learning-for-rookies-2-bf464f09eb7f Multi-Layer Neural Networks with Sigmoid Function, Towards Data Science]
* [https://www.kaggle.com/dansbecker/rectified-linear-units-relu-in-deep-learning Rectified Linear Units (ReLU) in Deep Learning, Kaggle]

Глубокое обучение

2019-01-28T14:39:14Z

Alexey Katsman: /* Определение */

[[Файл:Ml_areas.jpg|thumb|250px|Глубокое обучение как часть машинного обучения.]]

'''Глубокое обучение''' (англ. deep learning) {{---}} совокупность широкого семейства методов машинного обучения, основанных на имитации работы человеческого мозга в процессе обработки данных и создания паттернов, используемых для принятия решений<ref>[https://www.investopedia.com/terms/d/deep-learning.asp Deep Learning, Investopedia]</ref>. Как правило, глубокое обучение предназначено для работы с большими объемами данных и использует сложные алгоритмы для обучения модели<ref>[https://www.quora.com/What-is-the-difference-between-Neural-Networks-and-Deep-Learning The difference between neural networks and deep learning]</ref>. На больших датасетах глубокое обучение показывает более высокую точность результатов в сравнении с традиционным машинным обучением. Зависимость производительности (качества результатов) от объема данных представлена на рисунке ниже.

{|align="center"
|-valign="top"
|[[Файл:Perfm_data.jpg|border|450px|thumb|left|Зависимость производительности от объема данных.]]
|}

Несмотря на то, что данный раздел машинного обучения появился еще в 1980-х, до недавнего времени его применение было сильно ограничено из-за недостака вычислительных мощностей существовавших компьютеров. Ситуация изменилась только в середине 2000-х.

На создание моделей глубокого обучения оказали влияние некоторые процессы и паттерны, происходящие в биологических нейронных системах. Несмотря на это, данные модели во многом отличаются от биологического мозга (и в структуре и в функциях), что делает невозможным использование теорем и доказательств, применяющихся в нейробиологии.

== История ==
* 1943 {{---}} Искусственный нейрон Маккаллока — Питтса<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref> {{---}} узел искусственной нейронной сети, являющийся упрощённой моделью естественного нейрона.
* 1949 {{---}} Принцип обучения нейронов Хебба<ref>[https://en.wikipedia.org/wiki/Hebbian_theory Hebbian theory, Wikipedia]</ref> {{---}} изначально наблюдаемая причинно-следственная связь между активациями пре- и постсинаптического нейрона имеет тенденцию к усилению.
* 1957 {{---}} Модель перцептрона предложена Фрэнком Розенблаттом<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref> {{---}} математическая или компьютерная модель восприятия информации мозгом.
* 1960 {{---}} Дельта-правило обучения перцептрона<ref>[https://en.wikipedia.org/wiki/Delta_rule Delta rule, Wikipedia]</ref> {{---}} метод обучения перцептрона по принципу градиентного спуска по поверхности ошибки.
* 1969 {{---}} Выход книги Марвина Минска и Сеймура Паперта "Перцептроны"<ref>[https://en.wikipedia.org/wiki/Perceptrons_(book) Perceptrons book, WIkipedia]</ref>. В данной книге математически показаны ограничения перцептронов.
* 1974 {{---}} Метод обратного распространения ошибки впервые предложен А. И. Галушкиным и Дж. Вербосом<ref>[https://en.wikipedia.org/wiki/Backpropagation Backpropagation, Wikipedia]</ref> {{---}} метод вычисления градиента, который используется при обновлении весов многослойного перцептрона.
* 1980 {{---}} Первая свёрточная нейронная сеть предложена Кунихико Фукусимой<ref>[https://en.wikipedia.org/wiki/Convolutional_neural_network Convolutional_neural_network, Wikipedia]</ref> {{---}} специальная архитектура искусственных нейронных сетей использующая некоторые особенности зрительной коры.
* 1982 {{---}} Рекуррентные нейронные сети предложены Д. Хопфилдом {{---}} вид нейронных сетей, где связи между элементами образуют направленную последовательность.
* 1991 {{---}} Проблема "исчезающего" градиента была сформулирована С. Хочрейтом. Проблема "исчезающего" градиента заключается в быстрой потере информации с течением времени.
* 1997 {{---}} Долгая краткосрочная память предложена С. Хочрейтом и Ю. Шмидхубером<ref>[https://en.wikipedia.org/wiki/Long_short-term_memory Long short-term memory, Wikipedia]</ref>. В отличие от традиционных рекуррентных нейронных сетей, LSTM-сеть хорошо приспособлена к обучению на задачах классификации, обработки и прогнозирования временных рядов в случаях, когда важные события разделены временными промежутками с неопределённой продолжительностью и границами.
* 1998 {{---}} Градиентный спуск для сверточных нейронных сетей предложен Я. Лекуном.
* 2006 {{---}} Публикации Г. Хинтона, С. Осиндера и Я. Теха об обучении сетей глубокого доверия. Данные публикации, а также их активное освещение в средствах массовой информации смогли привлечь внимание ученых и разработчиков со всего мира к глубоким сетям.
* 2012 {{---}} Предложение дропаута Г. Хинтоном, А. Крижевски и И. Шутковичем<ref>[https://en.wikipedia.org/wiki/Dropout_(neural_networks) Dropout, Wikipedia]</ref>. Дропаут (от англ. dropout) {{---}} метод регуляризации искусственных нейронных сетей, предназначен для предотвращения переобучения сети.
* 2012 {{---}} Нейронные сети побеждают в ImageNet Challenge<ref>[https://en.wikipedia.org/wiki/ImageNet#ImageNet_Challenge ImageNet Challenge, Wikipedia]</ref>. Данное событие ознаменовало начало эры нейронных сетей и глубокого обучения.
* 2014 {{---}} Группа исследователей под руководством Зеппа Хохрейтера использовала глубокое обучение для определения токсичного воздействия лекарств и бытовых средств на окружающую среду. Данна работа была отмечена первым местом на соревновании "Tox21 Data Challenge"<ref>[https://tripod.nih.gov/tox21/challenge/leaderboard.jsp Tox21 Data Challenge Winners]</ref>.
* 2016 {{---}} Программа для игры в го Google AlphaGo выиграла со счётом 4:1 у Ли Седоля, лучшего международного игрока в эту игру. AlphaGo, разработанная DeepMind, использует глубокое обучение с помощью многоуровневых нейронных сетей.
* 2018 {{---}} Глубокое обучение впервые используется для планирования лучевой терапии<ref>[https://aapm.onlinelibrary.wiley.com/doi/abs/10.1002/mp.13271 Automatic treatment planning based on three‐dimensional dose distribution predicted from deep learning technique]</ref>.

В настоящее время глубокое обучение используется [[Глубокое обучение#Применения | во многих сферах]].

== Определение ==
'''Глубокое обучение''' {{---}} это класс алгоритмов машинного обучения, который:

* Использует многослойную систему нелинейных фильтров для извлечения признаков с преобразованиями. Каждый последующий слой получает на входе выходные данные предыдущего слоя.
* Может сочетать алгоритмы [[Обучение с учителем | обучения с учителем]][на 28.01.19 не создан] (пример {{---}} классификация) и [[Обучение без учителя | без учителя ]][на 28.01.19 не создан] (пример {{---}} анализ образца).
* Формирует в процессе обучения слои выявления признаков на нескольких уровнях представлений, которые соответствуют различным уровням абстракции; при этом признаки организованы иерархически {{---}} признаки более высокого уровня являются производными от признаков более низкого уровня.
{|align="center"
|-valign="top"
|[[Файл:Network_dif.png|border|550px|thumb|left|Глубокие и неглубокие нейронные сети.]]
|}

== Применения ==
* Распознавание речи<ref>[https://en.wikipedia.org/wiki/Speech_recognition Speech recognition, Wikipedia]</ref>. Все основные коммерческие системы распознавания речи (например, Microsoft Cortana, Xbox, Skype Translator, Amazon Alexa, Google Now, Apple Siri, Baidu и iFlyTek) основаны на глубоком обучении.
* [[:Задача нахождения объектов на изображении | Компьютерное зрение]][на 06.12.18 не создан]. На сегодняшний день системы распознавания образов основанные на глубоком обучении уже умеют давать более точные результаты, чем человеческий глаз<ref>[https://www.sciencedirect.com/science/article/pii/S0893608012000524 Multi-column deep neural network for traffic sign classification]</ref>.
* Обработка естественного языка<ref>[https://en.wikipedia.org/wiki/Natural_language_processing Natural language processing, Wikipedia]</ref>. Нейронные сети использовались для реализации языковых моделей еще с начала 2000-х годов. Изобретение LSTM помогло улучшить машинный перевод и языковое моделирование<ref>[https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf Sequence to Sequence Learning with Neural Networks]</ref>.
* Обнаружение новых лекарственных препаратов. К примеру, нейронная сеть AtomNet использовалась для прогнозирования новых биомолекул {{---}} кандидатов для лечения таких заболевания, как вирус Эбола и рассеянный склероз.
* Рекомендательные системы<ref>[https://en.wikipedia.org/wiki/Recommender_system Recommender system, Wikipedia]</ref>. На сегодняшний день глубокое обучение применяется для изучения пользовательских предпочтений во многих доменах.
* Предсказание генномных онтологий в биоинформатике<ref>[https://en.wikipedia.org/wiki/Deep_learning#Bioinformatics Deep learning in bioinformatics, Wikipedia]</ref>.

Полный список возможных применений глубокого обучения<ref>[https://en.wikipedia.org/wiki/Deep_learning#Applications Applications of deep learning, Wikipedia]</ref>.

== Transfer learning ==
[[Файл:Transfer.jpeg|border|450px|thumb|Transfer learning. Иллюстрация из [https://habr.com/company/binarydistrict/blog/428255/ статьи] на habr.com.]]
'''Transfer learning''' - это применение к решению задачи знаний, извлеченных нейронной сетью при решении другой задачи.

Глубокие нейронные сети требуют больших объемов данных для сходимости обучения. Поэтому часто встречается ситуация, когда для решаемой задачи недостаточно данных для того, чтобы хорошо натренировать все слои нейросети. Для решения этой проблемы и используется '''transfer learning'''<ref>[https://habr.com/company/binarydistrict/blog/428255/ Transfer Learning: как быстро обучить нейросеть на своих данных, habr.com]</ref>.

Чаще всего '''transfer learning''' выглядит следующим образом: к натренированной на определенную задачу нейросети добавляется еще несколько скрытый слоев, которые позволяют использовать уже полученные знания для решения более конкретной задачи. Например, знания, полученные при обучении распознаванию различных предметов, могут применяться при решении задачи распознавания еды.
<div style="clear:{{{1|both}}};"></div>

== Фреймворки для глубокого обучения ==
* TensorFlow<ref>[https://en.wikipedia.org/wiki/TensorFlow TensorFlow, Wikipedia]</ref>
* Microsoft Cognitive Toolkit<ref>[https://en.wikipedia.org/wiki/Microsoft_Cognitive_Toolkit Microsoft Cognitive Toolkit, Wikipedia]</ref>
* Wolfram Mathematica<ref>[https://en.wikipedia.org/wiki/Wolfram_Mathematica Wolfram Mathematica, Wikipedia]</ref>
* Keras<ref>[https://en.wikipedia.org/wiki/Keras Keras, Wikipedia]</ref>
* Deeplearning4j<ref>[https://en.wikipedia.org/wiki/Deeplearning4j Deeplearning4j, Wikipedia]</ref>
* Caffe<ref>[https://en.wikipedia.org/wiki/Caffe_(software) Caffe, Wikipedia]</ref>
* Torch/PyTorch<ref>[https://habr.com/post/334380 PyTorch — ваш новый фреймворк глубокого обучения, habr]</ref>
* MXNet<ref>[https://mxnet.apache.org MXNet, official site]</ref>
* Chainer<ref>[https://chainer.org Chainer, official site]</ref>
Сопоставление фреймворков, библиотек и отдельных программ для глубокого обучения<ref>[https://en.wikipedia.org/wiki/Comparison_of_deep_learning_software Comparison of deep learning software, Wikipedia]</ref>.

== См. также ==
* [[:Нейронные сети, перцептрон]][на 06.12.18 не создан]
* [[:Сверточные нейронные сети]]
* [[:Рекуррентные нейронные сети]][на 06.12.18 не создан]
* [[:Обучение с подкреплением]][на 06.12.18 не создан]

== Примечания ==
<references/>

== Источники информации ==
* [https://en.wikipedia.org/wiki/Deep_learning Deep learning, Wikipedia]
* [https://ru.wikipedia.org/wiki/Глубокое_обучение Глубокое обучение, Wikipedia]
* [http://www.deeplearningbook.org/ Deep Learning Book, MIT]
* [https://towardsdatascience.com/multi-layer-neural-networks-with-sigmoid-function-deep-learning-for-rookies-2-bf464f09eb7f Multi-Layer Neural Networks with Sigmoid Function, Towards Data Science]
* [https://www.kaggle.com/dansbecker/rectified-linear-units-relu-in-deep-learning Rectified Linear Units (ReLU) in Deep Learning, Kaggle]

CatBoost

2019-01-28T14:38:47Z

Alexey Katsman: /* См. также */

Статья посвящена работе с библиотекой CatBoost {{---}} методу машинного обучения, основанному на градиентном бустинге (англ. ''gradient boosting'').

Практически любой современный метод на основе градиентного бустинга работает с числовыми признаками. Если у нас в наборе данных присутствуют не только числовые, но и категориальные признаки (англ. ''categorical features''), то необходимо переводить категориальные признаки в числовые. Это приводит к искажению их сути и потенциальному снижению точности работы модели.
Именно поэтому было важно разработать алгоритм, который умеет работать не только с числовыми признаками, но и с категориальными напрямую, закономерности между которыми этот алгоритм будет выявлять самостоятельно, без ручной «помощи».
CatBoost {{---}} библиотека для градиентного бустинга, главным преимуществом которой является то, что она одинаково хорошо работает «из коробки» как с числовыми признаками, так и с категориальными.

Документацию по CatBoost можно найти на сайте<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/ Документация CatBoost]</ref>.

----
== Общий принцип работы ==

=== Дерево решений ===

Алгоритм работы следующий: для каждого документа имеется набор значений признаков, имеется дерево, в вершинах дерева {{---}} условия. Если условие выполнено, осуществляется переход в правого ребенка вершины, иначе в левого. Нужно пройти до листа по дереву в соответствии со значениями признаков для документа. На выходе каждому документу соответствует значение листа. Это и есть ответ.

=== Бустинг ===

Идея бустинг-подхода заключается в комбинации слабых (с невысокой обобщающей способностью) функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Результирующая функция представляет собой линейную комбинацию базовых, слабых моделей. Более подробно можно посмотреть в статье про градиентный бустинг<ref>[https://en.wikipedia.org/wiki/Gradient_boosting |Gradient Boosting, Wikipedia]</ref>.

Далее будет рассматриваться бустинг деревьев решений. Будем строить несколько деревьев, чтобы добавление новых деревьев уменьшало ошибку. Итого при достаточно большом количестве деревьев мы сможем сильно уменьшить ошибку, однако не стоит забывать, что чем больше деревьев, тем дольше обучается модель и в какой-то момент прирост качества становится незначительным.

=== Градиентный бустинг ===

* В основе CatBoost лежит градиентный бустинг.

* Градиент функции ошибки {{---}} все производные по всем значениям функции
Градиентный бустинг {{---}} метод машинного обучения, который создает решающую модель прогнозирования в виде ансамбля слабых моделей прогнозирования, обычно деревьев решений. Он строит модель поэтапно, позволяя оптимизировать произвольную дифференцируемую функцию потерь.

== Особенности CatBoost ==

=== Режимы работы ===

* Регрессия (англ. ''regression'')
* Классификация (англ. ''classification'')
Функция потерь (англ. ''loss function'') {{---}} максимизируем вероятность того, что все объекты в обучающей выборке классифицированы правильно, вероятность - это сигмоида над значением формулы.
Функция ''predict_proba'' {{---}} на выходе получаем готовые вероятности. Нужно отметить, что складывать их уже нельзя.
Функция ''predict'' {{---}} выдает необработанный результат. Такой результат можно складывать, например, с результатами других моделей.
* Мультиклассификация (англ. ''multiclass classification'')
* Ранжирование (англ. ''ranking'')
Объекты с попарной классификацией

=== Метрики ===

Поддерживает множество [[Оценка_качества_в_задачах_классификации_и_регресси|метрик]][на 28.01.19 не создан] (англ. ''metrics''), таких как:
* Регрессия: ''MAE, MAPE, RMSE, SMAPE'' etc.
* Классификация: ''Logloss , Precision, Recall, F1, CrossEntropy, BalancedAccuracy'' etc.
* Мультиклассификация: ''MultiClass, MultiClassOneVsAll, HammingLoss, F1'' etc.
* Ранжирование: ''NDCG, PrecisionAt, RecallAt, PFound, PairLogit'' etc.

== Обучение ==
=== Шаги обучения ===

* Строим дерево
* Считаем значение в листьях

=== Построение дерева ===

Процесс построения происходит жадно.

* Выбираем первую вершину
* Выбираем лучшее дерево с одной вершиной.
* Считаем метрику и по ней выбираем лучшее дерево.

Дерево строится по слоям. Гарантировано на каждом слое один и тот же сплит (условие, по которому мы делим).

=== Вычисление значений в листьях ===
Во время вычисления значений в листьях можем позволить себе сделать больше операций, так как у нас уже зафиксирована структура дерева и значения в листьях будут вычислены единожды. Поэтому можем себе позволить даже сделать несколько шагов по градиенту или применить метод Ньютона.

=== Как выбрать лучшее дерево? ===

Смотрим, на сколько меняется функция ошибки, выбираем такое дерево, чтобы оно как можно лучше приближало вектор градиентов.

=== Как работает градиентный бустинг? ===

Отметим, что существует идеальный шаг по градиенту, однако листьев в дереве меньше, чем документов в датасете.
Поэтому мы можем пытаться приближать тот самый идеальный шаг.
Чтобы найти лучший сплит, проверяем похожесть после одного шага алгоритма по градиенту.

=== Рандомизация ===

Есть рандомизация метрики, по которой выбирается лучшее дерево.
''Score += random_strength * Rand (0, lenofgrad * q)''

''q'' {{---}} множитель, уменьшающийся при увеличении итерации.
Таким образом, рандом уменьшается ближе к концу.

----

== Работа с датасетом ==

=== Режимов выборки данных ===

CatBoost поддерживает несколько режимов выборки данных

* Бутстрап (англ. ''bootstrap'') Бернулли {{---}} выбираем документ с вероятностью ''p''. Регулируется параметром ''sample_rate''
* Байесовский бутстрап {{---}} байесовское распределение. Регулируется параметром ''bagging_temp''

Отметим, что бутстрап используется только для выбора структуры дерева, для подсчета значения в листьях используем всю выборку. Это сделано, так как выбор структуры дерева происходит долго, нужно несколько раз пересчитывать значения, поэтому использовать всю выборку {{---}} слишком дорого. Однако значения в листьях с уже готовой структурой дерева считаются один раз, и для большей точности можно позволить использовать весь датасет.

=== Бинаризация признаков ===

Пробовать все {{---}} долго. Поэтому выбираем сетку заранее и ходим по ней.

Есть несколько способов выбора:

* Uniform. Равномерно разбиваем отрезок от минимума значения для данного признака до максимума.
* Медианная сетка. Задаем количество разбиений над множеством значений, далее идем по объектам в порядке сортировки и разбиваем на группы по k объектов, где k {{---}} количество объектов в одном слоте разбиения.
* UniformAndQuantiles. Комбинация 1 и 2 пунктов.
* MaxSumLog {{---}} в основе лежит динамика, работает долго.
* GreedyLogSum {{---}} аналог MaxSumLog, используется жадный алгоритм, поэтому работает не точно, однако быстрее чем MaxSumLog

=== Работа с категориальными признаками ===

* LabelEncoding {{---}} на реальных примерах точность работы низкая, так как появляется отношения порядка между объектами.
* One-hot encoding {{---}} дает неплохую точность, если различных значений признаков не много. Иначе один признак размножится на множество признаков и будет влиять на модель заведомо сильнее остальных признаков.

Лучше не делать препроцессинг самим, из-за проблем, описанных выше. В CatBoost можно задать параметр cat_features, передав туда индексы категориальных признаков. Также можно отрегулировать параметр ''one_hot_max_size'' {{---}} максимальное количество различных значений у категориального признака, чтобы он мог в последствии быть подвержен one-hot encoding.

== Подбор параметров ==

Ниже описаны гиперпараметры (англ. ''hyperparameters''), на которые стоит обратить внимание при использовании библиотеки.

* cat_features
* Overfitting detector
* Число итераций и learning rate
* L2_reg
* Random_srength
* Bagging_temp
* Глубина дерева (стоит попробовать 10 и 6)

== Полезная функциональность ==

* Snapshots
* Overfitting detector
* CV
* eval_metrics

== Бенчмарки ==

Сравнение библиотеки CatBoost с открытыми аналогами XGBoost, LightGBM и H20 на наборе публичных датасетов<ref>[https://catboost.yandex/#benchmark| Benchmarks]</ref>.

== Пример использования ==
* Делим данные на тренировочное и тестовое множество
'''from''' sklearn.model_selection '''import''' train_test_split

X_train, X_validation, y_train, y_validation = train_test_split(X, y, '''train_size'''=0.5, '''random_state'''=1234)
'''print'''(X_train.shape, X_validation.shape)

* Создаем классификатор
'''from''' catboost '''import''' CatBoostClassifier

best_model = CatBoostClassifier(
'''bagging_temperature'''=1,
'''random_strength'''=1,
'''thread_count'''=3,
'''iterations'''=500,
'''l2_leaf_reg''' = 4.0,
'''learning_rate''' = 0.07521709965938336,
'''save_snapshot'''=True,
'''snapshot_file'''='snapshot_best.bkp',
'''random_seed'''=63,
'''od_type'''='Iter',
'''od_wait'''=20,
'''custom_loss'''=['AUC', 'Accuracy'],
'''use_best_model'''=True
)

* Обучаемся

best_model.fit(
X_train, y_train,
'''cat_features'''=cat_features,
'''eval_set'''=(X_validation, y_validation),
'''logging_level'''='Silent',
'''plot'''=True
)

* Вывод числа деревьев в модели

'''print'''('Resulting tree count:', best_model.tree_count_)

> '''Resulting tree count: 217'''

* Используем скользящий контроль (англ. cross validation)
'''from''' catboost '''import''' cv

params = best_model.get_params()
params['iterations'] = 10
params['custom_loss'] = 'AUC'
del params['use_best_model']
pool1 = Pool(X, '''label'''=y, '''cat_features'''=cat_features)

cv_data = cv(
'''params''' = params,
'''pool''' = pool1,
'''fold_count'''=2,
'''inverted'''=False,
'''shuffle'''=True,
'''stratified'''=False,
'''partition_random_seed'''=0
)

* Выводим результат
best_value = np.max(cv_data['AUC_test_avg'])
best_iter = np.argmax(cv_data['AUC_test_avg'])
'''print'''('Best validation AUC score: {:.2f}±{:.2f} on step {}'.format(
best_value,
cv_data['AUC_test_stddev'][best_iter],
best_iter
))

> '''Best validation AUC score: 0.91±0.00 on step 9'''

''Больше примеров<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/python-usages-examples-docpage Примеры ипользования CatBoost]</ref> можно найти на сайте библиотеки''.

==См. также==
*[[:Дерево_решений_и_случайный_леc|Дерево решений и случайный леc]][на 28.01.19 не создан]
*[[:Бустинг,_AdaBoost|Бустинг, AdaBoost]]

==Примечания==
<references/>

== Источники информации ==
* [https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/| Overview of CatBoost]
* [https://en.wikipedia.org/wiki/Gradient_boosting| Gradient Boosting, WIkipedia]
[[Категория: Машинное обучение]]

CatBoost

2019-01-28T14:38:32Z

Alexey Katsman: /* Метрики */

Статья посвящена работе с библиотекой CatBoost {{---}} методу машинного обучения, основанному на градиентном бустинге (англ. ''gradient boosting'').

Практически любой современный метод на основе градиентного бустинга работает с числовыми признаками. Если у нас в наборе данных присутствуют не только числовые, но и категориальные признаки (англ. ''categorical features''), то необходимо переводить категориальные признаки в числовые. Это приводит к искажению их сути и потенциальному снижению точности работы модели.
Именно поэтому было важно разработать алгоритм, который умеет работать не только с числовыми признаками, но и с категориальными напрямую, закономерности между которыми этот алгоритм будет выявлять самостоятельно, без ручной «помощи».
CatBoost {{---}} библиотека для градиентного бустинга, главным преимуществом которой является то, что она одинаково хорошо работает «из коробки» как с числовыми признаками, так и с категориальными.

Документацию по CatBoost можно найти на сайте<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/ Документация CatBoost]</ref>.

----
== Общий принцип работы ==

=== Дерево решений ===

Алгоритм работы следующий: для каждого документа имеется набор значений признаков, имеется дерево, в вершинах дерева {{---}} условия. Если условие выполнено, осуществляется переход в правого ребенка вершины, иначе в левого. Нужно пройти до листа по дереву в соответствии со значениями признаков для документа. На выходе каждому документу соответствует значение листа. Это и есть ответ.

=== Бустинг ===

Идея бустинг-подхода заключается в комбинации слабых (с невысокой обобщающей способностью) функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Результирующая функция представляет собой линейную комбинацию базовых, слабых моделей. Более подробно можно посмотреть в статье про градиентный бустинг<ref>[https://en.wikipedia.org/wiki/Gradient_boosting |Gradient Boosting, Wikipedia]</ref>.

Далее будет рассматриваться бустинг деревьев решений. Будем строить несколько деревьев, чтобы добавление новых деревьев уменьшало ошибку. Итого при достаточно большом количестве деревьев мы сможем сильно уменьшить ошибку, однако не стоит забывать, что чем больше деревьев, тем дольше обучается модель и в какой-то момент прирост качества становится незначительным.

=== Градиентный бустинг ===

* В основе CatBoost лежит градиентный бустинг.

* Градиент функции ошибки {{---}} все производные по всем значениям функции
Градиентный бустинг {{---}} метод машинного обучения, который создает решающую модель прогнозирования в виде ансамбля слабых моделей прогнозирования, обычно деревьев решений. Он строит модель поэтапно, позволяя оптимизировать произвольную дифференцируемую функцию потерь.

== Особенности CatBoost ==

=== Режимы работы ===

* Регрессия (англ. ''regression'')
* Классификация (англ. ''classification'')
Функция потерь (англ. ''loss function'') {{---}} максимизируем вероятность того, что все объекты в обучающей выборке классифицированы правильно, вероятность - это сигмоида над значением формулы.
Функция ''predict_proba'' {{---}} на выходе получаем готовые вероятности. Нужно отметить, что складывать их уже нельзя.
Функция ''predict'' {{---}} выдает необработанный результат. Такой результат можно складывать, например, с результатами других моделей.
* Мультиклассификация (англ. ''multiclass classification'')
* Ранжирование (англ. ''ranking'')
Объекты с попарной классификацией

=== Метрики ===

Поддерживает множество [[Оценка_качества_в_задачах_классификации_и_регресси|метрик]][на 28.01.19 не создан] (англ. ''metrics''), таких как:
* Регрессия: ''MAE, MAPE, RMSE, SMAPE'' etc.
* Классификация: ''Logloss , Precision, Recall, F1, CrossEntropy, BalancedAccuracy'' etc.
* Мультиклассификация: ''MultiClass, MultiClassOneVsAll, HammingLoss, F1'' etc.
* Ранжирование: ''NDCG, PrecisionAt, RecallAt, PFound, PairLogit'' etc.

== Обучение ==
=== Шаги обучения ===

* Строим дерево
* Считаем значение в листьях

=== Построение дерева ===

Процесс построения происходит жадно.

* Выбираем первую вершину
* Выбираем лучшее дерево с одной вершиной.
* Считаем метрику и по ней выбираем лучшее дерево.

Дерево строится по слоям. Гарантировано на каждом слое один и тот же сплит (условие, по которому мы делим).

=== Вычисление значений в листьях ===
Во время вычисления значений в листьях можем позволить себе сделать больше операций, так как у нас уже зафиксирована структура дерева и значения в листьях будут вычислены единожды. Поэтому можем себе позволить даже сделать несколько шагов по градиенту или применить метод Ньютона.

=== Как выбрать лучшее дерево? ===

Смотрим, на сколько меняется функция ошибки, выбираем такое дерево, чтобы оно как можно лучше приближало вектор градиентов.

=== Как работает градиентный бустинг? ===

Отметим, что существует идеальный шаг по градиенту, однако листьев в дереве меньше, чем документов в датасете.
Поэтому мы можем пытаться приближать тот самый идеальный шаг.
Чтобы найти лучший сплит, проверяем похожесть после одного шага алгоритма по градиенту.

=== Рандомизация ===

Есть рандомизация метрики, по которой выбирается лучшее дерево.
''Score += random_strength * Rand (0, lenofgrad * q)''

''q'' {{---}} множитель, уменьшающийся при увеличении итерации.
Таким образом, рандом уменьшается ближе к концу.

----

== Работа с датасетом ==

=== Режимов выборки данных ===

CatBoost поддерживает несколько режимов выборки данных

* Бутстрап (англ. ''bootstrap'') Бернулли {{---}} выбираем документ с вероятностью ''p''. Регулируется параметром ''sample_rate''
* Байесовский бутстрап {{---}} байесовское распределение. Регулируется параметром ''bagging_temp''

Отметим, что бутстрап используется только для выбора структуры дерева, для подсчета значения в листьях используем всю выборку. Это сделано, так как выбор структуры дерева происходит долго, нужно несколько раз пересчитывать значения, поэтому использовать всю выборку {{---}} слишком дорого. Однако значения в листьях с уже готовой структурой дерева считаются один раз, и для большей точности можно позволить использовать весь датасет.

=== Бинаризация признаков ===

Пробовать все {{---}} долго. Поэтому выбираем сетку заранее и ходим по ней.

Есть несколько способов выбора:

* Uniform. Равномерно разбиваем отрезок от минимума значения для данного признака до максимума.
* Медианная сетка. Задаем количество разбиений над множеством значений, далее идем по объектам в порядке сортировки и разбиваем на группы по k объектов, где k {{---}} количество объектов в одном слоте разбиения.
* UniformAndQuantiles. Комбинация 1 и 2 пунктов.
* MaxSumLog {{---}} в основе лежит динамика, работает долго.
* GreedyLogSum {{---}} аналог MaxSumLog, используется жадный алгоритм, поэтому работает не точно, однако быстрее чем MaxSumLog

=== Работа с категориальными признаками ===

* LabelEncoding {{---}} на реальных примерах точность работы низкая, так как появляется отношения порядка между объектами.
* One-hot encoding {{---}} дает неплохую точность, если различных значений признаков не много. Иначе один признак размножится на множество признаков и будет влиять на модель заведомо сильнее остальных признаков.

Лучше не делать препроцессинг самим, из-за проблем, описанных выше. В CatBoost можно задать параметр cat_features, передав туда индексы категориальных признаков. Также можно отрегулировать параметр ''one_hot_max_size'' {{---}} максимальное количество различных значений у категориального признака, чтобы он мог в последствии быть подвержен one-hot encoding.

== Подбор параметров ==

Ниже описаны гиперпараметры (англ. ''hyperparameters''), на которые стоит обратить внимание при использовании библиотеки.

* cat_features
* Overfitting detector
* Число итераций и learning rate
* L2_reg
* Random_srength
* Bagging_temp
* Глубина дерева (стоит попробовать 10 и 6)

== Полезная функциональность ==

* Snapshots
* Overfitting detector
* CV
* eval_metrics

== Бенчмарки ==

Сравнение библиотеки CatBoost с открытыми аналогами XGBoost, LightGBM и H20 на наборе публичных датасетов<ref>[https://catboost.yandex/#benchmark| Benchmarks]</ref>.

== Пример использования ==
* Делим данные на тренировочное и тестовое множество
'''from''' sklearn.model_selection '''import''' train_test_split

X_train, X_validation, y_train, y_validation = train_test_split(X, y, '''train_size'''=0.5, '''random_state'''=1234)
'''print'''(X_train.shape, X_validation.shape)

* Создаем классификатор
'''from''' catboost '''import''' CatBoostClassifier

best_model = CatBoostClassifier(
'''bagging_temperature'''=1,
'''random_strength'''=1,
'''thread_count'''=3,
'''iterations'''=500,
'''l2_leaf_reg''' = 4.0,
'''learning_rate''' = 0.07521709965938336,
'''save_snapshot'''=True,
'''snapshot_file'''='snapshot_best.bkp',
'''random_seed'''=63,
'''od_type'''='Iter',
'''od_wait'''=20,
'''custom_loss'''=['AUC', 'Accuracy'],
'''use_best_model'''=True
)

* Обучаемся

best_model.fit(
X_train, y_train,
'''cat_features'''=cat_features,
'''eval_set'''=(X_validation, y_validation),
'''logging_level'''='Silent',
'''plot'''=True
)

* Вывод числа деревьев в модели

'''print'''('Resulting tree count:', best_model.tree_count_)

> '''Resulting tree count: 217'''

* Используем скользящий контроль (англ. cross validation)
'''from''' catboost '''import''' cv

params = best_model.get_params()
params['iterations'] = 10
params['custom_loss'] = 'AUC'
del params['use_best_model']
pool1 = Pool(X, '''label'''=y, '''cat_features'''=cat_features)

cv_data = cv(
'''params''' = params,
'''pool''' = pool1,
'''fold_count'''=2,
'''inverted'''=False,
'''shuffle'''=True,
'''stratified'''=False,
'''partition_random_seed'''=0
)

* Выводим результат
best_value = np.max(cv_data['AUC_test_avg'])
best_iter = np.argmax(cv_data['AUC_test_avg'])
'''print'''('Best validation AUC score: {:.2f}±{:.2f} on step {}'.format(
best_value,
cv_data['AUC_test_stddev'][best_iter],
best_iter
))

> '''Best validation AUC score: 0.91±0.00 on step 9'''

''Больше примеров<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/python-usages-examples-docpage Примеры ипользования CatBoost]</ref> можно найти на сайте библиотеки''.

==См. также==
*[[:Дерево_решений_и_случайный_леc|Дерево решений и случайный леc]]
*[[:Бустинг,_AdaBoost|Бустинг, AdaBoost]]

==Примечания==
<references/>

== Источники информации ==
* [https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/| Overview of CatBoost]
* [https://en.wikipedia.org/wiki/Gradient_boosting| Gradient Boosting, WIkipedia]
[[Категория: Машинное обучение]]

Бустинг, AdaBoost

2019-01-28T14:38:14Z

Alexey Katsman: /* См. также */

==Описание==
'''Бустинг''' (англ. ''boosting'') — это [[Мета-обучение|мета-алгоритм машинного обучения]]. Основной идеей бустинга является комбинирование слабых функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Сильный обучающий алгоритм является классификатором, хорошо [[Корреляция случайных величин|коррелирующим]] с верной классификацией, в отличие от слабого. Наравне с бустингом в мета-обучении также рассматривают такие понятия, как [[Виды ансамблей|бэггинг]] (англ. ''bagging'') и стэкинг<ref>[https://dyakonov.org/2017/03/10/c%D1%82%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3-stacking-%D0%B8-%D0%B1%D0%BB%D0%B5%D0%BD%D0%B4%D0%B8%D0%BD%D0%B3-blending/#more-4558 Стекинг {{---}} Дьяконов Александр]</ref> (англ. ''stacking''). Бэггинг, в отличии от бустинга, использует параллельное обучение базовых классификаторов. Стэкинг же комбинирует результаты различных алгоритмов, получая тем самым более точный ответ.

Одним из недостатков бустинга является то, что он может приводить к построению громоздких композиций, состоящих из сотен алгоритмов. Такие композиции исключают возможность содержательной интерпретации, требуют больших объёмов памяти для хранения базовых алгоритмов и существенных затрат времени на вычисление классификаций.

==Алгоритмы бустинга==
{{Определение
|definition='''Композицией''' $T$ '''алгоритмов''' <tex>a_t(x) = C(b_t(x)),\ t = 1,...,T</tex> называется [[Суперпозиции|суперпозиция]] алгоритмических операторов <tex>b_t\ :\ X\to R</tex>, корректирующей операции <tex>F\ :\ R^T\to R</tex> и решающего правила <tex> C\ :\ R\to Y</tex>, где <tex>R</tex> {{---}} пространство оценок, <center><tex>a(x) = C(F(b_1(x),...,b_T(x))), x \in X</tex></center> Алгоритмы $a_t$ называют ''базовыми алгоритмами''.}}
Бустинг представляет собой композицию алгоритмов, в которых ошибки отдельных алгоритмов взаимно компенсируются. Например, в задаче классификации на два класса $Y = {-1, +1}$ в качестве пространства оценок принимают $R = \mathbb{R}$ и <tex>C(b(x)) = \textrm{sign}(b(x))</tex>. Тогда базовые алгоритмы возвращают ответы $−1, 0, +1$. Ответ $b_t(x) = 0$ означает, что базовый алгоритм $b_t$ отказывается от классификации объекта $x$, и ответ $b_t(x)$ не учитывается в композиции. Получаем искомую композицию:
<center><tex>a(x) = C(F(b_1(x),...,b_T(x))) = \textrm{sign}\left(\sum\limits_{t=1}^T \alpha_t b_t(x)\right),\ x\in X</tex></center>

Большая часть алгоритмов бустинга основывается на итеративном обучении слабых классификаторов с дальнейшей сборкой их в сильный классификатор. Когда они добавляются, им обычно приписываются веса, обычно связанные с [[Общие понятия|точностью обучения]]. После добавления слабого классификатора, веса пересчитываются ('''«пересчёт весовых коэффициентов»'''). Неверно классифицированные входные данные получают больший вес, а правильно классифицированные экземпляры теряют вес. Таким образом, дальнейшее слабое обучение фокусируется на примерах, где предыдущие слабые обучения дали ошибочную классификацию.

Основное расхождение между многими алгоритмами бустинга заключается в методах определения весовых коэффициентов точек [[Общие понятия|тренировочных данных]] и гипотез. Первым алгоритмом, который смог адаптироваться к слабому обучению был '''AdaBoost'''<ref>[http://rob.schapire.net/papers/explaining-adaboost.pdf Explaining AdaBoost {{---}} Robert E. Schapire]</ref> (сокр. ''Adaptive Boosting''), предложенный Шапире и Фройндом.

Алгоритмы бустинга могут использовать выпуклую или невыпуклую функцию потерь. Алгоритмы с выпуклой функцией, такие как AdaBoost и LogitBoost<ref>[https://en.wikipedia.org/wiki/LogitBoost Wikipedia {{---}} LogitBoost]</ref>, могут некорректно классифицировать из-за случайного шума, так как не могут обучить базовым и поддающимся научению комбинациям слабых гипотез. Алгоритмы бустинга, основанные на невыпуклой функции потерь, такие как BrownBoost<ref>[https://ru.wikipedia.org/wiki/BrownBoost Википедия {{---}} BrownBoost]</ref>, позволяют избежать переобучения на данных с большим количеством "шума", откидывая зашумленные элементы.

==Прикладное использование алгоритмов бустинга==
===Задача классификации объектов===
Если даны изображения, содержащие различные известные в мире объекты, классификатор может быть обучен на основе них для автоматической классификации объектов в будущих неизвестных изображениях. Простые классификаторы, построенные на основе некоторых признаков изображения объекта, обычно оказываются малоэффективными в классификации. Использование методов бустинга для классификации объектов — это путь объединения слабых классификаторов специальным образом для улучшения общей возможности классификации.

Классификация признаков является типичной задачей компьютерного зрения, где определяется, содержит ли изображение некоторую категорию объектов или нет. Идея тесно связана с распознаванием, идентификацией и обнаружением. Классификация по обнаружению объекта обычно содержит выделение [[Общие понятия|признаков]], обучение классификатора и применение классификатора к новым данным. Есть много способов представления категории объектов, например по анализу формы, с помощью модели '''«мешок слов»''', с помощью локальных описателей, таких как '''SIFT'''<ref>[https://en.wikipedia.org/wiki/Scale-invariant_feature_transform Wikipedia {{---}} Scale-invariant feature transform]</ref>, и так далее. Примерами классификаторов с учителем служат наивные [[Байесовская классификация|байесовские классификаторы]][на 28.01.19 не создан], [[Метод опорных векторов (SVM)|методы опорных векторов]][на 28.01.19 не создан], смесь гауссиан и [[Нейронные сети, перцептрон|нейронные сети]]. Однако исследования показали, что категории объектов и их положение в изображениях могут быть обнаружены также с помощью обучения без учителя.

===Задача ранжирования выдачи поисковых систем===
Благодаря AdaBoost в мире появился [[CatBoost|градиентный бустинг]] (англ. ''gradient boosting'') или GBM. Задачу ранжирования выдачи поисковых запросов рассмотрели с точки зрения функции потерь, которая штрафует за ошибки в порядке выдачи, поэтому было удобно внедрить GBM в ранжирование.

==AdaBoost==
===Описание===
Алгоритм может использоваться в сочетании с несколькими алгоритмами классификации для улучшения их эффективности. Алгоритм усиливает классификаторы, объединяя их в «комитет». AdaBoost является адаптивным в том смысле, что каждый следующий комитет классификаторов строится по объектам, неверно классифицированным предыдущими комитетами. AdaBoost чувствителен к шуму в данных и выбросам. Однако он менее подвержен переобучению по сравнению с другими алгоритмами машинного обучения.

AdaBoost вызывает слабые классификаторы <tex>h_i^t</tex> в цикле <tex>t = 1,...,T</tex>. После каждого вызова обновляется распределение весов <tex>D_t</tex>, которые отвечают важности каждого из объектов обучающего множества для классификации. На каждой итерации веса каждого неверно классифицированного объекта возрастают, таким образом новый комитет классификаторов «фокусирует своё внимание» на этих объектах.

===Описание алгоритма===

//<tex>x_i \in X, y_i \in Y = \{-1,+1\}, size(x) = size(y) = m</tex>
'''function''' AdaBoost($X$, $Y$, $m$):
//Инициализируем
'''for''' i = 1..m '''do''':
<tex>D_i^1 = \frac{1}{m}</tex>
'''end''' '''for'''

'''for''' t = 1..T '''do''':
<tex>h_t = \arg \min\limits_{h_j \in \mathcal{H}} \epsilon_j = \sum\limits_{i=1}^{m} D_i^t〚y_i\neq h_j(x_i)〛</tex> //$\epsilon$ {{---}} Взвешенная ошибка классификации, классификатор <tex>h_t:X\to \{-1,+1\}</tex>
<tex>\alpha_t = \frac{1}{2}\ln\frac{1-\epsilon_t}{\epsilon_t}</tex>
'''for''' i = 1..m '''do''':
//<tex>Z_t</tex> {{---}} нормализующий параметр, выбранный так, чтобы <tex>D^{t+1}</tex> являлось распределением вероятностей, то есть <tex>\sum\limits_{i-1}^{m} D_i^{t+1} = 1</tex>, для <tex>t=1,...,T</tex>
<tex>D_i^{t+1} = \dfrac{D_i^t \textrm{exp}(-\alpha_t y_i h_t(x_i))}{Z_t}</tex>
'''end''' '''for'''
'''end''' '''for'''
<tex>H(x) = \textrm{sign}\left(\sum\limits_{t=1}^{T} \alpha_t h_t(x)\right)</tex> //$H(x)$ {{---}} результирующий классификатор
'''return''' $H$
Выражение для обновления распределения <tex>D^t</tex> должно быть сконструировано таким образом, чтобы выполнялось условие:
<center><tex>\exp^{\alpha_t y_i h_t(x_i)} \begin{cases}<1,\ y(i) = h_t(x_i) \\ >1,\ y(i) \neq h_t(x_i)\end{cases}</tex></center>

Таким образом, после выбора оптимального классификатора <tex>h_t</tex> для распределения <tex>D^t</tex>, объекты <tex>x_i</tex>, которые классификатор <tex>h_t</tex> идентифицирует корректно, имеют веса меньшие, чем те, которые идентифицируются некорректно. Следовательно, когда алгоритм тестирует классификаторы на распределении <tex>D^{t+1}</tex>, он будет выбирать классификатор, который лучше идентифицирует объекты неверно распознаваемые предыдущим классификатором.

===Пример работы===
Рассмотрим набор данных, которые пометим как $-$ и $+$.
[[Файл:Adaboost1.jpg|600px|thumb|center|Результат после первой итерации]]
Для всех ошибочно классифицированных объектов увеличим веса, а для верно классифицированных уменьшим
[[Файл:Adaboost2.jpg|1000px|thumb|center|Результат после пересчета весов и второй итерации]]
Рассмотрим результат после $2$-х итераций:
[[Файл:Adaboost_result12.jpg|1000px|thumb|center|Итоговый результат после $2$-х итераций]]
Как видно из последнего изображения, все, что находиться в "цветной" зоне, мы можем однозначно классифицировать, но тогда у нас появляются ошибки и "белые" зоны, которые мы не можем однозначно классифицировать. Рассмотрим алгоритм после $30$-ти итераций:
[[Файл:Adaboost_resultfinal.jpg|300px|thumb|center|Результат работы алгоритма после $30$-ти итераций]]
Теперь у нас все объекты классифицируются верно и число ошибок на выборке равно нулю.

===Достоинства и недостатки===
'''Достоинства:'''
# Простота реализации
# Хорошая обобщающая способность. В реальных задачах удаётся строить композиции, превосходящие по качеству базовые алгоритмы. Обобщающая способность может улучшаться по мере увеличения числа базовых алгоритмов.
# Время построения композиции практически полностью определяется временем обучения базовых алгоритмов.
# Возможность идентифицировать выбросы. Это наиболее «трудные» объекты $x_i$, для которых в процессе наращивания композиции веса $w_i$ принимают наибольшие значения.
'''Недостатки:'''
# Склонен к переобучению при наличии значительного уровня шума в данных.
# Требует достаточно длинных обучающих выборок. Другие методы линейной коррекции, в частности, бэггинг, способны строить алгоритмы сопоставимого качества по меньшим выборкам данных.

===Пример кода на python для scikit-learn===
Классификатор sklearn.ensemble.'''AdaBoostClassifier'''<ref>[https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html Документация AdaBoostClassifier]</ref> имеет 5 параметров: '''base_estimator''', '''n_estimators''', '''learning_rate''', '''algorithm''', '''random_state'''.
Наиболее важными являются:
# '''base_estimator''' {{---}} базовый алгоритм. По умолчанию используется DecisionTreeClassifier(max_depth=1)
# '''n_estimators''' {{---}} максимальное количество оценок, после которого бустинг прекращается. Если произойдет полное совпадение, то закончится раньше.
# '''learning_rate''' {{---}} вклад каждой модели в весовые коэффициенты и значение по умолчанию равно $1$. Снижение этого параметра будет означать, что весовые коэффициенты буду увеличиваться или уменьшаться в небольшой степени, вынуждая модель дольше обучаться (но иногда повышается производительность).

'''from''' sklearn.ensemble '''import''' AdaBoostClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split
'''from''' sklearn '''import''' metrics

iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

abc = AdaBoostClassifier(n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.8888888888888888

Теперь рассмотрим алгоритм с SVC в качестве базы:
'''from''' sklearn.svm '''import''' SVC

svc=SVC(probability='''True''', kernel=''''linear'''')

abc = AdaBoostClassifier(base_estimator='''svc''', n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.9555555555555556

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.adaboost<ref>[https://haifengl.github.io/smile/classification.html#adaboost Smile, AdaBoost]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''ada: AdaBoost = adaboost(x, y, ntrees = 500, maxNodes = 2)
'''val '''predictions: Array['''Int'''] = x.map(ada.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, ada)

== См. также ==
*[[Метод опорных векторов (SVM)|Метод опорных векторов]][на 28.01.19 не создан]
*[[Байесовская классификация|Байесовская классификация]][на 28.01.19 не создан]
*[[Мета-обучение|Мета-обучение]]
*[[Нейронные сети, перцептрон|Нейронные сети]]
*[[Оценка качества в задаче кластеризации|Оценка качества в задаче кластеризации]]
*[[CatBoost|CatBoost]]

== Примечания==
<references />

== Источники информации ==
# [http://www.machinelearning.ru/wiki/index.php?title=AdaBoost AdaBoost] {{---}} статья на machinelearning.ru
# [http://cmp.felk.cvut.cz/~sochmj1/adaboost_talk.pdf AdaBoost] {{---}} презентация по AdaBoost
# [https://ru.coursera.org/lecture/ml-classification/example-of-adaboost-in-action-um0cX Example of AdaBoost in action] {{---}} презентация на coursera.org
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2) Курс лекций по машинному обучению] {{---}} Воронцов К.В.
[[Категория: Автоматическое машинное обучение]]
[[Категория: Машинное обучение]]

Бустинг, AdaBoost

2019-01-28T14:37:50Z

Alexey Katsman: /* Задача классификации объектов */

==Описание==
'''Бустинг''' (англ. ''boosting'') — это [[Мета-обучение|мета-алгоритм машинного обучения]]. Основной идеей бустинга является комбинирование слабых функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Сильный обучающий алгоритм является классификатором, хорошо [[Корреляция случайных величин|коррелирующим]] с верной классификацией, в отличие от слабого. Наравне с бустингом в мета-обучении также рассматривают такие понятия, как [[Виды ансамблей|бэггинг]] (англ. ''bagging'') и стэкинг<ref>[https://dyakonov.org/2017/03/10/c%D1%82%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3-stacking-%D0%B8-%D0%B1%D0%BB%D0%B5%D0%BD%D0%B4%D0%B8%D0%BD%D0%B3-blending/#more-4558 Стекинг {{---}} Дьяконов Александр]</ref> (англ. ''stacking''). Бэггинг, в отличии от бустинга, использует параллельное обучение базовых классификаторов. Стэкинг же комбинирует результаты различных алгоритмов, получая тем самым более точный ответ.

Одним из недостатков бустинга является то, что он может приводить к построению громоздких композиций, состоящих из сотен алгоритмов. Такие композиции исключают возможность содержательной интерпретации, требуют больших объёмов памяти для хранения базовых алгоритмов и существенных затрат времени на вычисление классификаций.

==Алгоритмы бустинга==
{{Определение
|definition='''Композицией''' $T$ '''алгоритмов''' <tex>a_t(x) = C(b_t(x)),\ t = 1,...,T</tex> называется [[Суперпозиции|суперпозиция]] алгоритмических операторов <tex>b_t\ :\ X\to R</tex>, корректирующей операции <tex>F\ :\ R^T\to R</tex> и решающего правила <tex> C\ :\ R\to Y</tex>, где <tex>R</tex> {{---}} пространство оценок, <center><tex>a(x) = C(F(b_1(x),...,b_T(x))), x \in X</tex></center> Алгоритмы $a_t$ называют ''базовыми алгоритмами''.}}
Бустинг представляет собой композицию алгоритмов, в которых ошибки отдельных алгоритмов взаимно компенсируются. Например, в задаче классификации на два класса $Y = {-1, +1}$ в качестве пространства оценок принимают $R = \mathbb{R}$ и <tex>C(b(x)) = \textrm{sign}(b(x))</tex>. Тогда базовые алгоритмы возвращают ответы $−1, 0, +1$. Ответ $b_t(x) = 0$ означает, что базовый алгоритм $b_t$ отказывается от классификации объекта $x$, и ответ $b_t(x)$ не учитывается в композиции. Получаем искомую композицию:
<center><tex>a(x) = C(F(b_1(x),...,b_T(x))) = \textrm{sign}\left(\sum\limits_{t=1}^T \alpha_t b_t(x)\right),\ x\in X</tex></center>

Большая часть алгоритмов бустинга основывается на итеративном обучении слабых классификаторов с дальнейшей сборкой их в сильный классификатор. Когда они добавляются, им обычно приписываются веса, обычно связанные с [[Общие понятия|точностью обучения]]. После добавления слабого классификатора, веса пересчитываются ('''«пересчёт весовых коэффициентов»'''). Неверно классифицированные входные данные получают больший вес, а правильно классифицированные экземпляры теряют вес. Таким образом, дальнейшее слабое обучение фокусируется на примерах, где предыдущие слабые обучения дали ошибочную классификацию.

Основное расхождение между многими алгоритмами бустинга заключается в методах определения весовых коэффициентов точек [[Общие понятия|тренировочных данных]] и гипотез. Первым алгоритмом, который смог адаптироваться к слабому обучению был '''AdaBoost'''<ref>[http://rob.schapire.net/papers/explaining-adaboost.pdf Explaining AdaBoost {{---}} Robert E. Schapire]</ref> (сокр. ''Adaptive Boosting''), предложенный Шапире и Фройндом.

Алгоритмы бустинга могут использовать выпуклую или невыпуклую функцию потерь. Алгоритмы с выпуклой функцией, такие как AdaBoost и LogitBoost<ref>[https://en.wikipedia.org/wiki/LogitBoost Wikipedia {{---}} LogitBoost]</ref>, могут некорректно классифицировать из-за случайного шума, так как не могут обучить базовым и поддающимся научению комбинациям слабых гипотез. Алгоритмы бустинга, основанные на невыпуклой функции потерь, такие как BrownBoost<ref>[https://ru.wikipedia.org/wiki/BrownBoost Википедия {{---}} BrownBoost]</ref>, позволяют избежать переобучения на данных с большим количеством "шума", откидывая зашумленные элементы.

==Прикладное использование алгоритмов бустинга==
===Задача классификации объектов===
Если даны изображения, содержащие различные известные в мире объекты, классификатор может быть обучен на основе них для автоматической классификации объектов в будущих неизвестных изображениях. Простые классификаторы, построенные на основе некоторых признаков изображения объекта, обычно оказываются малоэффективными в классификации. Использование методов бустинга для классификации объектов — это путь объединения слабых классификаторов специальным образом для улучшения общей возможности классификации.

Классификация признаков является типичной задачей компьютерного зрения, где определяется, содержит ли изображение некоторую категорию объектов или нет. Идея тесно связана с распознаванием, идентификацией и обнаружением. Классификация по обнаружению объекта обычно содержит выделение [[Общие понятия|признаков]], обучение классификатора и применение классификатора к новым данным. Есть много способов представления категории объектов, например по анализу формы, с помощью модели '''«мешок слов»''', с помощью локальных описателей, таких как '''SIFT'''<ref>[https://en.wikipedia.org/wiki/Scale-invariant_feature_transform Wikipedia {{---}} Scale-invariant feature transform]</ref>, и так далее. Примерами классификаторов с учителем служат наивные [[Байесовская классификация|байесовские классификаторы]][на 28.01.19 не создан], [[Метод опорных векторов (SVM)|методы опорных векторов]][на 28.01.19 не создан], смесь гауссиан и [[Нейронные сети, перцептрон|нейронные сети]]. Однако исследования показали, что категории объектов и их положение в изображениях могут быть обнаружены также с помощью обучения без учителя.

===Задача ранжирования выдачи поисковых систем===
Благодаря AdaBoost в мире появился [[CatBoost|градиентный бустинг]] (англ. ''gradient boosting'') или GBM. Задачу ранжирования выдачи поисковых запросов рассмотрели с точки зрения функции потерь, которая штрафует за ошибки в порядке выдачи, поэтому было удобно внедрить GBM в ранжирование.

==AdaBoost==
===Описание===
Алгоритм может использоваться в сочетании с несколькими алгоритмами классификации для улучшения их эффективности. Алгоритм усиливает классификаторы, объединяя их в «комитет». AdaBoost является адаптивным в том смысле, что каждый следующий комитет классификаторов строится по объектам, неверно классифицированным предыдущими комитетами. AdaBoost чувствителен к шуму в данных и выбросам. Однако он менее подвержен переобучению по сравнению с другими алгоритмами машинного обучения.

AdaBoost вызывает слабые классификаторы <tex>h_i^t</tex> в цикле <tex>t = 1,...,T</tex>. После каждого вызова обновляется распределение весов <tex>D_t</tex>, которые отвечают важности каждого из объектов обучающего множества для классификации. На каждой итерации веса каждого неверно классифицированного объекта возрастают, таким образом новый комитет классификаторов «фокусирует своё внимание» на этих объектах.

===Описание алгоритма===

//<tex>x_i \in X, y_i \in Y = \{-1,+1\}, size(x) = size(y) = m</tex>
'''function''' AdaBoost($X$, $Y$, $m$):
//Инициализируем
'''for''' i = 1..m '''do''':
<tex>D_i^1 = \frac{1}{m}</tex>
'''end''' '''for'''

'''for''' t = 1..T '''do''':
<tex>h_t = \arg \min\limits_{h_j \in \mathcal{H}} \epsilon_j = \sum\limits_{i=1}^{m} D_i^t〚y_i\neq h_j(x_i)〛</tex> //$\epsilon$ {{---}} Взвешенная ошибка классификации, классификатор <tex>h_t:X\to \{-1,+1\}</tex>
<tex>\alpha_t = \frac{1}{2}\ln\frac{1-\epsilon_t}{\epsilon_t}</tex>
'''for''' i = 1..m '''do''':
//<tex>Z_t</tex> {{---}} нормализующий параметр, выбранный так, чтобы <tex>D^{t+1}</tex> являлось распределением вероятностей, то есть <tex>\sum\limits_{i-1}^{m} D_i^{t+1} = 1</tex>, для <tex>t=1,...,T</tex>
<tex>D_i^{t+1} = \dfrac{D_i^t \textrm{exp}(-\alpha_t y_i h_t(x_i))}{Z_t}</tex>
'''end''' '''for'''
'''end''' '''for'''
<tex>H(x) = \textrm{sign}\left(\sum\limits_{t=1}^{T} \alpha_t h_t(x)\right)</tex> //$H(x)$ {{---}} результирующий классификатор
'''return''' $H$
Выражение для обновления распределения <tex>D^t</tex> должно быть сконструировано таким образом, чтобы выполнялось условие:
<center><tex>\exp^{\alpha_t y_i h_t(x_i)} \begin{cases}<1,\ y(i) = h_t(x_i) \\ >1,\ y(i) \neq h_t(x_i)\end{cases}</tex></center>

Таким образом, после выбора оптимального классификатора <tex>h_t</tex> для распределения <tex>D^t</tex>, объекты <tex>x_i</tex>, которые классификатор <tex>h_t</tex> идентифицирует корректно, имеют веса меньшие, чем те, которые идентифицируются некорректно. Следовательно, когда алгоритм тестирует классификаторы на распределении <tex>D^{t+1}</tex>, он будет выбирать классификатор, который лучше идентифицирует объекты неверно распознаваемые предыдущим классификатором.

===Пример работы===
Рассмотрим набор данных, которые пометим как $-$ и $+$.
[[Файл:Adaboost1.jpg|600px|thumb|center|Результат после первой итерации]]
Для всех ошибочно классифицированных объектов увеличим веса, а для верно классифицированных уменьшим
[[Файл:Adaboost2.jpg|1000px|thumb|center|Результат после пересчета весов и второй итерации]]
Рассмотрим результат после $2$-х итераций:
[[Файл:Adaboost_result12.jpg|1000px|thumb|center|Итоговый результат после $2$-х итераций]]
Как видно из последнего изображения, все, что находиться в "цветной" зоне, мы можем однозначно классифицировать, но тогда у нас появляются ошибки и "белые" зоны, которые мы не можем однозначно классифицировать. Рассмотрим алгоритм после $30$-ти итераций:
[[Файл:Adaboost_resultfinal.jpg|300px|thumb|center|Результат работы алгоритма после $30$-ти итераций]]
Теперь у нас все объекты классифицируются верно и число ошибок на выборке равно нулю.

===Достоинства и недостатки===
'''Достоинства:'''
# Простота реализации
# Хорошая обобщающая способность. В реальных задачах удаётся строить композиции, превосходящие по качеству базовые алгоритмы. Обобщающая способность может улучшаться по мере увеличения числа базовых алгоритмов.
# Время построения композиции практически полностью определяется временем обучения базовых алгоритмов.
# Возможность идентифицировать выбросы. Это наиболее «трудные» объекты $x_i$, для которых в процессе наращивания композиции веса $w_i$ принимают наибольшие значения.
'''Недостатки:'''
# Склонен к переобучению при наличии значительного уровня шума в данных.
# Требует достаточно длинных обучающих выборок. Другие методы линейной коррекции, в частности, бэггинг, способны строить алгоритмы сопоставимого качества по меньшим выборкам данных.

===Пример кода на python для scikit-learn===
Классификатор sklearn.ensemble.'''AdaBoostClassifier'''<ref>[https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html Документация AdaBoostClassifier]</ref> имеет 5 параметров: '''base_estimator''', '''n_estimators''', '''learning_rate''', '''algorithm''', '''random_state'''.
Наиболее важными являются:
# '''base_estimator''' {{---}} базовый алгоритм. По умолчанию используется DecisionTreeClassifier(max_depth=1)
# '''n_estimators''' {{---}} максимальное количество оценок, после которого бустинг прекращается. Если произойдет полное совпадение, то закончится раньше.
# '''learning_rate''' {{---}} вклад каждой модели в весовые коэффициенты и значение по умолчанию равно $1$. Снижение этого параметра будет означать, что весовые коэффициенты буду увеличиваться или уменьшаться в небольшой степени, вынуждая модель дольше обучаться (но иногда повышается производительность).

'''from''' sklearn.ensemble '''import''' AdaBoostClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split
'''from''' sklearn '''import''' metrics

iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

abc = AdaBoostClassifier(n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.8888888888888888

Теперь рассмотрим алгоритм с SVC в качестве базы:
'''from''' sklearn.svm '''import''' SVC

svc=SVC(probability='''True''', kernel=''''linear'''')

abc = AdaBoostClassifier(base_estimator='''svc''', n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.9555555555555556

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.adaboost<ref>[https://haifengl.github.io/smile/classification.html#adaboost Smile, AdaBoost]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''ada: AdaBoost = adaboost(x, y, ntrees = 500, maxNodes = 2)
'''val '''predictions: Array['''Int'''] = x.map(ada.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, ada)

== См. также ==
*[[Метод опорных векторов (SVM)|Метод опорных векторов]]
*[[Байесовская классификация|Байесовская классификация]]
*[[Мета-обучение|Мета-обучение]]
*[[Нейронные сети, перцептрон|Нейронные сети]]
*[[Оценка качества в задаче кластеризации|Оценка качества в задаче кластеризации]]
*[[CatBoost|CatBoost]]

== Примечания==
<references />

== Источники информации ==
# [http://www.machinelearning.ru/wiki/index.php?title=AdaBoost AdaBoost] {{---}} статья на machinelearning.ru
# [http://cmp.felk.cvut.cz/~sochmj1/adaboost_talk.pdf AdaBoost] {{---}} презентация по AdaBoost
# [https://ru.coursera.org/lecture/ml-classification/example-of-adaboost-in-action-um0cX Example of AdaBoost in action] {{---}} презентация на coursera.org
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2) Курс лекций по машинному обучению] {{---}} Воронцов К.В.
[[Категория: Автоматическое машинное обучение]]
[[Категория: Машинное обучение]]

Бустинг, AdaBoost

2019-01-28T14:37:32Z

Alexey Katsman: /* Описание */

==Описание==
'''Бустинг''' (англ. ''boosting'') — это [[Мета-обучение|мета-алгоритм машинного обучения]]. Основной идеей бустинга является комбинирование слабых функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Сильный обучающий алгоритм является классификатором, хорошо [[Корреляция случайных величин|коррелирующим]] с верной классификацией, в отличие от слабого. Наравне с бустингом в мета-обучении также рассматривают такие понятия, как [[Виды ансамблей|бэггинг]] (англ. ''bagging'') и стэкинг<ref>[https://dyakonov.org/2017/03/10/c%D1%82%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3-stacking-%D0%B8-%D0%B1%D0%BB%D0%B5%D0%BD%D0%B4%D0%B8%D0%BD%D0%B3-blending/#more-4558 Стекинг {{---}} Дьяконов Александр]</ref> (англ. ''stacking''). Бэггинг, в отличии от бустинга, использует параллельное обучение базовых классификаторов. Стэкинг же комбинирует результаты различных алгоритмов, получая тем самым более точный ответ.

Одним из недостатков бустинга является то, что он может приводить к построению громоздких композиций, состоящих из сотен алгоритмов. Такие композиции исключают возможность содержательной интерпретации, требуют больших объёмов памяти для хранения базовых алгоритмов и существенных затрат времени на вычисление классификаций.

==Алгоритмы бустинга==
{{Определение
|definition='''Композицией''' $T$ '''алгоритмов''' <tex>a_t(x) = C(b_t(x)),\ t = 1,...,T</tex> называется [[Суперпозиции|суперпозиция]] алгоритмических операторов <tex>b_t\ :\ X\to R</tex>, корректирующей операции <tex>F\ :\ R^T\to R</tex> и решающего правила <tex> C\ :\ R\to Y</tex>, где <tex>R</tex> {{---}} пространство оценок, <center><tex>a(x) = C(F(b_1(x),...,b_T(x))), x \in X</tex></center> Алгоритмы $a_t$ называют ''базовыми алгоритмами''.}}
Бустинг представляет собой композицию алгоритмов, в которых ошибки отдельных алгоритмов взаимно компенсируются. Например, в задаче классификации на два класса $Y = {-1, +1}$ в качестве пространства оценок принимают $R = \mathbb{R}$ и <tex>C(b(x)) = \textrm{sign}(b(x))</tex>. Тогда базовые алгоритмы возвращают ответы $−1, 0, +1$. Ответ $b_t(x) = 0$ означает, что базовый алгоритм $b_t$ отказывается от классификации объекта $x$, и ответ $b_t(x)$ не учитывается в композиции. Получаем искомую композицию:
<center><tex>a(x) = C(F(b_1(x),...,b_T(x))) = \textrm{sign}\left(\sum\limits_{t=1}^T \alpha_t b_t(x)\right),\ x\in X</tex></center>

Большая часть алгоритмов бустинга основывается на итеративном обучении слабых классификаторов с дальнейшей сборкой их в сильный классификатор. Когда они добавляются, им обычно приписываются веса, обычно связанные с [[Общие понятия|точностью обучения]]. После добавления слабого классификатора, веса пересчитываются ('''«пересчёт весовых коэффициентов»'''). Неверно классифицированные входные данные получают больший вес, а правильно классифицированные экземпляры теряют вес. Таким образом, дальнейшее слабое обучение фокусируется на примерах, где предыдущие слабые обучения дали ошибочную классификацию.

Основное расхождение между многими алгоритмами бустинга заключается в методах определения весовых коэффициентов точек [[Общие понятия|тренировочных данных]] и гипотез. Первым алгоритмом, который смог адаптироваться к слабому обучению был '''AdaBoost'''<ref>[http://rob.schapire.net/papers/explaining-adaboost.pdf Explaining AdaBoost {{---}} Robert E. Schapire]</ref> (сокр. ''Adaptive Boosting''), предложенный Шапире и Фройндом.

Алгоритмы бустинга могут использовать выпуклую или невыпуклую функцию потерь. Алгоритмы с выпуклой функцией, такие как AdaBoost и LogitBoost<ref>[https://en.wikipedia.org/wiki/LogitBoost Wikipedia {{---}} LogitBoost]</ref>, могут некорректно классифицировать из-за случайного шума, так как не могут обучить базовым и поддающимся научению комбинациям слабых гипотез. Алгоритмы бустинга, основанные на невыпуклой функции потерь, такие как BrownBoost<ref>[https://ru.wikipedia.org/wiki/BrownBoost Википедия {{---}} BrownBoost]</ref>, позволяют избежать переобучения на данных с большим количеством "шума", откидывая зашумленные элементы.

==Прикладное использование алгоритмов бустинга==
===Задача классификации объектов===
Если даны изображения, содержащие различные известные в мире объекты, классификатор может быть обучен на основе них для автоматической классификации объектов в будущих неизвестных изображениях. Простые классификаторы, построенные на основе некоторых признаков изображения объекта, обычно оказываются малоэффективными в классификации. Использование методов бустинга для классификации объектов — это путь объединения слабых классификаторов специальным образом для улучшения общей возможности классификации.

Классификация признаков является типичной задачей компьютерного зрения, где определяется, содержит ли изображение некоторую категорию объектов или нет. Идея тесно связана с распознаванием, идентификацией и обнаружением. Классификация по обнаружению объекта обычно содержит выделение [[Общие понятия|признаков]], обучение классификатора и применение классификатора к новым данным. Есть много способов представления категории объектов, например по анализу формы, с помощью модели '''«мешок слов»''', с помощью локальных описателей, таких как '''SIFT'''<ref>[https://en.wikipedia.org/wiki/Scale-invariant_feature_transform Wikipedia {{---}} Scale-invariant feature transform]</ref>, и так далее. Примерами классификаторов с учителем служат наивные [[Байесовская классификация|байесовские классификаторы]][на 22.01.19 не создан], [[Метод опорных векторов (SVM)|методы опорных векторов]][на 22.01.19 не создан], смесь гауссиан и [[Нейронные сети, перцептрон|нейронные сети]]. Однако исследования показали, что категории объектов и их положение в изображениях могут быть обнаружены также с помощью обучения без учителя.

===Задача ранжирования выдачи поисковых систем===
Благодаря AdaBoost в мире появился [[CatBoost|градиентный бустинг]] (англ. ''gradient boosting'') или GBM. Задачу ранжирования выдачи поисковых запросов рассмотрели с точки зрения функции потерь, которая штрафует за ошибки в порядке выдачи, поэтому было удобно внедрить GBM в ранжирование.

==AdaBoost==
===Описание===
Алгоритм может использоваться в сочетании с несколькими алгоритмами классификации для улучшения их эффективности. Алгоритм усиливает классификаторы, объединяя их в «комитет». AdaBoost является адаптивным в том смысле, что каждый следующий комитет классификаторов строится по объектам, неверно классифицированным предыдущими комитетами. AdaBoost чувствителен к шуму в данных и выбросам. Однако он менее подвержен переобучению по сравнению с другими алгоритмами машинного обучения.

AdaBoost вызывает слабые классификаторы <tex>h_i^t</tex> в цикле <tex>t = 1,...,T</tex>. После каждого вызова обновляется распределение весов <tex>D_t</tex>, которые отвечают важности каждого из объектов обучающего множества для классификации. На каждой итерации веса каждого неверно классифицированного объекта возрастают, таким образом новый комитет классификаторов «фокусирует своё внимание» на этих объектах.

===Описание алгоритма===

//<tex>x_i \in X, y_i \in Y = \{-1,+1\}, size(x) = size(y) = m</tex>
'''function''' AdaBoost($X$, $Y$, $m$):
//Инициализируем
'''for''' i = 1..m '''do''':
<tex>D_i^1 = \frac{1}{m}</tex>
'''end''' '''for'''

'''for''' t = 1..T '''do''':
<tex>h_t = \arg \min\limits_{h_j \in \mathcal{H}} \epsilon_j = \sum\limits_{i=1}^{m} D_i^t〚y_i\neq h_j(x_i)〛</tex> //$\epsilon$ {{---}} Взвешенная ошибка классификации, классификатор <tex>h_t:X\to \{-1,+1\}</tex>
<tex>\alpha_t = \frac{1}{2}\ln\frac{1-\epsilon_t}{\epsilon_t}</tex>
'''for''' i = 1..m '''do''':
//<tex>Z_t</tex> {{---}} нормализующий параметр, выбранный так, чтобы <tex>D^{t+1}</tex> являлось распределением вероятностей, то есть <tex>\sum\limits_{i-1}^{m} D_i^{t+1} = 1</tex>, для <tex>t=1,...,T</tex>
<tex>D_i^{t+1} = \dfrac{D_i^t \textrm{exp}(-\alpha_t y_i h_t(x_i))}{Z_t}</tex>
'''end''' '''for'''
'''end''' '''for'''
<tex>H(x) = \textrm{sign}\left(\sum\limits_{t=1}^{T} \alpha_t h_t(x)\right)</tex> //$H(x)$ {{---}} результирующий классификатор
'''return''' $H$
Выражение для обновления распределения <tex>D^t</tex> должно быть сконструировано таким образом, чтобы выполнялось условие:
<center><tex>\exp^{\alpha_t y_i h_t(x_i)} \begin{cases}<1,\ y(i) = h_t(x_i) \\ >1,\ y(i) \neq h_t(x_i)\end{cases}</tex></center>

Таким образом, после выбора оптимального классификатора <tex>h_t</tex> для распределения <tex>D^t</tex>, объекты <tex>x_i</tex>, которые классификатор <tex>h_t</tex> идентифицирует корректно, имеют веса меньшие, чем те, которые идентифицируются некорректно. Следовательно, когда алгоритм тестирует классификаторы на распределении <tex>D^{t+1}</tex>, он будет выбирать классификатор, который лучше идентифицирует объекты неверно распознаваемые предыдущим классификатором.

===Пример работы===
Рассмотрим набор данных, которые пометим как $-$ и $+$.
[[Файл:Adaboost1.jpg|600px|thumb|center|Результат после первой итерации]]
Для всех ошибочно классифицированных объектов увеличим веса, а для верно классифицированных уменьшим
[[Файл:Adaboost2.jpg|1000px|thumb|center|Результат после пересчета весов и второй итерации]]
Рассмотрим результат после $2$-х итераций:
[[Файл:Adaboost_result12.jpg|1000px|thumb|center|Итоговый результат после $2$-х итераций]]
Как видно из последнего изображения, все, что находиться в "цветной" зоне, мы можем однозначно классифицировать, но тогда у нас появляются ошибки и "белые" зоны, которые мы не можем однозначно классифицировать. Рассмотрим алгоритм после $30$-ти итераций:
[[Файл:Adaboost_resultfinal.jpg|300px|thumb|center|Результат работы алгоритма после $30$-ти итераций]]
Теперь у нас все объекты классифицируются верно и число ошибок на выборке равно нулю.

===Достоинства и недостатки===
'''Достоинства:'''
# Простота реализации
# Хорошая обобщающая способность. В реальных задачах удаётся строить композиции, превосходящие по качеству базовые алгоритмы. Обобщающая способность может улучшаться по мере увеличения числа базовых алгоритмов.
# Время построения композиции практически полностью определяется временем обучения базовых алгоритмов.
# Возможность идентифицировать выбросы. Это наиболее «трудные» объекты $x_i$, для которых в процессе наращивания композиции веса $w_i$ принимают наибольшие значения.
'''Недостатки:'''
# Склонен к переобучению при наличии значительного уровня шума в данных.
# Требует достаточно длинных обучающих выборок. Другие методы линейной коррекции, в частности, бэггинг, способны строить алгоритмы сопоставимого качества по меньшим выборкам данных.

===Пример кода на python для scikit-learn===
Классификатор sklearn.ensemble.'''AdaBoostClassifier'''<ref>[https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html Документация AdaBoostClassifier]</ref> имеет 5 параметров: '''base_estimator''', '''n_estimators''', '''learning_rate''', '''algorithm''', '''random_state'''.
Наиболее важными являются:
# '''base_estimator''' {{---}} базовый алгоритм. По умолчанию используется DecisionTreeClassifier(max_depth=1)
# '''n_estimators''' {{---}} максимальное количество оценок, после которого бустинг прекращается. Если произойдет полное совпадение, то закончится раньше.
# '''learning_rate''' {{---}} вклад каждой модели в весовые коэффициенты и значение по умолчанию равно $1$. Снижение этого параметра будет означать, что весовые коэффициенты буду увеличиваться или уменьшаться в небольшой степени, вынуждая модель дольше обучаться (но иногда повышается производительность).

'''from''' sklearn.ensemble '''import''' AdaBoostClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split
'''from''' sklearn '''import''' metrics

iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

abc = AdaBoostClassifier(n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.8888888888888888

Теперь рассмотрим алгоритм с SVC в качестве базы:
'''from''' sklearn.svm '''import''' SVC

svc=SVC(probability='''True''', kernel=''''linear'''')

abc = AdaBoostClassifier(base_estimator='''svc''', n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.9555555555555556

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.adaboost<ref>[https://haifengl.github.io/smile/classification.html#adaboost Smile, AdaBoost]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''ada: AdaBoost = adaboost(x, y, ntrees = 500, maxNodes = 2)
'''val '''predictions: Array['''Int'''] = x.map(ada.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, ada)

== См. также ==
*[[Метод опорных векторов (SVM)|Метод опорных векторов]]
*[[Байесовская классификация|Байесовская классификация]]
*[[Мета-обучение|Мета-обучение]]
*[[Нейронные сети, перцептрон|Нейронные сети]]
*[[Оценка качества в задаче кластеризации|Оценка качества в задаче кластеризации]]
*[[CatBoost|CatBoost]]

== Примечания==
<references />

== Источники информации ==
# [http://www.machinelearning.ru/wiki/index.php?title=AdaBoost AdaBoost] {{---}} статья на machinelearning.ru
# [http://cmp.felk.cvut.cz/~sochmj1/adaboost_talk.pdf AdaBoost] {{---}} презентация по AdaBoost
# [https://ru.coursera.org/lecture/ml-classification/example-of-adaboost-in-action-um0cX Example of AdaBoost in action] {{---}} презентация на coursera.org
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2) Курс лекций по машинному обучению] {{---}} Воронцов К.В.
[[Категория: Автоматическое машинное обучение]]
[[Категория: Машинное обучение]]

Иерархическая кластеризация

2019-01-28T14:36:39Z

Alexey Katsman: /* См. также */

{{Определение
|definition =
'''Иерархическая кластеризация''' (англ. ''hierarchical clustering'') — множество алгоритмов
кластеризации, направленных на создание иерархии вложенных разбиений исходного множества объектов.
}}
Иерархические алгоритмы кластеризации часто называют '''алгоритмами таксономии'''.
Для визуального представления результатов кластеризации используется '''дендрограмма'''
{{---}} дерево, построенное по матрице мер близости между кластерами. В узлах дерева находятся подмножества объектов из обучающей выборки.
При этом на каждом ярусе дерева множество объектов из всех узлов составляет исходное множество объектов.
Объединение узлов между ярусами соответствует слиянию двух кластеров. При этом длина ребра соответствует расстоянию между кластерами.

== Алгоритм иерархической кластеризации ==
Дерево строится от листьев к корню. В начальный момент времени каждый объект содержится в собственном кластере.
Далее происходит итеративный процесс слияния двух ближайших кластеров до тех пор, пока все кластеры не объединятся в один или не будет найдено необходимое число кластеров.
На каждом шаге необходимо уметь вычислять расстояние между кластерами и пересчитывать расстояние между новыми кластерами.
Расстояние между одноэлементными кластерами определяется через расстояние между объектами: <tex>\mathrm{R}(\{x\}, \{y\}) = \rho(x, y)</tex>.
Для вычисления расстояния <tex>\mathrm{R}(U, V)</tex> между кластерами <tex>\mathrm{U}</tex> и <tex>\mathrm{V}</tex> на практике используются различные функции в зависимости от специфики задачи.

== Функции расстояния между кластерами ==
* '''Метод одиночной связи''' (англ. ''single linkage'')
: <tex>\mathrm{R_{min}}(U, V) = \displaystyle\min_{u \in U, v \in V} \rho(u, v)</tex>
* '''Метод полной связи''' (англ. ''complete linkage'')
: <tex>\mathrm{R_{max}}(U, V) = \displaystyle\max_{u \in U, v \in V} \rho(u, v)</tex>
* '''Метод средней связи''' (англ. ''UPGMA (Unweighted Pair Group Method with Arithmetic mean)'')
: <tex>\mathrm{R_{avg}}(U, V) = \displaystyle\dfrac{1}{|U| \cdot |V|}\sum_{u \in U} \sum_{v \in V} \rho(u, v)</tex>
* '''Центроидный метод''' (англ. ''UPGMC (Unweighted Pair Group Method with Centroid average)'')
: <tex>\mathrm{R_{c}}(U, V) = \displaystyle\rho^2\left(\sum_{u \in U}\dfrac{u}{|U|}, \sum_{v \in V}\dfrac{v}{|V|}\right)</tex>
* '''Метод Уорда''' (англ. ''Ward's method'')
: <tex>\mathrm{R_{ward}}(U, V) = \displaystyle\dfrac{|U| \cdot |V|}{|U| + |V|}\rho^2\left(\sum_{u \in U}\dfrac{u}{|U|}, \sum_{v \in V}\dfrac{v}{|V|}\right)</tex>

== Формула Ланса-Уильямса ==
На каждом шаге необходимо уметь быстро подсчитывать расстояние от образовавшегося кластера <tex>\mathrm{W}=\mathrm{U}\cup\mathrm{V}</tex> до любого другого кластера <tex>\mathrm{S}</tex>, используя известные расстояния с предыдущих шагов.
Это легко выполняется при использовании формулы, предложенной Лансом и Уильямсом в 1967 году:
<center><tex>\mathrm{R}(W, S) = \alpha_U \cdot \mathrm{R}(U, S) + \alpha_V \cdot \mathrm{R}(V, S) + \beta \cdot \mathrm{R}(U, V) + \gamma \cdot |\mathrm{R}(U, S) - \mathrm{R}(V, S)| </tex></center>
, где <tex>\alpha_U, \alpha_V, \beta, \gamma </tex> {{---}} числовые параметры.

Каждая из указанных выше функций расстояния удовлетворяет формуле Ланса-Уильямса со следующими коэффициентами:
* '''Метод одиночной связи''' (англ. ''single linkage'')
: <tex>\alpha_U = \dfrac{1}{2}, \alpha_V = \dfrac{1}{2}, \beta = 0, \gamma = -\dfrac{1}{2}</tex>
* '''Метод полной связи''' (англ. ''complete linkage'')
: <tex>\alpha_U = \dfrac{1}{2}, \alpha_V = \dfrac{1}{2}, \beta = 0, \gamma = \dfrac{1}{2} </tex>
* '''Метод средней связи''' (англ. ''UPGMA (Unweighted Pair Group Method with Arithmetic mean)'')
: <tex>\alpha_U = \dfrac{|U|}{|W|}, \alpha_V = \dfrac{|V|}{|W|}, \beta = 0, \gamma = 0 </tex>
* '''Центроидный метод''' (англ. ''UPGMC (Unweighted Pair Group Method with Centroid average)'')
: <tex>\alpha_U = \dfrac{|U|}{|W|}, \alpha_V = \dfrac{|V|}{|W|}, \beta = -\alpha_U \cdot \alpha_V, \gamma = 0</tex>
* '''Метод Уорда''' (англ. ''Ward's method'')
: <tex>\alpha_U = \dfrac{|S|+|U|}{|S|+|W|}, \alpha_V = \dfrac{|S|+|V|}{|S|+|W|}, \beta = \dfrac{-|S|}{|S|+|W|}, \gamma = 0 </tex>

== Свойство монотонности ==
Введем обозначение <tex>\mathrm{R_t}</tex> {{---}} расстояние между кластерами, выбранными на шаге <tex>t</tex> для объединения.

Дендрограмма позволяет представлять зависимости между множеством объектов с любым числом заданных характеристик
на двумерном графике, где по одной из осей откладываются все объекты, а по другой {{---}} расстояние <tex>\mathrm{R_t}</tex>.
Если не накладывать на это расстояние никаких ограничений, то дендрограмма будет иметь большое число самопересечений и изображение перестанет быть наглядным.
Чтобы любой кластер мог быть представлен в виде непрерывного отрезка на оси объектов и ребра не пересекались,
необходимо наложить ограничение монотонности на <tex>\mathrm{R_t}</tex>.
{{Определение
|definition =
Функция расстояния <tex>\mathrm{R}</tex> является '''монотонной''', если на каждом следующем шаге расстояние между кластерами не уменьшается:
<tex>\mathrm{R_2} \leqslant \mathrm{R_3} \leqslant \dots \leqslant \mathrm{R_m}</tex>
}}

Расстояние является монотонным, если для коэффициентов в формул Ланса-Уильямса верна теорема Миллигана.
{{Теорема
|author=Миллиган, 1979
|statement=Если выполняются следующие три условия, то кластеризация является монотонной:
# <tex>\alpha_U \geqslant 0, \alpha_V \geqslant 0 </tex>;
# <tex>\alpha_U + \alpha_V + \beta \geqslant 1</tex>;
# <tex>\min\{\alpha_U, \alpha_V\} + \gamma \geqslant 0 </tex>.
}}

Из перечисленных выше расстояний теореме удовлетворяют все, кроме центроидного.

== Определение числа кластеров ==
Для определения числа кластеров находится интервал максимальной длины <tex>|\mathrm{R_{t+1}} - \mathrm{R_t}|</tex>.
В качестве итоговых кластеров выдаются кластеры, полученные на шаге <tex>\mathrm{t}</tex>.
При этом число кластеров равно <tex>m - t + 1</tex>.

Однако, когда число кластеров заранее неизвестно и объектов в выборке не очень много, бывает полезно изучить дендрограмму целиком.

== Псевдокод ==
// алгоритм принимает множество объектов и возвращает множество кластеров для каждого шага 
'''function''' hierarchy(X: '''Set<Object>'''): '''Set<Set<Object>>'''
t = 1
<tex>\mathrm{C_t} = {{x_1}, \dots, {x_m}}</tex>
'''for''' i = 2 '''to''' m
<tex>\langle U, V \rangle = \displaystyle \arg \min_{U \neq V, U \in C_{i-1}, V \in C_{i-1}} R(U, V)</tex>
<tex>\mathrm{R_{t}} = \mathrm{R}(U, V)</tex>
<tex>\mathrm{C_{i}} = \mathrm{C_{i-1}} \cup \{\mathrm{W}\} \setminus \{\mathrm{U}, \mathrm{V}\}</tex>
'''for''' <tex> S </tex> '''in''' <tex> C_t </tex>
<tex>\mathrm{R_{i}}(W, S) = \alpha_U \cdot \mathrm{R_{i-1}}(U, S) + \alpha_V \cdot \mathrm{R_{i-1}}(V, S) + \beta \cdot \mathrm{R_{i-1}}(U, V) + \gamma \cdot |\mathrm{R_{i-1}}(U, S) - \mathrm{R{i-1}}(V, S)| </tex>
'''return''' <tex> C </tex>

== Пример ==
# Подключение библиотек
from scipy.cluster.hierarchy import linkage, dendrogram
from sklearn import datasets
import matplotlib.pyplot as plt
<tex></tex>
# Создание полотна для рисования
fig = plt.figure(figsize=(15, 30))
fig.patch.set_facecolor('white')
<tex></tex>
# Загрузка набора данных "Ирисы Фишера"
iris = datasets.load_iris()
<tex></tex>
# Реализация иерархической кластеризации при помощи функции linkage
mergings = linkage(iris.data, method='ward')
<tex></tex>
# Построение дендрограммы. Разными цветами выделены автоматически определенные кластеры
R = dendrogram(mergings, labels=[iris.target_names[i] for i in iris.target], orientation = 'left', leaf_font_size = 12)
<tex></tex>
# Отображение дендрограммы
plt.show()

{| class="wikitable"
| style="text-align:center; font-weight:bold;" colspan = 4 |Дендрограммы кластеризации ирисов Фишера<ref>[https://ru.wikipedia.org/wiki/%D0%98%D1%80%D0%B8%D1%81%D1%8B_%D0%A4%D0%B8%D1%88%D0%B5%D1%80%D0%B0 Википедия {{---}} Ирисы Фишера]</ref> в зависимости от функции расстояния между кластерами
|-
| style="padding:5px;" |[[Файл:hierarchy_min.png|350px|Расстояние минимума.]]
| style="padding:5px;" |[[Файл:hierarchy_max.png|350px|Расстояние максимума.]]
|-
| style="text-align:center;" | Метод одиночной связи
| style="text-align:center;" | Метод полной связи
|-
| style="padding:5px;" |[[Файл:hierarchy_avg.png|350px|Расстояние среднего.]]
| style="padding:5px;" |[[Файл:hierarchy_ward.png|350px|Расстояние Уорда.]]
|-
| style="text-align:center;" | Метод средней связи
| style="text-align:center;" | Метод Уорда
|}

Лучше всего с задачей справился алгоритм с использованием расстояния Уорда. Он точно выделил класс ''Iris setosa'' и заметно отделил вид ''Iris virginica'' от ''Iris versicolor''.

== См. также ==
* [[Кластеризация|Кластеризация]]
* [[Оценка_качества_в_задаче_кластеризации|Оценка качества в задаче кластеризации]]
* [[EM-алгоритм|EM-алгоритм]][на 28.01.18 не создан]
* [[k-средних|<tex>\mathrm{k}</tex>-средних]][на 28.01.18 не создан]

== Примечания ==
<references/>

== Источники информации ==

* [https://ru.wikipedia.org/wiki/%D0%98%D0%B5%D1%80%D0%B0%D1%80%D1%85%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BA%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F Википедия {{---}} Иерархическая кластеризация]
* [https://docs.scipy.org/doc/scipy/reference/cluster.hierarchy.html Scipy Documentation {{---}} Hierarchical clustering (scipy.cluster.hierarchy)]
* [http://www.machinelearning.ru/wiki/images/c/ca/Voron-ML-Clustering.pdf К.В.Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования]
* G. N. Lance, W. T. Williams; A General Theory of Classificatory Sorting Strategies: 1. Hierarchical Systems, The Computer Journal, Volume 9, Issue 4, 1 February 1967, Pages 373–380

[[Категория: Машинное обучение]]
[[Категория: Кластеризация]]

Кластеризация

2019-01-28T14:36:05Z

Alexey Katsman: /* Методы кластеризации */

[[Файл:clusters.png|thumb|300px|Пример кластеризации]]
'''Кластеризация''' (англ. ''cluster analysis'') {{---}} задача группировки множества объектов на подмножества ('''кластеры''') таким образом,
чтобы объекты из одного кластера были более похожи друг на друга, чем на объекты из других кластеров по какому-либо критерию.

Задача кластеризации относится к классу задач обучения без учителя.
== Постановка задачи кластеризации ==
Пусть <tex>X</tex> {{---}} множество объектов, <tex>Y</tex> {{---}} множество идентификаторов (меток) кластеров.
На множестве <tex>X</tex> задана функция расстояния между объектами <tex>\rho(x,x')</tex>.
Дана конечная обучающая выборка объектов <tex>X^m = \{ x_1, \dots, x_m \} \subset X</tex>.
Необходимо разбить выборку на подмножества (кластеры), то есть каждому объекту <tex>x_i \in X^m</tex> сопоставить метку <tex>y_i \in Y</tex>,
таким образом чтобы объекты внутри каждого кластера были близки относительно метрики <tex>\rho</tex>, а объекты из разных кластеров значительно различались.
{{Определение
|definition =
'''Алгоритм кластеризации''' — функция <tex>a\colon X\to Y</tex>, которая любому объекту <tex>x\in X</tex> ставит в соответствие идентификатор кластера <tex>y\in Y</tex>.
}}
Множество <tex>Y</tex> в некоторых случаях известно заранее, однако чаще ставится задача
определить оптимальное число кластеров, с точки зрения того или иного ''критерия качества'' кластеризации.

Кластеризация (обучение без учителя) отличается от классификации (обучения с учителем) тем,
что метки объектов из обучающей выборки <tex>y_i</tex> изначально не заданы, и даже может быть неизвестно само множество <tex>Y</tex>.

Решение задачи кластеризации объективно неоднозначно по ряду причин:
* Не существует однозначного критерия качества кластеризации. Известен ряд алгоритмов, осуществляющих разумную кластеризацию "по построению", однако все они могут давать разные результаты. Следовательно, для определения качества кластеризации и оценки выделенных кластеров необходим эксперт предметной области.
* Число кластеров, как правило, заранее не известно и выбирается по субъективным критериям. Даже если алгоритм не требует изначального знания о числе классов, конкретные реализации зачастую требуют указать этот параметр<ref>[https://scikit-learn.org/stable/modules/clustering.html scikit-learn {{---}} Clustering]</ref>.
* Результат кластеризации существенно зависит от метрики. Однако существует ряд рекомендаций по выбору метрик для определенных классов задач.<ref>Cornwell, B. (2015). Linkage Criteria for Agglomerative Hierarchical Clustering. Social Sequence Analysis, 270–274.</ref>

Число кластеров фактически является гиперпараметром для алгоритмов кластеризации. Подробнее про другие гиперпараметры и их настройку можно прочитать в статье<ref>Shalamov Viacheslav, Valeria Efimova, Sergey Muravyov, and Andrey Filchenkov. "Reinforcement-based Method for Simultaneous Clustering Algorithm Selection and its Hyperparameters Optimization." Procedia Computer Science 136 (2018): 144-153.</ref>.

== Теорема невозможности Клейнберга ==
Для формализации алгоритмов кластеризации была использована аксиоматическая теория. Клейнберг постулировал три простых свойства в качестве аксиом кластеризации и доказал теорему, связывающую эти свойства.
{{Определение
|definition =
Алгоритм кластеризации <tex>a</tex> является '''масштабно инвариантным''' (англ. ''scale-invariant''), если для любой функции расстояния <tex>\rho</tex> и любой константы <tex>\alpha > 0</tex> результаты кластеризации с использованием расстояний <tex>\rho</tex> и <tex>\alpha\cdot\rho</tex> совпадают.
}}
Первая аксиома интуитивно понятна. Она требует, чтобы функция кластеризации не зависила от системы счисления функции расстояния и была нечувствительна к линейному растяжению и сжатию метрического пространства обучающей выборки.
{{Определение
|definition =
'''Полнота''' (англ. ''Richness''). Множество результатов кластеризации алгоритма <tex>a</tex> в зависимости от изменения функции расстояния <tex>\rho</tex> должно совпадать со множеством всех возможных разбиений множества объектов <tex>X</tex>.
}}
Вторая аксиома утверждает, что алгоритм кластеризации должен уметь кластеризовать обучающую выборку на любое фиксированное разбиение для какой-то функции расстояния <tex>\rho</tex>.
{{Определение
|definition =
Функция расстояния <tex>{\rho}'</tex> является '''допустимым преобразованием''' функции расстояния <tex>\rho</tex>, если
#<tex>{\rho}'(x_i, x_j) \leqslant \rho(x_i, x_j)</tex>, если <tex>x_i</tex> и <tex>x_j</tex> лежат в одном кластере
#<tex>{\rho}'(x_i, x_j) \geqslant \rho(x_i, x_j)</tex>, если <tex>x_i</tex> и <tex>x_j</tex> лежат в разных кластерах.
}}
{{Определение
|definition =
Алгоритм кластеризации является '''согласованным''' (англ. ''consistent''), если результат кластеризации не изменяется после допустимого преобразования функции расстояния.
}}
Третья аксиома требует сохранения кластеров при уменьшении внутрикластерного расстояния и увеличении межкластерного расстояния.

{| class="wikitable"
| style="text-align:center; font-weight:bold;" colspan=3|Примеры преобразований с сохранением кластеров
|-
| style="padding:5px;" |[[Файл:cluster_0.png|300px]]
| style="padding:5px;" |[[Файл:clusters_scale_inv.png|300px]]
| style="padding:5px;" |[[Файл:cluster_consist.png|300px]]
|-
| style="text-align:center;width:305px;" | Исходное расположение объектов и их кластеризация
| style="text-align:center;width:305px;" | Пример масштабной инвариантности. Уменьшен масштаб по оси ординат в два раза.
| style="text-align:center;width:305px;" | Пример допустимого преобразования. Каждый объект в два раза приближен к центроиду своего класса. Внутриклассовое расстояние уменьшилось, межклассовое увеличилось.
|}

Исходя из этих аксиом Клейнберг сформулировал и доказал теорему:
{{Теорема
|author=Клейнберга
|about=о невозможности
|statement=Для множества объектов, состоящего из двух и более элементов, не существует алгоритма кластеризации, который был бы одновременно масштабно-инвариантным, согласованным и полным.
}}
Несмотря на эту теорему Клейнберг показал<ref>[https://www.cs.cornell.edu/home/kleinber/nips15.pdf Kleinberg J. An Impossibility Theorem for Clustering]</ref>,
что иерархическая кластеризация по методу одиночной связи с различными критериями останова удовлетворяет любым двум из трех аксиом.

== Типология задач кластеризации ==
=== Типы входных данных ===
* Признаковое описание объектов. Каждый объект описывается набором своих характеристик, называемых признаками (англ. ''features''). Признаки могут быть как числовыми, так и категориальными.
* Матрица расстояний между объектами. Каждый объект описывается расстоянием до всех объектов из обучающей выборки.

Вычисление матрицы расстояний по признаковому описанию объектов может быть выполнено бесконечным числом способов в
зависимости от определения метрики между объектами. Выбор метрики зависит от обучающей выборки и поставленной задачи.

=== Цели кластеризации ===
* Классификация объектов. Попытка понять зависимости между объектами путем выявления их кластерной структуры. Разбиение выборки на группы схожих объектов упрощает дальнейшую обработку данных и принятие решений, позволяет применить к каждому кластеру свой метод анализа (стратегия «разделяй и властвуй»). В данном случае стремятся уменьшить число кластеров для выявления наиболее общих закономерностей.
* Сжатие данных. Можно сократить размер исходной выборки, взяв один или несколько наиболее типичных представителей каждого кластера. Здесь важно наиболее точно очертить границы каждого кластера, их количество не является важным критерием.
* Обнаружение новизны (обнаружение шума). Выделение объектов, которые не подходят по критериям ни в один кластер. Обнаруженные объекты в дальнейшем обрабатывают отдельно.

=== Методы кластеризации ===
* Графовые алгоритмы кластеризации. Наиболее примитивный класс алгоритмов. В настоящее время практически не применяется на практике.
* Вероятностные алгоритмы кластеризации. Каждый объект из обучающей выборки относится к каждому из кластеров с определенной степенью вероятности.
** [[EM-алгоритм]][на 28.01.19 не создан]
* [[Иерархическая_кластеризация|Иерархические алгоритмы кластеризации]]. Упорядочивание данных путем создания иерархии вложенных кластеров.
* [[K-средних|Алгоритм <tex>\mathrm{k}</tex>-средних]][на 28.01.19 не создан] (англ. ''<tex>\mathrm{k}</tex>-means''). Итеративный алгоритм, основанный на минимизации суммарного квадратичного отклонения точек кластеров от центров этих кластеров.
* Распространение похожести (англ. ''affinity propagation''). Распространяет сообщения о похожести между парами объектов для выбора типичных представителей каждого кластера.
* Сдвиг среднего значения (англ. ''mean shift''). Выбирает центроиды кластеров в областях с наибольшей плотностью.
* Спектральная кластеризация (англ. ''spectral clustering''). Использует собственные значения матрицы расстояний для понижения размерности перед использованием других методов кластеризации.
* Основанная на плотности пространственная кластеризация для приложений с шумами (англ. ''Density-based spatial clustering of applications with noise'', ''DBSCAN''). Алгоритм группирует в один кластер точки в области с высокой плотностью. Одиноко расположенные точки помечает как шум.

[[Файл:cluster_comparison.png|thumb|800px|center|<div style="text-align:center">Сравнение алгоритмов кластеризации из пакета scikit-learn<ref>[https://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html scikit-learn {{---}} Comparing different clustering algorithms on toy datasets]</ref></div>]]

== Меры качества кластеризации ==
Для оценки качества кластеризации задачу можно переформулировать в терминах задачи дискретной оптимизации.
Необходима так сопоставить объектам из множества <tex>X</tex> метки кластеров, чтобы значение выбранного функционала качества приняло наилучшее значение.
В качестве примера, стремятся достичь минимума среднего внутрикластерного расстояния <tex>F_0 = \dfrac{\sum_{i<j}{[y_i=y_j]\cdot\rho(x_i, x_j)}}{\sum_{i<j}[y_i=y_j]}</tex> или максимума среднего межкластерного расстояния <tex>F_1 = \dfrac{\sum_{i<j}{[y_i\neq y_j]\cdot\rho(x_i, x_j)}}{\sum_{i<j}[y_i\neq y_j]}</tex>.

Подробнее про меры качества можно прочитать в статье [[Оценка_качества_в_задаче_кластеризации|оценка качества в задаче кластеризации]].

== Применение ==
=== Биология и биоинформатика ===
* В области экологии кластеризация используется для выделения пространственных и временных сообщест организмов в однородных условиях.
* Кластерный анализ используется для группировки схожих геномных последовательностей в семейство генов, которые являются консервативными структурами для многих организмов и могут выполнять схожие функции.
* Кластеризация помогает автоматически определять генотипы по различным частям хромосом.
* Алгоритмы применяются для выделения небольшого числа групп генетических вариации человеческого генома.
=== Медицина ===
* Используется в позитронно-эмиссионной томографии для автоматического выделения различных типов тканей на трехмерном изображении.
* Применяется для выявления шаблонов устойчивости к антибиотикам; для классификации антибиотиков по типу антибактериальной активности.
=== Маркетинг ===
Кластеризация широко используется при изучении рынка для обработки данных, полученных из различных опросов.
Может применяться для выделения типичных групп покупателей, разделения рынка для создания персонализированных предложений, разработки новых линий продукции.
=== Интернет ===
* Выделение групп людей на основе графа связей в социальных сетях.
* Повышение релевантности ответов на поисковые запросы путем группировки веб-сайтов по смысловым значениям поискового запроса.
=== Компьютерные науки ===
* Кластеризация используется в сегментации изображений для определения границ и распознавания объектов.
* Кластерный анализ применяется для определения образовавшихся популяционных ниш в ходе работы эволюционных алгоритмов для улучшения параметров эволюции.
* Подбор рекомендаций для пользователя на основе предпочтений других пользователей в данном кластере.
* Определение аномалий путем построения кластеров и выявления неклассифицированных объектов.

== См. также ==
* [[Оценка_качества_в_задаче_кластеризации|Оценка качества в задаче кластеризации]]
* [[EM-алгоритм|EM-алгоритм]][на 28.01.18 не создан]
* [[Иерархическая_кластеризация|Иерархическая кластеризация]]
* [[k-средних|<tex>\mathrm{k}</tex>-средних]][на 28.01.18 не создан]

== Примечания ==
<references/>

== Источники информации ==

* [https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7 Википедия {{---}} Кластерный анализ]
* [https://en.wikipedia.org/wiki/Cluster_analysis Wikipedia {{---}} Cluster analysis]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F MachineLearning {{---}} Кластеризация]
* [http://www.machinelearning.ru/wiki/images/c/ca/Voron-ML-Clustering.pdf К.В.Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования]
* [https://www.cs.cornell.edu/home/kleinber/nips15.pdf Kleinberg J. An Impossibility Theorem for Clustering]

[[Категория: Машинное обучение]]
[[Категория: Кластеризация]]

Кластеризация

2019-01-28T14:35:43Z

Alexey Katsman: /* См. также */

[[Файл:clusters.png|thumb|300px|Пример кластеризации]]
'''Кластеризация''' (англ. ''cluster analysis'') {{---}} задача группировки множества объектов на подмножества ('''кластеры''') таким образом,
чтобы объекты из одного кластера были более похожи друг на друга, чем на объекты из других кластеров по какому-либо критерию.

Задача кластеризации относится к классу задач обучения без учителя.
== Постановка задачи кластеризации ==
Пусть <tex>X</tex> {{---}} множество объектов, <tex>Y</tex> {{---}} множество идентификаторов (меток) кластеров.
На множестве <tex>X</tex> задана функция расстояния между объектами <tex>\rho(x,x')</tex>.
Дана конечная обучающая выборка объектов <tex>X^m = \{ x_1, \dots, x_m \} \subset X</tex>.
Необходимо разбить выборку на подмножества (кластеры), то есть каждому объекту <tex>x_i \in X^m</tex> сопоставить метку <tex>y_i \in Y</tex>,
таким образом чтобы объекты внутри каждого кластера были близки относительно метрики <tex>\rho</tex>, а объекты из разных кластеров значительно различались.
{{Определение
|definition =
'''Алгоритм кластеризации''' — функция <tex>a\colon X\to Y</tex>, которая любому объекту <tex>x\in X</tex> ставит в соответствие идентификатор кластера <tex>y\in Y</tex>.
}}
Множество <tex>Y</tex> в некоторых случаях известно заранее, однако чаще ставится задача
определить оптимальное число кластеров, с точки зрения того или иного ''критерия качества'' кластеризации.

Кластеризация (обучение без учителя) отличается от классификации (обучения с учителем) тем,
что метки объектов из обучающей выборки <tex>y_i</tex> изначально не заданы, и даже может быть неизвестно само множество <tex>Y</tex>.

Решение задачи кластеризации объективно неоднозначно по ряду причин:
* Не существует однозначного критерия качества кластеризации. Известен ряд алгоритмов, осуществляющих разумную кластеризацию "по построению", однако все они могут давать разные результаты. Следовательно, для определения качества кластеризации и оценки выделенных кластеров необходим эксперт предметной области.
* Число кластеров, как правило, заранее не известно и выбирается по субъективным критериям. Даже если алгоритм не требует изначального знания о числе классов, конкретные реализации зачастую требуют указать этот параметр<ref>[https://scikit-learn.org/stable/modules/clustering.html scikit-learn {{---}} Clustering]</ref>.
* Результат кластеризации существенно зависит от метрики. Однако существует ряд рекомендаций по выбору метрик для определенных классов задач.<ref>Cornwell, B. (2015). Linkage Criteria for Agglomerative Hierarchical Clustering. Social Sequence Analysis, 270–274.</ref>

Число кластеров фактически является гиперпараметром для алгоритмов кластеризации. Подробнее про другие гиперпараметры и их настройку можно прочитать в статье<ref>Shalamov Viacheslav, Valeria Efimova, Sergey Muravyov, and Andrey Filchenkov. "Reinforcement-based Method for Simultaneous Clustering Algorithm Selection and its Hyperparameters Optimization." Procedia Computer Science 136 (2018): 144-153.</ref>.

== Теорема невозможности Клейнберга ==
Для формализации алгоритмов кластеризации была использована аксиоматическая теория. Клейнберг постулировал три простых свойства в качестве аксиом кластеризации и доказал теорему, связывающую эти свойства.
{{Определение
|definition =
Алгоритм кластеризации <tex>a</tex> является '''масштабно инвариантным''' (англ. ''scale-invariant''), если для любой функции расстояния <tex>\rho</tex> и любой константы <tex>\alpha > 0</tex> результаты кластеризации с использованием расстояний <tex>\rho</tex> и <tex>\alpha\cdot\rho</tex> совпадают.
}}
Первая аксиома интуитивно понятна. Она требует, чтобы функция кластеризации не зависила от системы счисления функции расстояния и была нечувствительна к линейному растяжению и сжатию метрического пространства обучающей выборки.
{{Определение
|definition =
'''Полнота''' (англ. ''Richness''). Множество результатов кластеризации алгоритма <tex>a</tex> в зависимости от изменения функции расстояния <tex>\rho</tex> должно совпадать со множеством всех возможных разбиений множества объектов <tex>X</tex>.
}}
Вторая аксиома утверждает, что алгоритм кластеризации должен уметь кластеризовать обучающую выборку на любое фиксированное разбиение для какой-то функции расстояния <tex>\rho</tex>.
{{Определение
|definition =
Функция расстояния <tex>{\rho}'</tex> является '''допустимым преобразованием''' функции расстояния <tex>\rho</tex>, если
#<tex>{\rho}'(x_i, x_j) \leqslant \rho(x_i, x_j)</tex>, если <tex>x_i</tex> и <tex>x_j</tex> лежат в одном кластере
#<tex>{\rho}'(x_i, x_j) \geqslant \rho(x_i, x_j)</tex>, если <tex>x_i</tex> и <tex>x_j</tex> лежат в разных кластерах.
}}
{{Определение
|definition =
Алгоритм кластеризации является '''согласованным''' (англ. ''consistent''), если результат кластеризации не изменяется после допустимого преобразования функции расстояния.
}}
Третья аксиома требует сохранения кластеров при уменьшении внутрикластерного расстояния и увеличении межкластерного расстояния.

{| class="wikitable"
| style="text-align:center; font-weight:bold;" colspan=3|Примеры преобразований с сохранением кластеров
|-
| style="padding:5px;" |[[Файл:cluster_0.png|300px]]
| style="padding:5px;" |[[Файл:clusters_scale_inv.png|300px]]
| style="padding:5px;" |[[Файл:cluster_consist.png|300px]]
|-
| style="text-align:center;width:305px;" | Исходное расположение объектов и их кластеризация
| style="text-align:center;width:305px;" | Пример масштабной инвариантности. Уменьшен масштаб по оси ординат в два раза.
| style="text-align:center;width:305px;" | Пример допустимого преобразования. Каждый объект в два раза приближен к центроиду своего класса. Внутриклассовое расстояние уменьшилось, межклассовое увеличилось.
|}

Исходя из этих аксиом Клейнберг сформулировал и доказал теорему:
{{Теорема
|author=Клейнберга
|about=о невозможности
|statement=Для множества объектов, состоящего из двух и более элементов, не существует алгоритма кластеризации, который был бы одновременно масштабно-инвариантным, согласованным и полным.
}}
Несмотря на эту теорему Клейнберг показал<ref>[https://www.cs.cornell.edu/home/kleinber/nips15.pdf Kleinberg J. An Impossibility Theorem for Clustering]</ref>,
что иерархическая кластеризация по методу одиночной связи с различными критериями останова удовлетворяет любым двум из трех аксиом.

== Типология задач кластеризации ==
=== Типы входных данных ===
* Признаковое описание объектов. Каждый объект описывается набором своих характеристик, называемых признаками (англ. ''features''). Признаки могут быть как числовыми, так и категориальными.
* Матрица расстояний между объектами. Каждый объект описывается расстоянием до всех объектов из обучающей выборки.

Вычисление матрицы расстояний по признаковому описанию объектов может быть выполнено бесконечным числом способов в
зависимости от определения метрики между объектами. Выбор метрики зависит от обучающей выборки и поставленной задачи.

=== Цели кластеризации ===
* Классификация объектов. Попытка понять зависимости между объектами путем выявления их кластерной структуры. Разбиение выборки на группы схожих объектов упрощает дальнейшую обработку данных и принятие решений, позволяет применить к каждому кластеру свой метод анализа (стратегия «разделяй и властвуй»). В данном случае стремятся уменьшить число кластеров для выявления наиболее общих закономерностей.
* Сжатие данных. Можно сократить размер исходной выборки, взяв один или несколько наиболее типичных представителей каждого кластера. Здесь важно наиболее точно очертить границы каждого кластера, их количество не является важным критерием.
* Обнаружение новизны (обнаружение шума). Выделение объектов, которые не подходят по критериям ни в один кластер. Обнаруженные объекты в дальнейшем обрабатывают отдельно.

=== Методы кластеризации ===
* Графовые алгоритмы кластеризации. Наиболее примитивный класс алгоритмов. В настоящее время практически не применяется на практике.
* Вероятностные алгоритмы кластеризации. Каждый объект из обучающей выборки относится к каждому из кластеров с определенной степенью вероятности.
** [[EM-алгоритм]]
* [[Иерархическая_кластеризация|Иерархические алгоритмы кластеризации]]. Упорядочивание данных путем создания иерархии вложенных кластеров.
* [[K-средних|Алгоритм <tex>\mathrm{k}</tex>-средних]] (англ. ''<tex>\mathrm{k}</tex>-means''). Итеративный алгоритм, основанный на минимизации суммарного квадратичного отклонения точек кластеров от центров этих кластеров.
* Распространение похожести (англ. ''affinity propagation''). Распространяет сообщения о похожести между парами объектов для выбора типичных представителей каждого кластера.
* Сдвиг среднего значения (англ. ''mean shift''). Выбирает центроиды кластеров в областях с наибольшей плотностью.
* Спектральная кластеризация (англ. ''spectral clustering''). Использует собственные значения матрицы расстояний для понижения размерности перед использованием других методов кластеризации.
* Основанная на плотности пространственная кластеризация для приложений с шумами (англ. ''Density-based spatial clustering of applications with noise'', ''DBSCAN''). Алгоритм группирует в один кластер точки в области с высокой плотностью. Одиноко расположенные точки помечает как шум.

[[Файл:cluster_comparison.png|thumb|800px|center|<div style="text-align:center">Сравнение алгоритмов кластеризации из пакета scikit-learn<ref>[https://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html scikit-learn {{---}} Comparing different clustering algorithms on toy datasets]</ref></div>]]
== Меры качества кластеризации ==
Для оценки качества кластеризации задачу можно переформулировать в терминах задачи дискретной оптимизации.
Необходима так сопоставить объектам из множества <tex>X</tex> метки кластеров, чтобы значение выбранного функционала качества приняло наилучшее значение.
В качестве примера, стремятся достичь минимума среднего внутрикластерного расстояния <tex>F_0 = \dfrac{\sum_{i<j}{[y_i=y_j]\cdot\rho(x_i, x_j)}}{\sum_{i<j}[y_i=y_j]}</tex> или максимума среднего межкластерного расстояния <tex>F_1 = \dfrac{\sum_{i<j}{[y_i\neq y_j]\cdot\rho(x_i, x_j)}}{\sum_{i<j}[y_i\neq y_j]}</tex>.

Подробнее про меры качества можно прочитать в статье [[Оценка_качества_в_задаче_кластеризации|оценка качества в задаче кластеризации]].

== Применение ==
=== Биология и биоинформатика ===
* В области экологии кластеризация используется для выделения пространственных и временных сообщест организмов в однородных условиях.
* Кластерный анализ используется для группировки схожих геномных последовательностей в семейство генов, которые являются консервативными структурами для многих организмов и могут выполнять схожие функции.
* Кластеризация помогает автоматически определять генотипы по различным частям хромосом.
* Алгоритмы применяются для выделения небольшого числа групп генетических вариации человеческого генома.
=== Медицина ===
* Используется в позитронно-эмиссионной томографии для автоматического выделения различных типов тканей на трехмерном изображении.
* Применяется для выявления шаблонов устойчивости к антибиотикам; для классификации антибиотиков по типу антибактериальной активности.
=== Маркетинг ===
Кластеризация широко используется при изучении рынка для обработки данных, полученных из различных опросов.
Может применяться для выделения типичных групп покупателей, разделения рынка для создания персонализированных предложений, разработки новых линий продукции.
=== Интернет ===
* Выделение групп людей на основе графа связей в социальных сетях.
* Повышение релевантности ответов на поисковые запросы путем группировки веб-сайтов по смысловым значениям поискового запроса.
=== Компьютерные науки ===
* Кластеризация используется в сегментации изображений для определения границ и распознавания объектов.
* Кластерный анализ применяется для определения образовавшихся популяционных ниш в ходе работы эволюционных алгоритмов для улучшения параметров эволюции.
* Подбор рекомендаций для пользователя на основе предпочтений других пользователей в данном кластере.
* Определение аномалий путем построения кластеров и выявления неклассифицированных объектов.

== См. также ==
* [[Оценка_качества_в_задаче_кластеризации|Оценка качества в задаче кластеризации]]
* [[EM-алгоритм|EM-алгоритм]][на 28.01.18 не создан]
* [[Иерархическая_кластеризация|Иерархическая кластеризация]]
* [[k-средних|<tex>\mathrm{k}</tex>-средних]][на 28.01.18 не создан]

== Примечания ==
<references/>

== Источники информации ==

* [https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7 Википедия {{---}} Кластерный анализ]
* [https://en.wikipedia.org/wiki/Cluster_analysis Wikipedia {{---}} Cluster analysis]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F MachineLearning {{---}} Кластеризация]
* [http://www.machinelearning.ru/wiki/images/c/ca/Voron-ML-Clustering.pdf К.В.Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования]
* [https://www.cs.cornell.edu/home/kleinber/nips15.pdf Kleinberg J. An Impossibility Theorem for Clustering]

[[Категория: Машинное обучение]]
[[Категория: Кластеризация]]

Модель алгоритма и её выбор

2019-01-28T14:34:43Z

Alexey Katsman: /* Мета-обучение */

==Понятие модели==
Пусть дана обучающая выборка <tex>(X, Y)</tex>, где <tex> X </tex> {{---}} множество признаков, описывающих объекты, а <tex> Y </tex> {{---}} конечное множество меток.

Пусть задана функция <tex> g: X \times \Theta \rightarrow Y </tex>, где <tex> \Theta </tex> {{---}} множество дополнительных параметров (весов) функции.

Описанная выше функция <tex> g </tex> для фиксированного значения весов <tex> \theta \in \Theta </tex> называется '''решающим правилом'''.

'''Модель''' {{---}} это совокупность всех решающих правил, которые получаются путем присваивания весам всех возможных допустимых значений.

Формально модель <tex> A = \{g(x, \theta)| \theta \in \Theta\} </tex>.

Модель определяется множеством допустимых весов <tex> \Theta </tex> и структурой решающего правила <tex> g(x,\theta) </tex>

=== Понятие гиперпараметров модели ===
'''Гиперпараметры модели''' {{---}} это параметры, значения которых задается до начала обучения модели и не изменяется в процессе обучения. У модели может не быть гиперпараметров.

'''Параметры модели''' {{---}} это параметры, которые изменяются и оптимизируются в процессе обучения модели и итоговые значения этих параметров являются результатом обучения модели.

Примерами гиперпараметров могут служить количество слоев нейронной сети, а также количество нейронов на каждом слое. Примерами параметров могут служить веса ребер нейронной сети.

Для нахождения оптимальных гиперпараметров модели могут применяться различные алгоритмы [[Настройка гиперпараметров | настройки гиперпараметров]][на 28.01.19 не создан].

=== Пример ===
[[Файл:Linear-regression.png|300px|thumb|[http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F_%28%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%29 Рис 1. Пример линейной регрессии]]]
В качестве примера модели приведем [[Линейная регрессия | линейную регрессию]][на 28.01.19 не создан].

Линейная регрессия задается следующей формулой:

<tex> g(x, \theta) = \theta_0 + \theta_1x_1 + ... + \theta_kx_k = \theta_0 + \sum_{i=1}^k \theta_ix_i = \theta_0 + x^T\theta</tex>, где <tex> x^T = (x_1, x_2, ..., x_k) </tex> {{---}} вектор признаков, <tex> \theta = (\theta_1, \theta_2, ..., \theta_k)</tex> {{---}} веса модели, настраиваемые в процессе обучения.

Гиперпараметром модели является число слагаемых в функции <tex> g(x, \theta) </tex>.

Более подробный пример линейной регрессии можно посмотреть в статье [[Переобучение | переобучение]].

== Задача выбора модели ==
Пусть <tex> A </tex> {{---}} модель алгоритма, характеризующаяся гиперпараметрами <tex> \lambda = \{\lambda_1, ..., \lambda_m\}, \lambda_1 \in \Lambda_1, ..., \lambda_m \in \Lambda_m </tex>. Тогда с ней связано пространство гиперпараметров <tex> \Lambda = \Lambda_1 \times ... \times \Lambda_m </tex>. За <tex> A_{\lambda}</tex> обозначим алгоритм, то есть модель алгоритма, для которой задан вектор гиперпараметров <tex> \lambda \in \Lambda </tex>.

Для выбора наилучшего алгоритма необходимо зафиксировать меру качества работы алгоритма. Назовем эту меру <tex> Q(A_{\lambda}, D) </tex>.

Задачу выбора наилучшего алгоритма можно разбить на две подзадачи: подзадачу выбора лучшего алгоритма из портфолио и подзадачу настройки гиперпараметров.

==== Подзадача выбора лучшего алгоритма из портфолио ====
Дано некоторое множество алгоритмов с фиксированными структурными параметрами <tex> \mathcal{A} = \{A^1_{\lambda_1}, ..., A^m_{\lambda_m}\}</tex> и обучающая выборка <tex> D = \{d_1, ..., d_n\}</tex>. Здесь <tex> d_i = (x_i, y_i) \in (X, Y)</tex>. Требуется выбрать алгоритм <tex> A^*_{\lambda_*} </tex>, который окажется наиболее эффективным с точки зрения меры качества <tex> Q </tex>
==== Подзадача оптимизации гиперпараметров ====
Подзадача оптимизации гиперпараметров заключается в подборе таких <tex> \lambda^* \in \Lambda </tex>, при которых заданная модель алгоритма <tex> A </tex> будет наиболее эффективна.

Гиперпараметры могут выбираться из ограниченного множества или с помощью перебора из неограниченного множества гиперпараметров, это зависит от непосредственной задачи. Во втором случае актуален вопрос максимального времени, которое можно потратить на поиск наилучших гиперпараметров, так как чем больше времени происходит перебор, тем лучше гиперпараметры можно найти, но при этом может быть ограничен временной бюджет, из-за чего перебор придется прервать.

=== Методы выбора модели ===
Модель можно выбрать из некоторого множества моделей, проверив результат работы каждой модели из множества с помощью ручного тестирования, но ручное тестирование серьезно ограничивает количество моделей, которые можно перебрать, а также требует больших трудозатрат. Поэтому в большинстве случаев используются алгоритмы, позволяющие автоматически выбирать модель. Далее будут рассмотрены некоторые из таких алгоритмов.
[[Файл:Scikit-learn-scheme.png|900px|thumb|[https://www.codeastar.com/choose-machine-learning-models-python/ Рис 2. Схема выбора модели в библиотеке scikit-learn для Python]]]
==== Кросс-валидация ====
Основная идея алгоритма кросс-валидации {{---}} разбить обучающую выборку на обучающую и тестовую, чтобы таким образом эмулировать наличие тестовой выборки, которая не участвует в обучении, но для которой известны правильные ответы. Более подробно про алгоритм кросс-валидации можно прочитать в [[Кросс-валидация | соответствующей статье]].

Достоинства и недостатки кросс-валидации:
# Ошибка в процедуре кросс-валидации является достаточно точной оценкой ошибки на генеральной совокупности;
# Проведение кросс-валидации требует значительного времени на многократное повторное обучение алгоритмов и применимо лишь для «быстрых» алгоритмов машинного обучения;
# Кросс-валидация плохо применима в задачах кластерного анализа и прогнозирования временных рядов.

==== Мета-обучение ====
Целью мета-обучения является решение задачи выбора алгоритма из портфолио алгоритмов для решения поставленной задачи без непосредственного применения каждого из них. Решение этой задачи в рамках мета-обучения сводится к задаче [https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D1%83%D1%87%D0%B8%D1%82%D0%B5%D0%BB%D0%B5%D0%BC обучения с учителем]. Для этого используется заранее отобранное множество наборов данных <tex> D </tex>. Для каждого набора данных <tex> d \in D </tex> вычисляется вектор мета-признаков, которые описывают свойства этого набора данных. Ими могут быть: число категориальных или численных признаков объеков в <tex> d </tex>, число возможных меток, размер <tex> d </tex> и [https://ieeexplore.ieee.org/document/7382962 многие другие], а еще эту статью можно найти вот [https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf тут]. Каждый алгоритм запускается на всех наборах данных из <tex> D </tex>. После этого вычисляется эмпирический риск, на основе которого формируются метки классов. Затем мета-классификатор обучается на полученных результатах. В качестве описания набора данных выступает вектор мета-признаков, а в качестве метки — алгоритм, оказавшийся самым эффективным с точки зрения заранее выбранной меры качества.

Более подробно про мета-обучение можно почитать в [[Мета-обучение | соответствующей статье]]

Достоинства и недостатки мета-обучения:
# Алгоритм, обучающийся большое время, запускается меньшее количество раз, что сокращает время работы;
# Точность алгоритма может быть ниже, чем при кросс-валидации.

==== Теория Вапника-Червоненкиса ====
Идея данной теории заключается в следующем: чем более «гибкой» является модель, тем хуже ее обобщающая способность. Данная идея базируется на том, что «гибкое» решающее правило способно настраиваться на малейшие шумы, содержащиеся в обучающей выборке.

'''Емкость модели для задачи классификации''' {{---}} максимальное число объектов обучающей выборки, для которых при любом их разбиении на классы найдется хотя бы одно решающее правило, безошибочно их классифицирующее.

По аналогии емкость обобщается на другие задачи машинного обучения.

Очевидно, что чем больше емкость, тем более «гибкой» является модель и, соответственно, тем хуже. Значит нужно добиваться минимально возможного количества ошибок на обучении при минимальной возможной емкости.

Существует формула Вапника, связывающая ошибку на обучении <tex> P_{train}(\theta) </tex>, емкость <tex> h(\theta) </tex> и ошибку на генеральной совокупности <tex> P_{test}(\theta) </tex>:

<tex> P_{test}(\theta) <= P_{train}(\theta) + \sqrt{\frac{h(\Theta) * (\log{(\frac{2d}{h(\Theta)})} + 1) - \log{(\frac{\eta}{4})}}{n}} </tex>, где <tex> d </tex> {{---}} размерность пространства признаков.

Неравенство верно с вероятностью <tex> 1 - \eta </tex> <tex> \forall \theta \in \Theta </tex>

Алгоритм выбора модели согласно теории Вапника-Червоненкиса: Последовательно анализируя модели с увеличивающейся емкостью, необходимо выбирать модель с наименьшей верхней оценкой тестовой ошибки.

Достоинства теории Вапника-Червоненкиса:
# Серьезное теоретическое обоснование, связь с ошибкой на генеральной совокупности;
# Теория продолжает развиваться и в наши дни.
Недостатки теории Вапника-Червоненкиса:
# Оценки ошибки на генеральной совокупности сильно завышены;
# Для большинства моделей емкость не поддается оценке;
# Многие модели с бесконечной емкостью показывают хорошие результаты на практике.

== Существующие системы автоматического выбора модели ==
===Автоматизированный выбор модели в библиотеке [https://www.ml4aad.org/wp-content/uploads/2018/07/automl_book_draft_auto-weka.pdf auto-WEKA] для Java.===
Библиотека используется для одновременного поиска оптимальной модели и оптимальных гиперпараметров модели для задач классификации и регрессии (начиная с версии 2.0).

Библиотека позволяет автоматически выбирать из 27 базовых алгоритмов, 10 мета-алгоритмов и 2 ансамблевых алгоритмов лучший, одновременно настраивая его гиперпараметры при помощи алгоритма [https://www.ml4aad.org/automated-algorithm-design/algorithm-configuration/smac/ SMAC]. Решение достигается полным перебором: оптимизация гиперпараметров запускается на всех алгоритмах по очереди. Недостатком такого подхода является слишком большое время выбора модели.
===Автоматизированный выбор модели в библиотеке [https://epistasislab.github.io/tpot/ Tree-base Pipeline Optimization Tool (TPOT)] для Python.===
[[Файл:TPOT-scheme.jpeg|500px|thumb|[https://raw.githubusercontent.com/EpistasisLab/tpot/master/images/tpot-ml-pipeline.png Рис 3. Схема выбора модели в библиотеке TPOT]]]
Библиотека используется для одновременного поиска оптимальной модели и оптимальных гиперпараметров модели для задачи классификации.

Выбор модели осуществляется на основе конвейера, организованного в древовидной структуре. Каждая вершина дерева {{---}} один из четырех операторов конвейера (preprocessing, decomposition, feature selection, modelling). Каждый конвейер начинается с одной или нескольких копий входного набора данных, которые являются листьями дерева и которые подаются в операторы в соответствии со структурой конвейера. Данные модифицируются оператором в вершине и поступают на вход следующей вершины. В библиотеке используются генетические алгоритмы для нахождения лучших конвейеров.

После поиска конвейера его также можно экспортировать в файл Python.

===Автоматизированный выбор модели в библиотеке [https://automl.github.io/auto-sklearn/stable/ auto-sklearn] для Python.===
[[Файл:Auto-sklearn-scheme.png|500px|thumb|[https://papers.nips.cc/paper/5872-efficient-and-robust-automated-machine-learning.pdf Рис 4. Схема выбора модели в библиотеке auto-sklearn]]]
Библиотека используется для одновременного поиска оптимальной модели и оптимальных гиперпараметров модели для задачи классификации.

Сначала используется мета-обучение на основе различных признаков и мета-признаков набора данных, чтобы найти наилучшие модели. После этого используется подход [https://en.wikipedia.org/wiki/Bayesian_optimization Байесовской оптимизации], чтобы найти наилучшие гиперпараметры для наилучших моделей.

== См. также ==
* [[Настройка гиперпараметров]][на 28.01.19 не создан]
* [[Переобучение]]
* [[Мета-обучение]]
* [[Линейная регрессия]][на 28.01.19 не создан]

== Примечания ==
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%92%D0%B0%D0%BF%D0%BD%D0%B8%D0%BA%D0%B0-%D0%A7%D0%B5%D1%80%D0%B2%D0%BE%D0%BD%D0%B5%D0%BD%D0%BA%D0%B8%D1%81%D0%B0 Теория Вапника-Червоненкинса]
# [https://en.wikipedia.org/wiki/Cross-validation_(statistics) Кросс-валидация]
# [https://link.springer.com/article/10.1023/B:MACH.0000015878.60765.42 Мета-обучение]
# [https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D1%83%D1%87%D0%B8%D1%82%D0%B5%D0%BB%D0%B5%D0%BC Обучение с учителем]
# [https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F Линейная регрессия]
# [https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf Datasets Meta-Feature Description for Recommending Feature Selection Algorithm]
# [https://www.ml4aad.org/automated-algorithm-design/algorithm-configuration/smac/ SMAC]
# [https://7bce9816-a-62cb3a1a-s-sites.googlegroups.com/site/automl2017icml/accepted-papers/AutoML_2017_paper_23.pdf?attachauth=ANoY7cr6uPaUoNh3gc3A-A1UbLXQgNEATEkfZmKD8kozB3hpCYtM9JwnOevEsW9W42CwurzJKrxxEatcB4DCjWNB_Ndvy1uC0lbQyCTlDIfrW6eYJXvdbFJPilYfmf8_ryilH0IwG0ddntLYy-VA3Fm1JeM495fTZxorYth0DDKiqtKvSR92dGl8CM_mUB7sun0R6wurCxM36QqcYEaf5kIm13MM0reWlR3aPZVNe_-AefOCpoXznR-wH04mSWjH8jmlk5Bw51AN&attredirects=0 Fast Automated Selection of Learning Algorithm And its Hyperparameters by Reinforcement Learning]
# Shalamov V., Efimova V., Muravyov S., and Filchenkov A. "Reinforcement-based Method for Simultaneous Clustering Algorithm Selection and its Hyperparameters Optimization." Procedia Computer Science 136 (2018): 144-153.
== Источники информации ==
# [http://www.machinelearning.ru/wiki/images/0/05/BMMO11_4.pdf Выбор модели] - презентация на MachineLearning.ru
# [https://en.wikipedia.org/wiki/Hyperparameter_(machine_learning) Гиперпараметры] - статья на Википедии
# [https://machinelearningmastery.com/difference-between-a-parameter-and-a-hyperparameter/ Разница между параметрами и гиперпараметрами] - описание разницы между параметрами и гиперпараметрами модели
# [http://jmlda.org/papers/doc/2016/no2/Efimova2016Reinforcement.pdf Применение обучения с подкреплением для одновременного выбора модели алгоритма классификации и ее структурных параметров]

[[Категория: Автоматическое машинное обучение]]
[[Категория: Машинное обучение]]

Логистическая регрессия

2019-01-28T14:34:15Z

Alexey Katsman: /* См. также */

'''Логистическая регрессия''' (англ. ''logistic regression'') — метод построения линейного классификатора, позволяющий оценивать апостериорные вероятности принадлежности объектов классам.
== Описание ==
Логистическая регрессия применяется для прогнозирования вероятности возникновения некоторого события по значениям множества признаков. Для этого вводится зависимая переменная $y$, принимающая значения $0$ и $1$ и множество [[Независимые случайные величины|независимых]] переменных <tex>x_1, ... x_n</tex> на основе значений которых требуется вычислить вероятность принятия того или иного значения зависимой переменной.

Итак, пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex>

Рассмотрим случай двух классов: $Y = \{-1, +1\}$. В логистической регрессии строится линейный алгоритм классификации $a: X \to Y$ вида
<center><tex>a(x, w) = \mathrm{sign}\left(\sum\limits_{j=1}^n w_j f_j(x) - w_0 \right)=\mathrm{sign}\left<x, w\right></tex></center>
где $w_j$ $-$ вес $j$-го признака, $w_0$ $-$ порог принятия решения, $w=\left(w_0, ..., w_n\right)$ $-$ вектор весов, $\left<x, w\right>$ $-$ скалярное произведение признакового описания объекта на вектор весов. Предполагается, что искусственно введён нулевой признак: $f_{0}(x)=-1$.

Задача обучения линейного классификатора заключается в том, чтобы по выборке $X^m$ настроить вектор весов $w$. В логистической регрессии для этого решается задача минимизации эмпирического риска с функцией потерь специального вида: <center><tex>Q(w) = \sum\limits_{i=1}^m \ln\left( 1 + \exp( -y_i \langle x_i,w \rangle ) \right) \to \min_{w}</tex></center>

После того, как решение $w$ найдено, становится возможным не только вычислять классификацию $a(x) = \mathrm{sign}\langle x,w \rangle$ для произвольного объекта $x$, но и оценивать апостериорные вероятности его принадлежности классам:
<center><tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex></center>
где $\sigma(z) = \frac1{1+e^{-z}}$ — сигмоидная функция.

== Обоснование ==
'''С точки зрения [[Байесовский классификатор|байесовского классификатора]][на 28.01.19 не создан]'''

Наиболее строгое обоснование логистической регрессии опирается на следующую теорему
{{Теорема
|statement=Пусть
*выборка прецедентов $\mathrm{X}^l=\{\left(x_1, y_1\right), ... ,\left(x_l, y_l\right)\}$ получена согласно вероятностному распределению с плотностью
<tex>p\left(x, y\right)=\mathrm{P}_yp_y\left(x\right)=\mathrm{P}\left(y|x\right)p\left(x\right)</tex>
где $\mathrm{P}_y$ $-$ ''априорные вероятности'',
$p_y(x)$ $-$ ''функции правдоподобия'', принадлежащие экспонентному семейству плотностей (т.е. $p_y(x) = \exp \left( \langle\theta,x\rangle \cdot a(\delta) + b(\delta,\theta) + d(x,\delta) \right)$, где $a, b, d$ $-$ произвольные функции)
*функции правдоподобия имеют равные знаения параметра разброса $\delta$ и отличаются только значениями параметра сдвига $\theta_y$
*среди признаков есть константа, скажем, $f_0(x) = -1$
Тогда
*линейный классификатор является оптимальным байесовским классификатором
*апостериорные вероятности классов оценивается по формуле <tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>
|proof=

Напомним, что оптимальный байесовский классификатор для двух классов выглядит следущим образом:
<center><tex>a\left(x\right)=
\mathrm{sign}\left(\lambda_+\mathrm{P}\left(+1|x\right)-\lambda_-\mathrm{P}\left(-1|x\right)\right)=
\mathrm{sign}\left(\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)}-\frac{\lambda_-}{\lambda_+}\right)</tex></center>

Рассмотрим отношение апостериорных вероятностей классов
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)}</tex></center>
и распишем функции правдоподобия, используя экспонентную формулу с параметрами $\theta_y$ и $\delta$:
<center><tex>\frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)} = \exp\left(\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle+b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-}\right)</tex></center>

Рассмотрим получившуюся под экспонентой сумму:
*$\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle = \langle w, x\rangle$. Вектор $w$ не зависит от $x$ и является вектором свободных коэффициентов(весов) при константных признаках
*$b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-} = \mathrm{const}\left(x\right)$. Можно считать данные слагаемые аддитивной добавкой к коэффициенту при признаке. Но так как свободные коэффициенты настраиваются по обучающей выборке, вычислять эту добавку не имеет смысла и ее можно включить в $\langle w, x\rangle$.

Таким образом,
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \mathrm{e}^{\langle w, x\rangle}</tex></center>

Разделяющая поверхность в байесовском решающем правиле определяется уравнением
<center><tex>\lambda_- \mathrm{P}\left(-1|x\right) = \lambda_+ \mathrm{P}\left(+1|x\right)</tex></center>
которое равносильно
<center><tex>\langle w, x\rangle - \ln\frac{\lambda_-}{\lambda_+} = 0</tex></center>
Следовательно, разделяющая поверхность линейна и первый пункт теоремы доказан.

Используя [[Формула полной вероятности|формулу полной вероятности]] получаем следующее равенство
<center><tex>\mathrm{P}\left(+1|x\right) + \mathrm{P}\left(-1|x\right) = \sigma\left(+\langle w ,x\rangle\right) + \sigma\left(-\langle w ,x\rangle\right) = 1</tex></center>

Откуда следует
<center><tex>\mathrm{P}\left(y|x\right)=\sigma\left(\langle w, x\rangle y\right), y = \{-1, +1\}</tex></center>
Таким образом, второй пункт теоремы доказан.
}}

== Примеры кода ==
==== scikit-learn ====
Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.'''LogisticRegression'''] имеет несколько параметров, например:
* '''solver''' $-$ алгоритм, использующийся для оптимизации
* '''multi_class''' $-$ классификация на 2 или много классов

* Импортируем нужные библиотеки
'''from''' sklearn.linear_model '''import''' LogisticRegression
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение
clf = LogisticRegression(random_state='''0''', solver='lbfgs', multi_class='multinomial')
model = clf.'''fit'''(X_train, y_train)

* Предсказание
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

==== [[Примеры кода на Scala#Логистическая регрессия|Пример кода на Scala]] ====

== См. также ==
* [[Байесовская классификация]][на 28.01.19 не создан]
* [[Линейная регрессия]][на 28.01.19 не создан]
* [[Вариации регрессии]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Общие понятия]]
* [[Уменьшение размерности]]

== Источники информации ==
#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F Логистическая регрессия] $-$ курс лекций Воронцова
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.LogisticRegression] $-$ реализация алгоритма на scikit-learn.org

[[Категория: Машинное обучение]]

Логистическая регрессия

2019-01-28T14:33:46Z

Alexey Katsman: /* Обоснование */

'''Логистическая регрессия''' (англ. ''logistic regression'') — метод построения линейного классификатора, позволяющий оценивать апостериорные вероятности принадлежности объектов классам.
== Описание ==
Логистическая регрессия применяется для прогнозирования вероятности возникновения некоторого события по значениям множества признаков. Для этого вводится зависимая переменная $y$, принимающая значения $0$ и $1$ и множество [[Независимые случайные величины|независимых]] переменных <tex>x_1, ... x_n</tex> на основе значений которых требуется вычислить вероятность принятия того или иного значения зависимой переменной.

Итак, пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex>

Рассмотрим случай двух классов: $Y = \{-1, +1\}$. В логистической регрессии строится линейный алгоритм классификации $a: X \to Y$ вида
<center><tex>a(x, w) = \mathrm{sign}\left(\sum\limits_{j=1}^n w_j f_j(x) - w_0 \right)=\mathrm{sign}\left<x, w\right></tex></center>
где $w_j$ $-$ вес $j$-го признака, $w_0$ $-$ порог принятия решения, $w=\left(w_0, ..., w_n\right)$ $-$ вектор весов, $\left<x, w\right>$ $-$ скалярное произведение признакового описания объекта на вектор весов. Предполагается, что искусственно введён нулевой признак: $f_{0}(x)=-1$.

Задача обучения линейного классификатора заключается в том, чтобы по выборке $X^m$ настроить вектор весов $w$. В логистической регрессии для этого решается задача минимизации эмпирического риска с функцией потерь специального вида: <center><tex>Q(w) = \sum\limits_{i=1}^m \ln\left( 1 + \exp( -y_i \langle x_i,w \rangle ) \right) \to \min_{w}</tex></center>

После того, как решение $w$ найдено, становится возможным не только вычислять классификацию $a(x) = \mathrm{sign}\langle x,w \rangle$ для произвольного объекта $x$, но и оценивать апостериорные вероятности его принадлежности классам:
<center><tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex></center>
где $\sigma(z) = \frac1{1+e^{-z}}$ — сигмоидная функция.

== Обоснование ==
'''С точки зрения [[Байесовский классификатор|байесовского классификатора]][на 28.01.19 не создан]'''

Наиболее строгое обоснование логистической регрессии опирается на следующую теорему
{{Теорема
|statement=Пусть
*выборка прецедентов $\mathrm{X}^l=\{\left(x_1, y_1\right), ... ,\left(x_l, y_l\right)\}$ получена согласно вероятностному распределению с плотностью
<tex>p\left(x, y\right)=\mathrm{P}_yp_y\left(x\right)=\mathrm{P}\left(y|x\right)p\left(x\right)</tex>
где $\mathrm{P}_y$ $-$ ''априорные вероятности'',
$p_y(x)$ $-$ ''функции правдоподобия'', принадлежащие экспонентному семейству плотностей (т.е. $p_y(x) = \exp \left( \langle\theta,x\rangle \cdot a(\delta) + b(\delta,\theta) + d(x,\delta) \right)$, где $a, b, d$ $-$ произвольные функции)
*функции правдоподобия имеют равные знаения параметра разброса $\delta$ и отличаются только значениями параметра сдвига $\theta_y$
*среди признаков есть константа, скажем, $f_0(x) = -1$
Тогда
*линейный классификатор является оптимальным байесовским классификатором
*апостериорные вероятности классов оценивается по формуле <tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>
|proof=

Напомним, что оптимальный байесовский классификатор для двух классов выглядит следущим образом:
<center><tex>a\left(x\right)=
\mathrm{sign}\left(\lambda_+\mathrm{P}\left(+1|x\right)-\lambda_-\mathrm{P}\left(-1|x\right)\right)=
\mathrm{sign}\left(\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)}-\frac{\lambda_-}{\lambda_+}\right)</tex></center>

Рассмотрим отношение апостериорных вероятностей классов
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)}</tex></center>
и распишем функции правдоподобия, используя экспонентную формулу с параметрами $\theta_y$ и $\delta$:
<center><tex>\frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)} = \exp\left(\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle+b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-}\right)</tex></center>

Рассмотрим получившуюся под экспонентой сумму:
*$\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle = \langle w, x\rangle$. Вектор $w$ не зависит от $x$ и является вектором свободных коэффициентов(весов) при константных признаках
*$b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-} = \mathrm{const}\left(x\right)$. Можно считать данные слагаемые аддитивной добавкой к коэффициенту при признаке. Но так как свободные коэффициенты настраиваются по обучающей выборке, вычислять эту добавку не имеет смысла и ее можно включить в $\langle w, x\rangle$.

Таким образом,
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \mathrm{e}^{\langle w, x\rangle}</tex></center>

Разделяющая поверхность в байесовском решающем правиле определяется уравнением
<center><tex>\lambda_- \mathrm{P}\left(-1|x\right) = \lambda_+ \mathrm{P}\left(+1|x\right)</tex></center>
которое равносильно
<center><tex>\langle w, x\rangle - \ln\frac{\lambda_-}{\lambda_+} = 0</tex></center>
Следовательно, разделяющая поверхность линейна и первый пункт теоремы доказан.

Используя [[Формула полной вероятности|формулу полной вероятности]] получаем следующее равенство
<center><tex>\mathrm{P}\left(+1|x\right) + \mathrm{P}\left(-1|x\right) = \sigma\left(+\langle w ,x\rangle\right) + \sigma\left(-\langle w ,x\rangle\right) = 1</tex></center>

Откуда следует
<center><tex>\mathrm{P}\left(y|x\right)=\sigma\left(\langle w, x\rangle y\right), y = \{-1, +1\}</tex></center>
Таким образом, второй пункт теоремы доказан.
}}

== Примеры кода ==
==== scikit-learn ====
Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.'''LogisticRegression'''] имеет несколько параметров, например:
* '''solver''' $-$ алгоритм, использующийся для оптимизации
* '''multi_class''' $-$ классификация на 2 или много классов

* Импортируем нужные библиотеки
'''from''' sklearn.linear_model '''import''' LogisticRegression
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение
clf = LogisticRegression(random_state='''0''', solver='lbfgs', multi_class='multinomial')
model = clf.'''fit'''(X_train, y_train)

* Предсказание
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

==== [[Примеры кода на Scala#Логистическая регрессия|Пример кода на Scala]] ====

== См. также ==
* [[Байесовская классификация]]
* [[Линейная регрессия]]
* [[Вариации регрессии]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Общие понятия]]
* [[Уменьшение размерности]]

== Источники информации ==
#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F Логистическая регрессия] $-$ курс лекций Воронцова
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.LogisticRegression] $-$ реализация алгоритма на scikit-learn.org

[[Категория: Машинное обучение]]

Нейронные сети, перцептрон

2019-01-28T14:33:03Z

Alexey Katsman: /* См. также */

'''Искусственная нейронная сеть (ИНС)''' (англ. ''Artificial neural network (ANN)'') {{---}} это упрощенная модель биологической нейронной сети, представляющая собой совокупность искусственных нейронов, взаимодействующих между собой.

[[File:Нейронная_сеть.png|700px|thumb|[https://neuralnet.info/chapter/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5/#%D0%92-%D1%86%D0%B5%D0%BB%D0%BE%D0%BC-%D0%BE%D0%B1-%D0%98%D0%9D%D0%A1 Упрощение биологической нейронной сети]]]

Основные принципы работы нейронных сетей были описаны еще в 1943 году Уорреном Мак-Каллоком и Уолтером Питтсом<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref>. В 1957 году нейрофизиолог Фрэнк Розенблатт разработал первую нейронную сеть<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref>, а в 2010 году большие объемы данных для обучения открыли возможность использовать нейронные сети для машинного обучения.

На данный момент нейронные сети используются в многочисленных областях машинного обучения и решают проблемы различной сложности.

==Структура нейронной сети==

[[File:Искусственный_нейрон_схема.png|700px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD Схема искусственного нейрона]]]

Хорошим примером биологической нейронной сети является человеческий мозг. Наш мозг {{---}} сложнейшая биологическая нейронная сеть, которая принимает информацию от органов чувств и каким-то образом ее обрабатывает (узнавание лиц, возникновение ощущений и т.д.). Мозг же, в свою очередь, состоит из нейронов, взаимодействующих между собой.

Для построения искусственной нейронной сети будем использовать ту же структуру. Как и биологическая нейронная сеть, искусственная состоит из нейронов, взаимодействующих между собой, однако представляет собой упрощенную модель. Так, например, искусственный нейрон, из которых состоит ИНС, имеет намного более простую структуру: у него есть несколько входов, на которых он принимает различные сигналы, преобразует их и передает другим нейронам. Другими словами, искусственный нейрон {{---}} это такая функция <tex>\mathbb{R}^n \rightarrow \mathbb{R}</tex>, которая преобразует несколько входных параметров в один выходной.

Как видно на рисунке справа, у нейрона есть <tex>n</tex> входов <tex>x_i</tex>, у каждого из которого есть вес <tex>w_i</tex>, на который умножается сигнал, проходящий по связи. После этого взвешенные сигналы <tex>x_i \cdot w_i</tex> направляются в сумматор, который аггрегирует все сигналы во взвешенную сумму. Эту сумму также называют <tex>net</tex>. Таким образом, <tex>net = \sum_{i=1}^{i=n} w_i \cdot x_i = w^T \cdot x</tex>.

Просто так передавать взвешенную сумму <tex>net</tex> на выход достаточно бессмысленно {{---}} нейрон должен ее как-то обработать и сформировать адекватный выходной сигнал. Для этих целей используют [[Практики реализации нейронных сетей#Функции активации|функцию активации]], которая преобразует взвешенную сумму в какое-то число, которое и будет являться выходом нейрона. Функция активации обозначается <tex>\phi(net)</tex>. Таким образом, выходов искусственного нейрона является <tex>\phi(net)</tex>.

Для разных типов нейронов используют самые разные функции активации, но одними из самых популярных являются:
* Функция единичного скачка. Если <tex>net > threshold</tex>, <tex>\phi(net) = 1</tex>, а иначе <tex>0</tex>;
* Сигмоидальная функция. <tex>\phi(net) = \frac{1}{1 + exp(-a \cdot net)}</tex>, где параметр <tex>a</tex> характеризует степень крутизны функции;
* Гиперболический тангенс. <tex>\phi(net) = tanh(\frac{net}{a})</tex>, где параметр <tex>a</tex> также определяет степень крутизны графика функции;
* Rectified linear units (ReLU). <tex>ReLU(x) = \begin{cases}
x & x \geq 0 \\
0 & x < 0
\end{cases} = \max(x, 0)</tex>.

==Виды нейронных сетей==

Разобравшись с тем, как устроен нейрон в нейронной сети, осталось понять, как их в этой сети располагать и соединять.

Как правило, в большинстве нейронных сетей есть так называемый ''входной слой'', который выполняет только одну задачу {{---}} распределение входных сигналов остальным нейронам. Нейроны этого слоя не производят никаких вычислений. В остальном нейронные сети делятся на основные категории, представленные ниже.

===Однослойные нейронные сети===

[[File:Single-layer-neural-net-scheme.png|500px|thumb|[https://studfiles.net/preview/3170620/page:3/ Схема однослойной нейронной сети]]]

'''Однослойная нейронная сеть''' (англ. ''Single-layer neural network'') {{---}} сеть, в которой сигналы от входного слоя сразу подаются на выходной слой, который и преобразует сигнал и сразу же выдает ответ.

Как видно из схемы однослойной нейронной сети, представленной справа, сигналы <tex>x_1, x_2, \ldots x_n</tex> поступают на входной слой (который не считается за слой нейронной сети), а затем сигналы распределяются на выходной слой обычных нейронов. На каждом ребре от нейрона входного слоя к нейрону выходного слоя написано число {{---}} вес соответствующей связи.

===Многослойные нейронные сети===

[[File:Multi-layer-neural-net-scheme.png|500px|thumb|[https://wiki.loginom.ru/articles/multilayer-neural-net.html Схема многослойной нейронной сети]]]

'''Многослойная нейронная сеть''' (англ. ''Multilayer neural network'') {{---}} нейронная сеть, состоящая из входного, выходного и расположенного(ых) между ними одного (нескольких) скрытых слоев нейронов.

Помимо входного и выходного слоев эти нейронные сети содержат промежуточные, ''скрытые слои''. Такие сети обладают гораздо большими возможностями, чем однослойные нейронные сети, однако методы обучения нейронов скрытого слоя были разработаны относительно недавно.

Работу скрытых слоев нейронов можно сравнить с работой большого завода. Продукт (выходной сигнал) на заводе собирается по стадиям на станках. После каждого станка получается какой-то промежуточный результат. Скрытые слои тоже преобразуют входные сигналы в некоторые промежуточные результаты.

===Сети прямого распространения===

'''Сети прямого распространения''' (англ. ''Feedforward neural network'') (feedforward сети) {{---}} искусственные нейронные сети, в которых сигнал распространяется строго от входного слоя к выходному. В обратном направлении сигнал не распространяется.

Все сети, описанные выше, являлись сетями прямого распространения, как следует из определения. Такие сети широко используются и вполне успешно решают определенный класс задач: прогнозирование, кластеризация и распознавание.

Однако сигнал в нейронных сетях может идти и в обратную сторону.

===Сети с обратными связями===

[[File:Сети_с_обратными_связями.png|400px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%A1%D0%B5%D1%82%D0%B8-%D1%81-%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%BC%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8F%D0%BC%D0%B8 Схема сети с обратными связями]]]

'''[[Рекуррентные нейронные сети|Сети с обратными связями]]''' (англ. ''Recurrent neural network'') {{---}} искусственные нейронные сети, в которых выход нейрона может вновь подаваться на его вход. В более общем случае это означает возможность распространения сигнала от выходов к входам.

В сетях прямого распространения выход сети определяется входным сигналом и весовыми коэффициентами при искусственных нейронах. В сетях с обратными связями выходы нейронов могут возвращаться на входы. Это означает, что выход какого-нибудь нейрона определяется не только его весами и входным сигналом, но еще и предыдущими выходами (так как они снова вернулись на входы).

==Обучение нейронной сети==

'''Обучение нейронной сети''' {{---}} поиск такого набора весовых коэффициентов, при котором входной сигнал после прохода по сети преобразуется в нужный нам выходной.

Это определение «обучения нейронной сети» соответствует и биологическим нейросетям. Наш мозг состоит из огромного количества связанных друг с другом нейросетей, каждая из которых в отдельности состоит из нейронов одного типа (с одинаковой функцией активации). Наш мозг обучается благодаря изменению синапсов {{---}} элементов, которые усиливают или ослабляют входной сигнал.

Если обучать сеть, используя только один входной сигнал, то сеть просто «запомнит правильный ответ», а как только мы подадим немного измененный сигнал, вместо правильного ответа получим бессмыслицу. Мы ждем от сети способности ''обобщать'' какие-то признаки и решать задачу на различных входных данных. Именно с этой целью и создаются ''обучающие выборки''.

'''Обучающая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит обучение сети.

После обучения сети, то есть когда сеть выдает корректные результаты для всех входных сигналов из обучающей выборки, ее можно использовать на практике. Однако прежде чем сразу использовать нейронную сеть, обычно производят оценку качества ее работы на так называемой ''тестовой выборке''.

'''Тестовая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит оценка качества работы сети.

Само обучение нейронной сети можно разделить на два подхода: [[Обучение с учителем|обучение с учителем]][на 28.01.19 не создан] и [[Обучение без учителя|обучение без учителя]][на 28.01.19 не создан]. В первом случае веса меняются так, чтобы ответы сети минимально отличались от уже готовых правильных ответов, а во втором случае сеть самостоятельно классифицирует входные сигналы.

==Перцептрон==

[[File:Перцептрон.png|350px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9F%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема перцептрона]]]

'''Перцептрон''' (англ. ''Perceptron'') {{---}} простейший вид нейронных сетей. В основе лежит математическая модель восприятия информации мозгом, состоящая из сенсоров, ассоциативных и реагирующих элементов.

===История===

Идею перцептрона предложил нейрофизиолог Фрэнк Розенблатт. Он предложил схему устройства, моделирующего процесс человеческого восприятия, и назвал его ''«перцептроном»'' (от латинского ''perceptio'' {{---}} восприятие). В 1960 году Розенблатт представил первый нейрокомпьютер {{---}} «Марк-1», который был способен распознавать некоторые буквы английского алфавита.

Таким образом перцептрон является одной из первых '''моделей нейросетей''', а «Марк-1» {{---}} первым в мире '''нейрокомпьютером'''.

===Описание===

В основе перцептрона лежит математическая модель восприятия информации мозгом. Разные исследователи по-разному его определяют. В самом общем своем виде (как его описывал Розенблатт) он представляет систему из элементов трех разных типов: сенсоров, ассоциативных элементов и реагирующих элементов.

Принцип работы перцептрона следующий:
# Первыми в работу включаются S-элементы. Они могут находиться либо в состоянии покоя (сигнал равен ''0''), либо в состоянии возбуждения (сигнал равен ''1'').
# Далее сигналы от S-элементов передаются A-элементам по так называемым S-A связям. Эти связи могут иметь веса, равные только ''-1'', ''0'' или ''1''.
# Затем сигналы от сенсорных элементов, прошедших по S-A связям, попадают в A-элементы, которые еще называют ассоциативными элементами.
#* Одному A-элементу может соответствовать несколько S-элементов;
#* Если сигналы, поступившие на A-элемент, в совокупности превышают некоторый его порог <tex>\theta</tex>, то этот A-элемент возбуждается и выдает сигнал, равный ''1'';
#* В противном случае (сигнал от S-элементов не превысил порога A-элемента), генерируется нулевой сигнал.
# Далее сигналы, которые произвели возбужденные A-элементы, направляются к сумматору (R-элемент), действие которого нам уже известно. Однако, чтобы добраться до R-элемента, они проходят по A-R связям, у которых тоже есть веса (которые уже могут принимать любые значения, в отличие от S-A связей).
# R-элемент складывает друг с другом взвешенные сигналы от A-элементов, а затем
#* если превышен определенный порог, генерирует выходной сигнал, равный ''1'';
#* eсли порог не превышен, то выход перцептрона равен ''-1''.

Для элементов перцептрона используют следующие названия:
* S-элементы называют сенсорами;
* A-элементы называют ассоциативными;
* R-элементы называют реагирующими.

===Классификация перцептронов===

[[File:Однслойный_перцептрон.png|300px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9-%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема однослойного перцептрона]]]

'''Перцептрон с одним скрытым слоем''' ('''элементарный перцептрон''', англ. ''elementary perceptron'') {{---}} перцептрон, у которого имеется только по одному слою S, A и R элементов.

'''Однослойный персептрон''' (англ. ''Single-layer perceptron'') {{---}} перцептрон, каждый S-элемент которого однозначно соответствует одному А-элементу, S-A связи всегда имеют вес ''1'', а порог любого А-элемента равен ''1''. Часть однослойного персептрона соответствует модели искусственного нейрона.

Его ключевая особенность состоит в том, что каждый S-элемент однозначно соответствует одному A-элементу, все S-A связи имеют вес, равный ''+1'', а порог A элементов равен ''1''. Часть однослойного перцептрона, не содержащая входы, соответствует искусственному нейрону, как показано на картинке. Таким образом, однослойный перцептрон {{---}} это искусственный нейрон, который на вход принимает только ''0'' и ''1''.

Однослойный персептрон также может быть и элементарным персептроном, у которого только по одному слою S,A,R-элементов.

'''Многослойный перцептрон по Розенблатту''' (англ. ''Rosenblatt multilayer perceptron'') {{---}} перцептрон, который содержит более 1 слоя А-элементов.

'''Многослойный перцептрон по Румельхарту''' (англ. ''Rumelhart multilater perceptron'') {{---}} частный случай многослойного персептрона по Розенблатту, с двумя особенностями:
* S-A связи могут иметь произвольные веса и обучаться наравне с A-R связями;
* Обучение производится по специальному алгоритму, который называется обучением по методу обратного распространения ошибки.

===Обучение перцептрона===

Задача обучения перцептрона {{---}} подобрать такие <tex>w_0, w_1, w_2, \ldots, w_n</tex>, чтобы <tex>sign(\sigma(w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n))</tex> как можно чаще совпадал с <tex>y(x)</tex> {{---}} значением в обучающей выборке (здесь <tex>\sigma</tex> {{---}} функция активации). Для удобства, чтобы не тащить за собой свободный член <tex>w_0</tex>, добавим в вектор $x$ лишнюю «виртуальную размерность» и будем считать, что <tex>x = (1, x_1, x_2, \ldots, x_n)</tex>. Тогда <tex>w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n</tex> можно заменить на <tex>w^T \cdot x</tex>.

Чтобы обучать эту функцию, сначала надо выбрать функцию ошибки, которую потом можно оптимизировать [[Стохастический градиентный спуск|градиентным спуском]]. Число неверно классифицированных примеров не подходит на эту кандидатуру, потому что эта функция кусочно-гладкая, с массой разрывов: она будет принимать только целые значения и резко меняться при переходе от одного числа неверно классифицированных примеров к другому. Поэтому использовать будем другую функцию, так называемый ''критерий перцептрона'': <tex>E_P(w) = -\sum_{x \in M} y(x)(\sigma(w^T \cdot x))</tex>, где <tex>M</tex> {{---}} множество примеров, которые перцептрон с весами <tex>w</tex> классифицирует неправильно.

Иначе говоря, мы минимизируем суммарное отклонение наших ответов от правильных, но только в неправильную сторону; верный ответ ничего не вносит в функцию ошибки. Умножение на <tex>y(x)</tex> здесь нужно для того, чтобы знак произведения всегда получался отрицательным: если правильный ответ ''−1'', значит, перцептрон выдал положительное число (иначе бы ответ был верным), и наоборот. В результате у нас получилась кусочно-линейная функция, дифференцируемая почти везде, а этого вполне достаточно.

Теперь <tex>E_P(w)</tex> можно оптимизировать градиентным спуском. На очередном шаге получаем: <tex>w^{(\tau+1)} = w^{(\tau)} − \eta\triangledown_w E_P(w)</tex>.

Алгоритм такой {{---}} мы последовательно проходим примеры <tex>x_1, x_2, \ldots</tex> из обучающего множества, и для каждого <tex>x_n</tex>:
* если он классифицирован правильно, не меняем ничего;
* а если неправильно, прибавляем <tex>\eta \triangledown_w E_P(w)</tex>.

Ошибка на примере <tex>x_n</tex> при этом, очевидно, уменьшается, но, конечно, совершенно никто не гарантирует, что вместе с тем не увеличится ошибка от других примеров. Это правило обновления весов так и называется {{---}} правило обучения перцептрона, и это было основной математической идеей работы Розенблатта.

===Применение===

* Решение задач классификации, если объекты классификации обладают свойством линейной разделимости
* Прогнозирование и распознавание образов
* Управление агентами<ref>[https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D0%BE%D0%B2 Применения перцептрона, Wikipedia]</ref>

===Пример использования с помощью scikit-learn<ref>[https://scikit-learn.org Библиотека scikit-learn для Python]</ref>===

Будем классифицировать с помощью перцептрона датасет MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>.

# Load required libraries
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Perceptron #Single-layer perceptron
from sklearn.neural_network import MLPClassifier #Multilayer perceptron
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# Load the mnist dataset
mnist = datasets.load_digits()

# Create our X and y data
n_samples = len(mnist.images)
X = mnist.images.reshape((n_samples, -1))
y = mnist.target

# Split the data into 70% training data and 30% test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Train the scaler, which standarizes all the features to have mean=0 and unit variance
sc = StandardScaler()
sc.fit(X_train)

# Apply the scaler to the X training data
X_train_std = sc.transform(X_train)

# Apply the SAME scaler to the X test data
X_test_std = sc.transform(X_test)

# Create a single-layer perceptron object with the parameters: 40 iterations (epochs) over the data, and a learning rate of 0.1
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
# Create a multilayer perceptron object
mppn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(256, 512, 128), random_state=1)

# Train the perceptrons
ppn.fit(X_train_std, y_train)
mppn.fit(X_train_std, y_train)

# Apply the trained perceptrons on the X data to make predicts for the y test data
y_pred = ppn.predict(X_test_std)
multi_y_pred = mppn.predict(X_test_std)

# View the accuracies of the model, which is: 1 - (observations predicted wrong / total observations)
print('Single-layer perceptron accuracy: %.4f' % accuracy_score(y_test, y_pred))
print('Multilayer perceptron accuracy: %.4f' % accuracy_score(y_test, multi_y_pred))

Вывод:
Single-layer perceptron accuracy: 0.9574
Multilayer perceptron accuracy: 0.9759

===Пример использования с помощью tensorflow<ref>[https://www.tensorflow.org/ Библиотека tensorflow для Python]</ref>===

Будем классифицировать цифры из того же датасета MNIST.

# Load required libraries
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Load MNIST dataset
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#placeholder for test data
x = tf.placeholder(tf.float32, [None, 784])
#placeholder for weights and bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#tensorflow model
y = tf.nn.softmax(tf.matmul(x, W) + b)

#loss function
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#gradient descent step
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Accuracy: %s" % sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

[[File:Tensorflow-mnist-failures.png|400px|thumb|Правильные метки {{---}} 5, 4, 9, 7. Результат классификации {{---}} 6, 6, 4, 4.]]

Вывод:
Accuracy: 0.9164

На рисунке справа показаны четыре типичных изображения, на которых классификаторы ошибаются. Согласитесь, случаи действительно тяжелые.

==См. также==
*[[:Сверточные нейронные сети|Сверточные нейронные сети]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан]

==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 93-123.
* [https://neuralnet.info/book/ Нейронные сети {{---}} учебник ]

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]

Нейронные сети, перцептрон

2019-01-28T14:32:45Z

Alexey Katsman: /* Обучение перцептрона */

'''Искусственная нейронная сеть (ИНС)''' (англ. ''Artificial neural network (ANN)'') {{---}} это упрощенная модель биологической нейронной сети, представляющая собой совокупность искусственных нейронов, взаимодействующих между собой.

[[File:Нейронная_сеть.png|700px|thumb|[https://neuralnet.info/chapter/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5/#%D0%92-%D1%86%D0%B5%D0%BB%D0%BE%D0%BC-%D0%BE%D0%B1-%D0%98%D0%9D%D0%A1 Упрощение биологической нейронной сети]]]

Основные принципы работы нейронных сетей были описаны еще в 1943 году Уорреном Мак-Каллоком и Уолтером Питтсом<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref>. В 1957 году нейрофизиолог Фрэнк Розенблатт разработал первую нейронную сеть<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref>, а в 2010 году большие объемы данных для обучения открыли возможность использовать нейронные сети для машинного обучения.

На данный момент нейронные сети используются в многочисленных областях машинного обучения и решают проблемы различной сложности.

==Структура нейронной сети==

[[File:Искусственный_нейрон_схема.png|700px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD Схема искусственного нейрона]]]

Хорошим примером биологической нейронной сети является человеческий мозг. Наш мозг {{---}} сложнейшая биологическая нейронная сеть, которая принимает информацию от органов чувств и каким-то образом ее обрабатывает (узнавание лиц, возникновение ощущений и т.д.). Мозг же, в свою очередь, состоит из нейронов, взаимодействующих между собой.

Для построения искусственной нейронной сети будем использовать ту же структуру. Как и биологическая нейронная сеть, искусственная состоит из нейронов, взаимодействующих между собой, однако представляет собой упрощенную модель. Так, например, искусственный нейрон, из которых состоит ИНС, имеет намного более простую структуру: у него есть несколько входов, на которых он принимает различные сигналы, преобразует их и передает другим нейронам. Другими словами, искусственный нейрон {{---}} это такая функция <tex>\mathbb{R}^n \rightarrow \mathbb{R}</tex>, которая преобразует несколько входных параметров в один выходной.

Как видно на рисунке справа, у нейрона есть <tex>n</tex> входов <tex>x_i</tex>, у каждого из которого есть вес <tex>w_i</tex>, на который умножается сигнал, проходящий по связи. После этого взвешенные сигналы <tex>x_i \cdot w_i</tex> направляются в сумматор, который аггрегирует все сигналы во взвешенную сумму. Эту сумму также называют <tex>net</tex>. Таким образом, <tex>net = \sum_{i=1}^{i=n} w_i \cdot x_i = w^T \cdot x</tex>.

Просто так передавать взвешенную сумму <tex>net</tex> на выход достаточно бессмысленно {{---}} нейрон должен ее как-то обработать и сформировать адекватный выходной сигнал. Для этих целей используют [[Практики реализации нейронных сетей#Функции активации|функцию активации]], которая преобразует взвешенную сумму в какое-то число, которое и будет являться выходом нейрона. Функция активации обозначается <tex>\phi(net)</tex>. Таким образом, выходов искусственного нейрона является <tex>\phi(net)</tex>.

Для разных типов нейронов используют самые разные функции активации, но одними из самых популярных являются:
* Функция единичного скачка. Если <tex>net > threshold</tex>, <tex>\phi(net) = 1</tex>, а иначе <tex>0</tex>;
* Сигмоидальная функция. <tex>\phi(net) = \frac{1}{1 + exp(-a \cdot net)}</tex>, где параметр <tex>a</tex> характеризует степень крутизны функции;
* Гиперболический тангенс. <tex>\phi(net) = tanh(\frac{net}{a})</tex>, где параметр <tex>a</tex> также определяет степень крутизны графика функции;
* Rectified linear units (ReLU). <tex>ReLU(x) = \begin{cases}
x & x \geq 0 \\
0 & x < 0
\end{cases} = \max(x, 0)</tex>.

==Виды нейронных сетей==

Разобравшись с тем, как устроен нейрон в нейронной сети, осталось понять, как их в этой сети располагать и соединять.

Как правило, в большинстве нейронных сетей есть так называемый ''входной слой'', который выполняет только одну задачу {{---}} распределение входных сигналов остальным нейронам. Нейроны этого слоя не производят никаких вычислений. В остальном нейронные сети делятся на основные категории, представленные ниже.

===Однослойные нейронные сети===

[[File:Single-layer-neural-net-scheme.png|500px|thumb|[https://studfiles.net/preview/3170620/page:3/ Схема однослойной нейронной сети]]]

'''Однослойная нейронная сеть''' (англ. ''Single-layer neural network'') {{---}} сеть, в которой сигналы от входного слоя сразу подаются на выходной слой, который и преобразует сигнал и сразу же выдает ответ.

Как видно из схемы однослойной нейронной сети, представленной справа, сигналы <tex>x_1, x_2, \ldots x_n</tex> поступают на входной слой (который не считается за слой нейронной сети), а затем сигналы распределяются на выходной слой обычных нейронов. На каждом ребре от нейрона входного слоя к нейрону выходного слоя написано число {{---}} вес соответствующей связи.

===Многослойные нейронные сети===

[[File:Multi-layer-neural-net-scheme.png|500px|thumb|[https://wiki.loginom.ru/articles/multilayer-neural-net.html Схема многослойной нейронной сети]]]

'''Многослойная нейронная сеть''' (англ. ''Multilayer neural network'') {{---}} нейронная сеть, состоящая из входного, выходного и расположенного(ых) между ними одного (нескольких) скрытых слоев нейронов.

Помимо входного и выходного слоев эти нейронные сети содержат промежуточные, ''скрытые слои''. Такие сети обладают гораздо большими возможностями, чем однослойные нейронные сети, однако методы обучения нейронов скрытого слоя были разработаны относительно недавно.

Работу скрытых слоев нейронов можно сравнить с работой большого завода. Продукт (выходной сигнал) на заводе собирается по стадиям на станках. После каждого станка получается какой-то промежуточный результат. Скрытые слои тоже преобразуют входные сигналы в некоторые промежуточные результаты.

===Сети прямого распространения===

'''Сети прямого распространения''' (англ. ''Feedforward neural network'') (feedforward сети) {{---}} искусственные нейронные сети, в которых сигнал распространяется строго от входного слоя к выходному. В обратном направлении сигнал не распространяется.

Все сети, описанные выше, являлись сетями прямого распространения, как следует из определения. Такие сети широко используются и вполне успешно решают определенный класс задач: прогнозирование, кластеризация и распознавание.

Однако сигнал в нейронных сетях может идти и в обратную сторону.

===Сети с обратными связями===

[[File:Сети_с_обратными_связями.png|400px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%A1%D0%B5%D1%82%D0%B8-%D1%81-%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%BC%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8F%D0%BC%D0%B8 Схема сети с обратными связями]]]

'''[[Рекуррентные нейронные сети|Сети с обратными связями]]''' (англ. ''Recurrent neural network'') {{---}} искусственные нейронные сети, в которых выход нейрона может вновь подаваться на его вход. В более общем случае это означает возможность распространения сигнала от выходов к входам.

В сетях прямого распространения выход сети определяется входным сигналом и весовыми коэффициентами при искусственных нейронах. В сетях с обратными связями выходы нейронов могут возвращаться на входы. Это означает, что выход какого-нибудь нейрона определяется не только его весами и входным сигналом, но еще и предыдущими выходами (так как они снова вернулись на входы).

==Обучение нейронной сети==

'''Обучение нейронной сети''' {{---}} поиск такого набора весовых коэффициентов, при котором входной сигнал после прохода по сети преобразуется в нужный нам выходной.

Это определение «обучения нейронной сети» соответствует и биологическим нейросетям. Наш мозг состоит из огромного количества связанных друг с другом нейросетей, каждая из которых в отдельности состоит из нейронов одного типа (с одинаковой функцией активации). Наш мозг обучается благодаря изменению синапсов {{---}} элементов, которые усиливают или ослабляют входной сигнал.

Если обучать сеть, используя только один входной сигнал, то сеть просто «запомнит правильный ответ», а как только мы подадим немного измененный сигнал, вместо правильного ответа получим бессмыслицу. Мы ждем от сети способности ''обобщать'' какие-то признаки и решать задачу на различных входных данных. Именно с этой целью и создаются ''обучающие выборки''.

'''Обучающая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит обучение сети.

После обучения сети, то есть когда сеть выдает корректные результаты для всех входных сигналов из обучающей выборки, ее можно использовать на практике. Однако прежде чем сразу использовать нейронную сеть, обычно производят оценку качества ее работы на так называемой ''тестовой выборке''.

'''Тестовая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит оценка качества работы сети.

Само обучение нейронной сети можно разделить на два подхода: [[Обучение с учителем|обучение с учителем]][на 28.01.19 не создан] и [[Обучение без учителя|обучение без учителя]][на 28.01.19 не создан]. В первом случае веса меняются так, чтобы ответы сети минимально отличались от уже готовых правильных ответов, а во втором случае сеть самостоятельно классифицирует входные сигналы.

==Перцептрон==

[[File:Перцептрон.png|350px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9F%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема перцептрона]]]

'''Перцептрон''' (англ. ''Perceptron'') {{---}} простейший вид нейронных сетей. В основе лежит математическая модель восприятия информации мозгом, состоящая из сенсоров, ассоциативных и реагирующих элементов.

===История===

Идею перцептрона предложил нейрофизиолог Фрэнк Розенблатт. Он предложил схему устройства, моделирующего процесс человеческого восприятия, и назвал его ''«перцептроном»'' (от латинского ''perceptio'' {{---}} восприятие). В 1960 году Розенблатт представил первый нейрокомпьютер {{---}} «Марк-1», который был способен распознавать некоторые буквы английского алфавита.

Таким образом перцептрон является одной из первых '''моделей нейросетей''', а «Марк-1» {{---}} первым в мире '''нейрокомпьютером'''.

===Описание===

В основе перцептрона лежит математическая модель восприятия информации мозгом. Разные исследователи по-разному его определяют. В самом общем своем виде (как его описывал Розенблатт) он представляет систему из элементов трех разных типов: сенсоров, ассоциативных элементов и реагирующих элементов.

Принцип работы перцептрона следующий:
# Первыми в работу включаются S-элементы. Они могут находиться либо в состоянии покоя (сигнал равен ''0''), либо в состоянии возбуждения (сигнал равен ''1'').
# Далее сигналы от S-элементов передаются A-элементам по так называемым S-A связям. Эти связи могут иметь веса, равные только ''-1'', ''0'' или ''1''.
# Затем сигналы от сенсорных элементов, прошедших по S-A связям, попадают в A-элементы, которые еще называют ассоциативными элементами.
#* Одному A-элементу может соответствовать несколько S-элементов;
#* Если сигналы, поступившие на A-элемент, в совокупности превышают некоторый его порог <tex>\theta</tex>, то этот A-элемент возбуждается и выдает сигнал, равный ''1'';
#* В противном случае (сигнал от S-элементов не превысил порога A-элемента), генерируется нулевой сигнал.
# Далее сигналы, которые произвели возбужденные A-элементы, направляются к сумматору (R-элемент), действие которого нам уже известно. Однако, чтобы добраться до R-элемента, они проходят по A-R связям, у которых тоже есть веса (которые уже могут принимать любые значения, в отличие от S-A связей).
# R-элемент складывает друг с другом взвешенные сигналы от A-элементов, а затем
#* если превышен определенный порог, генерирует выходной сигнал, равный ''1'';
#* eсли порог не превышен, то выход перцептрона равен ''-1''.

Для элементов перцептрона используют следующие названия:
* S-элементы называют сенсорами;
* A-элементы называют ассоциативными;
* R-элементы называют реагирующими.

===Классификация перцептронов===

[[File:Однслойный_перцептрон.png|300px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9-%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема однослойного перцептрона]]]

'''Перцептрон с одним скрытым слоем''' ('''элементарный перцептрон''', англ. ''elementary perceptron'') {{---}} перцептрон, у которого имеется только по одному слою S, A и R элементов.

'''Однослойный персептрон''' (англ. ''Single-layer perceptron'') {{---}} перцептрон, каждый S-элемент которого однозначно соответствует одному А-элементу, S-A связи всегда имеют вес ''1'', а порог любого А-элемента равен ''1''. Часть однослойного персептрона соответствует модели искусственного нейрона.

Его ключевая особенность состоит в том, что каждый S-элемент однозначно соответствует одному A-элементу, все S-A связи имеют вес, равный ''+1'', а порог A элементов равен ''1''. Часть однослойного перцептрона, не содержащая входы, соответствует искусственному нейрону, как показано на картинке. Таким образом, однослойный перцептрон {{---}} это искусственный нейрон, который на вход принимает только ''0'' и ''1''.

Однослойный персептрон также может быть и элементарным персептроном, у которого только по одному слою S,A,R-элементов.

'''Многослойный перцептрон по Розенблатту''' (англ. ''Rosenblatt multilayer perceptron'') {{---}} перцептрон, который содержит более 1 слоя А-элементов.

'''Многослойный перцептрон по Румельхарту''' (англ. ''Rumelhart multilater perceptron'') {{---}} частный случай многослойного персептрона по Розенблатту, с двумя особенностями:
* S-A связи могут иметь произвольные веса и обучаться наравне с A-R связями;
* Обучение производится по специальному алгоритму, который называется обучением по методу обратного распространения ошибки.

===Обучение перцептрона===

Задача обучения перцептрона {{---}} подобрать такие <tex>w_0, w_1, w_2, \ldots, w_n</tex>, чтобы <tex>sign(\sigma(w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n))</tex> как можно чаще совпадал с <tex>y(x)</tex> {{---}} значением в обучающей выборке (здесь <tex>\sigma</tex> {{---}} функция активации). Для удобства, чтобы не тащить за собой свободный член <tex>w_0</tex>, добавим в вектор $x$ лишнюю «виртуальную размерность» и будем считать, что <tex>x = (1, x_1, x_2, \ldots, x_n)</tex>. Тогда <tex>w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n</tex> можно заменить на <tex>w^T \cdot x</tex>.

Чтобы обучать эту функцию, сначала надо выбрать функцию ошибки, которую потом можно оптимизировать [[Стохастический градиентный спуск|градиентным спуском]]. Число неверно классифицированных примеров не подходит на эту кандидатуру, потому что эта функция кусочно-гладкая, с массой разрывов: она будет принимать только целые значения и резко меняться при переходе от одного числа неверно классифицированных примеров к другому. Поэтому использовать будем другую функцию, так называемый ''критерий перцептрона'': <tex>E_P(w) = -\sum_{x \in M} y(x)(\sigma(w^T \cdot x))</tex>, где <tex>M</tex> {{---}} множество примеров, которые перцептрон с весами <tex>w</tex> классифицирует неправильно.

Иначе говоря, мы минимизируем суммарное отклонение наших ответов от правильных, но только в неправильную сторону; верный ответ ничего не вносит в функцию ошибки. Умножение на <tex>y(x)</tex> здесь нужно для того, чтобы знак произведения всегда получался отрицательным: если правильный ответ ''−1'', значит, перцептрон выдал положительное число (иначе бы ответ был верным), и наоборот. В результате у нас получилась кусочно-линейная функция, дифференцируемая почти везде, а этого вполне достаточно.

Теперь <tex>E_P(w)</tex> можно оптимизировать градиентным спуском. На очередном шаге получаем: <tex>w^{(\tau+1)} = w^{(\tau)} − \eta\triangledown_w E_P(w)</tex>.

Алгоритм такой {{---}} мы последовательно проходим примеры <tex>x_1, x_2, \ldots</tex> из обучающего множества, и для каждого <tex>x_n</tex>:
* если он классифицирован правильно, не меняем ничего;
* а если неправильно, прибавляем <tex>\eta \triangledown_w E_P(w)</tex>.

Ошибка на примере <tex>x_n</tex> при этом, очевидно, уменьшается, но, конечно, совершенно никто не гарантирует, что вместе с тем не увеличится ошибка от других примеров. Это правило обновления весов так и называется {{---}} правило обучения перцептрона, и это было основной математической идеей работы Розенблатта.

===Применение===

* Решение задач классификации, если объекты классификации обладают свойством линейной разделимости
* Прогнозирование и распознавание образов
* Управление агентами<ref>[https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D0%BE%D0%B2 Применения перцептрона, Wikipedia]</ref>

===Пример использования с помощью scikit-learn<ref>[https://scikit-learn.org Библиотека scikit-learn для Python]</ref>===

Будем классифицировать с помощью перцептрона датасет MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>.

# Load required libraries
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Perceptron #Single-layer perceptron
from sklearn.neural_network import MLPClassifier #Multilayer perceptron
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# Load the mnist dataset
mnist = datasets.load_digits()

# Create our X and y data
n_samples = len(mnist.images)
X = mnist.images.reshape((n_samples, -1))
y = mnist.target

# Split the data into 70% training data and 30% test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Train the scaler, which standarizes all the features to have mean=0 and unit variance
sc = StandardScaler()
sc.fit(X_train)

# Apply the scaler to the X training data
X_train_std = sc.transform(X_train)

# Apply the SAME scaler to the X test data
X_test_std = sc.transform(X_test)

# Create a single-layer perceptron object with the parameters: 40 iterations (epochs) over the data, and a learning rate of 0.1
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
# Create a multilayer perceptron object
mppn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(256, 512, 128), random_state=1)

# Train the perceptrons
ppn.fit(X_train_std, y_train)
mppn.fit(X_train_std, y_train)

# Apply the trained perceptrons on the X data to make predicts for the y test data
y_pred = ppn.predict(X_test_std)
multi_y_pred = mppn.predict(X_test_std)

# View the accuracies of the model, which is: 1 - (observations predicted wrong / total observations)
print('Single-layer perceptron accuracy: %.4f' % accuracy_score(y_test, y_pred))
print('Multilayer perceptron accuracy: %.4f' % accuracy_score(y_test, multi_y_pred))

Вывод:
Single-layer perceptron accuracy: 0.9574
Multilayer perceptron accuracy: 0.9759

===Пример использования с помощью tensorflow<ref>[https://www.tensorflow.org/ Библиотека tensorflow для Python]</ref>===

Будем классифицировать цифры из того же датасета MNIST.

# Load required libraries
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Load MNIST dataset
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#placeholder for test data
x = tf.placeholder(tf.float32, [None, 784])
#placeholder for weights and bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#tensorflow model
y = tf.nn.softmax(tf.matmul(x, W) + b)

#loss function
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#gradient descent step
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Accuracy: %s" % sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

[[File:Tensorflow-mnist-failures.png|400px|thumb|Правильные метки {{---}} 5, 4, 9, 7. Результат классификации {{---}} 6, 6, 4, 4.]]

Вывод:
Accuracy: 0.9164

На рисунке справа показаны четыре типичных изображения, на которых классификаторы ошибаются. Согласитесь, случаи действительно тяжелые.

==См. также==
*[[:Сверточные нейронные сети|Сверточные нейронные сети]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]
==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 93-123.
* [https://neuralnet.info/book/ Нейронные сети {{---}} учебник ]

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]

Нейронные сети, перцептрон

2019-01-28T14:32:24Z

Alexey Katsman: /* Обучение нейронной сети */

'''Искусственная нейронная сеть (ИНС)''' (англ. ''Artificial neural network (ANN)'') {{---}} это упрощенная модель биологической нейронной сети, представляющая собой совокупность искусственных нейронов, взаимодействующих между собой.

[[File:Нейронная_сеть.png|700px|thumb|[https://neuralnet.info/chapter/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5/#%D0%92-%D1%86%D0%B5%D0%BB%D0%BE%D0%BC-%D0%BE%D0%B1-%D0%98%D0%9D%D0%A1 Упрощение биологической нейронной сети]]]

Основные принципы работы нейронных сетей были описаны еще в 1943 году Уорреном Мак-Каллоком и Уолтером Питтсом<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref>. В 1957 году нейрофизиолог Фрэнк Розенблатт разработал первую нейронную сеть<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref>, а в 2010 году большие объемы данных для обучения открыли возможность использовать нейронные сети для машинного обучения.

На данный момент нейронные сети используются в многочисленных областях машинного обучения и решают проблемы различной сложности.

==Структура нейронной сети==

[[File:Искусственный_нейрон_схема.png|700px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD Схема искусственного нейрона]]]

Хорошим примером биологической нейронной сети является человеческий мозг. Наш мозг {{---}} сложнейшая биологическая нейронная сеть, которая принимает информацию от органов чувств и каким-то образом ее обрабатывает (узнавание лиц, возникновение ощущений и т.д.). Мозг же, в свою очередь, состоит из нейронов, взаимодействующих между собой.

Для построения искусственной нейронной сети будем использовать ту же структуру. Как и биологическая нейронная сеть, искусственная состоит из нейронов, взаимодействующих между собой, однако представляет собой упрощенную модель. Так, например, искусственный нейрон, из которых состоит ИНС, имеет намного более простую структуру: у него есть несколько входов, на которых он принимает различные сигналы, преобразует их и передает другим нейронам. Другими словами, искусственный нейрон {{---}} это такая функция <tex>\mathbb{R}^n \rightarrow \mathbb{R}</tex>, которая преобразует несколько входных параметров в один выходной.

Как видно на рисунке справа, у нейрона есть <tex>n</tex> входов <tex>x_i</tex>, у каждого из которого есть вес <tex>w_i</tex>, на который умножается сигнал, проходящий по связи. После этого взвешенные сигналы <tex>x_i \cdot w_i</tex> направляются в сумматор, который аггрегирует все сигналы во взвешенную сумму. Эту сумму также называют <tex>net</tex>. Таким образом, <tex>net = \sum_{i=1}^{i=n} w_i \cdot x_i = w^T \cdot x</tex>.

Просто так передавать взвешенную сумму <tex>net</tex> на выход достаточно бессмысленно {{---}} нейрон должен ее как-то обработать и сформировать адекватный выходной сигнал. Для этих целей используют [[Практики реализации нейронных сетей#Функции активации|функцию активации]], которая преобразует взвешенную сумму в какое-то число, которое и будет являться выходом нейрона. Функция активации обозначается <tex>\phi(net)</tex>. Таким образом, выходов искусственного нейрона является <tex>\phi(net)</tex>.

Для разных типов нейронов используют самые разные функции активации, но одними из самых популярных являются:
* Функция единичного скачка. Если <tex>net > threshold</tex>, <tex>\phi(net) = 1</tex>, а иначе <tex>0</tex>;
* Сигмоидальная функция. <tex>\phi(net) = \frac{1}{1 + exp(-a \cdot net)}</tex>, где параметр <tex>a</tex> характеризует степень крутизны функции;
* Гиперболический тангенс. <tex>\phi(net) = tanh(\frac{net}{a})</tex>, где параметр <tex>a</tex> также определяет степень крутизны графика функции;
* Rectified linear units (ReLU). <tex>ReLU(x) = \begin{cases}
x & x \geq 0 \\
0 & x < 0
\end{cases} = \max(x, 0)</tex>.

==Виды нейронных сетей==

Разобравшись с тем, как устроен нейрон в нейронной сети, осталось понять, как их в этой сети располагать и соединять.

Как правило, в большинстве нейронных сетей есть так называемый ''входной слой'', который выполняет только одну задачу {{---}} распределение входных сигналов остальным нейронам. Нейроны этого слоя не производят никаких вычислений. В остальном нейронные сети делятся на основные категории, представленные ниже.

===Однослойные нейронные сети===

[[File:Single-layer-neural-net-scheme.png|500px|thumb|[https://studfiles.net/preview/3170620/page:3/ Схема однослойной нейронной сети]]]

'''Однослойная нейронная сеть''' (англ. ''Single-layer neural network'') {{---}} сеть, в которой сигналы от входного слоя сразу подаются на выходной слой, который и преобразует сигнал и сразу же выдает ответ.

Как видно из схемы однослойной нейронной сети, представленной справа, сигналы <tex>x_1, x_2, \ldots x_n</tex> поступают на входной слой (который не считается за слой нейронной сети), а затем сигналы распределяются на выходной слой обычных нейронов. На каждом ребре от нейрона входного слоя к нейрону выходного слоя написано число {{---}} вес соответствующей связи.

===Многослойные нейронные сети===

[[File:Multi-layer-neural-net-scheme.png|500px|thumb|[https://wiki.loginom.ru/articles/multilayer-neural-net.html Схема многослойной нейронной сети]]]

'''Многослойная нейронная сеть''' (англ. ''Multilayer neural network'') {{---}} нейронная сеть, состоящая из входного, выходного и расположенного(ых) между ними одного (нескольких) скрытых слоев нейронов.

Помимо входного и выходного слоев эти нейронные сети содержат промежуточные, ''скрытые слои''. Такие сети обладают гораздо большими возможностями, чем однослойные нейронные сети, однако методы обучения нейронов скрытого слоя были разработаны относительно недавно.

Работу скрытых слоев нейронов можно сравнить с работой большого завода. Продукт (выходной сигнал) на заводе собирается по стадиям на станках. После каждого станка получается какой-то промежуточный результат. Скрытые слои тоже преобразуют входные сигналы в некоторые промежуточные результаты.

===Сети прямого распространения===

'''Сети прямого распространения''' (англ. ''Feedforward neural network'') (feedforward сети) {{---}} искусственные нейронные сети, в которых сигнал распространяется строго от входного слоя к выходному. В обратном направлении сигнал не распространяется.

Все сети, описанные выше, являлись сетями прямого распространения, как следует из определения. Такие сети широко используются и вполне успешно решают определенный класс задач: прогнозирование, кластеризация и распознавание.

Однако сигнал в нейронных сетях может идти и в обратную сторону.

===Сети с обратными связями===

[[File:Сети_с_обратными_связями.png|400px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%A1%D0%B5%D1%82%D0%B8-%D1%81-%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%BC%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8F%D0%BC%D0%B8 Схема сети с обратными связями]]]

'''[[Рекуррентные нейронные сети|Сети с обратными связями]]''' (англ. ''Recurrent neural network'') {{---}} искусственные нейронные сети, в которых выход нейрона может вновь подаваться на его вход. В более общем случае это означает возможность распространения сигнала от выходов к входам.

В сетях прямого распространения выход сети определяется входным сигналом и весовыми коэффициентами при искусственных нейронах. В сетях с обратными связями выходы нейронов могут возвращаться на входы. Это означает, что выход какого-нибудь нейрона определяется не только его весами и входным сигналом, но еще и предыдущими выходами (так как они снова вернулись на входы).

==Обучение нейронной сети==

'''Обучение нейронной сети''' {{---}} поиск такого набора весовых коэффициентов, при котором входной сигнал после прохода по сети преобразуется в нужный нам выходной.

Это определение «обучения нейронной сети» соответствует и биологическим нейросетям. Наш мозг состоит из огромного количества связанных друг с другом нейросетей, каждая из которых в отдельности состоит из нейронов одного типа (с одинаковой функцией активации). Наш мозг обучается благодаря изменению синапсов {{---}} элементов, которые усиливают или ослабляют входной сигнал.

Если обучать сеть, используя только один входной сигнал, то сеть просто «запомнит правильный ответ», а как только мы подадим немного измененный сигнал, вместо правильного ответа получим бессмыслицу. Мы ждем от сети способности ''обобщать'' какие-то признаки и решать задачу на различных входных данных. Именно с этой целью и создаются ''обучающие выборки''.

'''Обучающая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит обучение сети.

После обучения сети, то есть когда сеть выдает корректные результаты для всех входных сигналов из обучающей выборки, ее можно использовать на практике. Однако прежде чем сразу использовать нейронную сеть, обычно производят оценку качества ее работы на так называемой ''тестовой выборке''.

'''Тестовая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит оценка качества работы сети.

Само обучение нейронной сети можно разделить на два подхода: [[Обучение с учителем|обучение с учителем]][на 28.01.19 не создан] и [[Обучение без учителя|обучение без учителя]][на 28.01.19 не создан]. В первом случае веса меняются так, чтобы ответы сети минимально отличались от уже готовых правильных ответов, а во втором случае сеть самостоятельно классифицирует входные сигналы.

==Перцептрон==

[[File:Перцептрон.png|350px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9F%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема перцептрона]]]

'''Перцептрон''' (англ. ''Perceptron'') {{---}} простейший вид нейронных сетей. В основе лежит математическая модель восприятия информации мозгом, состоящая из сенсоров, ассоциативных и реагирующих элементов.

===История===

Идею перцептрона предложил нейрофизиолог Фрэнк Розенблатт. Он предложил схему устройства, моделирующего процесс человеческого восприятия, и назвал его ''«перцептроном»'' (от латинского ''perceptio'' {{---}} восприятие). В 1960 году Розенблатт представил первый нейрокомпьютер {{---}} «Марк-1», который был способен распознавать некоторые буквы английского алфавита.

Таким образом перцептрон является одной из первых '''моделей нейросетей''', а «Марк-1» {{---}} первым в мире '''нейрокомпьютером'''.

===Описание===

В основе перцептрона лежит математическая модель восприятия информации мозгом. Разные исследователи по-разному его определяют. В самом общем своем виде (как его описывал Розенблатт) он представляет систему из элементов трех разных типов: сенсоров, ассоциативных элементов и реагирующих элементов.

Принцип работы перцептрона следующий:
# Первыми в работу включаются S-элементы. Они могут находиться либо в состоянии покоя (сигнал равен ''0''), либо в состоянии возбуждения (сигнал равен ''1'').
# Далее сигналы от S-элементов передаются A-элементам по так называемым S-A связям. Эти связи могут иметь веса, равные только ''-1'', ''0'' или ''1''.
# Затем сигналы от сенсорных элементов, прошедших по S-A связям, попадают в A-элементы, которые еще называют ассоциативными элементами.
#* Одному A-элементу может соответствовать несколько S-элементов;
#* Если сигналы, поступившие на A-элемент, в совокупности превышают некоторый его порог <tex>\theta</tex>, то этот A-элемент возбуждается и выдает сигнал, равный ''1'';
#* В противном случае (сигнал от S-элементов не превысил порога A-элемента), генерируется нулевой сигнал.
# Далее сигналы, которые произвели возбужденные A-элементы, направляются к сумматору (R-элемент), действие которого нам уже известно. Однако, чтобы добраться до R-элемента, они проходят по A-R связям, у которых тоже есть веса (которые уже могут принимать любые значения, в отличие от S-A связей).
# R-элемент складывает друг с другом взвешенные сигналы от A-элементов, а затем
#* если превышен определенный порог, генерирует выходной сигнал, равный ''1'';
#* eсли порог не превышен, то выход перцептрона равен ''-1''.

Для элементов перцептрона используют следующие названия:
* S-элементы называют сенсорами;
* A-элементы называют ассоциативными;
* R-элементы называют реагирующими.

===Классификация перцептронов===

[[File:Однслойный_перцептрон.png|300px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9-%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема однослойного перцептрона]]]

'''Перцептрон с одним скрытым слоем''' ('''элементарный перцептрон''', англ. ''elementary perceptron'') {{---}} перцептрон, у которого имеется только по одному слою S, A и R элементов.

'''Однослойный персептрон''' (англ. ''Single-layer perceptron'') {{---}} перцептрон, каждый S-элемент которого однозначно соответствует одному А-элементу, S-A связи всегда имеют вес ''1'', а порог любого А-элемента равен ''1''. Часть однослойного персептрона соответствует модели искусственного нейрона.

Его ключевая особенность состоит в том, что каждый S-элемент однозначно соответствует одному A-элементу, все S-A связи имеют вес, равный ''+1'', а порог A элементов равен ''1''. Часть однослойного перцептрона, не содержащая входы, соответствует искусственному нейрону, как показано на картинке. Таким образом, однослойный перцептрон {{---}} это искусственный нейрон, который на вход принимает только ''0'' и ''1''.

Однослойный персептрон также может быть и элементарным персептроном, у которого только по одному слою S,A,R-элементов.

'''Многослойный перцептрон по Розенблатту''' (англ. ''Rosenblatt multilayer perceptron'') {{---}} перцептрон, который содержит более 1 слоя А-элементов.

'''Многослойный перцептрон по Румельхарту''' (англ. ''Rumelhart multilater perceptron'') {{---}} частный случай многослойного персептрона по Розенблатту, с двумя особенностями:
* S-A связи могут иметь произвольные веса и обучаться наравне с A-R связями;
* Обучение производится по специальному алгоритму, который называется обучением по методу обратного распространения ошибки.

===Обучение перцептрона===

Задача обучения перцептрона {{---}} подобрать такие <tex>w_0, w_1, w_2, \ldots, w_n</tex>, чтобы <tex>sign(\sigma(w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n))</tex> как можно чаще совпадал с <tex>y(x)</tex> {{---}} значением в обучающей выборке (здесь <tex>\sigma</tex> {{---}} функция активации). Для удобства, чтобы не тащить за собой свободный член <tex>w_0</tex>, добавим в вектор $x$ лишнюю «виртуальную размерность» и будем считать, что <tex>x = (1, x_1, x_2, \ldots, x_n)</tex>. Тогда <tex>w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n</tex> можно заменить на <tex>w^T \cdot x</tex>.

Чтобы обучать эту функцию, сначала надо выбрать функцию ошибки, которую потом можно оптимизировать [[Стохастический градиентный спуск|градиентным спуском]][на 16.01.19 не создан]. Число неверно классифицированных примеров не подходит на эту кандидатуру, потому что эта функция кусочно-гладкая, с массой разрывов: она будет принимать только целые значения и резко меняться при переходе от одного числа неверно классифицированных примеров к другому. Поэтому использовать будем другую функцию, так называемый ''критерий перцептрона'': <tex>E_P(w) = -\sum_{x \in M} y(x)(\sigma(w^T \cdot x))</tex>, где <tex>M</tex> {{---}} множество примеров, которые перцептрон с весами <tex>w</tex> классифицирует неправильно.

Иначе говоря, мы минимизируем суммарное отклонение наших ответов от правильных, но только в неправильную сторону; верный ответ ничего не вносит в функцию ошибки. Умножение на <tex>y(x)</tex> здесь нужно для того, чтобы знак произведения всегда получался отрицательным: если правильный ответ ''−1'', значит, перцептрон выдал положительное число (иначе бы ответ был верным), и наоборот. В результате у нас получилась кусочно-линейная функция, дифференцируемая почти везде, а этого вполне достаточно.

Теперь <tex>E_P(w)</tex> можно оптимизировать градиентным спуском. На очередном шаге получаем: <tex>w^{(\tau+1)} = w^{(\tau)} − \eta\triangledown_w E_P(w)</tex>.

Алгоритм такой {{---}} мы последовательно проходим примеры <tex>x_1, x_2, \ldots</tex> из обучающего множества, и для каждого <tex>x_n</tex>:
* если он классифицирован правильно, не меняем ничего;
* а если неправильно, прибавляем <tex>\eta \triangledown_w E_P(w)</tex>.

Ошибка на примере <tex>x_n</tex> при этом, очевидно, уменьшается, но, конечно, совершенно никто не гарантирует, что вместе с тем не увеличится ошибка от других примеров. Это правило обновления весов так и называется {{---}} правило обучения перцептрона, и это было основной математической идеей работы Розенблатта.

===Применение===

* Решение задач классификации, если объекты классификации обладают свойством линейной разделимости
* Прогнозирование и распознавание образов
* Управление агентами<ref>[https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D0%BE%D0%B2 Применения перцептрона, Wikipedia]</ref>

===Пример использования с помощью scikit-learn<ref>[https://scikit-learn.org Библиотека scikit-learn для Python]</ref>===

Будем классифицировать с помощью перцептрона датасет MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>.

# Load required libraries
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Perceptron #Single-layer perceptron
from sklearn.neural_network import MLPClassifier #Multilayer perceptron
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# Load the mnist dataset
mnist = datasets.load_digits()

# Create our X and y data
n_samples = len(mnist.images)
X = mnist.images.reshape((n_samples, -1))
y = mnist.target

# Split the data into 70% training data and 30% test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Train the scaler, which standarizes all the features to have mean=0 and unit variance
sc = StandardScaler()
sc.fit(X_train)

# Apply the scaler to the X training data
X_train_std = sc.transform(X_train)

# Apply the SAME scaler to the X test data
X_test_std = sc.transform(X_test)

# Create a single-layer perceptron object with the parameters: 40 iterations (epochs) over the data, and a learning rate of 0.1
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
# Create a multilayer perceptron object
mppn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(256, 512, 128), random_state=1)

# Train the perceptrons
ppn.fit(X_train_std, y_train)
mppn.fit(X_train_std, y_train)

# Apply the trained perceptrons on the X data to make predicts for the y test data
y_pred = ppn.predict(X_test_std)
multi_y_pred = mppn.predict(X_test_std)

# View the accuracies of the model, which is: 1 - (observations predicted wrong / total observations)
print('Single-layer perceptron accuracy: %.4f' % accuracy_score(y_test, y_pred))
print('Multilayer perceptron accuracy: %.4f' % accuracy_score(y_test, multi_y_pred))

Вывод:
Single-layer perceptron accuracy: 0.9574
Multilayer perceptron accuracy: 0.9759

===Пример использования с помощью tensorflow<ref>[https://www.tensorflow.org/ Библиотека tensorflow для Python]</ref>===

Будем классифицировать цифры из того же датасета MNIST.

# Load required libraries
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Load MNIST dataset
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#placeholder for test data
x = tf.placeholder(tf.float32, [None, 784])
#placeholder for weights and bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#tensorflow model
y = tf.nn.softmax(tf.matmul(x, W) + b)

#loss function
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#gradient descent step
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Accuracy: %s" % sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

[[File:Tensorflow-mnist-failures.png|400px|thumb|Правильные метки {{---}} 5, 4, 9, 7. Результат классификации {{---}} 6, 6, 4, 4.]]

Вывод:
Accuracy: 0.9164

На рисунке справа показаны четыре типичных изображения, на которых классификаторы ошибаются. Согласитесь, случаи действительно тяжелые.

==См. также==
*[[:Сверточные нейронные сети|Сверточные нейронные сети]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]
==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 93-123.
* [https://neuralnet.info/book/ Нейронные сети {{---}} учебник ]

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]

Нейронные сети, перцептрон

2019-01-28T14:32:00Z

Alexey Katsman: /* Сети с обратными связями */

'''Искусственная нейронная сеть (ИНС)''' (англ. ''Artificial neural network (ANN)'') {{---}} это упрощенная модель биологической нейронной сети, представляющая собой совокупность искусственных нейронов, взаимодействующих между собой.

[[File:Нейронная_сеть.png|700px|thumb|[https://neuralnet.info/chapter/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5/#%D0%92-%D1%86%D0%B5%D0%BB%D0%BE%D0%BC-%D0%BE%D0%B1-%D0%98%D0%9D%D0%A1 Упрощение биологической нейронной сети]]]

Основные принципы работы нейронных сетей были описаны еще в 1943 году Уорреном Мак-Каллоком и Уолтером Питтсом<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref>. В 1957 году нейрофизиолог Фрэнк Розенблатт разработал первую нейронную сеть<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref>, а в 2010 году большие объемы данных для обучения открыли возможность использовать нейронные сети для машинного обучения.

На данный момент нейронные сети используются в многочисленных областях машинного обучения и решают проблемы различной сложности.

==Структура нейронной сети==

[[File:Искусственный_нейрон_схема.png|700px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD Схема искусственного нейрона]]]

Хорошим примером биологической нейронной сети является человеческий мозг. Наш мозг {{---}} сложнейшая биологическая нейронная сеть, которая принимает информацию от органов чувств и каким-то образом ее обрабатывает (узнавание лиц, возникновение ощущений и т.д.). Мозг же, в свою очередь, состоит из нейронов, взаимодействующих между собой.

Для построения искусственной нейронной сети будем использовать ту же структуру. Как и биологическая нейронная сеть, искусственная состоит из нейронов, взаимодействующих между собой, однако представляет собой упрощенную модель. Так, например, искусственный нейрон, из которых состоит ИНС, имеет намного более простую структуру: у него есть несколько входов, на которых он принимает различные сигналы, преобразует их и передает другим нейронам. Другими словами, искусственный нейрон {{---}} это такая функция <tex>\mathbb{R}^n \rightarrow \mathbb{R}</tex>, которая преобразует несколько входных параметров в один выходной.

Как видно на рисунке справа, у нейрона есть <tex>n</tex> входов <tex>x_i</tex>, у каждого из которого есть вес <tex>w_i</tex>, на который умножается сигнал, проходящий по связи. После этого взвешенные сигналы <tex>x_i \cdot w_i</tex> направляются в сумматор, который аггрегирует все сигналы во взвешенную сумму. Эту сумму также называют <tex>net</tex>. Таким образом, <tex>net = \sum_{i=1}^{i=n} w_i \cdot x_i = w^T \cdot x</tex>.

Просто так передавать взвешенную сумму <tex>net</tex> на выход достаточно бессмысленно {{---}} нейрон должен ее как-то обработать и сформировать адекватный выходной сигнал. Для этих целей используют [[Практики реализации нейронных сетей#Функции активации|функцию активации]], которая преобразует взвешенную сумму в какое-то число, которое и будет являться выходом нейрона. Функция активации обозначается <tex>\phi(net)</tex>. Таким образом, выходов искусственного нейрона является <tex>\phi(net)</tex>.

Для разных типов нейронов используют самые разные функции активации, но одними из самых популярных являются:
* Функция единичного скачка. Если <tex>net > threshold</tex>, <tex>\phi(net) = 1</tex>, а иначе <tex>0</tex>;
* Сигмоидальная функция. <tex>\phi(net) = \frac{1}{1 + exp(-a \cdot net)}</tex>, где параметр <tex>a</tex> характеризует степень крутизны функции;
* Гиперболический тангенс. <tex>\phi(net) = tanh(\frac{net}{a})</tex>, где параметр <tex>a</tex> также определяет степень крутизны графика функции;
* Rectified linear units (ReLU). <tex>ReLU(x) = \begin{cases}
x & x \geq 0 \\
0 & x < 0
\end{cases} = \max(x, 0)</tex>.

==Виды нейронных сетей==

Разобравшись с тем, как устроен нейрон в нейронной сети, осталось понять, как их в этой сети располагать и соединять.

Как правило, в большинстве нейронных сетей есть так называемый ''входной слой'', который выполняет только одну задачу {{---}} распределение входных сигналов остальным нейронам. Нейроны этого слоя не производят никаких вычислений. В остальном нейронные сети делятся на основные категории, представленные ниже.

===Однослойные нейронные сети===

[[File:Single-layer-neural-net-scheme.png|500px|thumb|[https://studfiles.net/preview/3170620/page:3/ Схема однослойной нейронной сети]]]

'''Однослойная нейронная сеть''' (англ. ''Single-layer neural network'') {{---}} сеть, в которой сигналы от входного слоя сразу подаются на выходной слой, который и преобразует сигнал и сразу же выдает ответ.

Как видно из схемы однослойной нейронной сети, представленной справа, сигналы <tex>x_1, x_2, \ldots x_n</tex> поступают на входной слой (который не считается за слой нейронной сети), а затем сигналы распределяются на выходной слой обычных нейронов. На каждом ребре от нейрона входного слоя к нейрону выходного слоя написано число {{---}} вес соответствующей связи.

===Многослойные нейронные сети===

[[File:Multi-layer-neural-net-scheme.png|500px|thumb|[https://wiki.loginom.ru/articles/multilayer-neural-net.html Схема многослойной нейронной сети]]]

'''Многослойная нейронная сеть''' (англ. ''Multilayer neural network'') {{---}} нейронная сеть, состоящая из входного, выходного и расположенного(ых) между ними одного (нескольких) скрытых слоев нейронов.

Помимо входного и выходного слоев эти нейронные сети содержат промежуточные, ''скрытые слои''. Такие сети обладают гораздо большими возможностями, чем однослойные нейронные сети, однако методы обучения нейронов скрытого слоя были разработаны относительно недавно.

Работу скрытых слоев нейронов можно сравнить с работой большого завода. Продукт (выходной сигнал) на заводе собирается по стадиям на станках. После каждого станка получается какой-то промежуточный результат. Скрытые слои тоже преобразуют входные сигналы в некоторые промежуточные результаты.

===Сети прямого распространения===

'''Сети прямого распространения''' (англ. ''Feedforward neural network'') (feedforward сети) {{---}} искусственные нейронные сети, в которых сигнал распространяется строго от входного слоя к выходному. В обратном направлении сигнал не распространяется.

Все сети, описанные выше, являлись сетями прямого распространения, как следует из определения. Такие сети широко используются и вполне успешно решают определенный класс задач: прогнозирование, кластеризация и распознавание.

Однако сигнал в нейронных сетях может идти и в обратную сторону.

===Сети с обратными связями===

[[File:Сети_с_обратными_связями.png|400px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%A1%D0%B5%D1%82%D0%B8-%D1%81-%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%BC%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8F%D0%BC%D0%B8 Схема сети с обратными связями]]]

'''[[Рекуррентные нейронные сети|Сети с обратными связями]]''' (англ. ''Recurrent neural network'') {{---}} искусственные нейронные сети, в которых выход нейрона может вновь подаваться на его вход. В более общем случае это означает возможность распространения сигнала от выходов к входам.

В сетях прямого распространения выход сети определяется входным сигналом и весовыми коэффициентами при искусственных нейронах. В сетях с обратными связями выходы нейронов могут возвращаться на входы. Это означает, что выход какого-нибудь нейрона определяется не только его весами и входным сигналом, но еще и предыдущими выходами (так как они снова вернулись на входы).

==Обучение нейронной сети==

'''Обучение нейронной сети''' {{---}} поиск такого набора весовых коэффициентов, при котором входной сигнал после прохода по сети преобразуется в нужный нам выходной.

Это определение «обучения нейронной сети» соответствует и биологическим нейросетям. Наш мозг состоит из огромного количества связанных друг с другом нейросетей, каждая из которых в отдельности состоит из нейронов одного типа (с одинаковой функцией активации). Наш мозг обучается благодаря изменению синапсов {{---}} элементов, которые усиливают или ослабляют входной сигнал.

Если обучать сеть, используя только один входной сигнал, то сеть просто «запомнит правильный ответ», а как только мы подадим немного измененный сигнал, вместо правильного ответа получим бессмыслицу. Мы ждем от сети способности ''обобщать'' какие-то признаки и решать задачу на различных входных данных. Именно с этой целью и создаются ''обучающие выборки''.

'''Обучающая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит обучение сети.

После обучения сети, то есть когда сеть выдает корректные результаты для всех входных сигналов из обучающей выборки, ее можно использовать на практике. Однако прежде чем сразу использовать нейронную сеть, обычно производят оценку качества ее работы на так называемой ''тестовой выборке''.

'''Тестовая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит оценка качества работы сети.

Само обучение нейронной сети можно разделить на два подхода: [[Обучение с учителем|обучение с учителем]][на 16.01.19 не создан] и [[Обучение без учителя|обучение без учителя]][на 16.01.19 не создан]. В первом случае веса меняются так, чтобы ответы сети минимально отличались от уже готовых правильных ответов, а во втором случае сеть самостоятельно классифицирует входные сигналы.

==Перцептрон==

[[File:Перцептрон.png|350px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9F%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема перцептрона]]]

'''Перцептрон''' (англ. ''Perceptron'') {{---}} простейший вид нейронных сетей. В основе лежит математическая модель восприятия информации мозгом, состоящая из сенсоров, ассоциативных и реагирующих элементов.

===История===

Идею перцептрона предложил нейрофизиолог Фрэнк Розенблатт. Он предложил схему устройства, моделирующего процесс человеческого восприятия, и назвал его ''«перцептроном»'' (от латинского ''perceptio'' {{---}} восприятие). В 1960 году Розенблатт представил первый нейрокомпьютер {{---}} «Марк-1», который был способен распознавать некоторые буквы английского алфавита.

Таким образом перцептрон является одной из первых '''моделей нейросетей''', а «Марк-1» {{---}} первым в мире '''нейрокомпьютером'''.

===Описание===

В основе перцептрона лежит математическая модель восприятия информации мозгом. Разные исследователи по-разному его определяют. В самом общем своем виде (как его описывал Розенблатт) он представляет систему из элементов трех разных типов: сенсоров, ассоциативных элементов и реагирующих элементов.

Принцип работы перцептрона следующий:
# Первыми в работу включаются S-элементы. Они могут находиться либо в состоянии покоя (сигнал равен ''0''), либо в состоянии возбуждения (сигнал равен ''1'').
# Далее сигналы от S-элементов передаются A-элементам по так называемым S-A связям. Эти связи могут иметь веса, равные только ''-1'', ''0'' или ''1''.
# Затем сигналы от сенсорных элементов, прошедших по S-A связям, попадают в A-элементы, которые еще называют ассоциативными элементами.
#* Одному A-элементу может соответствовать несколько S-элементов;
#* Если сигналы, поступившие на A-элемент, в совокупности превышают некоторый его порог <tex>\theta</tex>, то этот A-элемент возбуждается и выдает сигнал, равный ''1'';
#* В противном случае (сигнал от S-элементов не превысил порога A-элемента), генерируется нулевой сигнал.
# Далее сигналы, которые произвели возбужденные A-элементы, направляются к сумматору (R-элемент), действие которого нам уже известно. Однако, чтобы добраться до R-элемента, они проходят по A-R связям, у которых тоже есть веса (которые уже могут принимать любые значения, в отличие от S-A связей).
# R-элемент складывает друг с другом взвешенные сигналы от A-элементов, а затем
#* если превышен определенный порог, генерирует выходной сигнал, равный ''1'';
#* eсли порог не превышен, то выход перцептрона равен ''-1''.

Для элементов перцептрона используют следующие названия:
* S-элементы называют сенсорами;
* A-элементы называют ассоциативными;
* R-элементы называют реагирующими.

===Классификация перцептронов===

[[File:Однслойный_перцептрон.png|300px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9-%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема однослойного перцептрона]]]

'''Перцептрон с одним скрытым слоем''' ('''элементарный перцептрон''', англ. ''elementary perceptron'') {{---}} перцептрон, у которого имеется только по одному слою S, A и R элементов.

'''Однослойный персептрон''' (англ. ''Single-layer perceptron'') {{---}} перцептрон, каждый S-элемент которого однозначно соответствует одному А-элементу, S-A связи всегда имеют вес ''1'', а порог любого А-элемента равен ''1''. Часть однослойного персептрона соответствует модели искусственного нейрона.

Его ключевая особенность состоит в том, что каждый S-элемент однозначно соответствует одному A-элементу, все S-A связи имеют вес, равный ''+1'', а порог A элементов равен ''1''. Часть однослойного перцептрона, не содержащая входы, соответствует искусственному нейрону, как показано на картинке. Таким образом, однослойный перцептрон {{---}} это искусственный нейрон, который на вход принимает только ''0'' и ''1''.

Однослойный персептрон также может быть и элементарным персептроном, у которого только по одному слою S,A,R-элементов.

'''Многослойный перцептрон по Розенблатту''' (англ. ''Rosenblatt multilayer perceptron'') {{---}} перцептрон, который содержит более 1 слоя А-элементов.

'''Многослойный перцептрон по Румельхарту''' (англ. ''Rumelhart multilater perceptron'') {{---}} частный случай многослойного персептрона по Розенблатту, с двумя особенностями:
* S-A связи могут иметь произвольные веса и обучаться наравне с A-R связями;
* Обучение производится по специальному алгоритму, который называется обучением по методу обратного распространения ошибки.

===Обучение перцептрона===

Задача обучения перцептрона {{---}} подобрать такие <tex>w_0, w_1, w_2, \ldots, w_n</tex>, чтобы <tex>sign(\sigma(w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n))</tex> как можно чаще совпадал с <tex>y(x)</tex> {{---}} значением в обучающей выборке (здесь <tex>\sigma</tex> {{---}} функция активации). Для удобства, чтобы не тащить за собой свободный член <tex>w_0</tex>, добавим в вектор $x$ лишнюю «виртуальную размерность» и будем считать, что <tex>x = (1, x_1, x_2, \ldots, x_n)</tex>. Тогда <tex>w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n</tex> можно заменить на <tex>w^T \cdot x</tex>.

Чтобы обучать эту функцию, сначала надо выбрать функцию ошибки, которую потом можно оптимизировать [[Стохастический градиентный спуск|градиентным спуском]][на 16.01.19 не создан]. Число неверно классифицированных примеров не подходит на эту кандидатуру, потому что эта функция кусочно-гладкая, с массой разрывов: она будет принимать только целые значения и резко меняться при переходе от одного числа неверно классифицированных примеров к другому. Поэтому использовать будем другую функцию, так называемый ''критерий перцептрона'': <tex>E_P(w) = -\sum_{x \in M} y(x)(\sigma(w^T \cdot x))</tex>, где <tex>M</tex> {{---}} множество примеров, которые перцептрон с весами <tex>w</tex> классифицирует неправильно.

Иначе говоря, мы минимизируем суммарное отклонение наших ответов от правильных, но только в неправильную сторону; верный ответ ничего не вносит в функцию ошибки. Умножение на <tex>y(x)</tex> здесь нужно для того, чтобы знак произведения всегда получался отрицательным: если правильный ответ ''−1'', значит, перцептрон выдал положительное число (иначе бы ответ был верным), и наоборот. В результате у нас получилась кусочно-линейная функция, дифференцируемая почти везде, а этого вполне достаточно.

Теперь <tex>E_P(w)</tex> можно оптимизировать градиентным спуском. На очередном шаге получаем: <tex>w^{(\tau+1)} = w^{(\tau)} − \eta\triangledown_w E_P(w)</tex>.

Алгоритм такой {{---}} мы последовательно проходим примеры <tex>x_1, x_2, \ldots</tex> из обучающего множества, и для каждого <tex>x_n</tex>:
* если он классифицирован правильно, не меняем ничего;
* а если неправильно, прибавляем <tex>\eta \triangledown_w E_P(w)</tex>.

Ошибка на примере <tex>x_n</tex> при этом, очевидно, уменьшается, но, конечно, совершенно никто не гарантирует, что вместе с тем не увеличится ошибка от других примеров. Это правило обновления весов так и называется {{---}} правило обучения перцептрона, и это было основной математической идеей работы Розенблатта.

===Применение===

* Решение задач классификации, если объекты классификации обладают свойством линейной разделимости
* Прогнозирование и распознавание образов
* Управление агентами<ref>[https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D0%BE%D0%B2 Применения перцептрона, Wikipedia]</ref>

===Пример использования с помощью scikit-learn<ref>[https://scikit-learn.org Библиотека scikit-learn для Python]</ref>===

Будем классифицировать с помощью перцептрона датасет MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>.

# Load required libraries
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Perceptron #Single-layer perceptron
from sklearn.neural_network import MLPClassifier #Multilayer perceptron
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# Load the mnist dataset
mnist = datasets.load_digits()

# Create our X and y data
n_samples = len(mnist.images)
X = mnist.images.reshape((n_samples, -1))
y = mnist.target

# Split the data into 70% training data and 30% test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Train the scaler, which standarizes all the features to have mean=0 and unit variance
sc = StandardScaler()
sc.fit(X_train)

# Apply the scaler to the X training data
X_train_std = sc.transform(X_train)

# Apply the SAME scaler to the X test data
X_test_std = sc.transform(X_test)

# Create a single-layer perceptron object with the parameters: 40 iterations (epochs) over the data, and a learning rate of 0.1
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
# Create a multilayer perceptron object
mppn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(256, 512, 128), random_state=1)

# Train the perceptrons
ppn.fit(X_train_std, y_train)
mppn.fit(X_train_std, y_train)

# Apply the trained perceptrons on the X data to make predicts for the y test data
y_pred = ppn.predict(X_test_std)
multi_y_pred = mppn.predict(X_test_std)

# View the accuracies of the model, which is: 1 - (observations predicted wrong / total observations)
print('Single-layer perceptron accuracy: %.4f' % accuracy_score(y_test, y_pred))
print('Multilayer perceptron accuracy: %.4f' % accuracy_score(y_test, multi_y_pred))

Вывод:
Single-layer perceptron accuracy: 0.9574
Multilayer perceptron accuracy: 0.9759

===Пример использования с помощью tensorflow<ref>[https://www.tensorflow.org/ Библиотека tensorflow для Python]</ref>===

Будем классифицировать цифры из того же датасета MNIST.

# Load required libraries
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Load MNIST dataset
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#placeholder for test data
x = tf.placeholder(tf.float32, [None, 784])
#placeholder for weights and bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#tensorflow model
y = tf.nn.softmax(tf.matmul(x, W) + b)

#loss function
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#gradient descent step
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Accuracy: %s" % sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

[[File:Tensorflow-mnist-failures.png|400px|thumb|Правильные метки {{---}} 5, 4, 9, 7. Результат классификации {{---}} 6, 6, 4, 4.]]

Вывод:
Accuracy: 0.9164

На рисунке справа показаны четыре типичных изображения, на которых классификаторы ошибаются. Согласитесь, случаи действительно тяжелые.

==См. также==
*[[:Сверточные нейронные сети|Сверточные нейронные сети]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]
==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 93-123.
* [https://neuralnet.info/book/ Нейронные сети {{---}} учебник ]

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]