Python для алготрейдинга - страница 23

[MetaQuotes]

Нормализация и создание последовательностей Crypto RNN — глубокое обучение с Python, TensorFlow и Keras часть 9

Нормализация и создание последовательностей Crypto RNN — глубокое обучение с Python, TensorFlow и Keras часть 9

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

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

При работе с временными данными и данными временных рядов перетасовка и случайный выбор части в качестве данных вне выборки может привести к необъективной модели. В нашем случае с последовательностями в 60 минут и окном прогнозирования в 3 минуты случайный выбор данных вне выборки может привести к тому, что аналогичные примеры будут присутствовать как в наборах в выборке, так и вне выборки. Это упростит переоснащение модели и ухудшит ее работу с невидимыми данными.

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

Теперь давайте реализуем это разделение данных вне выборки. Мы отсортируем данные по метке времени и найдем порог последних 5% раз. Разделяя данные таким образом, мы гарантируем, что набор вне выборки содержит данные из будущего, предотвращая утечку данных и необъективное тестирование. После разделения у нас будут данные проверки и данные обучения.

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

Сначала мы импортируем модуль предварительной обработки из библиотеки sklearn. Если он у вас не установлен, вы можете сделать это, запустив pip install sklearn. Затем мы определяем функцию preprocess_df, которая принимает DataFrame в качестве параметра.

Внутри функции мы начинаем с удаления ненужного столбца будущего из DataFrame. Затем мы перебираем столбцы DataFrame и применяем преобразование процентного изменения. Этот шаг нормализации помогает обрабатывать различные величины цен и объемов в криптовалютах.

После нормализации данных мы удаляем все строки, содержащие значения NaN, поскольку они могут вызвать проблемы во время обучения. Затем мы используем функцию preprocessing.scale для масштабирования значений от 0 до 1. Кроме того, вы можете реализовать собственную логику масштабирования.

Теперь, когда мы предварительно обработали данные, давайте перейдем к обработке последовательных данных. Мы создаем пустой список с именем sequence_data и инициализируем объект очереди с именем prev_days с максимальной длиной 60. Объект очереди позволяет нам эффективно добавлять новые элементы и автоматически удалять старые, когда он достигает максимальной длины.

Затем мы перебираем значения DataFrame, который теперь содержит нормализованные и масштабированные данные. Для каждой строки мы добавляем значения в очередь prev_days. Как только двухсторонняя очередь достигает длины не менее 60, мы начинаем заполнять последовательные_данные.

for i in DF.values:
    # Create a deque object with a maximum length of max_len
    if len(prev_days) < max_len:
        prev_days.append([n for n in i[:-1]])
    else:
        # Append the current values to prev_days
        prev_days.append([n for n in i[:-1]])
        # Add the sequence to the sequential_data list
        sequential_data.append([np.array(prev_days), i[-1]])
        # Remove the oldest sequence from prev_days
        prev_days.popleft()

В этом фрагменте кода мы перебираем значения фрейма данных DF. Мы проверяем, меньше ли длина prev_days (объекта очереди), чем max_len. Если это так, мы добавляем текущие значения (i[:-1]) к prev_days. В противном случае мы добавляем текущие значения к prev_days, добавляем последовательность [np.array(prev_days), i[-1]] в список sequence_data и удаляем самую старую последовательность из prev_days с помощью prev_days.popleft().

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

buys = []
sells = []

for seq, target in sequential_data:
    if target == 0:
        sells.append([seq, target])
    elif target == 1:
        buys.append([seq, target])

# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))

# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]

# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells

# Shuffle the balanced_data
random.shuffle(balanced_data)

В приведенном выше коде мы создаем два отдельных списка: покупки и продажи. Мы перебираем список sequence_data и добавляем последовательности с соответствующим целевым значением в соответствующий список. Далее определяем минимальное количество последовательностей между покупками и продажами. Мы ограничиваем оба списка этим минимальным числом, чтобы сбалансировать данные. Затем мы объединяем покупки и продажи, чтобы создать файл balance_data. Наконец, мы перемешиваем balance_data для обеспечения случайности.

После балансировки данных мы можем разделить их на массивы входных признаков (X) и целевых меток (y).

X = []
y = []

for seq, target in balanced_data:
    X.append(seq)
    y.append(target)

# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)

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

# Split the data into training and validation sets
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)

В приведенном выше коде мы используем функцию train_test_split из scikit-learn для разделения данных на наборы для обучения и проверки. Мы назначаем 80% данных обучающему набору (train_x и train_y) и 20%

# Normalize the data
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))

# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)

В приведенном выше коде мы используем MinMaxScaler из scikit-learn для нормализации входных функций (train_x и val_x). Метод fit_transform используется в тренировочном наборе для подбора масштабирующего устройства и нормализации данных. Затем мы используем метод преобразования на проверочном наборе, чтобы применить такое же масштабирование на основе обучающего набора. Данные изменяются до и после масштабирования, чтобы соответствовать желаемой форме.

Подготовив данные, мы можем построить и обучить модель LSTM:

model = Sequential()
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())

model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())

model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())

model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))

model.add(Dense(units=2, activation='softmax'))

# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])

# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)

# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])

В приведенном выше коде мы определяем последовательную модель с помощью Sequential(). Мы добавляем три слоя LSTM по 128 единиц в каждом, за которыми следуют отсеваемые слои со скоростью 0,2, чтобы предотвратить переоснащение. Пакетная нормализация применяется после каждого слоя LSTM. Затем мы добавляем плотный слой с 32 единицами и функцией активации ReLU, а затем еще один выпадающий слой. Наконец, мы добавляем плотный слой с двумя единицами (представляющими два класса: покупка и продажа) и функцией активации softmax.

Мы определяем оптимизатор как Адама со скоростью обучения 0,001 и компилируем модель, используя разреженную категориальную кросс-энтропию в качестве функции потерь и точность в качестве метрики.

Ранняя остановка определяется с помощью обратного вызова EarlyStopping для отслеживания потери проверки и прекращения обучения, если оно не улучшается после 3 эпох.

Модель обучается с использованием функции подгонки, передавая обучающие данные (train_x и train_y), данные проверки (val_x и val_y) и определенные обратные вызовы. Обучение проводится в течение 20 эпох.

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

# Evaluate the model
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)

loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')

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

Затем мы используем метод оценки модели для вычисления потерь и точности тестовых данных. Метод оценки принимает входные данные теста (test_x) и соответствующие метки достоверности (test_y). Вычисленные потери и точность выводятся на консоль.

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

import numpy as np
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense

Кроме того, перед выполнением кода убедитесь, что у вас есть необходимые наборы данных (train_x, train_y, val_x, val_y, test_x, test_y).

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

[MetaQuotes]

Балансировка данных последовательности RNN — глубокое обучение с Python, TensorFlow и Keras часть 10

Балансировка данных последовательности RNN — глубокое обучение с Python, TensorFlow и Keras часть 10

Всем привет и добро пожаловать в еще одно обучающее видео по глубокому изучению Python, TensorFlow и Keras. В этом видео мы продолжим разработку нашего предсказателя движения цены криптовалюты с использованием рекуррентной нейронной сети (RNN)».

Учебное видео посвящено созданию предиктора движения цены криптовалюты с использованием методов глубокого обучения.

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

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

Чтобы сбалансировать данные, ведущий создает два списка: покупает и продает. Они перебирают последовательные данные и проверяют, является ли цель 0 (продажа) или 1 (покупка). Если это продажа, они добавляют последовательность в список продаж. Если это покупка, они добавляют ее в список покупок. После этого они перемешивают оба списка.

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

Затем ведущий объединяет списки покупок и продаж в список sequence_data. Они снова перемешивают список sequence_data, чтобы еще больше рандомизировать порядок данных.

Следующим шагом будет разделение sequence_data на функции (X) и метки (Y). Они создают пустые списки x и y для хранения функций и меток соответственно. Они перебирают последовательные_данные и добавляют последовательность в список x, а цель — в список y.

Наконец, они возвращают массивы x и y в качестве предварительно обработанных данных.

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

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

[MetaQuotes]

Модель RNN для прогнозирования криптовалюты — глубокое обучение с Python, TensorFlow и Keras часть 11

Модель RNN для прогнозирования криптовалюты — глубокое обучение с Python, TensorFlow и Keras часть 11

Привет всем и добро пожаловать в еще один учебник по глубокому обучению с Python, TensorFlow и Keras. В этом уроке мы продолжим с того места, на котором остановились в предыдущем уроке. Наша цель — предсказать будущее движение цены конкретной криптовалюты на основе ее исторических цен, объема и других основных криптовалют. Мы достигнем этого, используя рекуррентную нейронную сеть (RNN).

Для начала нам нужно импортировать необходимые библиотеки. Мы импортируем библиотеку времени для последующего использования. Далее мы определяем несколько констант. Первая константа — это количество эпох, для которых мы хотим обучить модель. Изначально мы установили размер пакета равным 64, но при необходимости мы можем изменить его позже. Наконец, мы определяем имя модели, используя F-строку. Важно иметь уникальное имя для модели и журналов TensorBoard для удобства сравнения и идентификации.

Теперь мы импортируем необходимые модули TensorFlow. Мы импортируем TensorFlow как tf и необходимые подмодули: tf.keras.models, tf.keras.layers, tf.keras.optimizers, tf.keras.callbacks и tf.keras.backend. Мы также импортируем numpy и matplotlib для обработки и визуализации данных.

Далее начинаем строить нашу модель. Мы создаем последовательную модель, используя model = tf.keras.models.Sequential(). Внутри модели мы добавляем слои с помощью функции model.add(). Наш первый уровень — это уровень LSTM со 128 узлами. Мы устанавливаем return_sequences=True, так как мы хотим передать вывод на следующий уровень. Мы указываем входную форму как train_X.shape[1:], где train_X — входные данные. Мы также добавляем слой отсева со скоростью 0,2 и слой нормализации партии.

Мы повторяем этот процесс еще два раза, добавляя еще два слоя LSTM по 128 узлов в каждом. Мы удаляем return_sequences=True для последнего слоя LSTM, поскольку за ним будет следовать плотный слой. Мы также добавляем слои отсева и пакетной нормализации к каждому слою LSTM.

После слоев LSTM мы добавляем плотный слой с 32 узлами и выпрямленной линейной функцией активации. Мы добавляем слой отсева со скоростью 0,2 и, наконец, выходной слой с двумя узлами и функцией активации softmax.

Теперь мы указываем оптимизатор для нашей модели. Мы используем оптимизатор Adam со скоростью обучения 0,001 и скоростью затухания 1e-6. Мы компилируем модель с помощью model.compile() и указываем функцию потерь как разреженную категориальную кросс-энтропию, а метрики — как точность.

Затем мы определяем обратные вызовы для нашей модели. Мы создаем обратный вызов TensorBoard с каталогом журналов, установленным на «logs». Мы также создаем обратный вызов ModelCheckpoint, чтобы сохранить лучшую модель во время обучения. Путь к файлу для сохранения чекпоинтов указываем с помощью строкового форматирования.

Наконец, мы обучаем модель с помощью model.fit(). Мы передаем обучающие данные (train_X и train_Y), размер партии, количество эпох и данные проверки (validation_X и validation_Y). Мы также передаем обратные вызовы, которые мы определили ранее.

После обучения мы можем сохранить модель с помощью model.save() для использования в будущем.

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

[MetaQuotes]

Алгоритмическая торговая стратегия в Python

Алгоритмическая торговая стратегия в Python

В сегодняшнем уроке мы будем реализовывать алгоритмическую стратегию торговли акциями с использованием Python. Давайте погрузимся прямо в это.

Прежде чем мы начнем, я хочу подчеркнуть, что это видео не предназначено для инвестиций или финансового совета. Я не фондовый профессионал, инвестиционный эксперт или финансовый профессионал. Цель этого видео — продемонстрировать, как реализовать алгоритмическую торговую стратегию с помощью Python. Решите ли вы использовать его для своих инвестиций, это полностью ваше решение и ответственность. Я сосредоточусь только на аспекте программирования.

Для начала нам нужно установить две библиотеки: «pandas-datareader» для получения биржевых данных и «matplotlib» для визуализации данных. Откройте командную строку (CMD) и установите эти библиотеки. После установки мы можем приступить к кодированию.

Во-первых, мы импортируем необходимые модули: «datetime» для обработки даты и времени, «matplotlib.pyplot» для построения графиков и «pandas_datareader» как «web» для получения биржевых данных.

Далее мы определяем скользящие средние (MA), которые будем использовать. Скользящие средние представляют среднюю цену акций за определенный период времени, например, 30 или 100 дней. Мы создаем две переменные, «ma1» и «ma2», которым будут присвоены значения 30 и 100 соответственно. Эти значения определяют длину скользящих средних, которые мы будем анализировать.

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

Используя библиотеку datareader, мы извлекаем данные об акциях конкретной компании (в данном случае Facebook) из Yahoo Finance API. Мы передаем даты начала и окончания, чтобы получить соответствующие данные.

Для расчета скользящих средних мы добавляем два новых столбца в DataFrame данных. Мы используем «скользящую» функцию для расчета скользящей средней как для периодов «ma1», так и для «ma2». Столбец «скорректированное закрытие» представляет собой цену закрытия, скорректированную с учетом дробления акций. Мы храним скользящие средние в соответствующих столбцах.

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

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

Используя цикл for, мы перебираем данные DataFrame. Внутри цикла проверяем два условия: если первая скользящая средняя ("ma1") больше второй скользящей средней ("ma2"), и не равен ли триггер 1. Если выполняются оба условия, добавляем сигнал на покупку в список «buy_signals» и добавить «NaN» (не число) в список «sell_signals». Мы также обновляем триггер до 1.

В обратном случае, когда "ma1" меньше "ma2" и триггер не равен -1, мы добавляем сигнал на продажу в список "sell_signals" и добавляем реальную цену акции в список "buy_signals". Мы обновляем триггер до -1.

Если ни одно из условий не выполняется, мы добавляем значения «NaN» к обоим спискам, чтобы поддерживать постоянную длину.

Наконец, мы добавляем еще два столбца в DataFrame для хранения сигналов покупки и продажи.

Мы также собираемся рассеивать сигналы продажи, поэтому мы добавим еще один точечный график, используя plt.scatter. На этот раз мы разбросаем сигналы на продажу в data.index как значения x, а соответствующие цены сигналов на продажу — как значения y. Мы назовем этот точечный график «сигналом на продажу», чтобы отличить его от сигналов на покупку.

Наконец, мы добавим легенду к графику, используя plt.legend для отображения меток для различных элементов. Затем мы вызовем plt.show() для отображения графика.

Код:

plt.plot(data.index, data[ 'Adj Close' ], label= 'Share Price' , color= 'lightgray' )
plt.plot(data.index, data[ 'sma_{}' .format(ma1)], label= 'SMA {}' .format(ma1), linestyle= '--' )
plt.plot(data.index, data[ 'sma_{}' .format(ma2)], label= 'SMA {}' .format(ma2), linestyle= '--' )
plt.scatter(data.index, data[ 'Buy Signal' ], label= 'Buy Signal' )
plt.scatter(data.index, data[ 'Sell Signal' ], label= 'Sell Signal' )
plt.legend(loc= 'upper left' )
plt.show()

Теперь, когда вы запустите код, вы должны увидеть график, показывающий цену акций, скользящие средние и сигналы покупки и продажи.

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

[MetaQuotes]

Как использовать Alpha Vantage Free Real Time Stock API и Python для извлечения времени ежедневных максимумов и минимумов

Как использовать Alpha Vantage Free Real Time Stock API и Python для извлечения времени ежедневных максимумов и минимумов

В этом видео мы собираемся использовать блокнот Jupyter, чтобы изучить API Alpha Vantage и извлечь максимальную и минимальную торговые цены акции, используя данные за одну минуту. Alpha Vantage — это один из нескольких API, доступных для получения данных о торговле в режиме реального времени, и он работает по модели freemium. Для начала нам нужно зарегистрировать бесплатную учетную запись и получить ключ API на веб-сайте Alpha Vantage.

Мы будем использовать вспомогательную библиотеку Alpha Vantage под названием «alpha_vantage», которая упрощает процесс выполнения вызовов API. Если у вас не установлена библиотека, вы можете сделать это, выполнив команду «pip install alpha_vantage» в командной строке.

Для начала настроим нашу среду, импортировав необходимые сторонние библиотеки. Как только это будет сделано, мы сохраним наш ключ API в переменной. Если вы предпочитаете, чтобы ваш ключ API оставался закрытым, вы можете сохранить его в отдельном текстовом файле и прочитать в своем блокноте. Затем мы создаем объект временного ряда, указав ключ API и желаемый выходной формат. В этом случае мы решили использовать библиотеку pandas, поскольку она обеспечивает более простой способ работы с выходными данными, которые по умолчанию имеют формат JSON.

Чтобы получить торговые данные, мы обращаемся к API Alpha Vantage с помощью функции «get_intraday». Эта функция позволяет нам указать символ акции и желаемый интервал, например, одну минуту, пять минут или один час. Мы также можем установить размер вывода, который определяет количество исторических данных, которые мы хотим получить. Для этого видео мы установили значение «полный», что дает нам данные примерно за десять дней.

После получения данных мы можем изучить связанные с ними метаданные, обратившись к атрибуту «meta». Метаобъект предоставляет информацию о загруженных данных, такую как интервал, дата данных и содержащиеся в нем столбцы. Затем мы можем проверить сами данные, вызвав метод «info», который отображает имена столбцов и индекс даты и времени.

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

Затем мы извлекаем данные, соответствующие обычным торговым часам, исключая торговлю в нерабочее время, которая может внести искажения. Мы создаем новую переменную с именем «рынок», применяя к данным временной фильтр. Pandas предоставляет удобную функцию «between_time», которая позволяет нам указать время начала и окончания рынка.

На данный момент мы готовы извлечь даты и время максимумов и минимумов. Мы делаем это двумя способами. Сначала мы группируем данные по дате сделки и используем метод «ag» для расчета минимального и максимального значений для нижнего и верхнего столбцов соответственно. Этот подход дает нам фактические минимальные и максимальные значения для каждого торгового дня.

Во-вторых, мы применяем другой подход и сосредотачиваемся на минуте, когда произошли минимум и максимум. Мы используем функцию «loc», чтобы найти определенные строки, где минимумы и максимумы происходят в течение каждого торгового дня. Затем мы извлекаем индекс (дату и время) для минимального и максимального значений соответственно. Это позволяет нам определить точную минуту, когда были достигнуты минимальная и максимальная цены.

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

В этом видео представлен базовый обзор использования API Alpha Vantage для получения поминутных торговых данных и извлечения максимумов и минимумов для анализа. Он служит отправной точкой для изучения и использования API Alpha Vantage в ваших собственных проектах.

В заключение, в этом видеоруководстве показано, как использовать Alpha Vantage API и вспомогательную библиотеку Alpha Vantage в блокноте Jupyter Notebook для извлечения высоких и низких торговых цен на акции с использованием минутных торговых данных. Выполняя шаги, описанные в видео, вы можете получать торговые данные в реальном времени, анализировать их с помощью панд и получать представление о времени максимумов и минимумов в течение определенного торгового дня.

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

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

Не забудьте обратиться к документации Alpha Vantage за подробной информацией о доступных вызовах API, параметрах и опциях. Кроме того, обязательно соблюдайте положения и условия API Alpha Vantage, включая любые ограничения или ограничения на использование, связанные с вашей бесплатной учетной записью.

Используя API Alpha Vantage и комбинируя его с возможностями Jupyter Notebook и библиотеки pandas, вы можете получить доступ к большому количеству торговых данных и изучить различные стратегии и идеи для поддержки ваших инвестиционных решений и количественного анализа.

[MetaQuotes]

Введение в точечные диаграммы с помощью matplotlib Python для науки о данных

Введение в точечные диаграммы с помощью matplotlib Python для науки о данных

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

Для начала давайте настроим нашу среду, импортировав необходимые библиотеки. Мы импортируем NumPy, Matplotlib и средство чтения данных Pandas. Читатель данных Pandas позволит нам загружать реальные данные для работы. В этом случае мы будем загружать данные за три-четыре месяца для Google, Amazon и золотого ETF.

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

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

Для дальнейшего исследования мы можем рассчитать мгновенную норму прибыли для каждой ценной бумаги. Это даст нам лучшее понимание того, как изменения цены соотносятся друг с другом. Мы убираем абсолютную цену и уменьшаем ее до процентного изменения. Глядя на первые несколько наблюдений, мы видим, что все ценные бумаги упали, при этом Amazon и Google испытали снижение более чем на 1%, в то время как золото осталось относительно неизменным.

Затем мы удаляем первое наблюдение, которое не является числом, и строим точечную диаграмму, чтобы увидеть, связано ли изменение в Google с изменением в Amazon. Этот точечный график рассказывает другую историю, чем предыдущий. Мы можем наблюдать общую тенденцию, что по мере роста Google растет и Amazon, что указывает на сильную положительную связь между двумя переменными.

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

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

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

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

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

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

Кроме того, мы можем улучшить общий вид сюжета, применив тему. Мы можем использовать Seaborn в качестве темы, которая представляет собой оболочку Matplotlib, обеспечивающую визуально привлекательный стиль. Эта тема изменяет фон и добавляет линии сетки, не умаляя отображаемых данных.

Наконец, мы можем настроить границы графика, чтобы центрировать направляющие линии.

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

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

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

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

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

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

[MetaQuotes]

Введение в алгоритмическую торговлю с помощью Python: создание алгоритма торговли с возвратом к среднему

Введение в алгоритмическую торговлю с помощью Python: создание алгоритма торговли с возвратом к среднему

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

Торговая стратегия возврата к среднему предполагает, что ценная бумага будет возвращаться к среднему значению всякий раз, когда оно слишком сильно отклоняется от него. Есть несколько подходов к этой стратегии, например, использование линейной регрессии или скользящего среднего. Определение «слишком далеко» и используемое измерение могут различаться. Некоторые люди используют абсолютное значение в долларах, а в этом видео мы будем использовать процентили. Кроме того, для определения среднего значения будет использоваться скользящее среднее.

Для начала мы импортируем необходимые библиотеки, в том числе Pandas для обработки данных, Pandas DataReader для загрузки данных в реальном времени (также можно использовать другие сервисы), NumPy для числовых операций, Matplotlib для построения графиков и Seaborn для стилизации графиков. Необходимые библиотеки импортируются путем запуска соответствующей ячейки кода.

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

После получения данных мы добавляем несколько столбцов во фрейм данных. Первый добавленный столбец предназначен для скользящего среднего. Мы устанавливаем переменную для определения периода скользящей средней, которой можно легко манипулировать. Мгновенная норма доходности от закрытия предыдущего дня рассчитывается и сохраняется в новом столбце. Другой столбец под названием «скользящее среднее» создается для отслеживания среднего значения на основе цены закрытия с использованием среднего значения за 21 день (или один торговый месяц). Кроме того, добавляется столбец «коэффициент», представляющий деление цены закрытия на скользящее среднее. Этот столбец помогает определить, когда цена слишком далека от среднего значения.

Описательная статистика рассчитывается для столбца «соотношение», чтобы получить представление о распределении данных. Как и ожидалось, цены в целом остаются близкими к среднему значению. 25-й и 75-й процентили определяют нижнюю и верхнюю границы данных, а минимальное и максимальное значения указывают на крайние отклонения от среднего значения. Для анализа выбираются дополнительные ценовые точки, такие как 5-й, 10-й, 90-й и 95-й процентили, чтобы определить значительные отклонения от среднего значения. Функция процентиля numpy используется для расчета соответствующих значений на основе столбца «соотношение золота». Перед выполнением расчета пропущенные значения отбрасываются.

Чтобы визуализировать движение столбца отношения вокруг среднего значения, создается график. Нерелевантные значения отбрасываются, а столбец отношения отображается с легендой. Горизонтальные линии добавляются для представления ценовых разрывов в выбранных процентилях (5-й, 50-й и 95-й). Это визуальное представление помогает наблюдать за циклическим движением столбца отношений вокруг среднего значения, указывая на тенденцию к исправлению отклонений.

Затем определяются конкретные пороговые значения, чтобы определить, когда открывать короткую или длинную позицию. Короткая позиция определяется как 95-й процентиль, а длинная позиция определяется как 5-й процентиль. Во фрейм данных добавляется новый столбец, указывающий, является ли позиция длинной или короткой. Функция «где» Numpy используется для присвоения значений на основе столбца золотого отношения. Значение -1 присваивается, когда отношение меньше короткого порога, что указывает на короткую позицию, а значение 1 присваивается, когда отношение больше длинного порога, что указывает на длинную позицию. Наконец, создается график для визуализации позиций. На графике показан столбец соотношения, а длинные и короткие позиции выделены разными цветами.

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

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

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

Наконец, строится график для сравнения кумулятивной доходности стратегии возврата к среднему со стратегией «купи и держи». Стратегия «купи и держи» предполагает удержание актива в течение всего периода без каких-либо торговых решений. Этот график позволяет визуально сравнить две стратегии.

Таким образом, это видео демонстрирует реализацию торговой стратегии возврата к среднему значению с использованием Python и Jupyter Notebook. Он охватывает извлечение данных, расчет скользящих средних, определение пороговых значений, визуализацию позиций, расчет ежедневной доходности, оценку показателей производительности и сравнение со стратегией «купи и держи». В прилагаемом блокноте Jupyter содержится пошаговое руководство по воссозданию стратегии и дальнейшему изучению ее реализации. Помните, что это видео предназначено только для образовательных целей и не дает советов по инвестированию.

[MetaQuotes]

Панды Питона || Скользящие средние и статистика скользящего окна для цен на акции

Панды Питона || Скользящие средние и статистика скользящего окна для цен на акции

В этом видеоуроке я покажу, как использовать метод прокатки панд, который автоматизирует вычисления для скользящих средних и прокатки стандартных отклонений. Метод прокрутки — это мощный инструмент для выполнения агрегации прокручивающихся окон, и его можно легко реализовать с помощью pandas версии 0.21. Для справки я предоставлю ссылку на блокнот Jupyter Notebook, используемый в этом руководстве.

Для начала нам нужно настроить окружение. Мы импортируем библиотеку numpy, так как pandas полагается на нее. Хотя мы не будем широко использовать numpy напрямую, это необходимо для правильной работы pandas. Кроме того, мы импортируем средство чтения данных pandas для получения данных и matplotlib для построения графиков. Используя волшебную функцию, мы гарантируем, что графики отображаются в блокноте Jupyter.

Далее получаем данные для анализа. Я загружу данные для золотого ETF (Exchange-Traded Fund) из Yahoo Finance. Чтобы указать желаемые временные рамки, я установил дату начала на день президентских выборов, примерно год назад. Чтобы убедиться, что данные получены правильно, я показываю первые несколько строк набора данных. Поскольку нас в первую очередь интересуют цены закрытия для этой демонстрации, я удаляю другие столбцы. Кроме того, поскольку загружаемый фрейм данных представляет собой серию серий и не имеет определенных свойств, которые мне нужны, я привожу его как фрейм данных.

Теперь мы готовы продемонстрировать метод прокатки. Я добавлю новый столбец во фрейм данных под названием «MA9», чтобы представить девятидневную скользящую среднюю. Используя скользящий метод, я вычисляю среднее значение за указанное количество периодов или строк. Я повторяю этот процесс для более длительного окна в 21 день. Эти два новых столбца представляют рассчитанные нами скользящие средние значения. Чтобы визуализировать данные, я рисую цены закрытия, скользящую среднюю за девять дней и скользящую среднюю за 21 день.

Иногда полезно отставать от скользящих средних. Добавив параметр center=True при использовании скользящего метода, мы можем сместить линию скользящего среднего на десять дней назад для 21-дневного окна. Это создает линию с запаздыванием, которая выравнивается с соответствующими данными. Этот сдвиг мы можем наблюдать на построенном графике.

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

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

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

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

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

[MetaQuotes]

Количественный анализ цен на акции с помощью Python, pandas, NumPy, matplotlib и SciPy

Количественный анализ цен на акции с помощью Python, pandas, NumPy, matplotlib и SciPy

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

Докладчик начинает с настройки среды и импорта библиотек анализа данных, таких как NumPy, Pandas и Matplotlib. Они также упоминают об использовании библиотеки Pandas Data Reader для загрузки оперативных данных из Yahoo API. Затем динамик извлекает данные о запасах для Amazon, указывая даты начала и окончания, которые по умолчанию соответствуют данным о ценах за последние пять лет.

После получения данных спикер проверяет первые несколько строк, чтобы проверить имеющуюся информацию. Они указывают столбцы, представляющие максимум, минимум, открытие, закрытие, объем и скорректированные цены закрытия. Поскольку их в первую очередь интересует цена закрытия, они обсуждают возможность использования столбца «закрытие» или «скорректированное закрытие», причем последний полезен для акций, подвергшихся дроблению. В этом случае, поскольку последнее разделение Amazon было в 1999 году, выбор между двумя столбцами не имеет существенного значения.

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

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

Описательная статистика движения цены получается с помощью функции Pandas «describe». Спикер упоминает возможность получения статистики индивидуально или с помощью других инструментов, но считает, что метод Pandas достаточен для их целей. Они также представляют библиотеку SciPy и демонстрируют другой способ расчета описательной статистики с использованием функции «описать» из статистики SciPy. Они упоминают, что некоторые значения отображаются как «NaN» из-за обработки отсутствующих значений в NumPy и SciPy.

Чтобы сделать числа более понятными, говорящий умножает значения на 100, чтобы преобразовать их в проценты. Это изменение улучшает читаемость вывода без изменения данных.

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

Затем спикер выполняет статистический тест, в частности тест на эксцесс, как для нормальной переменной, так и для доходности Амазонки. Тест на эксцесс проверяет, можно ли считать распределение нормальным, при этом нулевая гипотеза предполагает нормальное распределение. Получаются статистика теста и значение p, а докладчик объясняет интерпретацию результатов. Для нормальной переменной тестовая статистика слегка отрицательна, что указывает на отсутствие веских доказательств против нулевой гипотезы. Напротив, для доходности Amazon тестовая статистика намного больше, что предполагает отклонение нулевой гипотезы и вывод о том, что изменение цены Amazon не может быть описано как нормально распределенное.

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

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

import matplotlib.pyplot as plt

# Plot histogram
plt.hist(amazon_return, bins= 50 , density=True, alpha= 0.5 , label= 'Amazon Returns' )

# Generate normal curve
x = np.linspace(amazon_return.min(), amazon_return.max(), 100 )
normal_curve = norm.pdf(x, mu, sigma)

# Plot normal curve
plt.plot(x, normal_curve, 'r-' , label= 'Normal Distribution' )

# Add labels and legend
plt.xlabel( 'Daily Price Change' )
plt.ylabel( 'Proportion' )
plt.title( 'Histogram of Amazon Returns with Normal Distribution' )
plt.legend()

# Show the plot
plt.show()

Теперь давайте посмотрим на сюжет. У нас есть гистограмма доходности Amazon, а также наложение теоретической кривой нормального распределения. Это визуальное сравнение позволяет нам оценить, насколько дневные изменения цен соответствуют нормальному распределению.

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

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

[MetaQuotes]

Методы модели линейной регрессии с Python, NumPy, pandas и Seaborn

Методы модели линейной регрессии с Python, NumPy, pandas и Seaborn

В этом видео мы рассмотрим несколько простых методов регрессии в Python. Существует несколько инструментов для реализации регрессии в Python, но мы сосредоточимся на паре из них, особенно на использовании NumPy. Обратите внимание, что это руководство не является исчерпывающим, и мы не будем проводить статистические тесты. Мы просто подгоним строку и визуализируем вывод.

Вы можете скачать блокнот по ссылке, указанной в описании видео на GitHub, чтобы следовать ей. Начнем с настройки нашей среды и импорта необходимых библиотек. Мы будем использовать NumPy, pandas, Yahoo Finance API для получения данных в реальном времени, matplotlib для визуализации и seaborn для применения темы к нашим графикам.

Далее нам нужно получить данные. Мы получим данные для Google и S&P 500 ETF примерно за год. Для этой цели мы будем использовать средство чтения данных pandas и Yahoo Finance API. Когда у нас есть данные, мы можем быстро взглянуть на них. Поскольку для нашего анализа нас интересуют только «закрытые» цены, мы соответствующим образом скорректируем данные.

Чтобы выполнить регрессию, мы рассчитаем мгновенную норму доходности как для Google, так и для ETF S&P 500. После удаления любых недопустимых значений мы готовы вычислить корреляцию между двумя переменными. Мы находим, что они сильно коррелированы, но мы не будем пытаться определить причинно-следственную связь в этом анализе. Вместо этого мы будем рассматривать S&P 500 как независимую переменную.

Чтобы упростить визуализацию, мы выберем меньшее подмножество точек данных. В этом случае мы случайным образом выбираем 60 результатов и наблюдаем за корреляцией, которая остается похожей на общий набор данных. Затем мы приступаем к визуализации данных, строя график рассеяния с S&P 500 на оси x и Google на оси y.

Переходя к регрессии, мы подгоним линейную модель, используя функцию полифита NumPy. Мы передаем выборочные данные с S&P 500 в качестве независимой переменной и Google в качестве зависимой переменной вместе со степенью нашего полинома (1 для простой линейной регрессии). Это дает нам наклон и точку пересечения по оси Y наиболее подходящей линии, которую можно интерпретировать как бета-значение.

Чтобы построить линию тренда, мы используем многозначную функцию NumPy, передавая регрессию и независимую переменную. Мы можем наложить эту линию тренда на точечный график. Кроме того, регрессию можно использовать в качестве технического индикатора для прогнозирования будущих цен. В этом примере мы регрессируем цены закрытия S&P 500 в зависимости от времени.

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

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

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

Теперь, когда мы рассмотрели основы линейной регрессии в Python, давайте рассмотрим некоторые дополнительные методы и концепции.

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

Чтобы вычислить значение R-квадрата, мы можем использовать библиотеку statsmodels в Python. Мы импортируем необходимый модуль и подгоним модель линейной регрессии к нашим данным. Затем мы можем извлечь значение R-квадрата, используя атрибут модели rsquared.

Продемонстрируем это на примере. Предположим, у нас есть набор данных с двумя переменными, X и Y, и мы хотим подобрать модель линейной регрессии для прогнозирования Y на основе X. Мы будем использовать функцию sm.OLS (Обычные наименьшие квадраты) из библиотеки statsmodels для выполнения регрессии. анализ.

Сначала мы импортируем необходимые модули:

import statsmodels.api as sm
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Затем мы загружаем данные в DataFrame pandas и извлекаем переменные X и Y:

data = pd.read_csv( 'data.csv' )
X = data[ 'X' ]
Y = data[ 'Y' ]

Затем мы добавляем постоянный член к независимой переменной X. Это необходимо для того, чтобы библиотека statsmodels включала член перехвата в модель регрессии:

X = sm.add_constant(X)

Теперь мы можем подобрать модель линейной регрессии и рассчитать значение R-квадрата:

model = sm.OLS(Y, X).fit()
r_squared = model.rsquared

Наконец, мы можем распечатать значение R-квадрата, чтобы оценить качество подгонки:

print( "R-squared:" , r_squared)

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

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

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

Чтобы создать остаточный график, мы можем использовать библиотеку matplotlib в Python:

predicted_values = model.predict(X)
residuals = Y - predicted_values

plt.scatter(predicted_values, residuals)
plt.axhline(y= 0 , color= 'r' , linestyle= '-' )
plt.xlabel( 'Predicted Values' )
plt.ylabel( 'Residuals' )
plt.title( 'Residual Plot' )
plt.show()

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

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