• Главная
  •  > 
  • Questions
  •  > 
  • Oracle Enterprise R — запуск скриптов R на стороне базы данных из среды R (Embedded R). Использование snow между несколькими узлами

Oracle Enterprise R — запуск скриптов R на стороне базы данных из среды R (Embedded R). Использование snow между несколькими узлами

1. Инсталляция

Инсталлятор RStudio следует скачать с официального сайта проекта. RStudio можно установить как на персональный компьютер, так и на Linux-управляемый сервер. Ниже речь идет о варианте программы для персональных компьютеров.

Доступны инсталляторы RStudio для всех наиболее распространненных операционных систем, в частности Windows XP/Vista/7, Mac OS X 10.5, Debian 6+/Ubuntu 10.04 и Fedora 13. Выберите из списка соответствующий файл и скачайте его. Инсталляция происходит стандартно, без каких-либо особенностей.

2. Работа с Консолью

2.1. Общая информация

Консоль RStudio (Console) предоставляет целый ряд опций, делающих работу с R простой и продуктивной. Освоение этих опций, наряду с возможностями, доступными в панелях Source (Редактор кода) и History (История), может с лихвой воздать затреченное на обучение время.

2.2. Автоматическое завершение кода

RStudio поддерживает автоматическое завершение кода при помощи клавиши Tab. Например, если в рабочем пространстве имеется объект с именем pollResults , то можно набрать на клавиатуре poll , нажать Tab, и RStudio автоматически завершит название этого объекта. Аналогично можно получать подсказки по функциям при введении их имен. Например, введя название функции sub и нажав на Tab, получим следующее:

Завершение кода работает также для аргументов функций; например, если ввести subset( и нажать Tab, то получим:

2.3. Возврат к предыдущим командам

При работе с R постоянно возникает необходимость выполнить заново ту или иную команду, которая уже была выполнена ранее. Как и стандартная R-консоль, консоль RStudio поддерживает возможность навигации по ранее выполненным командам, используя клавиши со стрелками.

Для просмотря списка недавно выполненных команд и для выбора определенной команды из этого списка можно использовать также сочетание клавиш Ctrl+Вверх (Command-Вверх на Mac-компьютерах):

Такое же сочетание клавиш подходит и для быстрого поиска ранее вызванных функций, в имени которых имеется определенный префикс. Например, для поиска функций, в имени которых есть plot , следует просто ввести plot и нажать Ctrl+Вверх:

2.4. Заголовок окна Консоли

В заголовке окна Консоли имеется несколько дополнительных опций:

  • Отображение рабочей директории.
  • Возможность прервать текущие вычисления.
  • Сворачивание и разворачивание окна Консоли по отношению к панели Редактора кода (Source) (с использованием кнопок в правом верхнем углу или двойного клика по заголовку окна).

2.5. Горячие клавиши

Ctrl+L - Очищает окно Консоли от текста

Esc - прерывает вычисления

3. Редактирование и выполнение кода

3.1. Общая информация


Редактор кода RStudio включает ряд опций для продуктивной работы, в частности подсветку кода, автоматическое завершение кода, одновременное редактирование нескольких файлов, поиск и замену определенных частей кода.

Кроме того, в RStudio имеются гибкие возможности по выполнению кода непосредственно из окна редактора. Для многих пользователей это является предпочтительным способом работы с R. Выполнение команд из окна Редактора кода вместо командной строки Консоли облегчает воспроизведение одних и тех же команд и позволяет "упаковать" такие команды в одну функцию для последующего использования.

3.2. Управление файлами


RStudio поддерживает подсветку синтаксиса и другие специализированные опции по работе с кодом следущих типов файлов:

  • R-скрипты
  • документы Sweave
  • документы TeX
Для создания нового файла используте меню File -> New:

Для открытия существующего файла необходимо воспользоваться меню File -> Open или Open Recent (для открытия файла,с которым работа осуществлялась недавно). Если открыто несколько файлов одновременно, быстрый переход от одного документа к другому выполняется при помощи соответствующих закладок в верхней части окна редактора кода. Для навигация между большим количеством открытых файлов служит иконка >> в правой верхней части окна Редактора; можно также воспользоваться меню View -> Switch to.



3.3. Завершение кода

Как уже отмечалось выше при описании работы с Консолью, RStudio поддерживает автоматическое завершение кода при помощи клавши Tab. Например, если в рабочем пространстве имеется объект с именем pollResults , то можно набрать на клавиатуре poll , нажать Tab, и RStudio автоматически завершит название этого объекта.


3.4. Поиск и замена частей кода

В Редакторе кода RStudio имеется возможность найти и заменить необходимые части текста. Для выполнения этой операции необходимо воспользоваться сочетанием клавиш Ctrl+F или разделом меню Edit -> Find and Replace. В верхней части окна редактора имеется кнопка в виде увеличительного стекла - ее нажатие также приводит к открытию диалогового окна, в котором задаются параметры поиска.



3.5. Автоматичекое создание функций

Редактор кода RStudio может проанализировать выделенную часть текста и автоматически конвертировать ее в функцию для последующего многократного использования. Все "свободные" переменные в выделенном коде (т.е. объекты, на которые имеется ссылка, но которые не созданы внутри выделения) будут при этом преобразованы в аргументы функции:

3.6. Комментирование кода

Для комментирования выделенных частей кода (или для снятия комментирования) используйте пункт меню Edit -> Comment/Uncomment Lines (см. также рисунок ниже):

3.7. Выполнение кода

RStudio поддерживает выполнение кода непосредственно из окна Редактора (выполняемые команды посылаются в Консоль, где появляется также результат их выполнения).

Для выполнения текущей строки кода можно воспользоваться сочетанием клавиш Ctrl+Enter или кнопкой Run Line(s), расположенной в верхней части окна Редактора:


Имеются две возможности для одновременного выполнения нескольких строк кода:

  • Выделить необходимые строки и нажать клавиши Ctrl+Enter (или воспользоваться кнопкой Run Line(s), расположенной в верхней части окна Редактора);
  • Нажать Ctrl+Shift+Enter для выполнения всех строк, имеющихся в скрипте.

3.8. Горячие клавиши

Ctrl+Shift+N - создать новый документ

Ctrl+O - открыть документ

4. Навигация по коду

4.1. Общая информация

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

4.2. Переход к файлу или функции

Если Вы знаете имя файла со скриптом или название функции, Вы можете быстро найти их, используя поле поиска Go to File/Function (Перейти к Файлу/Функции) в главной панели инструментов RStudio:


Опция "Go to File/Function" работает благодаря постоянному индексированию создаваемого Вами кода. Конкретные файлы, подлежащие индексированию, определяются следующим образом:

  • Если какой-либо проект RStudio активен: индексируются все файлы, находящиеся в папке этого проекта;
  • Если проект не активен: индексируются все открытые в данный момент фалы с R-скриптами.

Горячие клавиши для вызова опции Go to File/Function: Ctrl+

4.3. Переход к определению функции

Благодаря постоянно выполняемому индексированию R-кода (см. выше), RStudio может также помочь Вам найти определение любой функции. Для перехода к коду функции наведите курсор на ее имя (не обязательно выделять его полностью) и выберите команду Go to Function Definition (Перейти к определению функции):

Перейти к определению функции можно также следующими способами:

  • Используя горячую клавишу F2.
  • Используя Ctrl + щелчок по имени функции.
  • Используя Редактор кода или Консоль.

Имеется возможность переходить к определению не только Ваших собственных функций, но также функций из любого пакета R. Код функций из дополнительных пакетов R отображается в специальном Окне просмотра исходного кода (Source Viewer pane) и предназначается только для чтения.

4.4. Навигация по скрипту

Существует несколько способов навигации по коду, хранящемуся в виде скрипта в отдельном файле:

  • Рассмотренная выше опция "Go to File/Function" поволяет выполнять поиск в пределах открытого файла со скриптом;
  • Команда Jump to Line (Перейти к строке) предназначена для перехода к определенной строке скрипта.

Можно также использовать опции из соответствующего меню (Code Tools):



4.5. Двусторонняя навигация по коду

При навигации по коду (особенно при последовательных переходах от одной функции к другой) часто возникает необходимость быстро вернуться к предыдущему месту, где выполнялось редактирование кода. RStudio хранит список таких редактирований и позволяет переходить от одного к другому в любом направлении, используя команды Back (Назад) и Forward (Вперед) (доступны из меню Edit (Редактирование), а также в верхнем левом углу окна Редактора кода). Команды Back и Forward позволяют повторять следующие действия:

  • Открытие документа (или переключение между закладками)
  • Переход к определению функции
  • Переход к определенной строке кода
  • Переход к функции с использованием меню Function
Команды Back и Forward можно вызвать, используя сочетания клавиш Ctrl+F9 / Ctrl+F10 (Cmd+F9 / Cmd+F10 на Mac компьютерах).

5. Использование истории команд

5.1. Общая информация

Во время работы RStudio создает базу данных всех команд, которые пользователь вводит в Консоль. Имеется возможность просмотра этой базы данных при помощи панели History (История).

5.2. Обзор истории команд

Закладка History в одной из служебных панелей RStudio служит для просмотра истории выполненных ранее команд. Команды отображаются в порядке их выполнения (недавние команды - внизу списка) и сгруппированы по времени:

5.3. Поиск в истории команд

В правом верхнем углу списка ранее выполненных комад имеется поле для ввода поисковых запросов (например, plot ). Условия поиска можно детализировать, введя несколько слов, разделенных пробелами (например, имя какой-либо таблицы данных):



После обнаружения необходимой команды можно также просмотреть и другие команды, которые выполнялись примерно в то же время. Для этого необходимо кликнуть по стрелке, расположенной справа от времени выполнения соответствующей команды:

5.4. Выполнение команд

Команды в панели History можно выделить и далее использовать двумя способами (в соответствии с названиями двух кнопок в левой верхней части панели):

  • Послать в Консоль (Send to Console) - отправляет выделенные команды в Консоль. Заметьте, однако, что отправленные в Консоль команды не будут выполнены пока не будет нажата клавиша Enter.
  • Вставить в Источник (Send to Source) - отправляет выбранные команды в активный документ Редактора кода. Если в данный момент в Редакторе нет активных открытых документов, будет создан новый документ без имени.

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


6. Рабочие директории и рабочие пространства

6.1. Общая информация

Учитывая то, как R по умолчанию обращается с файлами .RData и своими рабочими пространствами (workspaces), имеет смысл организовывать работу таким образом, чтобы файлы из разных проектов хранились в разных папках. Представленный ниже материал описывает имеющиеся в RStudio возможности для организации такой модели работы.

6.2. Рабочая директория по умолчанию


Аналогично стандартной версии R, RStudio руководствуется принципом "исходной рабочей директории". Как правило, это домашняя папка пользователя. При запуске RStudio происходит следующее:

  • Выполняется файл .Rprofile (если таковой имеется) из исходной рабочей папки.
  • Загружается файл .RData (если таковой имеется) из этой папки в рабочее пространство R.
  • Выполняются другие действия, описанные в служебном файле R Startup .

Если в рабочее пространство были внесены изменения, то при завершении работы RStudio появится диалоговая панель с вопросом о необходимости сохранить это рабочее пространство в виде файла .RData в текущей рабочей папке. Такое поведение можно изменить в настройках RStudio (меню Tools -> Options -> R General) следующим образом:

  • Изменить исходную рабочую директорию (Initial working directory)
  • Активировать/деактивировать автоматическую загрузку файла .RData из исходной рабочей папки R (Restore .RData into workspace at startup)
  • Выбрать, нужно ли файл .RData сохранять всегда (Always), никогда (Never), или спрашивать о сохранении при заврешении работы (Ask).

6.3. Изменение рабочей директории

Текущая рабочая директория отображается в верхней части окна Консоли. Имеется несколько способов изменить рабочую директорию:

  • Использовать функцию setwd()
  • Воспользоваться разделом меню Tools -> Change Working Dir...
  • На закладке Files выбрать More -> Set As Working Directory

Необходимо помнить о возможных последствиях изменения рабочей папки:

  • Имеющиеся в коде относительные ссылки на файлы станут недействительными.
  • При завершении работы файл .RData будет сохранен в новую папку.

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

Если все файлы, имеющие отношение к определенному проекту, хранятся в одной папке, имеет смысл сделать ее исходной для R. Способы для этого будут вариьировать в зависимости от операционной системы. Тем не менее, на всех платформах при инсталляции RStudio происходит ассоциация этой программы с .RData , .R и другими имеющими отношение к R файлами. При открытии таких файлов RStudio автоматически будет делать рабочей папкой ту, в которой хранится открываемый файл. Однако следует помнить, что если RStudio уже запущена, открытие новых ассоциированных с ней файлов не приведет к изменению рабочей папки.

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

Следует помнить, что функция load() добавит загружаемое рабочее простанство к текущему. Следовательно, если в активном и загружаемом пространствах имееются объекты с одинаковыми именами, то объекты из загружаемого пространства заменят одноименные объекты в активном пространстве. Это может привести к нежелательным последствиям. Поэтому перед загрузкой нового рабочего пространства может иметь смысл очистить активное пространство. Это можно сделать при помощи следующей команды:


Закладка Workspace также имеет опции для выполнения описанных выше операций:

  • Загружает проект и отображает его название в панели инструментов Projects (находится в дальнем правом углу рабочего окна программы).

    • 7.3. Работа с проектами

    Открытие проекта

    Имеется несколько способов открытия проектов:

    • Использование команды Open Project (Открыть Проект), доступной из закладки Projects главного меню и панели инструментов, для навигации к файлу ранее созданного проекта (например, MyProject.Rproj).
    • Выбор проекта из списка недавно редактированных проектов (эта опция также доступна из закладки Projects главного меню и из панели инструментов).
    • Двойной щелчок по файлу-ярлыку проекта (см. выше).

    При открытии проекта в RStudio выполняются следующие действия:

    • Запускается новая сессия R;
    • Выполняются команды из служебного файла.Rprofile (если таковой имеется в основной папке проекта);
    • Файл.Rhistory загружается из папки проекта в панель History (История) и используется для навигации по ранее выполненным командам;
    • Директория проекта становится рабочей директорией R;
    • В Редакторе кода открываются ранее редактированные скрипты с R-кодом.
    • Происходит возврат других настроек RStudio (например, активные закладки, состояние разделителей окон, и т.п.) к состоянию, имевшему место перед предыдущим закрытием проекта.

    Выход из проекта

    Когда Вы выбираете команду Quit R (Выход) из раздела File главного меню, команду Сlose Project (Закрыть Проект) из панели инструментов Project, или просто октрываете новый проект, происходит следующее:

    • В папку проекта записываются файлы.RData и/или.Rhistory (если текущие настройки программы предполагают это);
    • Сохраняется список входящих в проект скриптов для возможности открыть их в следующий раз;
    • Сохраняются другие настройки RStudio (см. выше);
    • Текущая сессия R завершается.

    Работа с несколькими проектами одновременно

    Вы можете работать с несколькими проектами одновременно, просто запуская соответствующее количество копий RStudio. Это можно сделать двумя способами:

    • Использовать команду Open Project in New Window (Открыть проект в новом окне), находящуюся в разделе Project главного меню.
    • Открыть несколько проектов из браузера файлов, щелкая по соответствующим ярлыкам.
    Настройка проектов

    Имеется несколько опций для настройки поведения каждого конкретного проекта в RStudio. Эти опции доступны по команде Project Options из раздела Project главного меню программы:


    Закладка General (Общие ): При помощи этой закладки можно изменить глобальные настройки поведения проектов. Если изменять их нет необходимости, оставьте значение Default (По умолчанию). Доступны следующие опции:
    • Restore .RData into workspace at startup - загрузка файла.RData (если таковой имеется) из исходной рабочей директории R. Если файл.RData имеет большой размер, для данной опции лучше выбрать значение "No" (Нет). Это значительно сократит время запуска программы.
    • Save workspace to .RData on exit - сохранение рабочего пространства в виде файла.RData при выходе из программы. Возможные варианты: "Default" (используются глобальные настройки), "Yes" (Да), "No" (Нет) и "Ask" (Спросить). Обратите внимание: если рабочее пространство не было изменено, запрос на сохранение изменений не появится, даже если задано значение "Ask".
    • Always save history (even when not saving .RData) - позволяет сделать так, чтобы файл.Rhistory с историей команд всегда сохранялся, даже если Вы выбрали не сохранять файл.RData при выходе из программы.
    Закладка Editing (Редактирование ):
    • Index R source files - позволяет сделать так, чтобы скрипты с R-кодом из конкретного проекта индексировались для возможности навигации по коду (см. выше). Обычно эта опция должна быть активирована, но если в папке проекта находятся "тысячи" файлов, эту опцию можно отключить во избежание замедления работы программы.
    • Insert spaces for tab - задает действие клавиши Tab, т.е. сколько пробелов должно появляться при ее нажатии.
    • Text encoding - задает кодировку текста в файлах-скриптах. Файлы, кодировка которых не соотвествует заданной, все равно могут быть открыты и правильно распознаны при использовании команды Reopen with Encoding из меню File.
    Закладка Version Control (Контроль версий ):
    • Version control system - позволяет указать систему, которая будет использоваться для контроля версий. RStudio автоматически определяет наличие контроля версий путем сканирования папки.git или.svn. Соответственно, эту настройку лучше не изменять. Причинами для внесения изменений могут быть следующие:
    1. В проекте имеется как папка.git, так и папка.svn, и Вы хотите указать однозначно, какая из систем контроля должа использоваться.
    2. Проект не привязан к какой-либо системе контроля версий и Вы хотите добавить логическое хранилище git (эквивалент выполнения команды git init из корневой папки проекта).
    • Origin - отображение источника системы контроля версий.

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

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

    • Подключайте более мощные параллельные библиотеки, например, Intel BLAS (доступна под Linux, OS X и Windows как часть дистрибутива Microsoft R Open). Это позволит заменить уже используемые библиотеки их параллельными версиями, благодаря чему получите ускорение (на соответствующих задачах, например, связанных с линейной алгеброй в lm()/glm()).
    • Вынесите обработку задач моделирования из R во внешнюю библиотеку для параллелизации . Это стратегия, которую используют следующие системы: методы rx от RevoScaleR (теперь Microsoft Open R) , методы h2o от h2o.ai , RHadoop .
    • Используйте утилиту parallel в R, чтобы запускать функции на других экземплярах R . Эта стратегия из «Небольшого введения в параллельное программирование на R» и ряда библиотек на основе parallel . Фактически это реализация удаленного вызова процедуры через сокет или сеть.

    Рассмотрим подробнее третий подход.

    Фактически, третий подход представляет собой очень мелко подробленный удаленный вызов процедуры. Он зависит от передачи копий кода и данных на удаленные процессы и последующий возврат результатов. Это плохо подходит для очень маленьких задач, но отлично - для приемлемого числа средних или больших. Эта стратегия используется в библиотеке R parallel и в библиотеке Python multiprocessing (хотя с multiprocessing для Python может понадобиться ряд дополнительных библиотек , чтобы перейти от одной машины к кластерным вычислениям).

    Этот метод может показаться менее эффективным и менее сложным, чем методы распределенной памяти, но полагаясь на передачу объекта, можно очень легко распространить технику от одной машины на несколько («кластерные вычисления»). Именно это мы сделаем с помощью кода на R в этой статье (переход от одной машины к кластеру приведет к многочисленным проблемам систем/сети/безопасности, и с ними придется справляться).

    Вам понадобится весь код на R из предыдущей статьи. Также предполагается, что вы можете сконфигурировать ssh , или у вас есть человек, который может помочь с настройкой. Вместо запуска параллельного кластера командой “ parallelCluster <- parallel::makeCluster(parallel::detectCores()) ” сделайте следующее.

    Соберите список адресов машин, к которым вы можете применить ssh . Это сложная часть, зависит от операционной системы и может потребовать помощи, если вы раньше этого не делали. В этом примере я использую IPv4 адреса, а для Amazon EC2 - имена узлов.

    В моем случае список такой:

    • Моя машина (основная): “192.168.1.235”, пользователь “johnmount”
    • Другая машина Win-Vector LLC: “192.168.1.70”, пользователь “johnmount”

    Обратите внимание, мы не собираем пароли, предполагая, что установлены правильные «authorized_keys» и пары ключей в конфигурациях ".ssh" всех этих машин. Будем называть машину, с которой будет осуществляться расчет в целом, «первичной».

    Обязательно стоит попробовать все эти адреса с «ssh» в терминале перед тем, как использовать их в R. Также адрес машины, выбранной «первичной», должен быть достижим с рабочих машин (т.е. нельзя использовать «localhost» или выбирать недостижимую машину «первичной»). Попробуйте вручную ssh между первичной и остальными машинами, и в обратную сторону, после чего настройки можно будет использовать в R.

    Когда системные настройки позади, часть на R будет выглядеть так. Запустите ваш кластер:

    Primary <- "192.168.1.235" machineAddresses <- list(list(host=primary,user="johnmount", ncore=4), list(host="192.168.1.70",user="johnmount", ncore=4)) spec <- lapply(machineAddresses, function(machine) { rep(list(list(host=machine$host, user=machine$user)), machine$ncore) }) spec <- unlist(spec,recursive=FALSE) parallelCluster <- parallel::makeCluster(type="PSOCK", master=primary, spec=spec) print(parallelCluster) ## socket cluster with 8 nodes on hosts ## ‘192.168.1.235’, ‘192.168.1.70’

    Вот и все. Теперь можно запускать ваши функции на нескольких ядрах нескольких машин. Для правильных задач ускорение будет существенным . Всегда имеет смысл действовать пошагово: сначала напишите простой «hello world» на вашем кластере, потом убедитесь, что меньшая версия ваших расчетов работает локально, и только после этого переносите работу в кластер.

    Есть и другой способ работать с кластерами в R. Для начала нам понадобится версия R с предуслатновленными пакетами Rmpi и snow. Для этой цели я предлагаю билд R HSPCC, поддерживаемый Каспером Дэниэлом Хансеном. Вот инструкции по установке.

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

    Использование нескольких ядер внутри узла

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

    Запустите процесс на узле кластера с несколькими процессорами, набрав следующую команду:

    Qrsh -l mcmc -pe local 10-12

    Обратите внимание, здесь мы запрашиваем 10-12 процессоров на одном узле в очереди mcmc. Количество доступных ядер можно посмотреть в переменной окружения NSLOTS, доступной в R с помощью такой команды:

    As.integer(Sys.getenv("NSLOTS"))

    Следующий шаг - запустить R и загрузить библиотеку multicore. Наконец, можно продолжить использованием команды mclapply вместо lapply в R (передавая количество используемых ядер как аргумент mc.cores).

    Использование snow между несколькими узлами

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

    Для запуска кластера MPI с 12 узлами (ядрами), нужно набрать такое:

    Qrsh -V -l cegs -pe orte 12 /opt/openmpi/bin/mpirun -np 12 ~hcorrada/bioconductor/Rmpi/bstRMPISNOW

    Эта команда должна запустить 12 экземпляров R, один из которых будет первичным. Обратите внимание, стартовый процесс был в очереди cegs. Затем вы можете пользоваться узлами, установленными с помощью mpirun, набрав в R такое:

    Cl <- getMPIcluster()

    Затем можно просмотреть и воспользоваться нужными вам командами snow. Например,

    ClusterCall(cl, function() Sys.info())

    выдаст список узлов вашего кластера (если точнее, 11 запущенных рабочих узлов). находится список доступных команд.

    Когда вычисления на кластере завершены, нужно закрыть узлы следующей командой:

    StopCluster(cl)

    Предупреждение: удостоверьтесь, что вы не отменили процессы R нажатием комбинации клавиш Ctrl+C. Это может вызвать проблемы со snow.

    Пример: сравнение последовательной и параллельной обработки

    > f.long<-function(n) { + xx<-rnorm(n) + log(abs(xx))+xx^2 + } #Использование multicore ############ > system.time(mclapply(rep(5E6,11),f.long,mc.cores=11)) user system elapsed 26.271 3.514 5.516 #Использование snow через MPI ############ > system.time(sapply(rep(5E6,11),f.long)) user system elapsed 17.975 1.325 19.303 > system.time(parSapply(cl,rep(5E6,11),f.long)) user system elapsed 4.224 4.113 8.338

    Обратите внимание, параллельная обработка со snow дает улучшение более чем в 50% времени вычисления. Хотя можно предполагать, что улучшение должно составлять 10/11=91%, важно помнить, что процессоры не обязательно находятся на одном и том же узле, и взаимодействие между узлами может быть довольно медленным. Это взаимодействие может быть настолько медленным, что процедура на multicore без него может дать 40%-ое улучшение времени вычисления.

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

    Как-то попалась мне задача, в которой нужно было преобразовать 800 000 текстовых строк в несколько этапов. Большинство подобных задач я решаю с помощью R, потому и в этом случае начал пробовать использовать знакомый мне язык. Если первые несколько преобразований занимали секунды, то последующие начали занимать десятки минут.

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

    Неоценимый вклад в написание этого поста внес Антоша . Без него я бы потратил кучу времени на выбор операционной системы и установку программ в ней.

    Как создать виртуальную машину (инстанс) в Google Cloud Platform

    В первую очередь следует создать виртуальную машину в Google Cloud Platform. Довольно сложно выбрать из списка доступных машин , если вы не знаете необходимые для решения вашей задачи технические характеристики. Потому я начал с самого слабого варианта — f1-micro, который доступен бесплатно для региона US. Вы тоже можете начать с него.

    Когда вы определились с типом инстанса, и включите в нем биллинг . Чтобы создать инстанс, перейдите из вашего проекта в Google Developers Console и откройте Google Cloud Platform:

    На открывшейся странице задайте параметры машины, которую хотите получить. Я указал f1-micro в регионе us-central1-a с операционной системой Ubuntu 16.04 LTS. Также поставил две галочки Allow HTTP traffic и Allow HTTPS traffic для возможности взаимодействия с сервером по HTTP и HTTPS. Другие параметры я не трогал:

    Дополнительную информацию по запуску инстансов вы можете найти в справке .

    Как установить R и R Studio на инстанс в Google Cloud

    Чтобы начать установку нужных вам программ, подключитесь к созданной машине по SSH (сетевой протокол Secure Shell). Для этого нажмите соответствующую кнопку напротив названия вашего инстранса.

    Выполните команду:

    Sudo vim /etc/apt/sources.list

    Deb https://cran.rstudio.com/bin/linux/ubuntu xenial/

    Далее нажмите Esc, двоеточие (обратите внимание, что нужно именно двоеточие, а не точка с запятой) и выполните команду wq. В результате в файле /etc/apt/sources.list вы укажете, откуда нужно брать файлы для установки R. Мы будем устанавливать RStudio Server , а не обычный десктопный вариант.

    Sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E084DAB9 sudo apt update sudo apt-get install r-base sudo apt-get install gdebi-core wget https://download2.rstudio.org/rstudio-server-1.0.136-amd64.deb sudo gdebi rstudio-server-1.0.136-amd64.deb

    В процессе выполнения нужно будет несколько раз подтвердить, что вы готовы установить программное обеспечение. После выполнения всех этих команд необходимо указать порт, при обращении к которому вы будете получать доступ к R Studio. Для этого выполните команду:

    Sudo vim /etc/rstudio/rserver.conf

    В открывшийся файл вставьте строку:

    Www-port=80

    Нажмите Esc, двоеточие и выполните команду wq. С помощью этой строки вы укажете, что при обращении к 80 порту, к которому происходит обращении по умолчанию, должна запускаться R Studio. После этого выполните команду:

    Sudo passwd user_name

    Вместо user_name следует указать свое имя пользователя. Его можно найти здесь:

    Так вы зададите пароль для вашего пользователя в Ubuntu, который станет паролем при входе в R Studio.

    Sudo service rstudio-server restart

    Ура, у вас получилось установить R и R Studio в Google Cloud. Вернитесь в свой проект в Google Cloud Platform и перейдите по IP-адресу, который указан напротив названия вашего инстанса:

    Введите имя пользователя и пароль, которые вы задали на одном из предыдущих шагов. Нажмите кнопку входа — откроется привычный вам интерфейс R Studio:

    Как устанавливать пакеты R в облаке

    Для решения части задач придется устанавливать дополнительные пакеты, которых нет в базовой сборке R. Здесь возникают две проблемы. Во-первых, нехватка оперативной памяти у инстанса f1-micro. При установке R рекомендуется машина с не менее чем 1 GB оперативной памяти, а у нашего инстанса 0,6 GB.

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

    Проделав эту же процедуру после установки всех нужных пакетов, можете снова выбрать f1-micro, если его достаточно для ваших задач. Если сразу хотите попробовать машину помощнее, выбирайте доступные варианты из списка.

    Вторая проблема при установке пакетов — отсутствие в нашей машине необходимых для работы пакетов библиотек. Вы увидите сообщение об этом в консоли R Studio. Там будет указано название рекомендуемой библиотеки, которая решит проблему с установкой пакета.

    Скопируйте из R Studio название пакета, подключитесь к инстансу по SSH и введите следующую команду:

    Sudo apt install library_name

    Здесь library_name — название библиотеки, скопированное из R Studio.

    Что получилось в результате

    После установки R и R Studio я попробовал решить мою задачу на f1-micro. На выполнение всех преобразований понадобилось 2 часа. Это даже хуже, чем на моем компьютере:) Задача требовала большей мощности процессора, и я улучшил инстанс до n1-highcpu-2. После этого на выполнение всех преобразований ушло около 10 минут. Локальная машина все-таки сильно уступает серверу.

    Цены на использование машин в Google Cloud очень демократичные. Несколько часов работы с разными инстансами обошлись мне аж в 4 цента. Более того, для новых пользователей Google дает $300 на 12 месяцев. Вы сможете, например, без остановки использовать тот же n1-highcpu-2 без остановки 8 месяцев или месяц пользоваться машиной с 8 vCPU и 52 GB оперативной памяти. Удачной работы в облаке.

    Запуск R скриптов в режиме Embedded дает следующие возможности:

    • позволяет пользователям языка R запускать существующие скрипты R в стандартных приложениях R, а также приложениях, использующих SQL
    • запуск R скриптов осуществляется "рядом" с данными. Эти скрипты могут содержать как стандартные пакеты, так и расширенные из репозитория CRAN
    • работа в СУБД позволяет использовать управляемый пользователем или СУБД параллелизм

    Этот режим очень гибкий и также может быть дополнительно оптимизирован за счет использования прозрачного переписывания функций R в функции движка СУБД Oracle.

    Использованием генерации XML в Embed R-SQL API позволяет формировать графы на R и встраивать результаты работы в панели OBIEE и документы Publisher.

    Функции для запуска Embedded R из стандартной среды R

    Oracle разработал несколько функций в пакете ORE, которые позволяют взять готовый скрипт и передать его для исполнения на сторону СУБД.

    Интерфейс R для Embedded R позволяет не только запускать скрипты R ближе к базе данных, но также интерактивно тестировать их перед внедрением в интерфейс SQL.

    Интерфейс R для Embedded R состоит из следующего набора функций (каждая полезна в своей ситуации):

    ore.doEval() Запускает переданный скрипт R в базе и не позволяет передавать входные данные или параметры. Она просто возвращает ore.frame или сериализованный объект R
    ore.tableApply() Получает на вход таблицу (ore.frame), которая целиком подается на вход функции. Подобно doEval() она может возвращать ore.frame или сериализованный объект R
    ore.rowApply() Позволяет указать количество строк, с которыми будет работать функция (chunk size). Функция вызывается в параллели несколькими процессам, если разрешено запускать несколько R-движков в СУБД. Результатом является список результатов для каждого chunk.
    ore.groupApply() Разбивает поданные данные на части по значениям соответствующего столбца, а затем запуска переданный скрипт R для каждой секции в параллели. Результатом является список результатов для каждого уникального значения столбца.
    ore.indexApply() ????
    ore.scriptCreate() Создает именованный скрипт R в репозитории СУБД. Эти именованные сприпты могут быть использованы в других R скриптах, работающих в режиме R Embedded
    ore.scriptDrop() Удаляет именованный скрипт R

    Простые примеры с doEval

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

    id <- seq(10)
    frame1 <- data.frame(id = id, res = id / 10)

    Результатом работы будет

    ORE> frame1
    id res
    1 1 0.1
    2 2 0.2
    3 3 0.3
    4 4 0.4
    5 5 0.5
    6 6 0.6
    7 7 0.7
    8 8 0.8
    9 9 0.9
    10 10 1.0

    Теперь мы оборачиваем все это в функцию и вызываем ее в doEval:

    frame1 <- ore.doEval(
    function (num = 10, scale = 10)
    {
    id <- seq(num)
    data.frame(id = id, res = id / scale)
    }
    )

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

    В предыдущем примере мы использовали сгенерированные данные. Это не очень интересно. В этом примере мы посмотрим, как загрузить данные из Oracle. Это делается средствами пакета ORE. Затем мы применим линейную регрессию для прогнозирования. Если бы мы запускали скрипт на стороне среды R, то это было бы так:

    library(ORE)
    dat <- ore.pull(ONTIME_S)
    mod <- lm(ARRDELAY ~ DISTANCE + DEPDELAY, dat)

    Оборачиваем в функцию и передаем на вход в doEval:

    mod <- ore.doEval(
    function()
    {
    library(ORE)
    ore.connect (user="RUSER", sid="orcl", host="aryndin-ru", password="oracle",all=TRUE)
    dat <- ore.pull(ONTIME_S)
    lm(ARRDELAY ~ DISTANCE + DEPDELAY, dat)
    });
    mod_local<-ore.pull(mod)

    Использование ore.tableApply

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

    Возьмем пример с использованием GLM Regression Model. На обычном R это будет выглядеть вот так:

    ore.connect (user="RUSER", sid="orcl", host="aryndin-ru", password="oracle",all=TRUE)
    x <- ore.pull(ONTIME_S[,c("ARRDELAY","DISTANCE","DEPDELAY")])
    mod <- glm(ARRDELAY ~ DISTANCE + DEPDELAY, data=x, family=gaussian())

    Наши действия состоят в том, чтобы подключиться к базе (ore.connect) и взять столбцы "ARRDELAY","DISTANCE","DEPDELAY" из таблицы ONTIME_S. Затем мы просто вызывает алгоритм GLM Regression Model с функцией gaussian.

    В случае с Oracle R Enterprise мы некоторые значения (таблицу и функцию) передадим через параметры:

    modCoef <- ore.tableApply(
    ONTIME_S[,c("ARRDELAY","DISTANCE","DEPDELAY")],
    family=gaussian(),
    function(x, family) {
    mod <- glm(ARRDELAY ~ DISTANCE + DEPDELAY,
    data=x, family=family)
    });

    Давайте разберем, что происходит. Первым делом мы отбираем 3 столбца, которые будут поданы на вход алгоритму (ONTIME_S[,c("ARRDELAY","DISTANCE","DEPDELAY")]). Они будут переданы в функцию как параметр X. Мы также указываем функцию gaussian. Все остальное осталось тем же.

    Использование ore.rowApply

    Функция rowApply полезна, если построенную ранее модель нужно применить к набору данных (scoring). В этом случае нам необязательно вытаскивать весь объем данных в память, а можно просто выполнять построчную обработку.

    Ниже довольно простой пример для линейной регрессии. Сначала мы строим модель на прогнозирования столбца ARRDELAY на основе данных за 5-ый месяц.

    ontime <- ore.pull(ONTIME_S)
    mod <- lm(ARRDELAY ~ DISTANCE + DEPDELAY, data=ontime)

    Затем создаем новый новый data frame с дополнительным столбцом PRED_DELAY, который заполняется с помощью построчного (по 1000 строк за раз) применения ранее построенной модели:

    ONTIME_S2 <- ONTIME[,c("ARRDELAY","DEPDELAY","DISTANCE")]
    ONTIME_S2$PRED_DELAY <- 0
    res <- ore.rowApply(ONTIME,
    mod = mod,
    function(dat,mod) cbind(dat, predict(mod, dat)),
    FUN.VALUE = ONTIME_S2, rows=1000)

    Использование ore.groupApply

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

    Ниже пример использования groupApply для построения нескольких моделей. Каждая модель будет отвечать за своей аэропорт (INDEX=ONTIME_S$DEST):

    modList <- ore.groupApply(
    ONTIME_S,
    INDEX=ONTIME_S$DEST,
    function(dat) {
    library(biglm)
    biglm(ARRDELAY ~ DISTANCE + DEPDELAY, dat)
    });
    modList_local <- ore.pull(modList)
    summary(modList_local$BOS) ## return model for BOS

    Интересный пример использования ORE для отрисовки графики

    Вот такая команда позволяет нам запустить R-функцию для генерации PDF-документа с графиком на стороне сервер баз данных Oracle

    ore.doEval(function () {
    pdf(“c:/temp/my_file.pdf")
    set.seed(25)
    x <- rchisq(1000, df = 3)
    ## Compare data with a model distribution
    qqplot(x, qchisq(ppoints(x), df = 3));
    abline(0,1, col = 2, lty = 2)
    hist(x, freq = FALSE, ylim = c(0, 0.25))
    curve(dchisq(x, df = 3), col = 2, lty = 2,
    lwd = 2, add = TRUE)
    dev.off()
    TRUE})

    Будет сгенерирован вот такой PDF-документ

    Заключение

    Oracle R Enterprise позволяет запускать готовые R-скрипты на стороне сервера баз данных вообще их не меняя. Это очень полезно в следующих случаях:

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

    Единственно, что мне не очень понравилось в использовании функций ore*Apply — это плохая документированность, но, я думаю, это исправят.

    При работе с R скриптом может потребоваться обновлять его автоматически. Пакет “taskscheduleR” помогает настроить расписание для запуска R скрипта в Windows Task Schedule ежедневно, еженедельно, каждые N минут, после запуска Windows и так далее.

    1. Устанавливаем пакет “taskscheduleR” library(devtools) install.packages("devtools") install_github("jwijffels/taskscheduleR") library(taskscheduleR)

      Используем пакет «devtools», который позволяет скачивать и устанавливать пакеты напрямую с GitHub.

    2. Далее для настройки запуска скрипта можно воспользоваться либо интерактивной настройкой через форму, либо написав пару строк кода.

    Настройка расписания R скрипта в Task Scheduler через Addins:

    Настройка расписания R скрипта через функции пакета taskscheduleR:

    Функции пакета:

    • Получить список всех задач в Windows Task Sheduler
    • Удалить задачу из Windows Task Sheduler
    • Добавить задачу запуска R скрипта
      • Доступны следующие расписания: ‘ONCE’, ‘MONTHLY’, ‘WEEKLY’, ‘DAILY’, ‘HOURLY’, ‘MINUTE’, ‘ONLOGON’, ‘ONIDLE’
    ## Указываем название файла R скрипта для последующей работы с ним myscript <- system.file("extdata", "helloworld.R", package = "taskscheduleR") ## Запуск скрипта разово через 35 секунд taskscheduler_create(taskname = "myscript", rscript = myscript, schedule = "ONCE", starttime = format(Sys.time() + 35, "%H:%M")) ## Запуск скрипта ежедневно в 10:15, начиная с завтрашнего дня ## Важно: необходимо поменять формат даты, если он не совпадает с тем, что стоит на компьютере (пример: %m/%d/%Y) taskscheduler_create(taskname = "myscriptdaily", rscript = myscript, schedule = "DAILY", starttime = "10:15", startdate = format(Sys.Date()+1, "%d/%m/%Y")) ## Запуск скрипта каждую неделю в 10:15 по понедельникам taskscheduler_create(taskname = "myscript_mon", rscript = myscript, schedule = "WEEKLY", starttime = "10:15", days = "MON") ## Запуск каждые 5 минут, начиная с 10:15 taskscheduler_create(taskname = "myscript_5min", rscript = myscript, schedule = "MINUTE", starttime = "10:15", modifier = 5) ## Получить data.frame со всеми задачами tasks <- taskscheduler_ls() str(tasks) ## Удалить задачи taskscheduler_delete(taskname = "myscript") taskscheduler_delete(taskname = "myscriptdaily") taskscheduler_delete(taskname = "myscript_,mon") taskscheduler_delete(taskname = "myscript_5min") taskscheduler_delete(taskname = "myscript_withargs_a") taskscheduler_delete(taskname = "myscript_withargs_b")

    На что обращаем внимание:

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