R4marketing | канал Алексея Селезнёва | Язык R

Elmer: Универсальный инструмент для работы с LLM через R

Ранее я уже рассказывал о пакете Elmer, который позволяет взаимодействовать с большими языковыми моделями (LLM) прямо из R. Сегодня мы углубимся в детали его функционала и возможностей, чтобы вы могли максимально эффективно использовать этот инструмент.


1. Что такое Elmer?
Elmer — это пакет из экосистемы tidyverse, созданный для удобного использования LLM API. Его основные преимущества:

● Мульти-провайдерная поддержка, на данный момент реализована поддержка:
● Anthropic’s Claude: chat_claude().
● AWS Bedrock: chat_bedrock().
● Azure OpenAI: chat_azure().
● Databricks: chat_databricks().
● GitHub model marketplace: chat_github().
● Google Gemini: chat_gemini().
● Groq: chat_groq().
● Ollama: chat_ollama()`.
● OpenAI: `chat_openai()`.
● perplexity.ai: `chat_perplexity()`.
● Snowflake Cortex: `chat_cortex()`.

Кстати, создатели `elmer` утверждают, что для генерации кода по их мнению лучше всего себя проявляет Anthropic’s Claude, т.е. Claude.ai, и я по этому поводу тоже уже своими наблюдениями делился.

● Гибкость в настройках промптов и диалогов.
● Извлечение структурированных данных из текста.
● Поддержка асинхронных вызовов для повышения производительности.

Эти функции делают Elmer мощным инструментом для анализа данных, автоматизации задач и разработки приложений.


2. Установка
Установите elmer с помощью:

pak::pak("tidyverse/elmer")

3. Управление диалогами
Чат-объекты в elmer сохраняют историю, что упрощает многозадачные сценарии:

chat <- chat_openai(model = "gpt-4o-mini")
chat$chat("Кто создал R?")
#> "R был создан Россом Ихакой и Робертом Джентлменом."

4. Программные возможности
elmer поддерживает несколько способов взаимодействия с LLM:

4.1. Интерактивный режим: Используйте R-консоль для живого общения:

live_console(chat)

4.2. Программный режим: Создайте сценарий, возвращающий результаты для дальнейшей обработки:

my_function <- function() {
    chat <- chat_openai(model = "gpt-4o-mini")
    chat$chat("Что такое функциональное программирование?")
}

4.3. Асинхронные вызовы: Используйте асинхронный API для ускорения обработки больших объемов данных.

5. Извлечение структурированных данных
elmer позволяет преобразовывать текст в удобный формат для анализа:

● Анализ отзывов клиентов.
● Извлечение рецептов и их структурирование.
● Геокодирование адресов.

Пример:

chat$chat("Выдели ключевые слова из текста")

6. Работа с токенами
elmer помогает отслеживать использование токенов для оптимизации затрат:

chat$chat("Кто создал R?")
chat
token_usage()

Один запрос к модели GPT-4o mini может стоить от $0.15 за миллион токенов, что делает использование API доступным для экспериментов.

7. Рекомендации по промптам
Правильный дизайн промптов — ключ к качественным ответам. Например:

● Укажите системные инструкции для кастомизации:

chat <- chat_openai(system_prompt = "Отвечай всегда кратко и на русском языке.")

● Используйте промпты для автоматизации, например, создания документации на основе README вашего пакета.

8. Кейсы использования
Elmer отлично подходит для:

● Создания чат-ботов для поддержки пользователей.
● Прототипирования инструментов: автоматизация анализа данных и отчетности.
● Кастомизации работы LLM под специфические задачи.

————————————
elmer открывает новые горизонты для работы с LLM в R. Это не только инструмент для экспериментов, но и мощное средство для интеграции ИИ в ваши проекты. Узнайте больше из официальной документации.

Пока что elmer по прежнему находится в активной стадии разработки, текущая версия 0.0.0.9000, но будем следить за этим процессом, и в ближайшее время буду ещё делиться информацией об этом проекте.

#новости_и_релизы_по_R

Оптимизация функций в R: переосмысление аргументов с S7

Функции с множеством аргументов могут быть трудными для использования и сопровождения. Чтобы решить эту проблему, можно использовать подход с объектами опций (options objects), применяя возможности системы S7 (новая реализация ООП в R о которой мы недавно говорили). Рассмотрим пример, как можно переработать функцию readr::read_csv().


Проблема: слишком много параметров

Функция readr::read_csv() имеет более 20 аргументов, многие из которых редко используются, например, locale, skip, na. Перенос менее востребованных настроек в объект опций позволяет:

● Сократить количество аргументов в функции.
● Улучшить читаемость и поддерживаемость кода.
● Обеспечить строгую типизацию параметров.


Шаг 1: Создание свойств с помощью new_property()

Для начала определим свойства, которые будут использоваться в нашем объекте опций. Например, свойство для параметра `locale:

library(S7)

.locale <- new_property(
  class_list,
  default = readr::default_locale(),
  validator = function(value) {
    dnames <- value$date_names
    invalid <- !rlang::is_character(dnames$mon, n = 12) ||
      !rlang::is_character(dnames$mon_ab, n = 12) ||
      !rlang::is_character(dnames$day, n = 7) ||
      !rlang::is_character(dnames$day_ab, n = 7) ||
      !rlang::is_character(dnames$am_pm, n = 2) || !rlang::is_scalar_character(value$date_format) || !rlang::is_scalar_character(value$time_format) || !rlang::is_scalar_character(value$decimal_mark) || !rlang::is_scalar_character(value$grouping_mark) || !rlang::is_scalar_character(value$tz) || !rlang::is_scalar_character(value$encoding)

    if (invalid) {
      "expected `locale` object"
    }
  }
)

Этот код задает значения по умолчанию и проверяет, что все элементы locale имеют правильный тип.

Подобным образом мы можем создать объекты опций для большинства других аргументов:

● na
● quote
● comment
● trim_ws
● skip
● n_max
● guess_max
● name_repair
● num_threads
● progress
● show_col_types
● skip_empty_rows
● lazy


Шаг 2: Создание класса с помощью new_class()

Теперь создадим класс для объекта опций, который объединяет все свойства, включая locale, na, trim_ws и другие:

class_readr_opts <- new_class(
  "readr_opts",
  properties = list(
    locale = .locale,
    na = .na,
    quote = .quote,
    comment = .comment,
    trim_ws = .trim_ws,
    skip = .skip,
    n_max = .n_max,
    guess_max = .guess_max,
    name_repair = .name_repair,
    num_threads = .num_threads,
    progress = .progress,
    show_col_types = .show_col_types,
    skip_empty_rows = .skip_empty_rows,
    lazy = .lazy
  )
)

opts <- class_readr_opts()
opts

Такой подход позволяет гибко задавать опции с использованием строгой типизации.


Шаг 3: Переопределение функции read_csv()

После создания объекта опций можно переопределить функцию read_csv() для работы с новым подходом:

read_csv <- function(
  file,
  col_names = TRUE,
  col_types = NULL,
  col_select = NULL,
  id = NULL,
  options = class_readr_opts()
) {
    # function logic
}

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

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


Ссылки:
● В основе поста лежит статья "S7 & Options objects"

#заметки_по_R

Мобильные приложения с R: революция благодаря webR

Мир R и мобильных технологий стал на шаг ближе с выходом webR — WebAssembly-компиляции R. Эта технология позволяет запускать R-код прямо в JavaScript-средах, открывая новые возможности для создания мобильных приложений. В этом посте разбираем, как это работает и что это значит для разработчиков.


Что такое webR и в чем его уникальность?

webR — это специальная версия R, адаптированная для работы в WebAssembly. Если раньше R использовался преимущественно для серверных приложений (например, через Shiny), то теперь его можно внедрять прямо в браузеры и мобильные устройства.

Ключевые особенности webR:
● Нет необходимости в R-сервере.
● Полноценная работа с R-кодом в мобильной среде.
● Возможность использовать стандартные функции R для анализа данных и визуализации.
● Эта технология изменяет представление о том, где и как можно применять R, делая его доступным для разработчиков мобильных приложений.


Почему это важно?

До появления webR мобильные приложения, использующие R, в основном реализовывались через Shiny и shinyMobile. Однако такие решения имели ряд ограничений:
● Ограниченная функциональность: отсутствие доступа к API устройства, таких как камера, вибрация, или геолокация.
● Нет автономности: такие приложения требовали постоянного подключения к серверу.
● Сложности с установкой: их нельзя было загрузить из App Store или Google Play.

webR решает эти проблемы, позволяя создавать настоящие нативные мобильные приложения, которые:
● Устанавливаются через магазины приложений.
● Работают офлайн.
● Интегрируют функции смартфона.


Пример реализации: Игра на основе R

ThinkR представили рабочий прототип — мобильное приложение с интеграцией R-кода. Это игра, где пользователи угадывают, к какому пакету R принадлежит случайная функция.

Как работает приложение:
● Оно выбирает три случайных пакета из установленных.
● Генерирует функцию из одного из них.
● Пользователь угадывает, к какому пакету она относится.

Функционал включает:
● Локальное хранение данных о попытках пользователя в SQLite.
● Визуализацию прогресса на графиках.
● Поддержку вибрации, автономного режима и других мобильных API.

Этот проект демонстрирует не только возможности webR, но и задает направление для будущих приложений.


Что дальше?

Разработчики ThinkR работают над выпуском приложения в App Store и Google Play. Этот проект — шаг к тому, чтобы сделать R универсальным инструментом, доступным не только для серверных решений, но и для мобильной разработки.

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

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

#новости_и_релизы_по_R

S7 0.2.0: Новый стандарт ООП в R

S7 — это гибкий и мощный инструмент для объектно-ориентированного программирования в R, предлагающий строгость S4 и простоту S3. Новая версия 0.2.0 усиливает производительность, вводит улучшенную совместимость с S3 и добавляет гибкие валидаторы. Проектирование и реализация S7 были совместными усилиями рабочей группы из R Consortium , включая представителей R-Core, Bioconductor, tidyverse/Posit, ROpenSci и более широкого сообщества R. В будущем разработчики планируют интеграцию S7 в базовый R.

Установите пакет, чтобы попробовать новый подход к ООП:

install.packages("S7")

Основные возможности S7

1. Создание классов
S7 позволяет определять классы с четкими типами свойств. Для обеспечения корректности данных можно использовать валидаторы.

Пример:

Range <- new_class("Range",
  properties = list(
    start = class_double,
    end = class_double
  ),
  validator = function(self) {
    if (length(self@start) != 1) {
      "@start must be length 1"
    } else if (length(self@end) != 1) {
      "@end must be length 1"
    } else if (self@end < self@start) {
      "@end must be greater than or equal to @start"
    }
  }
)

# Создаем корректный объект
valid_range <- new_object(Range, start = 1, end = 10)
print(valid_range)

# Проверка с некорректными данными
tryCatch(
  new_object(Range, start = 10, end = 5),
  error = function(e) message("Ошибка: ", e$message)
)

2. Создание методов
Методы создаются через обобщенные функции (new_generic()). Это упрощает настройку поведения для различных классов.

Пример:

greeting <- new_generic("greeting", function(x) NULL)
method(greeting, Range) <- function(x) {
  paste("Диапазон начинается с", x@start, "и заканчивается", x@end)
}

greeting(valid_range) # Диапазон начинается с 1 и заканчивается 10

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

4. Наследование классов
Создание иерархий классов позволяет расширять возможности базового класса.

Пример:

Employee <- new_class("Employee", parent = Range, properties = list(
  name = class_character
))

worker <- Employee(start = 9, end = 18, name = "Jane")
print(worker)

Производительность и планы на будущее

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

Почему стоит использовать S7?

Простота: Создание классов и методов не сложнее, чем в S3.
Надежность: Строгая типизация предотвращает ошибки.
Универсальность: Подходит для создания библиотек, построения API и работы с данными.

Ссылки:
● S7 0.2.0 (eng)

Так же про ООП в R
● ООП в языке R (часть 1): S3 классы
● ООП в языке R (часть 2): R6 классы

#новости_и_релизы_по_R

R4marketing 6 лет

Ровно 6 лет назад, 1 ноября 2018 года, я анонсировал в Facebook запуск этого канала. Это было время, когда Telegram только набирал популярность как платформа для профессионального контента, и я решил создать пространство, где буду делиться знаниями и какими то заметками по языку R.

На данный момент в канале опубликовано 1256 постов, очень долгое время я держал темп в 1 пост каждый будний день, и не сбавлял его даже в периоды отпусков. Хотя сейчас темп публикаций уже не "пост каждый будний день", как было изначально, но я по-прежнему стараюсь делиться только действительно ценным контентом, который поможет вам в работе и профессиональном росте.

Спасибо каждому из вас за то, что остаётесь со мной все эти годы! Ваши комментарии, обратная связь и дискуссии делают этот канал живым и помогают развиваться всем нам.

Релиз patchwork 1.3.0

Вышла версия patchwork 1.3.0, которая привнесла интересные возможности для работы с таблицами в графических композициях. Теперь можно легко интегрировать таблицы gt с графиками, используя функции wrap_elements() и wrap_table(). Пример простого графика с таблицей:

library(patchwork)
library(ggplot2)
library(gt)

p1 <- ggplot(airquality) +
  geom_line(aes(x = Day, y = Temp, colour = month.name[Month])) +
  labs(colour = "Month")

aq <- airquality[sample(nrow(airquality), 10), ]
p1 + wrap_table(aq, space = "free_y")

Также доступны более продвинутые возможности для компоновки графиков и таблиц. Например, можно использовать сложный макет с элементами разного размера:

p1 <- ggplot(mtcars) +
  geom_point(aes(mpg, disp)) +
  ggtitle('Scatter plot')

p2 <- ggplot(mtcars) +
  geom_bar(aes(factor(cyl))) +
  ggtitle('Bar plot')

layout <- c(
  area(t = 1, l = 1, b = 2, r = 2),
  area(t = 1, l = 3, b = 2, r = 3)
)

p1 + p2 + plot_layout(design = layout)

Это позволяет гибко управлять макетом визуализации, комбинируя таблицы и графики разных типов.

Ссылки:
● Подробнее можно прочитать в оригинальной статье на Tidyverse Blog.
● Также ранее я уже рассказывал о пакете patchwork в посте "Как расположить несколько ggplot2 графиков на одном изображении".

#новости_и_релизы_по_R

Работа с динамическими именами столбцов в dplyr: sym(), syms() и оператор !!

Часто при работе с данными в R возникает необходимость обращаться к столбцам таблицы по их именам, которые могут передаваться как строки. Это может быть полезно, если имена столбцов не известны заранее или задаются динамически в функциях. В dplyr для таких задач существует механизм tidy evaluation, и одними из ключевых инструментов являются функции sym(), syms() и оператор !!.

Проблема:
Обычно в dplyr мы обращаемся к столбцам напрямую, как показано ниже:

library(dplyr)

data <- tibble(
  Area = c('IT', 'Finance', NA),
  Date = as.Date(c('2023-01-01', NA, '2023-03-15'))
)

# Фильтруем строки, где нет пропусков в столбцах 'Area' и 'Date'
filtered_data <- data %>%
  filter(!is.na(Area), !is.na(Date))

Но что, если имена столбцов будут передаваться в виде строк, например через аргументы функции? Простое использование строк в filter() не сработает.

Решение: sym() и оператор !!
Функция sym() преобразует строку в символ (символ — это объект, который может быть интерпретирован как имя переменной), а оператор !! используется для развертывания этого символа в выражении. Давайте рассмотрим, как это работает:

library(dplyr)

# Функция для фильтрации данных на основе имен столбцов, переданных как строки
filter_data <- function(data, col_name1, col_name2) {
  col1 <- sym(col_name1)
  col2 <- sym(col_name2)
  
  data %>%
    filter(!is.na(!!col1), !is.na(!!col2))
}

# Пример данных
data <- tibble(
  Area = c('IT', 'Finance', NA),
  Date = as.Date(c('2023-01-01', NA, '2023-03-15'))
)

# Фильтруем данные, используя имена столбцов как строки
filtered_data <- filter_data(data, 'Area', 'Date')
print(filtered_data)

В этой функции:
sym(col_name1) и sym(col_name2) преобразуют строки в символы, которые затем могут использоваться в dplyr::filter().
Оператор !! разворачивает символ в выражении, позволяя использовать его как имя переменной в функции filter().

Работа с несколькими столбцами: syms()
Если вам нужно работать сразу с несколькими столбцами, то для преобразования списка строк в символы можно использовать функцию syms().

library(dplyr)

# Функция для фильтрации нескольких столбцов
filter_multiple <- function(data, col_names) {
  cols <- syms(col_names)
  
  data %>%
    filter(across(all_of(col_names), ~ !is.na(.)))
}

# Пример данных
data <- tibble(
  Area = c('IT', 'Finance', NA),
  Date = as.Date(c('2023-01-01', NA, '2023-03-15')),
  Amount = c(1000, 2000, NA)
)

# Фильтруем строки, где нет пропусков в нескольких столбцах
filtered_data <- filter_multiple(data, c('Area', 'Date', 'Amount'))
print(filtered_data)

Здесь:

syms(col_names) преобразует вектор строк в список символов.
across() вместе с all_of() позволяет удобно применить фильтр ко всем указанным столбцам.

————————————
Использование функций sym(), syms() и оператора !! — это мощный инструмент для написания гибкого и динамического кода в R. Он особенно полезен при работе с большими данными и пакетами вроде dplyr, когда имена столбцов не известны заранее или приходят из пользовательского ввода.

О подобных примерах рассказано в виньетке "Программирование с dplyr".

#заметки_по_R

Динамическая вставка таблиц в RMarkdown

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

Изначально вам необходимо с помощью функции split() разбить основную таблицу, на подтаблицы, о том как это сделать я уже рассказывал.

Теперь для того, что бы каждую подтаблицу вывести в RMarkdown как отдельную таблицу необходимо пройтись по списку подтаблиц, например с помощью функции purrr:walk(), и вывести по очереди их на печать.

Ниже небольшой пример кода, как это можно сделать:

library(knitr)
library(kableExtra)
library(purrr)

# разбиваем большую таблицу на список подтаблиц
df_list <- split(df, df$type)

# печатаем по очереди каждую из подтаблиц
purrr::walk(names(df_list), ~{
  cat(
    knitr::kable(df_list[[.x]], caption = paste("Таблица для типа:", .x), format = "html") %>%
    kableExtra::kable_styling(full_width = FALSE) %>%
    as.character()
  )
  cat("\n\n")  # Добавляем пустые строки между таблицами
})

Этот код делает следующее:

1. Разбивает таблицу df на список подтаблиц;
2. Использует purrr::walk() для итерации по именам подтаблиц в нашем списке;
3. Создает HTML-таблицу для каждой подтаблицы с помощью kable();
4. Добавляет стили с kable_styling()
5. Выводит каждую таблицу в документ с помощью cat()
6. Добавляет пустые строки между таблицами для лучшей читаемости.

Надеюсь, этот подход будет полезен в вашей работе с RMarkdown. Если у вас возникнут вопросы или вы захотите поделиться своими методами работы с данными, пишите в комментариях!

#заметки_по_R

Округление в R

Вчера мы столкнулись с расхождением в расчёте LT на одних и тех же данных в Power BI и R. После некоторого ресёрча я понял, что разница была в округлении. Функция round() в R округлила число 6.5 до 6, а Power BI - до 7.

Впервые для себя я узнал, что функция round() использует не привычный нам математический способ округления, а так называемый банковский. Вот в чём их отличия:

Банковское округление:

● Числа с десятичной частью .5 округляются до ближайшего чётного целого числа.
● Например, 2.5 округляется до 2, а 3.5 округляется до 4.

Математическое округление:

● Числа с десятичной частью .5 всегда округляются вверх.
● Например, 2.5 округляется до 3, а 3.5 тоже округляется до 4.

То есть если вы через round() попробуете округлить числа 2.5, 4.5, 6.5, то получите соответственно 2, 4, 6, а не ожидаемые 3, 5, 7.

Как оказалось, в базовом R вообще нет функции для математического округления. Поэтому если вдруг вам понадобится где-то использовать математическое округление, которое мы с вами учили в школе, придётся писать собственную функцию. Ниже приведена функция, которая математическим способом округляет дробные числа до целого:

round_math <- function(x) {

  sign(x) * floor(abs(x) + 0.5)

}

Если вы хотите иметь возможность указать количество разрядов после запятой, то используйте эту функцию:

custom_round <- function(x, digits = 0) {
  posneg <- sign(x)  # Определяем знак числа
  z <- abs(x) * 10^digits
  z <- z + 0.5  # Добавляем 0.5 для округления вверх
  z <- floor(z)
  return(posneg * z / 10^digits)
}

#заметки_по_R

Новая глава в учебнике "Разработка Telegram ботов на языке R"

Не так давно я говорил о том, что работаю над новой главой учебника, и предыдущие 3 видео как раз были её дополнением.

В учебник добавлена 9 глава "Разворачиваем telegram бота в облачных сервисах", из которой вы узнаете:

● О том что такое Google Cloud Run и Heroku.
● Как запустить бота или настроить запуск своих скриптов по расписанию в упомянутых выше платформах.
● О преимуществах и недостатках каждой из платформ.

Содержание главы:
1. Google Cloud Run
1.1 Условные обозначения
1.2 Введение в Google Cloude Run
1.3 Как настроить запуск скрипта по расписанию с помощью Google Cloude Run Job
1.4 Разворачиваем Telegram бота в Google Cloud Run Service
2. Heroku
2.1 Разворачиваем telegram бота на Heroku
2.2 Как настроить запуск R скрипта по расписанию в Heroku
3. Какую из описанных облачных платформ выбрать
3.1 Преимущества Heroku
3.2 Преимущества Google Cloud Run
3.3 Итог
4. Заключение

#онлайн_книги_по_R

Новый видеоурок: Развертывание Telegram-бота на Heroku

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

В этом видео вы узнаете:

● Как подготовить ваш проект для развертывания на Heroku.
● Как использовать Heroku CLI для создания и управления приложениями.
● Как настроить переменные среды для вашего бота.
● Как отправить данные на Heroku, запустить бота и проверить его работу.

Тайм-коды:
00:00 – Вступление
00:30 – Что такое Heroku
00:52 – Какой софт понадобится
01:14 – Обзор рабочего процесса
02:25 – Файлы, необходимые для развертывания бота на Heroku
03:31 – Рассмотрение кода бота для Heroku
05:20 – Что такое Webhook
08:00 – Описание зависимостей и файл init.R
08:48 – Создание Profile
09:43 – Создание app.json
11:09 – Авторизация в Heroku CLI
12:33 – Создание приложения в Heroku
13:10 – Создание переменных среды в приложении
14:55 – Установка buildpack для развертывания
16:18 – Отправка данных в Heroku и запуск бота
17:44 – Тестирование бота в Telegram
18:15 – Заключение

Ссылки:
● Видео
● Файлы проекта
● Учебник по разработке telegram ботов

#видео_уроки_по_R

Новый урок на YouTube: Развёртывание Telegram-бота в Google Cloud Run!

Привет, друзья!

Не так давно я рассказывал о том, что работаю над новой главой книги по разработке telegram ботов на R. Так вот, мы на финишной прямой нашего пути по созданию Telegram-ботов, и я рад представить вам новый видеоурок, в котором мы освоим важный шаг — развертывание бота в облаке с помощью Google Cloud Run!

В этом видео вы узнаете:

● Что такое Google Cloud Run и как он поможет вашему боту
● Как настроить и развернуть бота в облаке
● Основы технологии Webhook и Docker
● Пошаговое руководство по созданию, сборке и запуску Docker образа

Тайм-коды:
00:00 Вступление
00:37 Какой софт нам потребуется
01:25 Что такое Google Cloud Run
02:45 Обзор рабочего процесса
04:30 Код бота
05:20 Технология Webhook
10:44 Обзор Dockerfile
14:33 Локальная сборка Docker образа
17:35 Настройка проекта в Google Cloud
19:45 Инициализация Google Cloud SDK
22:10 Тегирование и пушинг Docker образа
23:04 Первый запуск бота
24:14 Корректировка WEBHOOK_URL
25:33 Пересборка и пушинг Docker образа
27:03 Развёртывание в Google Cloud Run
27:14 Проверка бота
28:10 Заключение

Ссылки:
● Видео урок

#видео_уроки_по_R

Как настроить запуск R скриптов по расписанию в Google Cloud Run

Продолжаем изучать тему удалённой автоматизации запуска ваших скриптов. В этом видео мы погружаемся в мир Google Cloud Run и разбираемся с тем, как автоматизировать запуск R скриптов по расписанию. Мы подробно разберём каждый шаг — от настройки облачной платформы до создания Docker образа и его публикации. Итог — условно бесплатная автоматизированная система для выполнения скриптов без постоянного вмешательства.

Что вы узнаете из видео:
● Какой софт понадобится для настройки и запуска скриптов.
● Что такое Google Cloud Run и как он поможет автоматизировать задачи.
● Как настроить проект в Google Cloud для работы с R скриптами.
● Как создать Docker образ и развернуть его в облаке.
● Как настроить регулярный запуск скрипта с помощью триггеров.

Тайм-коды:
00:00 Введение
00:32 Какой софт нам понадобится
01:01 Что такое Google Cloud Run
02:25 Обзор рабочего процесса
03:26 Создание и настройка проекта в Google Cloud
05:36 Обзор R скрипта, который мы будет запускать по расписанию
07:07 Создание Dockerfile
09:54 Локальная сборка Docker образа и запуск контейнера
11:51 Инициализация проекта Google Cloud с Google Cloud SDK Shell
13:43 Отправка Docker образа в Google Container Registry
14:33 Создание Job в Google Cloud Run
16:07 Создание триггера для запуска скрипта по расписанию
18:31 Заключение

Полезные ссылки, которые я упоминаю в видео:
● Как создать Telegram бота и получить токен
● Как упаковать Telegram бота в Docker
● Курс по разработке Telegram ботов на R

Не забывайте подписываться на YouTube канал!

#видео_уроки_по_R

Обновления в книге по созданию Telegram-ботов!

Привет, друзья! Рад сообщить вам о свежих обновлениях в моей книге. Вот что нового:

● Новая обложка: Книга обзавелась новым дизайном.

● Глава 1: В раздел [Создаём бота, и отправляем с его помощью сообщения в Telegram] добавлен новый раздел [Настраиваем запуск расписания отправки сообщения с помощью GitHub Actions]. Теперь вы узнаете, как автоматизировать отправку сообщений с помощью мощных инструментов CI/CD.

● Глава 2: В раздел [Добавляем боту поддержку команд и фильтры сообщений, класс Updater] добавлен новый раздел [Обработка голосовых сообщений. Переводим голосовое сообщение в текст]. Мы рассмотрим, как преобразовать голосовые сообщения в текст и приведём пример бота, выполняющего эту задачу.

● Глава 2: Также добавлен новый раздел [Бот для сбора статистики из Telegram чатов]. Вы научитесь создавать бота, который собирает и анализирует статистику из чатов, что может быть полезно для анализа активности и взаимодействия.

● Предисловие и заключение: К книге добавлены новые предисловие и заключение, чтобы дать вам лучшее представление о содержании и итогах работы.

● Обновления в каждой главе: Предисловия и заключения в каждой главе переписаны для лучшего понимания материала и плавного перехода между темами.

В данный момент я работаю над новой главой книги, и буду рад поделиться с вами новыми подробностями, как только они будут готовы.

#онлайн_книги_по_R

Преобразовываем речь в текст с помощью R и Google Speech-to-Text API

Привет, друзья! Сегодня я расскажу вам, как создать функцию на R, которая преобразует речь из MP3, Wav или OGG (голосовые сообщения в телеге) файла в текст. Это особенно полезно для расшифровки аудиозаписей, подкастов или голосовых заметок.

Google Speech-to-Text API является условно бесплатным, т.е. бесплатно вы можете в месяц с помощью этого сервиса преобразовать час аудио в текст.

Давайте пройдемся по всему процессу шаг за шагом.

1️⃣ Настройка проекта Google Cloud
Прежде чем начать кодить, нам нужно настроить проект в Google Cloud:

1. Зайдите на console.cloud.google.com и создайте новый проект.
2. Включите API Speech-to-Text в разделе "APIs & Services".
3. Создайте учетные данные (Service Account Key) для доступа к API:
3.1. Перейдите в "APIs & Services" > "Credentials"
3.2. Нажмите "Create Credentials" > "Service Account Key"
3.3. Выберите роль "Project" > "Owner"
3.4. Скачайте JSON файл с ключом

2️⃣ Установка необходимых пакетов R

install.packages(c("tuneR", "seewave", "googledrive", "googleAuthR", "googleLanguageR", "av"))

3️⃣ Код функции
Вот функция, которая делает всю магию:

library(tuneR)
library(seewave)
library(googledrive)
library(googleAuthR)
library(googleLanguageR)
library(av)

speech_to_text_from_audio <- function(audio_file_path) {
  # Определяем расширение файла
  file_ext <- tolower(tools::file_ext(audio_file_path))
  
  # Создаем временный WAV файл
  temp_wav_file <- tempfile(fileext = ".wav")
  
  # Обработка в зависимости от типа файла
  if (file_ext == "mp3") {
    audio <- readMP3(audio_file_path)
  } else if (file_ext == "wav") {
    audio <- readWave(audio_file_path)
  } else if (file_ext == "ogg") {
    # Конвертируем OGG в WAV
    av_audio_convert(audio_file_path, temp_wav_file)
    audio <- readWave(temp_wav_file)
  } else {
    stop("Неподдерживаемый формат файла. Поддерживаются только MP3, WAV и OGG.")
  }
  
  # Если аудио стерео, конвертируем в моно
  if (audio@stereo) {
    audio <- mono(audio, "both")
  }
  
  # Изменяем частоту дискретизации на 16000 Гц, только если текущая частота отличается
  if (audio@samp.rate != 16000) {
    audio_resampled <- resamp(audio, g = 16000, output = "Wave")
  } else {
    audio_resampled <- audio
  }
  
  # Записываем обработанное аудио во временный WAV файл
  writeWave(audio_resampled, temp_wav_file)
  
  # Выполняем распознавание речи
  result <- tryCatch({
    gl_speech(temp_wav_file, 
              languageCode = "ru-RU",
              sampleRateHertz = 16000)$transcript
  }, error = function(e) {
    return(paste("Ошибка при распознавании речи:", e$message))
  })
  
  # Удаляем временный WAV файл
  file.remove(temp_wav_file)
  
  # Возвращаем результат
  return(result$transcript)
}

4️⃣ Использование функции

# Пример использования:
# Не забудьте аутентифицироваться перед использованием функции
gl_auth("path/to/your/google_cloud_credentials.json")

# Теперь вы можете использовать функцию так:
mp3_file <- "path/to/your/voice.mp3"
ogg_file <- "path/to/your/voice.ogg"

transcript_mp3 <- speech_to_text_from_audio(mp3_file)
transcript_ogg <- speech_to_text_from_audio(ogg_file)

В результате получим следующее:

> transcript_mp3
[1] "небольшая текстовая начитка для преобразования речи в текст с помощью языка R"

Ниже два небольших файла, один в mp3, второй в ogg формате, для тестов.

#заметки_по_R

Новое видео на YouTube: Как настроить запуск R скриптов по расписанию с помощью GitHub Action

В новом видеоуроке я погружаюсь в мир непрерывной интеграции и развёртывания (CI/CD), а также расскажу, как автоматизировать запуск скриптов с помощью GitHub Actions. Я покажу способ, который позволяет настроить расписание запуска ваших скриптов без необходимости аренды серверов.

Что вы узнаете из видео:

● Основы CI/CD и их роль в автоматизации.
● Настройка рабочего процесса с GitHub Actions.
● Конфигурация YAML файлов для управления рабочими процессами.
● Настройка автоматического запуска скриптов по расписанию.

Тайм-коды:
00:00 Вступление
00:49 CI/CD: Непрерывная интеграция и непрерывное развёртывание
01:45 Что такое GitHub Actions
02:30 Обзор рабочего процесса
03:05 Создание репозитория на GitHub
05:11 Добавляем в репозиторий R-скрипт
08:03 Настройка GitHub Actions
09:47 Конфигурация YAML файла, описывающего рабочий процесс
10:10 Настройка расписания запуска в YAML файле
12:17 Разбираем все команды в YAML файле рабочего процесса
19:01 Создание переменных среды в GitHub репозитории
20:26 Отправляем проект на GitHub
20:52 Запускаем GitHub Action
22:46 Заключение

Если видео окажется полезным и наберёт много откликов то в будущем запишу такое же видео про GitLab.

Ссылки:
● Видео урок
● Статья с конспектом к уроку

#видео_уроки_по_R