рекомендации

среда, 8 апреля 2020 г.

Работа с временными рядами в R с помощью пакетов xts и zoo. Часть 3.Слияние и изменение временных рядов.

Перевод. Оригинал: Manipulating Time Series Data in R with xts & zoo

Часть 3. Слияние и изменение временных рядов.

Первая часть
Вторая часть

Объединение xts по столбцам со слиянием

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

merge() принимает три ключевых аргумента, которые мы рассмотрим здесь. Во-первых, это …, который позволяет передавать произвольное количество объектов для объединения. Второй аргумент - это join, который указывает, как присоединиться к ряду, принимая такие аргументы, как inner или left. Это похоже на соединение с реляционной базой данных, только здесь индекс - это то, к чему мы присоединяемся. Последний аргумент для этого упражнения - fill. Это ключевое слово указывает, что делать с новыми значениями в ряду, если в результате слияния возникли пропуски.

# Базовое использование аргументов
merge(a, b, join = "right", fill = 9999)
В этом упражнении вы изучите несколько различных типов слияния, чтобы понять, как использовать merge(). Объекты a и b были предварительно загружены в рабочее пространство.

Инструкции:
Объедините a и b, используя merge() (или cbind ()) с аргументом join, установленным в «inner»).
Выполните левое соединение a и b. Используйте merge() и установите для аргумента join правильное значение. Заполните все пропущенные значения нулями (используйте аргумент fill).


# Выполняем внутреннее слияние a и b
merge(a, b, join = "inner")

# Левое слияние a и b, заполняем пропущенные значения нулями
merge(a, b, join = "left", fill = 0)

Объединение объектов xts по столбцам удобно при подготовке данных для анализа временных рядов.

Объединение xts по строкам с помощью rbind

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

xts предоставляет собственный метод S3 для базовой функции rbind(). Функция xts rbind намного проще, чем merge(). Единственный аргумент, который имеет значение, это ..., который принимает произвольное количество объектов для присоединения. Отличие состоит в том, что rbind требует временных рядов, поскольку нам нужно иметь временные метки, чтобы R знал, куда вставлять новые данные.

В этом упражнении вы обновите свои временные данные тремя новыми наблюдениями. Одно будет до начала ряда, а два - после. Обратите внимание на вызов функции, имеет ли значение порядок?

В вашей рабочей области уже загружены объекты temps, temps_june30, temps_july17 и temps_july18.

Инструкции:
Объедините строку 30 июня (temps_june30) с temps и назовите это temps2.
Объедините строки 17-го и 18-го июля с temps2. Назовите это temps3.


# Объединяем строки temps_june30 с temps, присваиваем имя temps2
temps2 <- rbind(temps, temps_june30)

# Объединяем строки temps_july17 и temps_july18 с temps2, называем temps3
temps3 <- rbind(temps_july17, temps_july18, temps2)
Поскольку объекты xts упорядочены по временному индексу, порядок аргументов в команде xts rbind() не имеет значения.

Какие типы данных могут быть объединены с помощью merge?

Хотя xts очень гибок, когда речь идет о присоединении новых столбцов к существующим объектам, есть некоторые исключения. Что из перечисленного не может быть успешно объединено с объектом xts a?

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

Возможные ответы:
xts объекты идентичного типа (например, целое число + целое число).
data.frames с различными типами столбцов (верный).
вектор дат POSIXct.
векторы одного типа (например, числовые).
единственное значение NA.

Заполнение пропущенных значений, используя последнее или предыдущее наблюдение

Как вы уже видели, весьма часто вы обнаруживаете, что в ваших временных рядах есть пропущенные значения (то есть NA). Это может быть результатом пропуска данных или какой-либо математической операции или операции слияния, которую вы выполняете над своими данными.

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

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

Вы также можете использовать следующее наблюдение, перенесенное назад, установив fromLast = TRUE.


# Прошлое наблюдение переносится вперед
na.locf(x)                

# Следующее наблюдение переносится назад
na.locf(x, fromLast = TRUE) 

Инструкции:
Используя подмножество temps, заполните недостающие наблюдения NA последним известным наблюдением. Сохраните их в temps_last.
Используя другое подмножество temps, заполните недостающие наблюдения NA следующим наблюдением. Сохраните их в temps_next.


# Заполняем пропущенные значения в temps, используя прошлое наблюдение
temps_last <- na.locf(temps)  

# Заполняем пропущенные значения в temps, используя следующее наблюдение
temps_next <- na.locf(temps, fromLast=TRUE)

Интерполяция NA с использованием na.approx()

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

Это сценарии, где полезна интерполяция. zoo предоставляет мощный инструмент для этого. На основе простой линейной интерполяции между точками, реализованной с помощью na.approx(), точки данных аппроксимируются с использованием расстояния между значениями индекса. Другими словами, оценочное значение является линейным во времени.

В этом упражнении вы будете использовать уменьшенную xts-версию набора данных Box and Jenkin’s AirPassengers, который поставляется вместе с R. Мы удалили данные за несколько месяцев, чтобы проиллюстрировать различные методы заполнения.

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

Набор данных AirPassengers доступен в вашей рабочей области как AirPass.

Инструкции:
Заполните пропущенные месяцы в AirPass с помощью линейной интерполяции, используя na.approx().


# Интерполяция NA с использованием линейной аппроксимации
na.approx(AirPass)

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

Оператор Lag и разностные операции

Комбинация опережающих и запаздывающих временных рядов

Еще одна распространенная модификация временного ряда - лаг. Также известная как операция обратного смещения, она обычно показана в литературе с использованием нотации LkLk, указывающей преобразование во времени LkX=Xt???kLkX=Xt???k. Она позволяет вам видеть наблюдения как вчерашнее значение в контексте сегодняшнего дня.

И zoo, и xts реализуют это поведение и фактически расширяют его по сравнению с оригиналом ts в R. Есть два основных различия между реализациями xts и zoo, о которых вам необходимо знать. Одним из них является направление отставания для данного k. Во-вторых, как пропажа обрабатывается впоследствии.

По историческим причинам в R zoo использует соглашение для знака k, в котором отрицательные значения указывают на запаздывание, а положительные значения указывают на опережение. То есть в zoo lag(x, k = 1) будет сдвигать будущие значения на один шаг назад во времени. Это не согласуется с подавляющим большинством литературы по временным рядам, но согласуется с поведением в base R. xts реализует эту функциональность с точностью до наоборот, а именно для положительного k ряд сместит последнее значение за время на один период вперед; это интуитивно понятно, но сильно отличается от zoo.

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


# Ваш финальный объект
cbind(lead_x, x, lag_x)

Инструкции:
Создайте опережение x на один период с именем lead_x.
Создайте задержку x на один период, с именем lag_x.
Используя функцию merge(), объедините lead + x + lag в новый объект z.


# Создаем объект с опережением с названием lead_x
lead_x <- lag(x, k = -1)

# Создаем объект с запаздыванием с названием lag_x
lag_x <- lag(x, k = 1)

# Объединяем три объекта в новый с именем z
z = cbind(lead_x, x, lag_x)

Генерация опережений и запаздываний может помочь вам визуализировать тренды в данных временных рядов во времени.

Расчет разности рядов с помощью diff()

Еще одна распространенная операция для временных рядов, обычно для нестационарных, состоит в определении разности рядов. 

Простой способ увидеть простую разность (или «первого порядка») состоит в том, чтобы рассчитать ее как x (t) - x (t-k), где k - количество лагов для возврата назад. Разности более высокого порядка - это просто повторное применение разности к каждому предыдущему результату.

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


# Эти две команды выполняют одно и то же действие
diff(x, differences = 2)
diff(diff(x))

В этом упражнении вы будете снова использовать данные AirPass, хотя на этот раз вы будете использовать полную серию с 1948 по 1960 годы.

Инструкции:
Создайте разность первого порядка AirPass вручную, используя lag() и вычитание. Сохраните результат как diff_by_hand.
Чтобы убедиться, что ваш результат идентичен использованию diff(AirPass), объедините их и посмотрите первые несколько строк в консоли. Используйте для этого merge() и head().
Получите разницу первого порядка за 12 месяцев. Убедитесь, что в diff() указаны аргументы как запаздывания, так и разности.


# Рассчитываем первую разность AirPass и сохраняем в diff_by_hand
diff_by_hand <- AirPass - lag(AirPass, k=1)

# Используем merge первых частей diff_by_hand и diff(AirPass)
merge(head(diff_by_hand), head(diff(AirPass)))

# Рассчитываем разность первого порядка AirPass за 12 месяцев
diff(AirPass, lag = 12, differences = 1)

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

В чем заключается ключевое отличие в lag между xts и zoo

Как вы уже видели, генерация запаздываний и опережений является важным инструментом в вашем арсенале для обработки данных временных рядов в R. Однако, поскольку xts использует несколько иные процедуры для генерации запаздываний и опережений по сравнению с zoo, вам необходимо быть очень точным при вызове lag().

Комментариев нет:

Отправка комментария