Вот пример кода на Python с использованием библиотеки Bokeh для визуализации данных из базы данных SQLite. Bokeh позволяет создавать интерактивные визуализации, которые могут быть отображены как в Jupyter Notebook, так и в веб-приложениях.

### 1. Установите необходимые библиотеки:

pip install sqlite3 bokeh pandas

### 2. Пример кода:

import sqlite3
import pandas as pd
from bokeh.plotting import figure, output_file, show
from bokeh.models import ColumnDataSource
from bokeh.io import output_notebook

# Подключение к базе данных SQLite
conn = sqlite3.connect('example.db')

# Создание таблицы и вставка данных (если еще не создана)
conn.execute('''
CREATE TABLE IF NOT EXISTS sales (
    id INTEGER PRIMARY KEY,
    product TEXT,
    quantity INTEGER,
    price REAL
)
''')
conn.execute('''
INSERT INTO sales (product, quantity, price) VALUES
('Product A', 10, 25.50),
('Product B', 20, 15.75),
('Product C', 5, 100.00)
''')
conn.commit()

# Загрузка данных из базы данных в DataFrame
df = pd.read_sql_query("SELECT * FROM sales", conn)

# Закрытие соединения
conn.close()

# Преобразование данных в ColumnDataSource для использования в Bokeh
source = ColumnDataSource(df)

# Настройка вывода для Jupyter Notebook
output_notebook()

# Создание фигуры
p = figure(x_range=df['product'], plot_height=400, title="Количество проданных товаров",
           toolbar_location=None, tools="")

# Добавление столбцов на график
p.vbar(x='product', top='quantity', width=0.5, source=source, legend_field="product")

# Настройки визуализации
p.xgrid.grid_line_color = None
p.y_range.start = 0
p.legend.orientation = "horizontal"
p.legend.location = "top_center"

# Отображение графика в Jupyter Notebook
show(p)

# Если нужно вывести график в HTML-файл
# output_file("sales_bokeh.html")
# show(p)

### Особенности Bokeh:
1. Интерактивность: Bokeh позволяет создавать интерактивные графики и диаграммы, которые поддерживают навигацию, зум, панорамирование и выбор данных прямо в браузере.
2. Поддержка сложных визуализаций: Вы можете легко создавать как простые, так и сложные визуализации, такие как карты, тепловые карты, временные ряды и многое другое.
3. Веб-интеграция: Графики, созданные с помощью Bokeh, могут быть легко интегрированы в веб-приложения или сохранены как автономные HTML-файлы.
4. Простота использования с Pandas: Bokeh хорошо интегрируется с Pandas, что позволяет легко загружать и отображать данные из баз данных.
5. ColumnDataSource: Bokeh использует специальный объект ColumnDataSource для передачи данных в график. Это упрощает работу с различными типами данных.

### Объяснение:
- SQLite: Используется для хранения данных о продажах.
- Pandas: Загружает данные из базы данных в DataFrame для удобного доступа.
- Bokeh: Используется для создания интерактивной столбчатой диаграммы. Столбцы соответствуют количеству проданных товаров по каждому продукту.
- ColumnDataSource: Преобразует данные из DataFrame в формат, совместимый с Bokeh.
- Интерактивные элементы: Можно выбирать, настраивать и изменять отображение элементов визуализации (например, легенды или зума).

Этот код создаст интерактивную диаграмму, которую можно отображать в Jupyter Notebook или сохранить как HTML-файл для дальнейшего использования.

Подпишись 👉🏻 @KodduuPython 🤖

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

import asyncio
from dataclasses import dataclass
from contextlib import asynccontextmanager
from typing import Callable, Awaitable
import time

# Декоратор для измерения времени выполнения асинхронной функции
def async_timeit(func: Callable[..., Awaitable]) -> Callable[..., Awaitable]:
    async def wrapper(*args, **kwargs):
        start = time.time()
        result = await func(*args, **kwargs)
        end = time.time()
        print(f"Время выполнения {func.__name__}: {end - start:.4f} секунд")
        return result
    return wrapper

# Асинхронный контекстный менеджер для управления ресурсами
@asynccontextmanager
async def managed_resource(name: str):
    print(f"Открытие ресурса: {name}")
    await asyncio.sleep(0.1)  # Имитация времени открытия ресурса
    try:
        yield
    finally:
        await asyncio.sleep(0.1)  # Имитация времени закрытия ресурса
        print(f"Закрытие ресурса: {name}")

# Датакласс для хранения данных пользователя
@dataclass
class User:
    id: int
    name: str
    email: str

# Асинхронная функция для имитации запроса данных
@async_timeit
async def fetch_user_data(user_id: int) -> User:
    await asyncio.sleep(1)  # Имитация задержки сети
    return User(id=user_id, name=f"User{user_id}", email=f"user{user_id}@example.com")

async def main():
    async with managed_resource("database"):
        user = await fetch_user_data(1)
        print(f"Получены данные пользователя: {user}")

# Запуск асинхронного события
asyncio.run(main())

Объяснение кода:

1. Декоратор `async_timeit`: Этот декоратор измеряет время выполнения асинхронной функции. Он оборачивает функцию и выводит время, затраченное на её выполнение.

2. Асинхронный контекстный менеджер `managed_resource`: Используя @asynccontextmanager, мы создаём контекстный менеджер, который может работать с async with. Он управляет ресурсом (например, подключением к базе данных), обеспечивая корректное открытие и закрытие.

3. Датакласс `User`: С помощью @dataclass мы легко создаём класс для хранения данных пользователя без необходимости писать стандартные методы вручную.

4. Асинхронная функция `fetch_user_data`: Имитация асинхронного запроса данных пользователя. Использует asyncio.sleep для симуляции задержки сети.

5. Функция `main`: Основная асинхронная функция, которая использует контекстный менеджер и вызывает функцию для получения данных пользователя.

6. Запуск программы: asyncio.run(main()) используется для запуска асинхронной функции main.

Пример вывода при выполнении программы:

Открытие ресурса: database
Время выполнения fetch_user_data: 1.0012 секунд
Получены данные пользователя: User(id=1, name='User1', email='user1@example.com')
Закрытие ресурса: database

Ключевые моменты:

- Асинхронное программирование: Использование async и await позволяет выполнять операции без блокировки основного потока, что повышает эффективность при работе с вводом/выводом.

- Декораторы: Позволяют добавлять дополнительную функциональность к функциям (например, измерение времени выполнения) без изменения их исходного кода.

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

- Датаклассы: Предоставляют удобный способ определения классов данных с автоматической генерацией методов __init__, __repr__ и других.

- Типизация: Использование аннотаций типов из модуля typing улучшает читаемость кода и позволяет использовать статические анализаторы для обнаружения ошибок.

Этот пример демонстрирует, как современные возможности Python могут быть объединены для написания эффективного и поддерживаемого кода.

Подпишись 👉🏻 @KodduuPython 🤖

Вот пример кода на Python, демонстрирующий использование библиотеки Sktime для анализа временных рядов. В этом примере мы будем использовать модель AutoARIMA для прогнозирования.

import pandas as pd
from sktime.datasets import load_airline
from sktime.forecasting.arima import AutoARIMA
from sktime.forecasting.model_selection import temporal_train_test_split
from sktime.performance_metrics.forecasting import mean_absolute_percentage_error
import matplotlib.pyplot as plt

# Загрузка встроенного датасета "Airline Passengers"
y = load_airline()

# Разделение данных на обучающую и тестовую выборки
y_train, y_test = temporal_train_test_split(y, test_size=36)

# Инициализация модели AutoARIMA
forecaster = AutoARIMA(sp=12, suppress_warnings=True)

# Обучение модели
forecaster.fit(y_train)

# Прогнозирование
fh = list(range(1, len(y_test) + 1))
y_pred = forecaster.predict(fh)

# Вычисление ошибки
mape = mean_absolute_percentage_error(y_test, y_pred)
print(f"MAPE: {mape:.2f}")

# Визуализация результатов
plt.figure(figsize=(12, 6))
plt.plot(y_train.index, y_train, label='Обучающая выборка')
plt.plot(y_test.index, y_test, label='Тестовая выборка')
plt.plot(y_test.index, y_pred, label='Прогноз')
plt.legend()
plt.show()

Объяснение кода:

- Импорт библиотек: Импортируем необходимые библиотеки, включая sktime, pandas и matplotlib.
- Загрузка данных: Используем встроенный датасет load_airline, который содержит ежемесячное количество авиапассажиров.
- Разделение данных: Разбиваем данные на обучающую и тестовую выборки с помощью функции temporal_train_test_split.
- Инициализация модели: Создаем экземпляр модели AutoARIMA, устанавливая сезонный период sp=12 (так как данные ежемесячные).
- Обучение модели: Обучаем модель на обучающей выборке.
- Прогнозирование: Прогнозируем значения для горизонта прогнозирования, равного длине тестовой выборки.
- Оценка модели: Вычисляем средний абсолютный процент ошибки (MAPE) между прогнозом и фактическими значениями.
- Визуализация: Строим график, отображающий обучающую выборку, тестовую выборку и прогнозные значения.

Дополнительная информация:

Библиотека Sktime предоставляет унифицированный интерфейс для обучения и прогнозирования моделей временных рядов, облегчая сравнение различных алгоритмов и упрощая процесс их применения.

Подпишись 👉🏻 @KodduuPython 🤖

Ниже пример использования библиотеки Darts для прогнозирования временных рядов на Python. В этом примере мы будем использовать модель LightGBM для прогнозирования пассажиропотока авиалиний.

import pandas as pd
import matplotlib.pyplot as plt
from darts import TimeSeries
from darts.datasets import AirPassengersDataset
from darts.models import LightGBMModel
from darts.metrics import mape

# Загрузка датасета "Air Passengers"
series = AirPassengersDataset().load()

# Разделение данных на обучающую и тестовую выборки (80% и 20%)
train, val = series.split_before(0.8)

# Инициализация модели LightGBM
model = LightGBMModel(lags=12)

# Обучение модели на обучающей выборке
model.fit(train)

# Прогнозирование на горизонте, равном длине тестовой выборки
forecast = model.predict(len(val))

# Вычисление ошибки MAPE
error = mape(val, forecast)
print(f"MAPE: {error:.2f}%")

# Визуализация результатов
plt.figure(figsize=(12, 6))
series.plot(label='Фактические данные')
forecast.plot(label='Прогноз')
plt.legend()
plt.title('Прогнозирование пассажиропотока авиалиний с помощью Darts')
plt.show()

Объяснение кода:

- Импорт библиотек:
- pandas и matplotlib для работы с данными и их визуализации.
- Модули из darts, включая TimeSeries, встроенные датасеты, модели и метрики.

- Загрузка данных:
- Используем встроенный датасет AirPassengersDataset, содержащий ежемесячные данные о количестве авиапассажиров с 1949 по 1960 год.

- Создание временного ряда:
- Данные преобразуются в объект TimeSeries, который является основным классом для работы с временными рядами в Darts.

- Разделение данных:
- Разбиваем данные на обучающую и тестовую выборки в соотношении 80/20 с помощью метода split_before.

- Инициализация модели:
- Используем модель LightGBMModel, указав lags=12, что означает использование данных за предыдущие 12 месяцев для прогнозирования.

- Обучение модели:
- Модель обучается на обучающей выборке с помощью метода fit.

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

- Оценка модели:
- Вычисляем метрику MAPE (Mean Absolute Percentage Error) между прогнозными и фактическими значениями тестовой выборки.

- Визуализация:
- Строим график фактических и прогнозных данных для наглядной оценки качества модели.

Дополнительный контекст по библиотеке Darts:

Darts — это мощная библиотека Python с открытым исходным кодом для анализа и прогнозирования временных рядов. Она предоставляет единый и простой в использовании интерфейс для различных моделей, включая:

- Классические статистические модели: ARIMA, Exponential Smoothing и др.
- Модели машинного обучения: LightGBM, Random Forest и др.
- Модели глубокого обучения: RNN, LSTM, TCN и др.

Основные преимущества Darts:

- Унифицированный интерфейс: Позволяет легко переключаться между моделями и сравнивать их.
- Поддержка многомерных временных рядов: Работает с одномерными и многомерными данными.
- Интеграция с другими библиотеками: Совместима с pandas, numpy и другими популярными библиотеками.
- Продвинутые функции:
- Обработка пропущенных значений.
- Масштабирование и нормализация данных.
- Возможность добавления экзогенных переменных.
- Поддержка вероятностного прогнозирования и ансамблирования моделей.

Когда использовать Darts:

- Разработка и прототипирование моделей: Быстрое тестирование различных моделей на ваших данных.
- Комплексные проекты: Когда требуется использование сложных моделей глубокого обучения или обработка многомерных временных рядов.
- Научные исследования: Для экспериментов с новыми архитектурами моделей и методами прогнозирования.

Установка библиотеки Darts:

Перед началом работы необходимо установить библиотеку Darts:

pip install darts

Важно: Некоторые модели могут требовать дополнительных зависимостей. Например, для моделей глубокого обучения может потребоваться установка torch или tensorflow. Установите их при необходимости:

pip install 'u8darts[torch]'

Пример расширения: Прогнозирование с экзогенными переменными

Вы можете улучшить модель, добавив экзогенные переменные (дополнительные признаки):

# Допустим, у нас есть экзогенные данные
exog_series = ...

# Разделение экзогенных данных
exog_train, exog_val = exog_series.split_before(0.8)

# Обновляем модель для использования экзогенных переменных
model = LightGBMModel(lags=12, lags_exog=[0])

# Обучение модели с экзогенными данными
model.fit(train, future_covariates=exog_train)

# Прогнозирование с использованием экзогенных данных
forecast = model.predict(len(val), future_covariates=exog_val)

Заключение:

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

Подпишись 👉🏻 @KodduuPython 🤖

Очень очень рады сообщить - мы обновили курс Python: самый быстрый курс 👍

👉 Добавили описания в уроки, где их не хватало
👉 Добавили 44 новых теста и 30 новых интерактивных задач
👉 И сохранили баланс курса, его все еще можно пройти за выходные

🔥 Ваша скидка 1500 руб до 8 ноября 🔥

Подпишись 👉🏻 @KodduuPython 🤖

Ниже приведён пример использования библиотеки AutoTS для прогнозирования временных рядов на Python, а также объяснение её преимуществ.

import pandas as pd
import matplotlib.pyplot as plt
from autots import AutoTS

# Загрузка данных
# Используем встроенный датасет о пассажиропотоке авиалиний
data_url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv'
df = pd.read_csv(data_url, parse_dates=['Month'])
df.rename(columns={'Month': 'date', 'Passengers': 'value'}, inplace=True)

# Просмотр первых нескольких строк данных
print(df.head())

# Инициализация модели AutoTS
model = AutoTS(
    forecast_length=12,
    frequency='MS',  # MS - начало месяца
    ensemble='simple',
    model_list='fast',  # варианты: 'superfast', 'default', 'fast_parallel'
    transformer_list='fast',  # методы предварительной обработки данных
    max_generations=5,
    num_validations=2,
)

# Обучение модели
model = model.fit(
    df,
    date_col='date',
    value_col='value',
    id_col=None,
)

# Получение прогноза
prediction = model.predict()
forecast = prediction.forecast

# Вывод прогноза
print(forecast)

# Объединение фактических данных и прогноза для визуализации
forecast = forecast.reset_index()
forecast.columns = ['date', 'value']
full_df = pd.concat([df, forecast], ignore_index=True)

# Визуализация результатов
plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['value'], label='Фактические данные')
plt.plot(forecast['date'], forecast['value'], label='Прогноз')
plt.legend()
plt.title('Прогнозирование пассажиропотока авиалиний с помощью AutoTS')
plt.xlabel('Дата')
plt.ylabel('Количество пассажиров')
plt.show()

Объяснение кода:

- Импорт библиотек:
- pandas для работы с табличными данными.
- matplotlib для визуализации результатов.
- autots для автоматизированного прогнозирования временных рядов.

- Загрузка данных:
- Используем датасет авиапассажиров, доступный по URL.
- Парсим колонку Month как даты и переименовываем колонки для соответствия формату, ожидаемому AutoTS.

- Инициализация модели AutoTS:
- forecast_length=12 — горизонт прогнозирования (12 месяцев).
- frequency='MS' — частота временного ряда (начало месяца).
- ensemble='simple' — использование простого ансамбля моделей для улучшения прогноза.
- model_list='fast' — быстрый набор моделей для тестирования (можно выбрать более полный набор).
- transformer_list='fast' — быстрый набор методов предварительной обработки.
- max_generations=5 — количество поколений генетического алгоритма для поиска оптимальной модели.
- num_validations=2 — количество разбиений для кросс-валидации.

- Обучение модели:
- Метод fit обучает модель на предоставленных данных, указывая, какие колонки содержат дату и значения.

- Получение прогноза:
- Метод predict получает прогноз на указанный горизонт.
- Результат содержит прогнозируемые значения в атрибуте forecast.

- Визуализация:
- Объединяем фактические данные и прогноз для наглядности.
- Строим график с фактическими данными и прогнозом.

Преимущества AutoTS:

- Автоматизация моделирования:
- AutoTS автоматизирует процесс выбора модели, предварительной обработки данных и настройки гиперпараметров, что экономит время и усилия аналитика.

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

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

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

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

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

- Диагностика и оценка:
- Предоставляет подробные метрики оценки моделей, такие как MAE, RMSE, MAPE и другие, а также визуализации для анализа результатов.

Когда использовать AutoTS:

- Быстрое получение прогноза:
- Если требуется оперативно получить прогноз без глубокого анализа и настройки моделей вручную.

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

- Исследование данных:
- Для предварительного анализа и выявления потенциально эффективных моделей для дальнейшей доработки.

- Сравнение моделей:
- Для сравнения производительности различных моделей и выбора наилучшей для конкретного набора данных.

Установка AutoTS:

Чтобы установить библиотеку AutoTS, выполните следующую команду:

pip install autots

Заключение:

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

Подпишись 👉🏻 @KodduuPython 🤖

Ниже приведён пример использования библиотеки Prophet для прогнозирования временных рядов на Python.

import pandas as pd
import matplotlib.pyplot as plt
from prophet import Prophet

# Загрузка данных
data_url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv'
df = pd.read_csv(data_url)
df.columns = ['ds', 'y']  # Переименовываем колонки для Prophet

# Обучение модели Prophet
model = Prophet()
model.fit(df)

# Прогнозирование на следующие 12 месяцев
future = model.make_future_dataframe(periods=12, freq='MS')
forecast = model.predict(future)

# Визуализация прогноза
model.plot(forecast)
plt.show()

Краткое объяснение:

- Загрузка данных: Скачиваем датасет авиапассажиров и переименовываем колонки в формат, ожидаемый Prophet (`ds` для даты и y для значений).

- Обучение модели: Инициализируем модель Prophet и обучаем её на исторических данных.

- Прогнозирование: Создаём будущий датафрейм на 12 месяцев вперед и получаем прогноз.

- Визуализация: Строим график прогнозируемых значений с помощью встроенного метода plot.

Подпишись 👉🏻 @KodduuPython 🤖

Ниже представлен пример использования библиотеки Kats для прогнозирования временных рядов на Python. В этом примере мы будем работать с данными о пассажиропотоке авиалиний и использовать модель Prophet, интегрированную в Kats.

import pandas as pd
import matplotlib.pyplot as plt
from kats.consts import TimeSeriesData
from kats.models.prophet import ProphetModel, ProphetParams

# Загрузка данных
data_url = 'https://raw.githubusercontent.com/facebookresearch/Kats/main/kats/data/air_passengers.csv'
df = pd.read_csv(data_url)
df.columns = ['ds', 'y']  # Переименовываем колонки для соответствия формату
df['ds'] = pd.to_datetime(df['ds'])

# Создание объекта TimeSeriesData
ts = TimeSeriesData(df)

# Инициализация модели Prophet с параметрами
params = ProphetParams(seasonality_mode='multiplicative')
model = ProphetModel(ts, params)

# Обучение модели
model.fit()

# Прогнозирование на следующие 12 месяцев
forecast_periods = 12
forecast = model.predict(steps=forecast_periods, freq='MS')

# Вывод прогноза
print(forecast[['time', 'fcst']])

# Визуализация результатов
plt.figure(figsize=(12, 6))
model.plot()
plt.title('Прогнозирование пассажиропотока авиалиний с помощью Kats')
plt.xlabel('Дата')
plt.ylabel('Количество пассажиров')
plt.show()

Объяснение кода:

- Импорт библиотек:
- pandas для работы с данными.
- matplotlib для визуализации.
- Модули из kats для работы с временными рядами и моделями.

- Загрузка данных:
- Используем датасет air_passengers.csv, доступный в репозитории Kats.
- Переименовываем колонки в ds (дата) и y (значение), что соответствует формату, ожидаемому Kats.

- Создание объекта TimeSeriesData:
- Оборачиваем DataFrame в объект TimeSeriesData, который используется Kats для обработки временных рядов.

- Инициализация модели Prophet:
- Задаем параметры модели с помощью ProphetParams.
- Устанавливаем seasonality_mode='multiplicative' для учета мультипликативной сезонности.
- Создаем экземпляр модели ProphetModel, передавая временной ряд и параметры.

- Обучение модели:
- Вызываем метод fit() для обучения модели на предоставленных данных.

- Прогнозирование:
- Прогнозируем на следующие 12 месяцев с помощью метода predict().
- Параметр freq='MS' указывает, что частота данных — начало месяца.

- Вывод прогноза:
- Отображаем столбцы time и fcst (прогнозируемые значения) из результата.

- Визуализация:
- Используем встроенный метод plot() для визуализации фактических и прогнозируемых значений.
- Настраиваем график с помощью matplotlib.

Дополнительная информация о Kats:

Kats (Kits to Analyze Time Series) — это всеобъемлющая библиотека с открытым исходным кодом, разработанная компанией Meta (Facebook) для анализа временных рядов. Она предоставляет широкий спектр инструментов для:

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

- Обнаружения аномалий:
- Предлагает методы для выявления аномальных точек и сегментов в данных.

- Обнаружения точек изменений (change point detection):
- Инструменты для определения моментов, когда статистические свойства временного ряда существенно изменяются.

- Анализа особенностей (feature extraction):
- Предоставляет функции для извлечения статистических признаков из временных рядов.

Основные преимущества Kats:

- Модульность и расширяемость:
- Легко интегрируется с другими библиотеками и позволяет добавлять собственные модели и методы.

- Единый интерфейс:
- Упрощает работу с различными моделями и инструментами через согласованный API.

- Инструменты для продвинутого анализа:
- Поддержка ансамблирования моделей, автоматической настройки гиперпараметров и т.д.

- Активное сообщество:
- Поскольку Kats разработан Meta, он поддерживается и развивается сообществом разработчиков.

Когда использовать Kats:

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

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

- Интеграция с существующими пайплайнами:
- Благодаря модульности Kats, его легко включить в существующие процессы обработки данных.

Установка Kats:

Перед началом работы необходимо установить библиотеку Kats:

pip install kats

Пример расширения: Использование модели LSTM

Kats также поддерживает модели глубокого обучения, такие как LSTM. Вот как можно использовать LSTM для прогнозирования:

from kats.models.deep_var import DeepVARModel, DeepVARParams

# Инициализация параметров модели LSTM
params = DeepVARParams(
    input_size=12,
    prediction_length=12,
    num_epochs=10,
)

# Создание и обучение модели
model = DeepVARModel(ts=ts, params=params)
model.fit()

# Прогнозирование
forecast = model.predict()

# Визуализация результатов
model.plot()
plt.title('Прогнозирование с использованием LSTM в Kats')
plt.show()

Заключение:

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

Подпишись 👉🏻 @KodduuPython 🤖

Неназойливо напоминаем - мы обновили курс Python: самый быстрый курс 👍

👉 Добавили описания в уроки, где их не хватало
👉 Добавили 44 новых теста и 30 новых интерактивных задач
👉 И сохранили баланс курса, его все еще можно пройти за выходные

🔥 Ваша скидка 1500 руб до 8 ноября 🔥 Это сегодня 👆

Подпишись 👉🏻 @KodduuPython 🤖

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

import pandas as pd
import numpy as np
from tsfresh import extract_features
from tsfresh.utilities.dataframe_functions import make_forecasting_frame
import matplotlib.pyplot as plt

# Генерация синтетического временного ряда
np.random.seed(42)
time = pd.date_range(start='2020-01-01', periods=100, freq='D')
values = np.sin(np.linspace(0, 20, 100)) + np.random.normal(0, 0.5, 100)
df = pd.DataFrame({'time': time, 'value': values})

# Создание фрейма данных для прогнозирования
df_fc, y = make_forecasting_frame(df['value'], kind='price', max_timeshift=10, rolling_direction=1)

# Извлечение признаков
X = extract_features(df_fc, column_id='id', column_sort='time')

# Просмотр извлеченных признаков
print(X.head())

# Визуализация исходного временного ряда
plt.figure(figsize=(12, 6))
plt.plot(df['time'], df['value'], label='Временной ряд')
plt.title('Синтетический временной ряд')
plt.xlabel('Время')
plt.ylabel('Значение')
plt.legend()
plt.show()

Объяснение кода:

- Импорт библиотек:
- pandas и numpy для работы с данными.
- tsfresh для извлечения признаков из временных рядов.
- matplotlib для визуализации.

- Генерация синтетического временного ряда:
- Создаем временной ряд длиной 100 точек с синусоидальным сигналом и добавляем шум.

- Создание фрейма данных для прогнозирования:
- Функция make_forecasting_frame преобразует временной ряд в формат, подходящий для извлечения признаков.
- Параметр max_timeshift=10 определяет максимальный лаг для признаков.

- Извлечение признаков:
- Функция extract_features вычисляет различные статистические признаки для каждого временного окна.
- Получаем DataFrame X с извлеченными признаками.

- Просмотр признаков:
- Выводим первые несколько строк DataFrame с признаками, чтобы ознакомиться с результатом.

- Визуализация:
- Строим график исходного временного ряда для наглядности.

Дополнительная информация о tsfresh:

- Цель библиотеки:
- tsfresh (Time Series FeatuRe Extraction on basis of Scalable Hypothesis tests) предназначена для автоматического извлечения большого количества признаков из временных рядов для задач классификации и регрессии.

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

- Когда использовать tsfresh:
- Машинное обучение: Для подготовки признаков временных рядов перед обучением моделей.
- Анализ данных: Для исследования и выявления важных характеристик временных рядов.
- Предобработка данных: В сочетании с другими методами для улучшения качества модели.

Ограничения:

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

Заключение:

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

Подпишись 👉🏻 @KodduuPython 🤖

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

import nltk
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from nltk.stem.snowball import SnowballStemmer
from nltk import pos_tag

# Загрузка необходимых ресурсов NLTK
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('universal_tagset')

# Пример текста
text = """Обработка естественного языка (NLP) — это область искусственного интеллекта, которая дает машинам способность читать, понимать и извлекать смысл из человеческих языков."""

# Токенизация предложений
sentences = sent_tokenize(text, language='russian')
print("Токенизация предложений:")
print(sentences)

# Токенизация слов
words = word_tokenize(text, language='russian')
print("\nТокенизация слов:")
print(words)

# Удаление стоп-слов
stop_words = set(stopwords.words('russian'))
filtered_words = [word for word in words if word.lower() not in stop_words]
print("\nУдаление стоп-слов:")
print(filtered_words)

# Стемминг
stemmer = SnowballStemmer("russian")
stemmed_words = [stemmer.stem(word) for word in filtered_words]
print("\nСтемминг:")
print(stemmed_words)

# Определение частей речи
pos_tags = nltk.pos_tag(filtered_words, lang='rus', tagset='universal')
print("\nОпределение частей речи:")
print(pos_tags)

# Распознавание именованных сущностей (NER)
# Для русского языка потребуется дополнительная библиотека Natasha
# Установка: pip install natasha
from natasha import Doc, Segmenter, MorphVocab, NewsNERTagger, NewsEmbedding, NewsSyntaxParser, NamesExtractor

# Инициализация моделей Natasha
segmenter = Segmenter()
morph_vocab = MorphVocab()
emb = NewsEmbedding()
ner_tagger = NewsNERTagger(emb)

doc = Doc(text)
doc.segment(segmenter)
doc.tag_ner(ner_tagger)

print("\nРаспознавание именованных сущностей:")
for span in doc.spans:
    print(f"{span.text} - {span.type}")

Особенности кода и применение NLTK:

1. Токенизация предложений и слов: Используются функции sent_tokenize и word_tokenize для разбиения текста на предложения и слова соответственно. Указывается параметр language='russian' для корректной работы с русским языком.

2. Удаление стоп-слов: С помощью stopwords.words('russian') получаем список часто встречающихся слов в русском языке (предлоги, союзы и т.д.), которые не несут существенной смысловой нагрузки и могут быть удалены из анализа.

3. Стемминг: Используем SnowballStemmer для русского языка, чтобы привести слова к их основы. Это помогает уменьшить разнообразие форм слов и сфокусироваться на их лексических корнях.

4. Определение частей речи (POS tagging): С помощью функции pos_tag определяем грамматические категории слов (существительное, глагол и т.д.). Для русского языка указываем параметры lang='rus' и tagset='universal'.

5. Распознавание именованных сущностей (NER): Для русского языка NLTK не предоставляет готовых моделей NER, поэтому используется библиотека Natasha, специализированная для обработки русского текста. Она позволяет извлекать именованные сущности, такие как имена, организации, локации и т.д.

Преимущества использования NLTK для NLP:

- Мощные инструменты для обработки текста: NLTK предоставляет широкий набор функций для различных задач NLP, что делает его универсальным инструментом для обработки текстовых данных.

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

- Гибкость и расширяемость: Возможность интеграции с другими библиотеками, такими как Natasha для русского языка, позволяет преодолевать ограничения и выполнять более сложные задачи.

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

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

Подпишись 👉🏻 @KodduuPython 🤖