Примеры кода на R — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
м (Описание известных пакетов)
(Небольшие правки + замена англоязычных терминов)
(не показаны 34 промежуточные версии 2 участников)
Строка 4: Строка 4:
  
 
Язык постоянно расширяется за счёт новых библиотек (пакетов). Для импорта одного пакета необходимо прописать в файле следующие строки:
 
Язык постоянно расширяется за счёт новых библиотек (пакетов). Для импорта одного пакета необходимо прописать в файле следующие строки:
<pre>
+
 
install.packages("packageName")
+
  install.packages(<font color="green">"packageName"</font>)
require("packageName")
+
  require(<font color="green">"packageName"</font>)
</pre>
 
  
 
Для того чтобы импортировать пакет с его зависимостями в код следует включить следующие строки:   
 
Для того чтобы импортировать пакет с его зависимостями в код следует включить следующие строки:   
<pre>
+
 
library("packageName")
+
  library(<font color="green">"packageName"</font>)
</pre>
 
  
 
== Описание известных пакетов ==
 
== Описание известных пакетов ==
Строка 18: Строка 16:
 
===Пакеты для обработки данных===
 
===Пакеты для обработки данных===
 
==== Pipelearner ====
 
==== Pipelearner ====
Пакет <code>Pipelearner</code><ref>[https://github.com/drsimonj/pipelearner Pipelearner github repository]</ref> предоставляет базовые возможности для разбиения набора данных на блоки для обучения моделей. В основе пакета лежит концепция работы конвейера. Пакет хорошо документирован, все непонятные моменты можно прояснить, просто изучив структуру объекта на каждом этапе работы алгоритма.
+
Пакет <code>Pipelearner</code><ref>[https://github.com/drsimonj/pipelearner Pipelearner github repository]</ref> предоставляет базовые возможности для разбиения набора данных на блоки для обучения моделей. В основе пакета лежит концепция работы конвейера.  
 +
Принцип работы очень прост и описывается 3 шагами:
 +
 
 +
# '''Инициализация'''
 +
#: Функция <code>pipelearner()</code> инициализирует новый объект, который используется в следующих функциях обработки. На этом этапе необходимо указать датасет, с которым производится работа. Также можно указать набор обучающих моделей и предсказываемую модель данных.
 +
# '''Настройка'''
 +
#: Для настройки есть 3 основных функции:
 +
#* <code>learn_cvpairs()</code> отвечает за [[Кросс-валидация|кросс-валидацию]]. Функция генерирует набор пар из тестовой и обучающей выборки на основе входного датасета.
 +
#: В качестве ядра разделения можно использовать <code>crossv_mc</code> ([[Кросс-валидация#Случайные разбиения (Random subsampling)|случайные разбиения]]), <code>crossv_kfold</code> ([[Кросс-валидация#k-fold кросс-валидация|k-fold кросс-валидация]]) или <code>crossv_loo</code> ([[Кросс-валидация#Кросс-валидация по отдельным объектам (Leave-One-Out)|leave-one-out разбиения]]) из пакета <code>modelr</code><ref>[https://github.com/tidyverse/modelr Modelr github repository]</ref>. Но если данных способов недостаточно, можно написать свою функцию разбиения.
 +
#* <code>learn_curves()</code> служит для настройки [[Переобучение#Кривые обучения|кривых обучения]]. Используется метод увеличивающихся пропорций относительно начала датасета.
 +
#: Например, вызов <code>learn_curves(.5, .75, 1)</code> создаст <tex>3</tex> сценария работы: в первом будет взята первая половина выбоки, во втором {{---}} первые <tex>\frac{3}{4}</tex> объектов, и в третьем {{---}} вся выборка. Авторы пакета утверждают, что брать случайные объекты выборки не имеет смысла, потому что выборка уже случайно разбита с помощью <code>learn_cvpairs()</code>.
 +
#* <code>learn_models()</code> предназначен для добавления новых обучающих моделей.
 +
# '''Обучение'''
 +
#: С помощью функции <code>learn()</code> все сконструированные ранее модели обучаются и выдается таблица результатов работы
 +
 
 +
В итоге работа с пакетом выглядит приблизительно следующим образом:
 +
  <font color="gray"># Load the dependencies</font>
 +
  library(pipelearner)
 +
  library(dplyr)
 +
 
 +
  iris %>% <font color="gray"># Use iris dataset</font>
 +
    pipelearner() %>% <font color="gray"># Initialize a blank pipelearner object</font>
 +
    learn_cvpairs(crossv_mc, <font color="#660099">n</font> = <font color="blue">50</font>) %>% <font color="gray"># Creating 50 random cross-validation pairs </font>
 +
    learn_curves(seq(<font color="blue">.5</font>, <font color="blue">1</font>, <font color="#660099">by</font> = <font color="blue">.1</font>)) %>% <font color="gray"># Copy each cv-pair to be fitted in sample size proportions of .5 to 1 in increments of .1.</font>
 +
    learn_models(lm, Sepal.Width ~ .*.) %>% <font color="gray"># Use regression modell</font>
 +
    learn_models(rpart::rpart, Sepal.Width ~ .) %>% <font color="gray"># Use decision tree modell</font>
 +
    learn() <font color="gray"># Fit all models on all partitions and return the results</font>
 +
 
 +
Пакет хорошо документирован, все непонятные моменты можно прояснить, просто изучив структуру объекта на каждом этапе работы алгоритма.
  
 
==== MICE ====
 
==== MICE ====
Пакет <code>MICE</code><ref>[https://cran.r-project.org/web/packages/mice/mice.pdf MICE package documentation]</ref> используется для заполнения пропущенных значений в данных. При этом нет необходимости думать о типах значений: для каждого из них в пакете предусмотрено заполнение по умолчанию.  
+
Пакет <code>MICE</code><ref>[https://cran.r-project.org/web/packages/mice/mice.pdf MICE package documentation]</ref> используется для заполнения пропущенных значений в данных. При этом нет необходимости думать о типах значений: для каждого из них в пакете предусмотрено заполнение по умолчанию.
 +
 
 +
Принцип работы основан на методе множественного восстановления<ref>[https://en.wikipedia.org/wiki/Imputation_(statistics)#Multiple_imputation Multiple Imputation]</ref>. Пропущенные данные заполняются не один, а несколько раз. После этого, каждый из полученных наборов обучается на определенной модели. Затем, результаты агрегируются и выдаются итоговые параметры модели.
 +
 
 +
Стандартный процесс работы выглядит так:
 +
<font color="gray"># Load the dependencies</font>
 +
library(mice)
 +
 +
<font color="gray"># Impute the missing data m times</font>
 +
imp <- mice(nhanes, <font color="#660099">m</font> = <font color="blue">5</font>)
 +
 +
<font color="gray"># Analize completed datasets using linear model</font>
 +
fit <- with(imp, lm(chl ~ bmi + age))
 +
 +
<font color="gray"># Combine parameter estimates</font>
 +
est <- pool(fit)
 +
 +
<font color="gray"># Print summary of estimation</font>
 +
summary(est)
 +
 
 
==== Ggplot2 ====
 
==== Ggplot2 ====
Данный пакет<ref>[https://cran.r-project.org/web/packages/ggplot2/index.html Ggplot2 main info page]</ref> используется для отрисовки данных и графиков.  
+
Данный пакет<ref>[https://cran.r-project.org/web/packages/ggplot2/index.html Ggplot2 main info page]</ref> используется для отрисовки данных и графиков.
 +
 
 
=== Пакеты с реализованными алгоритмами машинного обучения ===  
 
=== Пакеты с реализованными алгоритмами машинного обучения ===  
 
==== Caret ====
 
==== Caret ====
Строка 31: Строка 77:
 
==== Party ====
 
==== Party ====
 
Пакет <code>Party</code> <ref>[https://cran.r-project.org/web/packages/party/index.html party package main info page]</ref> содержит в себе инструменты для рекурсивного разбиения данных на классы. В пакета также доступна расширяемая функциональность для визуализации древовидных регрессионных моделей.  
 
Пакет <code>Party</code> <ref>[https://cran.r-project.org/web/packages/party/index.html party package main info page]</ref> содержит в себе инструменты для рекурсивного разбиения данных на классы. В пакета также доступна расширяемая функциональность для визуализации древовидных регрессионных моделей.  
Основная функция пакета — <code>ctree()</code>, которая используется для создания деревьев решения для таких задач регрессии как номинальные, порядковые, числовые а также многовариантные переменные отклика. На основе деревьев условного вывода <code>cforest()</code> предоставляет реализацию случайных лесов Бреймана. Функция <code>mob()</code> реализует алгоритм рекурсивного разделения на основе параметрических моделей (например, линейных моделей, GLM или регрессии выживания), использующих тесты нестабильности параметров для выбора разделения.
+
Основная функция пакета — <code>ctree()</code>, которая используется для создания деревьев решения для таких задач регрессии как номинальные, порядковые, числовые а также многовариантные переменные отклика. На основе деревьев условного вывода <code>cforest()</code> предоставляет реализацию ''случайных лесов Бреймана''. Функция <code>mob()</code> реализует алгоритм рекурсивного разделения на основе параметрических моделей (например, ''линейных моделей'', ''GLM'' или ''регрессии выживания''), использующих тесты нестабильности параметров для выбора разделения.
 +
 
 
==== RandomForest ====
 
==== RandomForest ====
<code>RandomForest</code> <ref>[https://cran.r-project.org/web/packages/randomForest/index.html RandomForest package main info]</ref> — пакет с реализацией алгоритма randomForest. Используется для решения задач регрессии и классификации, а также для поиска аномалий и отбора предикторов.  
+
<code>RandomForest</code> <ref>[https://cran.r-project.org/web/packages/randomForest/index.html RandomForest package main info]</ref> — пакет с реализацией алгоритма ''[[Дерево решений и случайный лес | случайного леса]]''. Используется для решения задач регрессии и классификации, а также для поиска аномалий и отбора предикторов.
 +
 
 
==== ClusterR ====
 
==== ClusterR ====
Пакет <code>ClusterR</code> <ref>[https://cran.r-project.org/web/packages/ClusterR/vignettes/the_clusterR_package.html ClusterR documentation]</ref> состоит из алгоритмов кластеризации на основе центроидов (k-means, mini-batch-kmeans, k-medoids) и распределений (GMM). Кроме того, пакет предлагает функции для:
+
Пакет <code>ClusterR</code> <ref>[https://cran.r-project.org/web/packages/ClusterR/vignettes/the_clusterR_package.html ClusterR documentation]</ref> состоит из алгоритмов кластеризации на основе центроидов (''[[Кластеризация#Метод K-средних (Алгоритм Ллойда) |метод K-средних]]'' (k-means), ''mini-batch-kmeans'', ''k-medoids'') и распределений (''GMM''). Кроме того, пакет предлагает функции для:
* проверки результатов
+
* проверки результатов,
* построения графика результатов, используя либо силуэт, либо 2-мерный график,
+
* построения графика результатов, используя ''[[Оценка качества в задаче кластеризации |метрики]]''
 
* прогнозирования новых наблюдения,
 
* прогнозирования новых наблюдения,
*оценки оптимального количества кластеров для каждого алгоритма  
+
* оценки оптимального количества кластеров для каждого алгоритма
 +
 
 
==== E1071 ====
 
==== E1071 ====
Пакет <ref>[https://www.rdocumentation.org/packages/e1071/versions/1.7-3 1071 package documentation]</ref> содержит в себя функции для анализа классов, кратковременного преобразование Фурье, нечеткой кластеризации, реализации SVM, вычисления кратчайшего пути, а также реализации наивного байесовского классификатора.
+
Пакет <ref>[https://www.rdocumentation.org/packages/e1071/versions/1.7-3 1071 package documentation]</ref> содержит в себя функции для анализа классов, ''кратковременного преобразование Фурье'', ''нечеткой кластеризации'', реализации ''[[Метод опорных векторов (SVM) | метода опорных векторов]]'', ''вычисления кратчайшего пути'', а также реализации ''[[Байесовская_классификация#Наивный байесовский классификатор | наивного байесовского классификатора]]''.
 +
 
 
==== Mlr ====
 
==== Mlr ====
В пакете <code>Mlr</code> <ref>[https://cran.r-project.org/web/packages/mlr/mlr.pdf Mlr package documentation]</ref> представлены модели для регрессии, классификации, кластеризации и анализа выживаемости, а также  широкие возможности для оценки качества (в том числе функции для анализа ROC-кривых).
+
В пакете <code>Mlr</code> <ref>[https://cran.r-project.org/web/packages/mlr/mlr.pdf Mlr package documentation]</ref> представлены модели для регрессии, классификации, кластеризации и анализа выживаемости, а также  широкие возможности для оценки качества (в том числе функции для анализа ''[https://en.wikipedia.org/wiki/Receiver_operating_characteristic ROC-кривых]'').
 
Есть поддержка параллельных вычислений и конвейерных операций.
 
Есть поддержка параллельных вычислений и конвейерных операций.
 +
 
==== H2O ====
 
==== H2O ====
В пакете <code>H20</code> <ref>[https://cran.r-project.org/web/packages/h2o/index.html H20 main info page]</ref> представлены линейные модели, такие как градиентный бустинг, PCA, GLRM, KNN, Radom forest, наивный Байесовский классификатор. Сильная сторона этой библиотеки работа с большими объемами данных и поддержка многопоточных вычислений.Однако в ней нет возможности задавать параметры используемых алгоритмов
+
В пакете <code>H20</code> <ref>[https://cran.r-project.org/web/packages/h2o/index.html H20 main info page]</ref> представлены линейные модели, такие как ''[[Бустинг, AdaBoost |градиентный бустинг]]'', ''[[Метод главных компонент (PCA)|метод главных компонент]]'' (PCA), ''GLRM'', ''[[Метрический классификатор и метод ближайших соседей|метод k ближайших соседей]]'', ''[[Дерево решений и случайный лес|случайный лес]]'', ''[[Байесовская_классификация#Наивный байесовский классификатор | наивный байесовский классификатор]]''. Сильная сторона этой библиотеки {{---}} работа с большими объемами данных и поддержка многопоточных вычислений. Однако в ней нет возможности задавать параметры используемых алгоритмов
  
 
== Примеры алгоритмов ==
 
== Примеры алгоритмов ==
В интернете много хороших примеров реализации алгоритмов на R, но среди них хотелось бы особо отметить один учебник<ref>[https://coderlessons.com/tutorials/kompiuternoe-programmirovanie/learn-r-programmirovanie/uchebnik-po-r Учебник по R]</ref> c портала coderlessons.com. В нем представлена реализация основных алгоритмов в порядке, удобном для изучения.   
+
В интернете много хороших примеров реализации алгоритмов на <code>R</code>, но среди них хотелось бы особо отметить один учебник<ref>[https://coderlessons.com/tutorials/kompiuternoe-programmirovanie/learn-r-programmirovanie/uchebnik-po-r Учебник по R]</ref> c портала coderlessons.com. В нем представлена реализация основных алгоритмов в порядке, удобном для изучения.   
 
=== Задачи регрессии ===
 
=== Задачи регрессии ===
 
==== Линейная регрессия ====
 
==== Линейная регрессия ====
<pre>
+
{{Main|Линейная регрессия|ll=Линейная регрессия}}
#$$reading data
 
data <- read.csv("input.csv", sep = ',', header = FALSE)
 
 
 
#evaluating linear regression model
 
model <- lm(data$x ~ data$y)
 
  
#getting summary  
+
<font color="gray"># reading data</font>
print(summary(model))
+
data <- read.csv(<font color="green">"input.csv"</font>, <font color="#660099">sep</font> = <font color="green">','</font>, <font color="#660099">header</font> = FALSE)
 
+
#visualizing data  
+
<font color="gray"># evaluating linear regression model</font>
plot(data$y, data$x)
+
model <- lm(data$<strong><font color="#660E7A">x</font></strong> ~ data$<strong><font color="#660E7A">y</font></strong>)
lines(data$y, predict(fit), col = 'red')
+
</pre>
+
<font color="gray"># getting summary</font>
 +
print(summary(model))
 +
 +
<font color="gray"># visualizing data</font>
 +
plot(data$<strong><font color="#660E7A">y</font></strong>, data$<strong><font color="#660E7A">x</font></strong>)
 +
lines(data$<strong><font color="#660E7A">y</font></strong>, predict(fit), <font color="#660099">col</font> = <font color="green">'red'</font>)
  
 
==== Множественная регрессия ====
 
==== Множественная регрессия ====
<pre>
 
#$$reading data
 
rdata <- read.csv("input.csv", sep = ',', header = FALSE)
 
  
#evaluating regression model
+
<font color="gray"># reading data</font>
model <- lm(target ~ x + y + z, data = rdata)
+
rdata <- read.csv(<font color="green">"input.csv"</font>, <font color="#660099">sep</font> = <font color="green">','</font>, <font color="#660099">header</font> = FALSE)
 
+
#getting summary  
+
<font color="gray"># evaluating regression model</font>
print(summary(model))
+
model <- lm(target ~ x + y + z, <font color="#660099">data</font> = rdata)
</pre>
+
 +
<font color="gray"># getting summary</font>
 +
print(summary(model))
  
 
==== Логистическая регрессия ====
 
==== Логистическая регрессия ====
Логистическая регрессия – это модель регрессии, в которой переменная ответа принимает значения 0 или 1 (True или False). Реализация на языке R представлена в следующем фрагменте:  
+
{{Main|Логистическая регрессия|ll=Логистическая регрессия}}
 +
Логистическая регрессия – это модель регрессии, в которой переменная ответа принимает значения 0 или 1 (True или False). Реализация на языке <code>R</code> представлена в следующем фрагменте:  
  
<pre>
+
<font color="gray"># reading data</font>
#$$reading data
+
rdata <- read.csv(<font color="green">"input.csv"</font>, <font color="#660099">sep</font> = <font color="green">','</font>, <font color="#660099">header</font> = FALSE)
rdata <- read.csv("input.csv", sep = ',', header = FALSE)
+
 +
<font color="gray"># evaluating model</font>
 +
model = glm(<font color="#660099">formula</font> = target ~ x + y + z, <font color="#660099">data</font> = rdata, <font color="#660099">family</font> = binomial)
 +
 +
<font color="gray"># printing summary</font>
 +
print(summary(model))
  
#evaluating model
+
=== Метод главных компонент ===
model = glm(formula = target ~ x + y + z, data = rdata, family = binomial)
+
{{Main|Метод главных компонент (PCA)|ll=PCA}}
  
#printing summary
+
<font color="gray"># importing library and its' dependencies</font>
print(summary(model))
+
library(h2o)
</pre>
+
h2o.init()
 
+
=== PCA ===
+
path <- system.file(<font color="green">"extdata"</font>, <font color="green">"data.csv"</font>, <font color="#660099">package</font> = <font color="green">"h2o"</font>)
<pre>
+
data <- h2o.uploadFile(<font color="#660099">path</font> = data)
#importing library and its' dependencies
+
library(h2o)
+
<font color="gray"># evaluating</font>
h2o.init()
+
h2o.prcomp(<font color="#660099">training_frame</font> = data, <font color="#660099">k</font> = <font color="blue">8</font>, <font color="#660099">transform</font> = <font color="green">"STANDARDIZE"</font>)
 
 
path <- system.file("extdata", "data.csv", package = "h2o")
 
data <- h2o.uploadFile(path = data)
 
 
 
#evaluating
 
h2o.prcomp(training_frame = data, k = 8, transform = "STANDARDIZE")
 
</pre>
 
  
 
=== Деревья решений, случайный лес ===
 
=== Деревья решений, случайный лес ===
 +
{{Main|Дерево решений и случайный лес |ll=деревьев решений}}
 
==== Деревья решений ====
 
==== Деревья решений ====
Для создания деревьев решений в R используется функция ctree из пакета party.
+
Для создания ''[[Дерево решений и случайный лес |деревьев решений]]'' в <code>R</code> используется функция <code>ctree()</code> из пакета <code>party</code>.  
 
 
<pre>
 
#importing package
 
install.packages("party")
 
 
 
#reading data
 
rdata <- read.csv("input.csv", sep = ',', header = FALSE)
 
 
 
#evaluating model
 
  output.tree <- ctree(target ~ x + y + z, data = rdata)
 
  
#plotting results
+
<font color="gray"># importing package </font>
plot(output.tree)
+
install.packages(<font color="green">"party"</font>)
</pre>
+
 +
<font color="gray"># reading data</font>
 +
rdata <- read.csv(<font color="green">"input.csv"</font>, <font color="#660099">sep</font> = <font color="green">','</font>, <font color="#660099">header</font> = FALSE)
 +
 +
<font color="gray"># evaluating model</font>
 +
output.tree <- ctree(target ~ x + y + z, <font color="#660099">data</font> = rdata)
 +
 +
<font color="gray"># plotting results</font>
 +
plot(output.tree)
  
 
==== Случайный лес ====
 
==== Случайный лес ====
Для создания случайного леса необходимо импортировать пакет randomForest
+
Для создания ''[[Дерево решений и случайный лес|случайного леса]]'' необходимо импортировать пакет <code>randomForest</code>
 
 
<pre>
 
#importing packages
 
install.packages("party")
 
install.packages("randomForest")
 
 
 
#reading data
 
rdata <- read.csv("input.csv", sep = ',', header = FALSE)
 
 
 
#creating the forest
 
output.forest <- randomForest(target ~ x + y + z,
 
          data = rdata)
 
  
#getting results
+
<font color="gray"># importing packages </font>
print(output.forest)  
+
install.packages(<font color="green">"party"</font>)
</pre>
+
install.packages(<font color="green">"randomForest"</font>)
 +
 +
<font color="gray"># reading data</font>
 +
rdata <- read.csv(<font color="green">"input.csv"</font>, <font color="#660099">sep</font> = <font color="green">','</font>, <font color="#660099">header</font> = FALSE)
 +
 +
<font color="gray"># creating the forest</font>
 +
output.forest <- randomForest(target ~ x + y + z, <font color="#660099">data</font> = rdata)
 +
 +
<font color="gray"># getting results</font>
 +
print(output.forest)
  
 
=== Наивный Бейесовский классификатор ===
 
=== Наивный Бейесовский классификатор ===
 +
{{Main|Байесовская классификация|ll=Байесовская классификация}}
  
<pre>
+
<font color="gray"># importing package and it's dependencies</font>
#$$importing package and it's dependencies
+
library(e1071)
library(e1071)
+
 
+
<font color="gray"># reading data</font>
#reading data
+
data <- read.csv(<font color="green">"input.csv"</font>, <font color="#660099">sep</font> = <font color="green">','</font>, <font color="#660099">header</font> = FALSE)
data <- read.csv("input.csv", sep = ',', header = FALSE)
+
 
+
<font color="gray"># splitting data into training and test data sets</font>
#splitting data into training and test data sets
+
index <- createDataPartition(<font color="#660099">y</font> = data$<strong><font color="#660E7A">target</font></strong>, <font color="#660099">p</font> = <font color="blue">0.8</font>, <font color="#660099">list</font> = FALSE)
index <- createDataPartition(y = data$target, p = 0.8,list = FALSE)
+
training <- data[index,]
training <- data[index,]
+
testing <- data[-index,]
testing <- data[-index,]
+
 
+
<font color="gray"># create objects x and y for predictor and response variables</font>
#create objects x and y for predictor and response variables
+
x <- training[, -<font color="blue">9</font>]
x = training[,-9]
+
y <- training$<strong><font color="#660E7A">target</font></strong>
y = training$target
+
 
+
<font color="gray"># training model</font>
#training model
+
model <- train(x, y, <font color="green">'nb'</font>, <font color="#660099">trControl</font> = trainControl(<font color="#660099">method</font> = <font color="green">'cv'</font>, <font color="#660099">number</font> = <font color="blue">10</font>))
model = train(x,y,'nb',trControl=trainControl(method='cv',number=10))
+
 
+
<font color="gray"># predicting results</font>
#predicting results
+
predictions <- predict(model, <font color="#660099">newdata</font> = testing)
predictions <- predict(model, newdata = testing)
 
</pre>
 
 
 
=== SVM ===
 
<pre>
 
#$$ importing package and its' dependencies
 
library(caret)
 
 
 
#reading data
 
data <- read.csv("input.csv", sep = ',', header = FALSE)
 
 
 
#splitting data into train and test sets
 
index <- createDataPartition(y = data$target, p=0.8, list = FALSE)
 
training <- data[index,]
 
testing <- data[-index,]
 
 
 
#evaluating model
 
fit <- train(target ~ x + y + z,
 
            data = train_flats,
 
            method = "svmRadial",
 
            trControl = trainControl(method = "repeatedcv", number = 10, repeats = 3))
 
 
 
#printing parameters
 
print(fit)
 
</pre>
 
 
 
=== GBM ===
 
<pre>
 
#loading libraries
 
install.packages("mlr")
 
library(mlr)
 
  
#loading data
+
=== Метод опорных векторов ===
train <- read.csv("input.csv")
+
{{Main|Метод опорных векторов (SVM)|ll=SVM}}
test <- read.csv("testInput.csv")
 
  
#loading GBM
+
<font color="gray"># importing package and its' dependencies</font>
getParamSet("classif.gbm")
+
library(caret)
baseLearner <- makeLearner("classif.gbm", predict.type = "response")
+
 +
<font color="gray">#reading data</font>
 +
data <- read.csv(<font color="green">"input.csv"</font>, <font color="#660099">sep</font> = <font color="green">','</font>, <font color="#660099">header</font> = FALSE)
 +
 +
<font color="gray"># splitting data into train and test sets</font>
 +
index <- createDataPartition(<font color="#660099">y</font> = data$<strong><font color="#660E7A">target</font></strong>, <font color="#660099">p</font> = <font color="blue">0.8</font>, <font color="#660099">list</font> = FALSE)
 +
training <- data[index,]
 +
testing <- data[-index,]
 +
 +
<font color="gray"># evaluating model</font>
 +
fit <- train(target ~ x + y + z,
 +
              <font color="#660099">data</font> = train_flats,
 +
              <font color="#660099">method</font> = <font color="green">"svmRadial"</font>,
 +
              <font color="#660099">trControl</font> = trainControl(<font color="#660099">method</font> = <font color="green">"repeatedcv"</font>, <font color="#660099">number</font> = <font color="blue">10</font>, <font color="#660099">repeats</font> = <font color="blue">3</font>))
 +
 +
<font color="gray"># printing parameters</font>
 +
print(fit)
  
#specifying parameters
+
=== Бустинг ===
controlFunction <- makeTuneControlRandom(maxit = 50000)#specifying tuning method
+
{{Main|Бустинг, AdaBoost|ll=Бустинг}}
cvFunction <- makeResampleDesc("CV",iters = 100000) #definig cross-validation function
 
  
gbmParameters<- makeParamSet(
+
<font color="gray"># loading libraries</font>
makeDiscreteParam("distribution", values = "bernoulli"),
+
install.packages(<font color="green">"mlr"</font>)
makeIntegerParam("n.trees", lower = 100, upper = 1000), #number of trees
+
library(mlr)
makeIntegerParam("interaction.depth", lower = 2, upper = 10), #depth of tree
+
makeIntegerParam("n.minobsinnode", lower = 10, upper = 80),
+
<font color="gray"># loading data</font>
makeNumericParam("shrinkage",lower = 0.01, upper = 1)
+
train <- read.csv(<font color="green">"input.csv"</font>)
)
+
test <- read.csv(<font color="green">"testInput.csv"</font>)
 
+
#tunning parameters
+
<font color="gray"># loading GBM</font>
gbmTuningParameters <- tuneParams(learner = baseLearner, task = trainTask,resampling = cvFunction,measures = acc,par.set = gbmParameters,control = controlFunction)
+
getParamSet(<font color="green">"classif.gbm"</font>)
 
+
baseLearner <- makeLearner(<font color="green">"classif.gbm"</font>, <font color="#660099">predict.type</font> = <font color="green">"response"</font>)
#creating model parameters
+
model <- setHyperPars(learner = baseLearner, par.vals = gbmTuningParameters)
+
<font color="gray"># specifying parameters</font>
 
+
controlFunction <- makeTuneControlRandom(<font color="#660099">maxit</font> = <font color="blue">50000</font>) <font color="gray"># specifying tuning method</font>
#evaluating model
+
cvFunction <- makeResampleDesc(<font color="green">"CV"</font>, <font color="#660099">iters</font> = <font color="blue">100000</font>) <font color="gray"># definig cross-validation function</font>
fit <- train(model, train)
+
predictions <- predict(fit, test)
+
gbmParameters<- makeParamSet(
</pre>
+
  makeDiscreteParam(<font color="green">"distribution"</font>, <font color="#660099">values</font> = <font color="green">"bernoulli"</font>),
 +
  makeIntegerParam(<font color="green">"n.trees"</font>, <font color="#660099">lower</font> = <font color="blue">100</font>, <font color="#660099">upper</font> = <font color="blue">1000</font>), <font color="gray"># number of trees</font>
 +
  makeIntegerParam(<font color="green">"interaction.depth"</font>, <font color="#660099">lower</font> = <font color="blue">2</font>, <font color="#660099">upper</font> = <font color="blue">10</font>), <font color="gray"># depth of tree</font>
 +
  makeIntegerParam(<font color="green">"n.minobsinnode"</font>, <font color="#660099">lower</font> = <font color="blue">10</font>, <font color="#660099">upper</font> = <font color="blue">80</font>),
 +
  makeNumericParam(<font color="green">"shrinkage"</font>, <font color="#660099">lower</font> = <font color="blue">0.01</font>, <font color="#660099">upper</font> = <font color="blue">1</font>)
 +
)
 +
 +
<font color="gray"># tunning parameters</font>
 +
gbmTuningParameters <- tuneParams(<font color="#660099">learner</font> = baseLearner,
 +
                                  <font color="#660099">task</font> = trainTask,
 +
                                  <font color="#660099">resampling</font> = cvFunction,
 +
                                  <font color="#660099">measures</font> = acc,
 +
                                  <font color="#660099">par.set</font> = gbmParameters,
 +
                                  <font color="#660099">control</font> = controlFunction)
 +
 +
<font color="gray"># creating model parameters</font>
 +
model <- setHyperPars(<font color="#660099">learner</font> = baseLearner, <font color="#660099">par.vals</font> = gbmTuningParameters)
 +
 +
<font color="gray"># evaluating model</font>
 +
fit <- train(model, train)
 +
predictions <- predict(fit, test)
  
 
=== Кластеризация ===
 
=== Кластеризация ===
Для реализации алгоритма кластеризации k-средних используется пакет ClusterR. В нем реализовано 2 функции:  KMeans_arma и KMeans_rcpp. В примере далее рассмотрена реализация с использованием функции KMeans_arma.
+
{{Main|Кластеризация}}
 
+
Для реализации алгоритма кластеризации ''k-средних'' используется пакет <code>ClusterR</code>. В нем реализовано 2 функции:  <code>KMeans_arma()</code> и <code>KMeans_rcpp()</code>. В примере далее рассмотрена реализация с использованием функции <code>KMeans_arma()</code>.
<pre>
 
#$$ importing package and its' dependencies
 
library(ClusterR)
 
 
 
#reading data
 
data <- read.csv("data.csv")
 
 
 
#evaluating model
 
model = KMeans_arma(data, clusters = 2, n_iter = 10, seed_mode = "random_subset",
 
                verbose = T, CENTROIDS = NULL)
 
 
 
#predicting results
 
predictions = predict_KMeans(test_data, model)
 
  
</pre>
+
<font color="gray"># importing package and its' dependencies</font>
 +
library(ClusterR)
 +
 +
<font color="gray"># reading data</font>
 +
data <- read.csv(<font color="green">"data.csv"</font>)
 +
 +
<font color="gray"># evaluating model</font>
 +
model <- KMeans_arma(data, <font color="#660099">clusters</font> = <font color="blue">2</font>, <font color="#660099">n_iter</font> = <font color="blue">10</font>, <font color="#660099">seed_mode</font> = <font color="green">"random_subset"</font>,
 +
                      <font color="#660099">verbose</font> = T, <font color="#660099">CENTROIDS</font> = NULL)
 +
 +
<font color="gray"># predicting results</font>
 +
predictions <- predict_KMeans(test_data, model)
  
 
==См. также==
 
==См. также==
 
*[[:Примеры кода на Scala|Примеры кода на Scala]]
 
*[[:Примеры кода на Scala|Примеры кода на Scala]]
 
*[[:Примеры кода на Java|Примеры кода на Java]]
 
*[[:Примеры кода на Java|Примеры кода на Java]]
 +
*[[:Примеры кода на Kotlin|Примеры кода на Kotlin]]
 
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]
 
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]
  

Версия 00:00, 16 декабря 2020

Особенности написания кода на R

Язык R изначально создавался как язык программирования для работы с графикой и статистической обработки данных. Поэтому он отличается большим количеством реализованных статистических алгоритмов, на основе которых можно создавать модели и алгоритмы машинного обучения.

Язык постоянно расширяется за счёт новых библиотек (пакетов). Для импорта одного пакета необходимо прописать в файле следующие строки:

 install.packages("packageName")
 require("packageName")

Для того чтобы импортировать пакет с его зависимостями в код следует включить следующие строки:

 library("packageName")

Описание известных пакетов

Для языка R написано много пакетов, каждый из которых предназначен для решения определенного круга проблем. Например, для обработки данных или реализации основных алгоритмов. В статье представлено несколько наиболее часто используемых пакетов.

Пакеты для обработки данных

Pipelearner

Пакет Pipelearner[1] предоставляет базовые возможности для разбиения набора данных на блоки для обучения моделей. В основе пакета лежит концепция работы конвейера. Принцип работы очень прост и описывается 3 шагами:

  1. Инициализация
    Функция pipelearner() инициализирует новый объект, который используется в следующих функциях обработки. На этом этапе необходимо указать датасет, с которым производится работа. Также можно указать набор обучающих моделей и предсказываемую модель данных.
  2. Настройка
    Для настройки есть 3 основных функции:
    • learn_cvpairs() отвечает за кросс-валидацию. Функция генерирует набор пар из тестовой и обучающей выборки на основе входного датасета.
    В качестве ядра разделения можно использовать crossv_mc (случайные разбиения), crossv_kfold (k-fold кросс-валидация) или crossv_loo (leave-one-out разбиения) из пакета modelr[2]. Но если данных способов недостаточно, можно написать свою функцию разбиения.
    • learn_curves() служит для настройки кривых обучения. Используется метод увеличивающихся пропорций относительно начала датасета.
    Например, вызов learn_curves(.5, .75, 1) создаст [math]3[/math] сценария работы: в первом будет взята первая половина выбоки, во втором — первые [math]\frac{3}{4}[/math] объектов, и в третьем — вся выборка. Авторы пакета утверждают, что брать случайные объекты выборки не имеет смысла, потому что выборка уже случайно разбита с помощью learn_cvpairs().
    • learn_models() предназначен для добавления новых обучающих моделей.
  3. Обучение
    С помощью функции learn() все сконструированные ранее модели обучаются и выдается таблица результатов работы

В итоге работа с пакетом выглядит приблизительно следующим образом:

 # Load the dependencies
 library(pipelearner)
 library(dplyr)
 
 iris %>% # Use iris dataset
   pipelearner() %>% # Initialize a blank pipelearner object
   learn_cvpairs(crossv_mc, n = 50) %>% # Creating 50 random cross-validation pairs 
   learn_curves(seq(.5, 1, by = .1)) %>% # Copy each cv-pair to be fitted in sample size proportions of .5 to 1 in increments of .1.
   learn_models(lm, Sepal.Width ~ .*.) %>% # Use regression modell
   learn_models(rpart::rpart, Sepal.Width ~ .) %>% # Use decision tree modell
   learn() # Fit all models on all partitions and return the results

Пакет хорошо документирован, все непонятные моменты можно прояснить, просто изучив структуру объекта на каждом этапе работы алгоритма.

MICE

Пакет MICE[3] используется для заполнения пропущенных значений в данных. При этом нет необходимости думать о типах значений: для каждого из них в пакете предусмотрено заполнение по умолчанию.

Принцип работы основан на методе множественного восстановления[4]. Пропущенные данные заполняются не один, а несколько раз. После этого, каждый из полученных наборов обучается на определенной модели. Затем, результаты агрегируются и выдаются итоговые параметры модели.

Стандартный процесс работы выглядит так:

# Load the dependencies
library(mice)

# Impute the missing data m times
imp <- mice(nhanes, m = 5)

# Analize completed datasets using linear model
fit <- with(imp, lm(chl ~ bmi + age))

# Combine parameter estimates
est <- pool(fit)

# Print summary of estimation
summary(est)

Ggplot2

Данный пакет[5] используется для отрисовки данных и графиков.

Пакеты с реализованными алгоритмами машинного обучения

Caret

В данном пакете [6] представлены модели для регрессии и классификации, а также большая часть популярных метрик. В настоящее время имеется возможность использовать более 180 различных алгоритмов. Основная функция в составе Caret — функция train(). Параметры обучения в ней задаются аргументом trControl, а оценка качества модели — аргументом metric. Отличительными особенностями Caret является универсальность используемых команд, наличие автоматического подбора гиперпараметров для алгоритмов, в также наличие параллельных вычислений.

Party

Пакет Party [7] содержит в себе инструменты для рекурсивного разбиения данных на классы. В пакета также доступна расширяемая функциональность для визуализации древовидных регрессионных моделей. Основная функция пакета — ctree(), которая используется для создания деревьев решения для таких задач регрессии как номинальные, порядковые, числовые а также многовариантные переменные отклика. На основе деревьев условного вывода cforest() предоставляет реализацию случайных лесов Бреймана. Функция mob() реализует алгоритм рекурсивного разделения на основе параметрических моделей (например, линейных моделей, GLM или регрессии выживания), использующих тесты нестабильности параметров для выбора разделения.

RandomForest

RandomForest [8] — пакет с реализацией алгоритма случайного леса. Используется для решения задач регрессии и классификации, а также для поиска аномалий и отбора предикторов.

ClusterR

Пакет ClusterR [9] состоит из алгоритмов кластеризации на основе центроидов (метод K-средних (k-means), mini-batch-kmeans, k-medoids) и распределений (GMM). Кроме того, пакет предлагает функции для:

  • проверки результатов,
  • построения графика результатов, используя метрики
  • прогнозирования новых наблюдения,
  • оценки оптимального количества кластеров для каждого алгоритма

E1071

Пакет [10] содержит в себя функции для анализа классов, кратковременного преобразование Фурье, нечеткой кластеризации, реализации метода опорных векторов, вычисления кратчайшего пути, а также реализации наивного байесовского классификатора.

Mlr

В пакете Mlr [11] представлены модели для регрессии, классификации, кластеризации и анализа выживаемости, а также широкие возможности для оценки качества (в том числе функции для анализа ROC-кривых). Есть поддержка параллельных вычислений и конвейерных операций.

H2O

В пакете H20 [12] представлены линейные модели, такие как градиентный бустинг, метод главных компонент (PCA), GLRM, метод k ближайших соседей, случайный лес, наивный байесовский классификатор. Сильная сторона этой библиотеки — работа с большими объемами данных и поддержка многопоточных вычислений. Однако в ней нет возможности задавать параметры используемых алгоритмов

Примеры алгоритмов

В интернете много хороших примеров реализации алгоритмов на R, но среди них хотелось бы особо отметить один учебник[13] c портала coderlessons.com. В нем представлена реализация основных алгоритмов в порядке, удобном для изучения.

Задачи регрессии

Линейная регрессия

Основная статья: Линейная регрессия
# reading data
data <- read.csv("input.csv", sep = ',', header = FALSE)

# evaluating linear regression model
model <- lm(data$x ~ data$y)

# getting summary
print(summary(model))

# visualizing data
plot(data$y, data$x)
lines(data$y, predict(fit), col = 'red')

Множественная регрессия

# reading data
rdata <- read.csv("input.csv", sep = ',', header = FALSE)

# evaluating regression model
model <- lm(target ~ x + y + z, data = rdata)

# getting summary
print(summary(model))

Логистическая регрессия

Основная статья: Логистическая регрессия

Логистическая регрессия – это модель регрессии, в которой переменная ответа принимает значения 0 или 1 (True или False). Реализация на языке R представлена в следующем фрагменте:

# reading data
rdata <- read.csv("input.csv", sep = ',', header = FALSE)

# evaluating model
model = glm(formula = target ~ x + y + z, data = rdata, family = binomial)

# printing summary
print(summary(model))

Метод главных компонент

# importing library and its' dependencies
library(h2o)
h2o.init()

path <- system.file("extdata", "data.csv", package = "h2o")
data <- h2o.uploadFile(path = data)

# evaluating
h2o.prcomp(training_frame = data, k = 8, transform = "STANDARDIZE")

Деревья решений, случайный лес

Деревья решений

Для создания деревьев решений в R используется функция ctree() из пакета party.

# importing package 
install.packages("party")

# reading data
rdata <- read.csv("input.csv", sep = ',', header = FALSE)

# evaluating model
output.tree <- ctree(target ~ x + y + z, data = rdata)

# plotting results
plot(output.tree)

Случайный лес

Для создания случайного леса необходимо импортировать пакет randomForest

# importing packages 
install.packages("party")
install.packages("randomForest")

# reading data
rdata <- read.csv("input.csv", sep = ',', header = FALSE)

# creating the forest
output.forest <- randomForest(target ~ x + y + z, data = rdata)

# getting results
print(output.forest) 

Наивный Бейесовский классификатор

# importing package and it's dependencies
library(e1071)

# reading data
data <- read.csv("input.csv", sep = ',', header = FALSE)

# splitting data into training and test data sets
index <- createDataPartition(y = data$target, p = 0.8, list = FALSE)
training <- data[index,]
testing <- data[-index,]

# create objects x and y for predictor and response variables
x <- training[, -9]
y <- training$target

# training model
model <- train(x, y, 'nb', trControl = trainControl(method = 'cv', number = 10))

# predicting results
predictions <- predict(model, newdata = testing)

Метод опорных векторов

# importing package and its' dependencies
library(caret)

#reading data
data <- read.csv("input.csv", sep = ',', header = FALSE)

# splitting data into train and test sets
index <- createDataPartition(y = data$target, p = 0.8, list = FALSE)
training <- data[index,]
testing <- data[-index,]

# evaluating model
fit <- train(target ~ x + y + z,
             data = train_flats,
             method = "svmRadial",
             trControl = trainControl(method = "repeatedcv", number = 10, repeats = 3))

# printing parameters
print(fit)

Бустинг

Основная статья: Бустинг, AdaBoost
# loading libraries
install.packages("mlr")
library(mlr)

# loading data
train <- read.csv("input.csv")
test <- read.csv("testInput.csv")

# loading GBM
getParamSet("classif.gbm")
baseLearner <- makeLearner("classif.gbm", predict.type = "response")

# specifying parameters
controlFunction <- makeTuneControlRandom(maxit = 50000) # specifying tuning method
cvFunction <- makeResampleDesc("CV", iters = 100000) # definig cross-validation function

gbmParameters<- makeParamSet(
  makeDiscreteParam("distribution", values = "bernoulli"),
  makeIntegerParam("n.trees", lower = 100, upper = 1000), # number of trees
  makeIntegerParam("interaction.depth", lower = 2, upper = 10), # depth of tree
  makeIntegerParam("n.minobsinnode", lower = 10, upper = 80),
  makeNumericParam("shrinkage", lower = 0.01, upper = 1)
)

# tunning parameters
gbmTuningParameters <- tuneParams(learner = baseLearner,
                                  task = trainTask,
                                  resampling = cvFunction,
                                  measures = acc,
                                  par.set = gbmParameters,
                                  control = controlFunction)

# creating model parameters
model <- setHyperPars(learner = baseLearner, par.vals = gbmTuningParameters)

# evaluating model
fit <- train(model, train)
predictions <- predict(fit, test)

Кластеризация

Основная статья: Кластеризация

Для реализации алгоритма кластеризации k-средних используется пакет ClusterR. В нем реализовано 2 функции: KMeans_arma() и KMeans_rcpp(). В примере далее рассмотрена реализация с использованием функции KMeans_arma().

# importing package and its' dependencies
library(ClusterR)

# reading data
data <- read.csv("data.csv")

# evaluating model
model <- KMeans_arma(data, clusters = 2, n_iter = 10, seed_mode = "random_subset", 
                     verbose = T, CENTROIDS = NULL)

# predicting results
predictions <- predict_KMeans(test_data, model)

См. также

Примечания