Статистическое программирование на R: Часть 3. Повторное использование кода и объектное программирование (исходники)

Источник: IBM developerWorks Россия

Девид Мертц (David Mertz)

Первые две статьи этой серии (часть 1, часть 2) рассматривали R в применении к "реальному миру". Мы исследовали различные возможности статистического анализа и графического отображения, используя большие наборы данных о температуре, которые собрал один из авторов этих статей. Как было упомянуто в предыдущих статьях, мы фактически обследовали лишь малую часть всей глубины и богатства статистических библиотек R.

В этой статье я хочу отойти от дальнейшего статистического анализа как такового (в основном потому, что я сам не имею необходимых знаний в области статистики, чтобы выбрать наиболее подходящий метод; и мой соавтор Брэд Хантинг, и многие читатели знают намного больше в этой области). В дополнение к богатству статистических понятий, предложенных в первых двух статьях, я ознакомлю читателя с некоторыми тонкостями, лежащими в основе языка программирования R. Предыдущие статьи рассказывали о функционально-ориентированном программировании в R; я подозреваю, что многим читателям будут больше близки процедурные и объектно-ориентированные языки программирования.

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

Назад к основам

Перед рассмотрением объектной модели R давайте изучим и уясним объекты и функции R. Главное, что нужно запомнить об объектах R - это то, что "все - вектор". Даже объекты, которые на первый взгляд отличаются от векторов - матрицы, массивы, структуры данных и остальное - на самом деле векторы с дополнительными (измененными) атрибутами, которые "указывают" R обрабатывать их специальным образом.

Массив (обозначаемый dim) - это один из наиболее важных атрибутов, которые имеют (некоторые) вектора R. Функции matrix(), array() и dim() - просто удобные функции для установки размерности вектора. Система ООП (объектно-ориентированного программирования) R также уходит корнями к атрибутам объектных (или других) классов.

Давайте рассмотрим объявление массива на примере кода в Листинге 1.

Листинг 1. Создание векторов и установка размерности

> v = 1:1000 > typeof(v) [1] "integer" > attributes(v) NULL > dim(v) = c(10,10,10)  # Установка размерности > attributes(v) $dim [1] 10 10 10 > v2 = matrix(1:1000, nrow=100, ncol=10) > typeof(v2) [1] "integer" > attributes(v2) $dim [1] 100  10 > attr(v2,'dim') = c(10,10,10)  # Изменение размерности > attributes(v2) $dim [1] 10 10 10

Кратко говоря, существуют различные синтаксические приемы установки атрибута dim вектору - но фактически все эти синтаксические ухищрения делают одно и то же.

Единственное, что может смутить в положении "все - вектор" - это построчные и постолбцовые операции, которые могут быть не так интуитивно понятны. Например, достаточно легко создать двумерный массив (матрицу) и поработать с одним столбцом или строкой:

Листинг 2. Построчные операции над матрицей

> m = matrix(1:12, nrow=3, ncol=4) > m [,1] [,2] [,3] [,4] [1,]    1    4    7   10 [2,]    2    5    8   11 [3,]    3    6    9   12 > sum(m)  # суммирование всех элементов матрицы m [1] 78 > sum(m[1,])  # суммирование по первой строке [1] 22

Но если бы вы захотели создать вектор сумм по строкам, вам, возможно, захотелось бы сделать что-либо вроде следующего:

Листинг 3. Неправильный способ выполнения построчных операций

> sum(m[c(1,2,3),])  # это НЕ суммирование строк [1] 78

Здесь можно было бы использовать цикл, но это идет вразрез с функциональными и векторно-ориентированными операциями R. Правильное решение - использовать функцию apply():

Листинг 4. Функция apply() для построчных операций

> apply(m, 1, sum) # по строке [1] 22 26 30 > apply(m, 2, sum) # по столбцу [1]  6 15 24 33 > apply(m, c(1,2), sum) # по столбцу и строке (суммирование каждой отдельной ячейки) [,1] [,2] [,3] [,4] [1,]    1    4    7   10 [2,]    2    5    8   11 [3,]    3    6    9   12 # Бесполезно суммировать каждую отдельную ячейку, но можно сделать так: > a = array(1:24,c(3,4,2)) > apply(a, c(1,2), sum)  # суммирование вглубь в 3-х мерном массиве [,1] [,2] [,3] [,4] [1,]   14   20   26   32 [2,]   16   22   28   34 [3,]   18   24   30   36 > apply(a, c(3), sum)    # суммирование по каждому направлению вглубь [1]  78 222

Бесконечная последовательность

Иногда, из чисто практических соображений, полезно использовать такую конструкцию, как бесконечная числовая последовательность. Например, мой соавтор по предыдущей статье делал некий анализ с помощью метода интегрирования Монте-Карло, и для его задачи было полезно использовать бесконечно длинную последовательность случайных чисел. Необходимо понять, что бесконечная последовательность - это не просто возможность генерации нового числа в случае необходимости; это также необходимость иметь возможность обращаться к любому предшествующему элементу и получать его прежнее значение.

Очевидно, нет ни компьютерного языка, ни компьютера, способного хранить бесконечную последовательность - все, что они могут хранить, - это "ленивые" ( lazy ) и неограниченные ( unbounded ) последовательности. Новые элементы добавляются к уже реализованному списку тогда и только тогда, когда это необходимо. Например, в Python можно выполнить такое создание спископодобных объектов методом .__getitem__(), который расширяет внутренние списки по необходимости. В Haskell "ленивые" последовательности встроены глубоко внутрь языка - в результате все последовательности являются "ленивыми". В моем руководстве по Haskell (Ресурсы) я использовал пример создания списка всех простых чисел:

Листинг 5. Список простых чисел в Haskell, полученных с помощью решета Эратосфена

primes :: [Int] primes = sieve [2 .. ] sieve (x:xs) = x : sieve [y / y <- xs, (y `rem` x)/=0]

В том, что касается бесконечности, R ближе к Python, чем к Haskell. Вам необходимо явно создавать новые элементы в случае необходимости. Подождем до раздела ООП, где мы увидим, как работает скрытый механизм векторного индексирования; здесь еще не так все запутано.

Листинг 6. Объявление вектора и способа его динамического расширения

inf_vector = rnorm(10, 0, 1)   # произвольный старт w/ , # инициализация 10 элементов assure <- function(index) { extend_by = max(index-length(inf_vector), 0) extras = rnorm(extend_by, 0, 1) v <- c(inf_vector, extras) assign("inf_vector", v, env=.GlobalEnv) return(index) } getRand <- function(index) { assure(index) return(inf_vector[index]) }

Вероятно, предпочтительнее получать значение элемента через функцию-контейнер getRand(). Заметим, что вы совершенно свободны в использовании срезов, вычисляемых значений либо отдельных индексов:

Листинг 7. Использование функции-контейнера в качестве посредника для бесконечного виртуального вектора

> getRand(3)                # единичный индекс [1] 0.5557101 > getRand(1:5)              # диапазон [1] -0.05472011 -0.30419695  0.55571013  0.91667175 -0.40644081 > getRand(sqrt(c(4,16)))    # расчет индекса коллекции [1] -0.3041970  0.9166717 > getRand(100)              # принудительное расширение вектора [1] 0.6577079

Если необходимо, перед использованием элементов можно создать достаточно большой вектор с помощью функции assure():

Листинг 8. Расширение вектора (при необходимости) перед работой с ним

> assure(2000) [1] 2000 > inf_vector[1500] [1] 1.267652

Объектно-ориентированное программирование в R

R полностью отвечает требованиям объектно-ориентированного программирования, но чтобы понять это, нужно вспомнить о том, что такое ООП. Пользователи таких языков, как Java и C++ и даже Python, Ruby или Smalltalk, могут иметь несколько ограниченное представление об объектно-ориентированном программировании. Не ошибочное, но ограниченное одной моделью.

Принципы ООП в R в большей степени основываются на обобщенных функциях, чем на иерархиях классов. Эта концепция будет близка читателям, использующим CLOS Lisp или тем, кто читал мои дискуссии по множественной диспетчеризации в Python. К сожалению, подход R - это единичная диспетчеризация; в этом отношении он эквивалентен "традиционным" языкам, упомянутым ранее (C++, Java и другие).

Необходимо заметить, хотя это и не будет обсуждаться подробно в данной статье, что наиболее новая версия R сопровождается пакетом methods, который определяет и использует так называемые "формальные методы". Применение этих формальных методов во многом накладывает некую дисциплину (и ограничения), знакомые по традиционным языкам ООП. В любом случае формальное ООП в R строится поверх "неформального ООП", о котором будет рассказано в этой статье. Насколько я знаю, пакет methods не имеет окончательного статуса, но некая слегка модифицированная версия этого пакета, по-видимому, будет сохранена в будущих версиях R.

Необходимо помнить, что суть концепции ООП на самом деле не в наследовании, а в более общем принципе - решениях по диспетчеризации . Например, вызов obj.method() в традиционных языках ООП будет использовать порядок разрешения методов ( method resolution order - MRO) объекта для поиска "первого" класса-предка obj, который имеет метод .method().

Что такое "первый" - это более тонкий вопрос, чем кажется на первый взгляд. R принимает те же решения, но выворачивает идею наследования наизнанку - вместо набора классов , которые могут объявлять и аннулировать различные методы внутри себя, R порождает семейство обобщенных (generic) функций , которые имеют метки, указывающие тип объекта, которым они хотят оперировать.

Обобщенные функции

В качестве простого примера создадим обобщенную функцию whoami() и несколько помеченных методов для диспетчеризации:

Листинг 9. Создание обобщенной функции и помеченных методов

#------------- Создание обобщенного  метода > whoami <- function(x, ...) UseMethod("whoami") > whoami.foo <- function(x) print("I am a foo") > whoami.bar <- function(x) print("I am a bar") > whoami.default <- function(x) print("I don't know who I am")

Ключевая идея состоит в том, что каждый объект в R может принадлежать нулю, одному или большему числу классов. MRO любого заданного объекта (относительно конкретного метода) - это просто вектор именованных классов (если они есть) в атрибуте его class. Например:

Листинг 10. Назначение объектам меток членства в классе

> a = 1:10 > b = 2:20 > whoami(a)                 # Нет соответствующего класса [1] "I don't know who I am" > attr(a,'class') <- 'foo' > attr(b,'class') <- c('baz','bam','bar') > whoami(a) [1] "I am a foo" > whoami(b)                 # поиск MRO для описываемого вектора [1] "I am a bar" > attr(a,'class') <- 'bar'  # изменение класса 'a' > whoami(a) [1] "I am a bar"

Как и в традиционных наследующих языках, объект не обязан использовать один и тот же класс для всех вызываемых методов. Традиционно, если Child наследуется от Mom и Dad, объект типа Child может использовать .meth1() от Mom и .meth2() от Dad. Все это можно сделать и в R, но Mom и Dad ничего не значат - это просто имена:

Листинг 11. Разрешение методов

> meth1 <- function(x) UseMethod("meth1") > meth1.Mom <- function(x) print("Mom's meth1") > meth1.Dad <- function(x) print("Dad's meth1") > meth2 <- function(x) UseMethod("meth2") > meth2.Dad <- function(x) print("Dad's meth2") > attr(a,'class') <- c('Mom','Dad') > meth1(a)  # несмотря на существование meth1.Dad, Mom используется первым для a [1] "Mom's meth1" > meth2(a) [1] "Dad's meth2"

Включение предков

Необходимость явного указания MRO объекта вместо неявного разрешения через синтаксис наследования может показаться ограничивающей. В действительности можно легко реализовать основанный на наследовании синтаксис MRO, используя минимальное количество функций-контейнеров. MRO, используемый в Листинге 11, вероятно, не лучший из всех возможных, но он демонстрирует идею:

Листинг 12. Реализация основанного на наследовании MRO с использованием минимального количества функций-контейнеров

char0 = character(0) makeMRO <- function(classes=char0, parents=char0) { # Создание MRO из опционального явного списка # и опционального списка предков mro <- c(classes) for (name in parents) { mro <- c(mro, name) ancestors <- attr(get(name),'class') mro <- c(mro, ancestors[ancestors != name]) } return(mro) } NewInstance <- function(value=0, classes=char0, parents=char0) { # Создание нового объекта, основываясь на первоначальном значении, # явных классах и предках (все опционально) obj <- value attr(obj,'class') <- makeMRO(classes, parents) return(obj) } MaternalGrandma <- NewInstance() PaternalGrandma <- NewInstance() Mom <- NewInstance(classes='Mom', parents='MaternalGrandma') Dad <- NewInstance(0, classes=c('Dad','Uncle'), 'PaternalGrandma') Me <- NewInstance(value='Hello World', 'Me', c('Mom','Dad'))

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

Листинг 13. Объект с основанным на наследовании MRO

> print(Me) [1] "Hello World" attr(,"class") [1] "Me"              "Mom"             "MaternalGrandma" "Dad" [5] "Uncle"           "PaternalGrandma"

Если следовать традиционному подходу отношений класс/наследование, надо включать имя создаваемого класса (подобно Mom в аргументе classes). Фактически, учитывая, что каждый класс - это нормальный объект, рассмотренная выше система ближе к прототипному ООП, чем к основанному на классах.

Опять же, вся система обладает достаточной гибкостью для реализации всех вариантов. Можно при желании совершенно свободно отделить объекты классов от объектов экземпляров - можно различать классы по соглашениям именования (например, Mom в отличие от mom), присваивая другие атрибуты (например, type может быть class или instance; функция обработки должна проверять тип) или другими способами.

Снова о бесконечном векторе

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

Операторы в R - это просто сокращенный способ вызова функций; вы можете свободно дифференцировать поведение операторов на основе классов, так же, как и для вызовов других функций. Попутно исправим еще несколько недостатков первой системы:

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

Сделаем все это:

Листинг 14. Объявление индексируемого бесконечного случайного вектора

"[.infinite_random" <- function(v, index) { name <- attr(v, 'name') rfunc <- attr(v, 'rfunc') extend_by = max(index-length(v), 0) extras = rfunc(extend_by) new <- c(v, extras) makeInfiniteRandomVector(name, v=new, rfunc) return(new[index]) } unitnorm <- function(n) return(rnorm(n,0,1)) empty <- vector('numeric', 0) makeInfiniteRandomVector <- function(name, v=empty, rfunc=unitnorm) { # Создание бесконечного вектора # можно расширить существующий вектор, настраиваемая функция rand attr(v,'class') <- 'infinite_random' attr(v,'name') <- name attr(v,'rfunc') <- rfunc assign(name, v, env=.GlobalEnv) } makeInfiniteRandomVector('v') # makeInfiniteRandomVector('inf_poisson', rfunc=my_poisson) # Использование: v[1]; v[10]; v[9:12]; и так далее.

Индексирование уже определено в R как обобщенная функция, так что для его настройки не нужно вызывать метод UseMethod(); можно просто определить столько новых специализаций, сколько нужно. Аналогично, встроенная функция print() тоже является обобщенной. Ею можно воспользоваться так:

Листинг 15. Печать бесконечного вектора

print.infinite_random <- function(v) { a_few = 5 len = length(v) end_range = (len-a_few)+1 cat('* Infinite Random Vector *\n') cat('[1] ', v[1:a_few], '...\n') cat('[') cat(end_range) cat('] ', v[end_range:len], '...\n') }

In action, the code produces the following:

Листинг 16. Пример печати бесконечного вектора

> v[1000] [1] -1.341881 > print(v) * Бесконечный случайный вектор * [1]  -0.6247392 1.308057 1.654919 1.691754 -2.251065 ... [996]  1.027440 0.8376 -0.7066545 -0.7778386 -1.341881 ...

Заключение

Для программирования функций общего назначения, объектов и классов в R нужно сделать шаг назад от подхода традиционных процедурных и объектно-ориентированных языков программирования. Первые две статьи демонстрировали примеры конкретного статистического анализа и не требовали отдельного обдумывания, но однажды, когда вам захочется создать повторно используемый код, придется понять концепцию обобщенных функций и "вывернутый наизнанку" объектно-ориентированный подход, на котором основано их применение (форма ООП "наизнанку" в действительности является более общей).

Вся хитрость такого понимания ООП в том, чтобы мыслить в терминах "какой код вызван?" и "как сделан выбор?". Не привязывайтесь к синтаксису, который применяется в конкретных языках - C++, Objective C, Java, Ruby или Python; сконцентрируйтесь на концепции диспетчеризации.

Статистическое программирование на R: Часть 3. Повторное использование кода и объектное программирование (исходники).

"Доктор Веб": Хронология эпидемии троянца BackDoor.Flashback.39.

SSL VPN - шаг вперед в технологии VPN сетей.

Oracle Day: день изменений.

Oracle Enterprise Manager 11g дополнено новыми средствами управления бизнес-транзакциями.

Главная » Java