Освоение прогнозирования фондового рынка: машинное обучение, LSTM и статистический анализ

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

# Import Modules

import numpy as np
import pandas as pd
import os
import random
import copy
import matplotlib.pyplot as plt
import pandas

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

Библиотека pandas Python используется для анализа данных. Структуры данных и инструменты анализа предоставляются в простом в использовании и высокопроизводительном пакете.

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

Модуль random предоставляет функции для генерации случайных чисел.

Модуль копирования предоставляет функции для копирования объектов.

Графики Python можно создавать с помощью matplotlib.pyplot.

Библиотека pandas Python позволяет анализировать данные. Предоставляется высокоуровневая структура данных и инструменты анализа данных.

В текущем пространстве имен модуль импортируется с помощью оператора import. При таком подходе вам не нужно указывать полный путь к модулю, чтобы использовать его функции и переменные. Например, чтобы создать массив, вы можете использовать функцию np.array() после импорта модуля numpy.

Выберите 8 случайных биржевых данных для анализа

#filenames = [x for x in os.listdir("./Stocks/") if x.endswith('.txt') and os.path.getsize(x) > 0]
filenames = random.sample([x for x in os.listdir() if x.endswith('.txt')
and os.path.getsize(os.path.join('',x)) > 0], 8)
print(filenames)

В фрагменте кода определяется переменная с именем filenames и ей присваивается список имен файлов. Чтобы найти эти имена файлов, используйте функцию os.listdir(), чтобы вывести список всех файлов в каталоге ./Stocks/. В список включаются имена файлов, оканчивающиеся на .txt и имеющие размер файла больше 0. Из-за того, что он начинается с символа #, строка в настоящее время закомментирована.

После этого фрагмент кода присваивает список из 8 случайных имен файлов другой переменной, называемой именами файлов. В текущем каталоге (где запущен сценарий) выбираются все файлы, оканчивающиеся на .txt и имеющие размер файла больше 0. Мы случайным образом выбираем 8 имен файлов из списка с помощью random.sample().

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

Код извлекает список имен файлов, отвечающих определенным критериям (заканчивающихся на .txt и имеющих ненулевой размер файла) из определенного каталога или текущего каталога, а затем выбирает из него 8 случайных имен файлов. Затем печатаются выбранные имена файлов.

Считывание данных во фреймы данных

data = []
for filename in filenames:
df = pd.read_csv(os.path.join('',filename), sep=',')
label, _, _ = filename.split(sep='.')
df['Label'] = label
df['Date'] = pd.to_datetime(df['Date'])

data.append(df)

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

Чтобы сохранить данные из файлов, он сначала создает пустой список под названием «данные».

На следующем шаге он перебирает каждое имя файла, указанное в списке «имена файлов».

Используя функцию read_csv() из библиотеки pandas, он считывает содержимое каждого файла в виде CSV-файла. Чтобы построить полный путь к файлу, функция os.path.join() соединяет пустую строку с текущим именем файла.

Если разделитель установлен на «….», имя файла разделяется с помощью функции split(). При этом имя файла разбивается на две части, и первая часть присваивается переменной «label». «Метка» — это метка или идентификатор, который идентифицирует данные в файле.

Новый столбец с именем «Label» добавляется к DataFrame (df), полученному из файла, и его значения устанавливаются в переменную «label». Строки DataFrame помечены в этом столбце соответствующим образом.

Новый столбец «Date» добавляется в DataFrame, а существующий столбец «Date» преобразуется в datetime с помощью функции pandas pd.to_datetime().

Наконец, все кадры данных, созданные из файлов, добавляются в список «данных».

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

data[0].head()

Data[0].head() извлекает первые несколько строк данных из DataFrame с индексом 0 списка «data».

Что он делает, так это следующее:

Доступ к элементу с индексом 0 списка «data» осуществляется с помощью data[0]. DataFrames содержатся в списке «data», поэтому data[0] относится к первому DataFrame.

DataFrame может быть вызван с помощью .head(). Извлекаются первые несколько строк DataFrame. Первые пять строк возвращаются по умолчанию.

Метод data[0].head() извлекает первые 5 строк данных из первого DataFrame в списке «data».

Добавление различных технических индикаторов в кадр данных

def rsi(values):
up = values[values>0].mean()
down = -1*values[values<0].mean()
return 100 * up / (up + down)

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

Мы можем вычислить RSI для всех входных значений, передав один аргумент, называемый значениями.

Ниже приведены шаги, выполняемые функцией:

В массив values включаются только значения, превышающие ноль. Среднее (среднее) этих отфильтрованных значений присваивается переменной вверх. Значения менялись в среднем положительно.

В массив values включаются только значения, меньшие нуля. Среднее (среднее) этих отфильтрованных значений вычисляется и присваивается переменной вниз. Умножив его на -1, отрицательные значения становятся положительными. Здесь показано среднее отрицательное изменение значений.

RSI рассчитывается путем деления среднего положительного изменения (вверх) на среднее отрицательное изменение (вниз). Затем результат умножается на 100, чтобы получить процент. RSI — это индикатор, используемый в техническом анализе для оценки силы или слабости тренда.

# Add Momentum_1D column for all 15 stocks.
# Momentum_1D = P(t) - P(t-1)
for stock in range(len(TechIndicator)):
TechIndicator[stock]['Momentum_1D'] = (TechIndicator[stock]['Close']-TechIndicator[stock]['Close'].shift(1)).fillna(0)
TechIndicator[stock]['RSI_14D'] = TechIndicator[stock]['Momentum_1D'].rolling(center=False, window=14).apply(rsi).fillna(0)
TechIndicator[0].tail(5)

Ряд шагов выполняется предоставленным кодом. Во-первых, он добавляет два новых столбца, «Momentum_1D» и «RSI_14D», к каждому DataFrame в списке «TechIndicator». Индикатор однодневного импульса и индикатор 14-дневного RSI будут храниться в этих столбцах. Затем каждый DataFrame в списке «TechIndicator» перебирается и выполняются вычисления. Он вычисляет однодневный импульс, вычитая цену закрытия предыдущего дня из цены закрытия текущего дня, и сохраняет результат в столбце «Momentum_1D». Этот столбец заполняется 0, если отсутствуют какие-либо значения. Кроме того, он вычисляет 14-дневный RSI, применяя пользовательскую функцию под названием «rsi» к значениям в столбце «Momentum_1D» в скользящем окне размера 14. В столбце «RSI_14D» сохраняется результат, и все пропущенные значения в этом столбце также заполняются 0. В списке «TechIndicator» код выводит последние 5 строк данных из первого DataFrame. Этот код добавляет и заполняет столбцы для индикаторов импульса и RSI для цены закрытия каждой акции, предоставляя дополнительную информацию.

for stock in range(len(TechIndicator)):
TechIndicator[stock]['Volume_plain'] = TechIndicator[stock]['Volume'].fillna(0)
TechIndicator[0].tail()

Ниже приведены шаги, выполняемые предоставленным кодом:

Список TechIndicator зацикливается с помощью переменной stock в цикле for. Длина списка TechIndicator включается в цикл.

DataFrame для каждой индексной акции в списке TechIndicator добавляется в цикл следующим образом:

В DataFrame создается новый столбец с именем Volume_plain.

Volume_plain содержит значения из столбца «Объем», но все отсутствующие значения (NaN) заменяются на 0.

С помощью функции .tail() он выводит последние 5 строк данных из первого DataFrame в списке TechIndicator (TechIndicator[0]).

К каждому DataFrame добавляется новый столбец с именем Volume_plain, который заполняется значениями Volume, оставляя все отсутствующие значения равными 0. Код выполняет итерацию по списку TechIndicator. После этого он отображает последние 5 строк данных из первого DataFrame в списке TechIndicator. Добавляя новый столбец и предоставляя сводное представление данных, этот код существенно изменяет кадры данных.

Расчет полос Боллинджера

def bbands(price, length=30, numsd=2):
""" returns average, upper band, and lower band"""
#ave = pd.stats.moments.rolling_mean(price,length)
ave = price.rolling(window = length, center = False).mean()
#sd = pd.stats.moments.rolling_std(price,length)
sd = price.rolling(window = length, center = False).std()
upband = ave + (sd*numsd)
dnband = ave - (sd*numsd)
return np.round(ave,3), np.round(upband,3), np.round(dnband,3)

Ваш код определяет функцию, называемую «bbands», которая вычисляет полосы Боллинджера для заданного ценового ряда.

Что он делает, так это следующее:

Полосы Боллинджера могут быть рассчитаны с использованием трех аргументов: «цена» (ценовой ряд), «длина» (длина окна для расчета среднего значения и стандартного отклонения) и «numsd» (количество стандартных отклонений, используемых для расчета верхней и нижней полос).

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

Используя price.rolling(window=length, center=False).mean(), код вычисляет скользящую среднюю (среднюю) ценового ряда и присваивает ее переменной «ave». В ценовом ряду это вычисляет среднее значение для каждого окна длины «длины».

Используя price.rolling(window=length, center=False).std(), он вычисляет скользящее стандартное отклонение ценового ряда и присваивает его переменной «sd». В этом примере мы вычисляем стандартное отклонение для каждого окна длины «длины» в ценовом ряду.

Верхняя полоса рассчитывается путем добавления «numsd», умноженного на стандартное отклонение, к среднему значению: ave + (sd * numsd). Верхняя граница полос Боллинджера представлена этой линией.

Нижняя полоса вычисляется путем вычитания «numsd», умноженного на стандартное отклонение от среднего: ave — (sd * numsd). Нижняя граница полос Боллинджера представлена этой линией.

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

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

for stock in range(len(TechIndicator)):
TechIndicator[stock]['BB_Middle_Band'], TechIndicator[stock]['BB_Upper_Band'], TechIndicator[stock]['BB_Lower_Band'] = bbands(TechIndicator[stock]['Close'], length=20, numsd=1)
TechIndicator[stock]['BB_Middle_Band'] = TechIndicator[stock]['BB_Middle_Band'].fillna(0)
TechIndicator[stock]['BB_Upper_Band'] = TechIndicator[stock]['BB_Upper_Band'].fillna(0)
TechIndicator[stock]['BB_Lower_Band'] = TechIndicator[stock]['BB_Lower_Band'].fillna(0)
TechIndicator[0].tail()

В цикле for с переменной «stock» он выполняет итерацию по диапазону чисел от 0 до длины списка «TechIndicator». Используя этот цикл, мы можем работать с каждой акцией в списке «TechIndicator».

Используя цикл «TechIndicator», для каждой акции в индексе «stock»:

Функция «bbands» вычисляет полосы Боллинджера для цен закрытия акций («TechIndicator[stock][‘Close’]») длиной 20 и стандартным отклонением 1. В DataFrame текущего запаса создаются три новых столбца: «BB_Middle_Band», «BB_Upper_Band» и «BB_Lower_Band.».

С. fillna(0), он заполняет все отсутствующие значения (NaN) в столбцах «BB_Middle_Band», «BB_Upper_Band» и «BB_Lower_Band» 0.

С помощью функции .tail() он выводит последние несколько строк данных из первого DataFrame в списке «TechIndicator» (TechIndicator[0]).

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

Расчет осциллятора Aroon

def aroon(df, tf=25):
aroonup = []
aroondown = []
x = tf
while x< len(df['Date']):
aroon_up = ((df['High'][x-tf:x].tolist().index(max(df['High'][x-tf:x])))/float(tf))*100
aroon_down = ((df['Low'][x-tf:x].tolist().index(min(df['Low'][x-tf:x])))/float(tf))*100
aroonup.append(aroon_up)
aroondown.append(aroon_down)
x+=1
return aroonup, aroondown

В этом коде представлена функция с именем aroon, которая вычисляет индикаторы Aroon для DataFrame, содержащего финансовые данные. Индикаторы помогают анализировать силу и направление тенденций на финансовых рынках.

Для расчета показателей Aroon функции требуется два аргумента: DataFrame, содержащий финансовые данные, и период времени (со значением по умолчанию 25).

Функция инициализирует два пустых списка: «aroonup» и «aroondown». Значения, вычисленные этой функцией, будут храниться в этих списках.

Итерация по DataFrame при вычислении индикаторов Aroon требует, чтобы переменная с именем «x» была установлена в значение «tf». Цикл while продолжается до тех пор, пока «x» не достигнет длины столбца «Date» в DataFrame. Таким образом, диапазоны данных учитываются при выполнении расчетов.

В каждой итерации цикла значение Aroon Up вычисляется путем нахождения индекса наибольшего значения в столбце «Высокий» в пределах предыдущего количества периодов «tf». Процентное значение рассчитывается путем деления этого показателя на «tf» и умножения его на 100.

Точно так же значение Aroon Down рассчитывается на основе самого низкого значения в столбце «Низкий» за предыдущий период «tf». Кроме того, этот индекс делится на «tf» и умножается на 100.

Вычисленные значения Aroon Up и Aroon Down добавляются к спискам «aroonup» и «aroondown» соответственно. Переменная «x» увеличивается после каждой итерации, что позволяет циклу переходить к следующему периоду. Наконец, функция возвращает списки «aroonup» и «aroondown», которые содержат вычисленные значения Aroon Up и Aroon Down.

Заданный DataFrame финансовых данных используется для расчета показателей Aroon в предоставленном коде. Каждый раз, когда DataFrame перебирается, вычисляются значения Aroon Up и Aroon Down, и для каждого периода создаются отдельные списки. Возвращая эти списки, функция может оценить силу и направление тенденций финансовых рынков.

for stock in range(len(TechIndicator)):
listofzeros = [0] * 25
up, down = aroon(TechIndicator[stock])
aroon_list = [x - y for x, y in zip(up,down)]
if len(aroon_list)==0:
aroon_list = [0] * TechIndicator[stock].shape[0]
TechIndicator[stock]['Aroon_Oscillator'] = aroon_list
else:
TechIndicator[stock]['Aroon_Oscillator'] = listofzeros+aroon_list

Код вычисляет и присваивает значения осциллятора Aroon для каждой акции в списке «TechIndicator». Его функционал следующий:

Код инициирует цикл for, который проходит через диапазон чисел от 0 до длины списка «TechIndicator». Следующие шаги могут быть выполнены индивидуально на каждом прикладе с помощью этого цикла.

В цикле для каждой акции в списке «TechIndicator» по текущему индексу «акция»:

Создается список из 25 нулей, названный «listofzeros». Код будет использовать этот список позже.

В качестве аргумента данные по текущему запасу передаются в функцию «aroon». Эта функция, назначенная переменным «вверх» и «вниз», вычисляет значения Aroon Up и Aroon Down, характерные для акции.

Используя понимание списка, мы создаем новый список с именем «aroon_list». Значения осциллятора Aroon рассчитываются путем вычитания соответствующих элементов в списках «вверх» и «вниз».

Затем выполняется проверка, чтобы определить, имеет ли «aroon_list» нулевую длину. Тогда акция не имеет значений Aroon. При этом создается новый список, состоящий из нулей той же длины, что и данные акции (TechIndicator[stock]). Новому списку присваивается значение «aroon_list».

В качестве альтернативы, если «aroon_list» не равен нулю, значения Aroon были успешно рассчитаны. Код переходит к следующему шагу, не изменяя «aroon_list».

Наконец, код присваивает значения «aroon_list» новому столбцу с именем «Aroon_Oscillator» в DataFrame, относящемся к текущему запасу (TechIndicator[stock]). При использовании конкатенации списков, если «aroon_list» не является пустым, его значения добавляются в начало «listofzeros». «Aroon_Oscillator» присваиваются значения «aroon_list», если «aroon_list» пусто, что означает, что значения Aroon не были рассчитаны.

Расчет тренда объема цен

for stock in range(len(TechIndicator)):
TechIndicator[stock]["PVT"] = (TechIndicator[stock]['Momentum_1D']/ TechIndicator[stock]['Close'].shift(1))*TechIndicator[stock]['Volume']
TechIndicator[stock]["PVT"] = TechIndicator[stock]["PVT"]-TechIndicator[stock]["PVT"].shift(1)
TechIndicator[stock]["PVT"] = TechIndicator[stock]["PVT"].fillna(0)
TechIndicator[0].tail()

Код вычисляет и заполняет значения Price Volume Trend (PVT) для каждой акции в списке «TechIndicator». Ниже приведены некоторые из его особенностей:

Цикл for используется для перебора диапазона чисел от 0 до длины списка «TechIndicator». Используя этот цикл, каждый запас может быть обработан индивидуально.

Для каждой акции в текущем индексе «акция» списка «TechIndicator»:

В DataFrame создается новый столбец с именем «PVT». Рассчитанные значения PVT будут храниться в этом столбце.

Чтобы рассчитать значение PVT, мы делим однодневный импульс («Momentum_1D») на цену закрытия предыдущего дня (столбец «Закрытие» в момент времени t-1). Умножьте результат на текущий объем торгов («Объем»). Целью этого расчета является оценка взаимосвязи между изменениями цен и объемом торгов.

Путем вычитания полученного значения PVT из значения PVT предыдущего дня определяется изменение PVT. На этом шаге можно отслеживать тенденции PVT с течением времени.

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

Код выводит последние несколько строк данных из первого DataFrame в списке «TechIndicator» (TechIndicator[0]) с помощью функции .tail(). В результате мы видим значения PVT для первой акции.

В целом, код вычисляет и добавляет значения тренда ценового объема (PVT) в кадры данных каждой акции в списке «TechIndicator». Для расчета значений PVT учитывается однодневный импульс, предыдущие цены закрытия и объем торгов. Если какие-либо значения отсутствуют, они заполняются 0. В DataFrame для первого запаса код отображает последние несколько строк данных PVT. В финансовом анализе PVT используется для анализа взаимодействия между движением цен и объемами торгов.

Расчет полос ускорения

def abands(df):
#df['AB_Middle_Band'] = pd.rolling_mean(df['Close'], 20)
df['AB_Middle_Band'] = df['Close'].rolling(window = 20, center=False).mean()
# High * ( 1 + 4 * (High - Low) / (High + Low))
df['aupband'] = df['High'] * (1 + 4 * (df['High']-df['Low'])/(df['High']+df['Low']))
df['AB_Upper_Band'] = df['aupband'].rolling(window=20, center=False).mean()
# Low *(1 - 4 * (High - Low)/ (High + Low))
df['adownband'] = df['Low'] * (1 - 4 * (df['High']-df['Low'])/(df['High']+df['Low']))
df['AB_Lower_Band'] = df['adownband'].rolling(window=20, center=False).mean()

Его код выполняет следующие задачи:

DataFrame, содержащий финансовые данные, представлен аргументом «df» в функции.

Первое, что он делает, это вводит новый столбец в DataFrame с именем «AB_Middle_Band». Значения этого столбца определяются путем вычисления скользящего среднего (среднего) столбца «Закрыть» за период в 20 периодов. Использование .rolling(window=20, center=False).mean() упрощает это вычисление.

Код вычисляет значения верхней полосы путем умножения значений в столбце «Высокий» на коэффициент, полученный из разницы между соответствующими значениями в столбцах «Высокий» и «Низкий». К коэффициенту умножения применяется одноразовое приращение. Столбец с именем «aupband» содержит вычисленные значения.

С помощью функции .rolling(window=20, center=False).mean() в DataFrame создается новый столбец с именем «AB_Upper_Band». В этом столбце вычисляется скользящее среднее значение с использованием окна в 20 периодов.

Код вычисляет значения нижнего диапазона путем умножения значений в столбце «Низкий» на разницу между соответствующими значениями в столбцах «Высокий» и «Низкий». Вычитание этого множителя из 1 приводит к коэффициенту умножения. Для временного хранения полученных значений используется столбец «adownband».

DataFrame также содержит столбец с именем «AB_Lower_Band». С помощью функции .rolling(window=20, center=False).mean() в этом столбце вычисляется скользящее среднее за окно в 20 периодов.

Abands — это функция, определенная в предоставленном коде, которая вычисляет полосы ускорения для заданного DataFrame. В этой функции к DataFrame добавляются три столбца: «AB_Middle_Band», «AB_Upper_Band» и «AB_Lower_Band». Средняя полоса представляет собой скользящую среднюю цен закрытия, в то время как верхняя и нижняя полосы определяются путем умножения максимальной и минимальной цен соответственно с соответствующими коэффициентами, полученными из их различий. Расчет скользящего среднего используется для сглаживания значений этих полос за 20-периодный период. В техническом анализе полосы ускорения широко используются для определения потенциальных уровней цен и рыночных тенденций.

for stock in range(len(TechIndicator)):
abands(TechIndicator[stock])
TechIndicator[stock] = TechIndicator[stock].fillna(0)
TechIndicator[0].tail()

Этот код, полосы ускорения, рассчитываются и обрабатываются для каждой акции в списке «TechIndicator» следующим образом:

Цикл for выполняет итерацию по акциям в списке «TechIndicator», при этом переменная цикла «stock» представляет индекс каждой акции.

Для каждой акции в цикле:

В качестве аргумента функции «abands» передается DataFrame текущей акции (TechIndicator[stock]). Добавляя средний, верхний и нижний столбцы в DataFrame, эта функция вычисляет полосы ускорения.

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

Наконец, код выводит последние несколько строк данных из первого DataFrame (TechIndicator[0]) с помощью функции .tail(). В этом примере мы видим моментальный снимок DataFrame после обработки и вычисления последних данных.

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

Удаление ненужных столбцов

columns2Drop = ['Momentum_1D', 'aupband', 'adownband']
for stock in range(len(TechIndicator)):
TechIndicator[stock] = TechIndicator[stock].drop(labels = columns2Drop, axis=1)
TechIndicator[0].head()

На первом шаге список «columns2Drop» инициализируется тремя столбцами: «Momentum_1D», «aupband» и «adownband». В DataFrame каждого запаса эти столбцы должны быть удалены.

После этого используется цикл for для перебора диапазона чисел от 0 до длины списка «TechIndicator». В результате этого цикла можно оперировать каждой акцией в списке.

В цикле для каждой акции в списке «TechIndicator» по текущему индексу «акция»:

В этом коде указанные столбцы удаляются с помощью функции .drop() в DataFrame, соответствующем текущему запасу (TechIndicator[stock]). В параметре labels «columns2Drop» задается список столбцов для удаления. Кроме того, для параметра оси установлено значение 1, что означает, что столбцы будут удалены, а не строки.

Затем DataFrame обновляется, чтобы отразить удаление указанных столбцов из текущего фонда.

Наконец, код выводит первые несколько строк из DataFrame первого запаса в списке «TechIndicator» (TechIndicator[0]) с помощью функции .head(). Здесь отображается измененный DataFrame после удаления указанных столбцов.

Код последовательно проходит каждую акцию в списке «TechIndicator» и удаляет определенные столбцы из их кадров данных. «Columns2Drop» перечисляет столбцы, которые необходимо удалить. В результате процесса удаления столбцов код выводит начальные строки данных из DataFrame первого фонда.

Расчет стохастического осциллятора (%K и %D)

def STOK(df, n):
df['STOK'] = ((df['Close'] - df['Low'].rolling(window=n, center=False).mean()) / (df['High'].rolling(window=n, center=False).max() - df['Low'].rolling(window=n, center=False).min())) * 100
df['STOD'] = df['STOK'].rolling(window = 3, center=False).mean()

Код определяет функцию с именем «STOK», которая отвечает за вычисление стохастического осциллятора для заданного DataFrame финансовых данных.

Вот подробное описание того, что делает код:

Функция принимает два аргумента: «df», который представляет DataFrame, содержащий финансовые данные, и «n», который указывает количество периодов, которые следует учитывать для вычислений.

В функции в DataFrame добавляется новый столбец с именем «STOK». В этом столбце представлено значение стохастического осциллятора %K. Значение %K вычисляется следующим образом:

Скользящее среднее столбца «Минимум» по окну из «n» периодов вычитается из соответствующих значений в столбце «Закрыть». Результат шага 1 делится на разницу между скользящим максимумом столбца «Высокий» и скользящим минимумом столбца «Низкий», которые вычисляются за период из «n» периодов. Наконец, полученное значение умножают на 100, чтобы выразить его в процентах. Кроме того, в коде вводится еще один столбец с именем «STOD» в DataFrame. В этом столбце представлено значение %D стохастического осциллятора, которое вычисляется как простая скользящая средняя столбца «STOK» за окно в 3 периода.

for stock in range(len(TechIndicator)):
STOK(TechIndicator[stock], 4)
TechIndicator[stock] = TechIndicator[stock].fillna(0)
TechIndicator[0].tail()

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

Он использует цикл for для перебора диапазона чисел от 0 до длины списка «TechIndicator». Этот цикл позволяет выполнять операции с каждой акцией в списке «TechIndicator».

В цикле для каждой акции, находящейся в индексе «акция» в списке «TechIndicator»:

Код вызывает функцию «STOK», передавая DataFrame текущей акции (TechIndicator[stock]) и значение 4 в качестве аргументов. Эта функция вычисляет значения стохастического осциллятора %K для указанного DataFrame с учетом окна в 4 периода. После вычисления значений стохастического осциллятора %K для каждой акции код переходит к дальнейшей обработке DataFrame каждой акции:

Он использует функцию .fillna(0) для замены любых отсутствующих значений (NaN) в DataFrame нулями. Этот шаг гарантирует, что все точки данных в DataFrame содержат числовые значения. Наконец, код использует функцию .tail() для вывода последних нескольких строк данных из DataFrame первого запаса в списке «TechIndicator» (TechIndicator[0]). Это дает представление об измененном DataFrame после вычислений и обработки.

Расчет денежного потока Чайкина

def CMFlow(df, tf):
CHMF = []
MFMs = []
MFVs = []
x = tf

while x < len(df['Date']):
PeriodVolume = 0
volRange = df['Volume'][x-tf:x]
for eachVol in volRange:
PeriodVolume += eachVol

MFM = ((df['Close'][x] - df['Low'][x]) - (df['High'][x] - df['Close'][x])) / (df['High'][x] - df['Low'][x])
MFV = MFM*PeriodVolume

MFMs.append(MFM)
MFVs.append(MFV)
x+=1

y = tf
while y < len(MFVs):
PeriodVolume = 0
volRange = df['Volume'][x-tf:x]
for eachVol in volRange:
PeriodVolume += eachVol
consider = MFVs[y-tf:y]
tfsMFV = 0

for eachMFV in consider:
tfsMFV += eachMFV

tfsCMF = tfsMFV/PeriodVolume
CHMF.append(tfsCMF)
y+=1
return CHMF

Код определяет функцию CMFlow, которая вычисляет показатель денежного потока Чайкина (CMF) для заданного DataFrame финансовых данных. Индикатор CMF — это метрика, основанная на объеме, используемая в техническом анализе для оценки потока денег в ценную бумагу или из нее, что указывает на давление покупки или продажи.

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

Затем функция принимает два аргумента: df, представляющий DataFrame, содержащий финансовые данные, и tf, представляющий временной интервал или период, за который следует вычислить CMF.

Затем функция входит в цикл while, который продолжается до тех пор, пока переменная x не достигнет длины столбца Date в DataFrame. В рамках каждой итерации цикла выполняется несколько вычислений.

Во-первых, функция вычисляет PeriodVolume, суммируя значения объема из столбца Volume в пределах предыдущего tf-числа периодов. Это значение представляет собой общий объем за указанный период времени.

Далее рассчитывается мультипликатор денежного потока (MFM). Он определяется путем деления разницы между ценой закрытия и средней точкой максимальной и минимальной цен на разницу между максимальной и минимальной ценами. MFM указывает на силу движения цены в течение данного периода.

Затем объем денежного потока (MFV) рассчитывается путем умножения множителя денежного потока (MFM) на PeriodVolume. Это значение представляет собой объем, скорректированный движением цены.

Вычисленные MFM добавляются к списку MFM, а вычисляемые MFV добавляются к списку MFV.

После каждой итерации переменная x увеличивается на 1 для перехода к следующему периоду.

После завершения первого цикла while функция инициализирует другую переменную y до значения tf. Затем он входит во второй цикл while, который продолжается до тех пор, пока y не достигнет длины списка MFV.

В этом цикле функция выполняет вычисления, аналогичные вычислениям в предыдущем цикле. Он вычисляет PeriodVolume путем суммирования значений объема из столбца Volume в пределах предыдущего tf количества периодов. Он также учитывает диапазон значений MFV в пределах предыдущего tf количества периодов.

Общий объем денежного потока (tfsMFV) рассчитывается путем суммирования значений в рассматриваемом диапазоне. Это представляет собой совокупный объем денежного потока в течение указанного периода времени.

Наконец, денежный поток Чайкина (CMF) рассчитывается путем деления общего объема денежного потока (tfsMFV) на PeriodVolume. Значение CMF указывает на давление покупателей или продавцов в течение заданного периода времени.

Рассчитанный CMF добавляется к списку CHMF, а переменная y увеличивается на 1 для перехода к следующему периоду.

После завершения второго цикла while функция возвращает список значений CMF (CHMF).

for stock in range(len(TechIndicator)):
listofzeros = [0] * 40
CHMF = CMFlow(TechIndicator[stock], 20)
if len(CHMF)==0:
CHMF = [0] * TechIndicator[stock].shape[0]
TechIndicator[stock]['Chaikin_MF'] = CHMF
else:
TechIndicator[stock]['Chaikin_MF'] = listofzeros+CHMF
TechIndicator[0].tail()

Этот фрагмент кода выполняет ряд операций по вычислению и присвоению значений денежного потока Чайкина (CMF) кадру данных TechIndicator.

Во-первых, код выполняет итерацию по диапазону значений на основе длины списка TechIndicator, который представляет различные акции.

В каждой итерации создается список с именем «listofzeros», состоящий из 40 нулей.

Затем значения CMF для текущих акций рассчитываются с использованием функции CMFlow с временным интервалом 20.

Далее код проверяет длину списка CMF. Если значение равно 0, указывающее, что значения CMF не были рассчитаны, столбцу «Chaikin_MF» кадра данных TechIndicator[stock] присваивается список нулей. Длина этого списка совпадает с данными в кадре DataFrame TechIndicator[stock].

С другой стороны, если список CMF не пуст, код объединяет listofzeros со списком CMF и присваивает результирующий список столбцу «Chaikin_MF» кадра данных TechIndicator[stock].

Наконец, в коде отображаются последние несколько строк кадра данных TechIndicator[0].

Расчет параболического SAR

def psar(df, iaf = 0.02, maxaf = 0.2):
length = len(df)
dates = (df['Date'])
high = (df['High'])
low = (df['Low'])
close = (df['Close'])
psar = df['Close'][0:len(df['Close'])]
psarbull = [None] * length
psarbear = [None] * length
bull = True
af = iaf
ep = df['Low'][0]
hp = df['High'][0]
lp = df['Low'][0]
for i in range(2,length):
if bull:
psar[i] = psar[i - 1] + af * (hp - psar[i - 1])
else:
psar[i] = psar[i - 1] + af * (lp - psar[i - 1])
reverse = False
if bull:
if df['Low'][i] < psar[i]:
bull = False
reverse = True
psar[i] = hp
lp = df['Low'][i]
af = iaf
else:
if df['High'][i] > psar[i]:
bull = True
reverse = True
psar[i] = lp
hp = df['High'][i]
af = iaf
if not reverse:
if bull:
if df['High'][i] > hp:
hp = df['High'][i]
af = min(af + iaf, maxaf)
if df['Low'][i - 1] < psar[i]:
psar[i] = df['Low'][i - 1]
if df['Low'][i - 2] < psar[i]:
psar[i] = df['Low'][i - 2]
else:
if df['Low'][i] < lp:
lp = df['Low'][i]
af = min(af + iaf, maxaf)
if df['High'][i - 1] > psar[i]:
psar[i] = df['High'][i - 1]
if df['High'][i - 2] > psar[i]:
psar[i] = df['High'][i - 2]
if bull:
psarbull[i] = psar[i]
else:
psarbear[i] = psar[i]
#return {"dates":dates, "high":high, "low":low, "close":close, "psar":psar, "psarbear":psarbear, "psarbull":psarbull}
#return psar, psarbear, psarbull
df['psar'] = psar
#df['psarbear'] = psarbear
#df['psarbull'] = psarbull

Этот код определяет функцию под названием psar, которая вычисляет индикатор Parabolic Stop and Reverse (PSAR) для заданного DataFrame финансовых данных. PSAR — это индикатор следования за трендом, используемый в техническом анализе для определения потенциальных точек разворота ценового тренда ценной бумаги.

Функция принимает три аргумента: df (DataFrame, содержащий финансовые данные), iaf (начальный коэффициент ускорения, по умолчанию равный 0,02) и maxaf (максимальный коэффициент ускорения, по умолчанию равный 0,2).

Функция инициализирует несколько переменных и списков на основе входного DataFrame. Он извлекает столбцы «Дата», «Высокий», «Низкий» и «Закрыть» из DataFrame и назначает их соответствующим переменным для удобства. Он также инициализирует список «psar» теми же значениями, что и столбец «Закрыть».

Затем функция вводит цикл for, который итерируется от индекса 2 до длины DataFrame. В рамках каждой итерации значения PSAR рассчитываются на основе текущего тренда (бычьего или медвежьего).

Если текущий тренд бычий, значение PSAR обновляется путем добавления коэффициента ускорения (af), умноженного на разницу между самой высокой ценой (hp) и предыдущим значением PSAR. Если тренд медвежий, значение PSAR обновляется путем сложения af, умноженного на разницу между самой низкой ценой (lp) и предыдущим значением PSAR.

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

Функция также регулирует коэффициент ускорения в зависимости от определенных условий. Если тренд бычий и текущая максимальная цена выше, чем предыдущая самая высокая цена (hp), hp обновляется, и af увеличивается до максимального коэффициента ускорения (maxaf). Аналогичные поправки вносятся и на медвежьи тренды.

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

Значения PSAR для каждой итерации хранятся в списке «psar», в то время как отдельные списки («psarbear» и «psarbull») создаются для отслеживания значений PSAR для медвежьего и бычьего трендов соответственно.

Наконец, функция назначает список ‘psar’ в качестве нового столбца (‘psar’) во входном DataFrame (‘df’).

Расчет средневзвешенной цены по объему

for stock in range(len(TechIndicator)):
TechIndicator[stock]['VWAP'] = np.cumsum(TechIndicator[stock]['Volume'] * (TechIndicator[stock]['High'] + TechIndicator[stock]['Low'])/2) / np.cumsum(TechIndicator[stock]['Volume'])
TechIndicator[stock] = TechIndicator[stock].fillna(0)
TechIndicator[0].tail()

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

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

Он умножает объем каждой сделки на среднее значение высоких и низких цен этой сделки. Он вычисляет кумулятивную сумму этих значений. Он делит кумулятивную сумму взвешенных по объему цен на кумулятивную сумму объема для получения значений VWAP. Затем вычисленные значения VWAP присваиваются новому столбцу с именем VWAP в кадре данных TechIndicator[stock].

После вычисления VWAP для каждой акции код заполняет все отсутствующие значения или значения NaN (не число) в DataFrame с 0.

Наконец, в коде отображаются последние несколько строк данных для первой акции в списке TechIndicator (TechIndicator[0]), включая недавно добавленный столбец VWAP.

Расчет импульса

for stock in range(len(TechIndicator)):
TechIndicator[stock]['Momentum'] = TechIndicator[stock]['Close'] - TechIndicator[stock]['Close'].shift(4)
TechIndicator[stock] = TechIndicator[stock].fillna(0)
TechIndicator[0].tail()

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

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

Он вычитает цену закрытия текущего периода из цены закрытия периода четыре периода назад. Эта разница представляет собой скорость изменения или импульс цены акции за указанный период. Затем вычисленные значения импульса присваиваются новому столбцу с именем «Momentum» в кадре данных TechIndicator[stock].

После вычисления импульса для каждой акции код заполняет все отсутствующие значения или значения NaN (не число) в DataFrame с 0.

Наконец, в коде отображаются последние несколько строк данных для первой акции в списке TechIndicator (TechIndicator[0]), включая недавно добавленный столбец «Momentum».

Расчет индекса товарного канала

def CCI(df, n, constant):
TP = (df['High'] + df['Low'] + df['Close']) / 3
CCI = pd.Series((TP - TP.rolling(window=n, center=False).mean()) / (constant * TP.rolling(window=n, center=False).std())) #, name = 'CCI_' + str(n))
return CCI

этот код определяет функцию CCI (Commodity Channel Index), которая вычисляет индикатор CCI для заданного DataFrame финансовых данных. CCI является популярным инструментом технического анализа, используемым для выявления потенциальных условий перекупленности или перепроданности ценной бумаги.

Функция принимает три аргумента: df (DataFrame, содержащий финансовые данные), n (количество периодов, которые следует учитывать при расчете CCI) и constant (постоянное значение, используемое в формуле CCI).

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

Затем значения CCI вычисляются по формуле CCI: CCI = (TP — скользящее среднее TP за n периодов) / (константа * скользящее стандартное отклонение TP за n периодов)

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

Результирующие значения CCI хранятся в объекте pandas Series.

Наконец, функция возвращает серию CCI.

Подводя итог, можно сказать, что этот код определяет функцию, которая вычисляет индекс товарного канала (CCI) для заданного DataFrame финансовых данных. Он вычисляет истинную цену (среднее значение максимальных, минимальных и закрытых цен), а затем вычисляет CCI, используя скользящее среднее и стандартное отклонение истинной цены за указанное количество периодов. Функция возвращает значения CCI в виде pandas Series.

Расчет балансового объема

for stock in range(len(TechIndicator)):
new = (TechIndicator[stock]['Volume'] * (~TechIndicator[stock]['Close'].diff().le(0) * 2 -1)).cumsum()
TechIndicator[stock]['OBV'] = new
TechIndicator[5].tail()

этот код вычисляет индикатор балансового объема (OBV) для каждой акции в списке TechIndicator. OBV — это инструмент технического анализа, используемый для оценки совокупного давления покупки или продажи ценной бумаги на основе объема.

Код выполняет итерации по диапазону фондовых индексов в списке TechIndicator. В рамках каждой итерации он выполняет следующие операции:

Он вычисляет новый ряд, называемый «новым», умножая объем каждого периода на двоичное значение, которое показывает, является ли изменение цены по сравнению с предыдущим периодом положительным или отрицательным. Если изменение цены положительное, двоичное значение равно 1, а если изменение цены отрицательное или нулевое, двоичное значение равно -1. Это достигается путем оценки состояния ~TechIndicator[stock][‘Close’].diff().le(0) * 2 -1. Он применяет операцию кумулятивной суммы (cumsum()) к «новому» ряду. Он присваивает вычисленные значения «нового» ряда новому столбцу с именем «OBV» в кадре данных TechIndicator[stock]. После вычисления OBV для каждой акции в коде отображаются последние несколько строк данных для шестой акции в списке TechIndicator (TechIndicator[5]), включая недавно добавленный столбец «OBV».

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

Калькуальация каналов Кельтнера

#Keltner Channel  
def KELCH(df, n):
KelChM = pd.Series(((df['High'] + df['Low'] + df['Close']) / 3).rolling(window =n, center=False).mean(), name = 'KelChM_' + str(n))
KelChU = pd.Series(((4 * df['High'] - 2 * df['Low'] + df['Close']) / 3).rolling(window =n, center=False).mean(), name = 'KelChU_' + str(n))
KelChD = pd.Series(((-2 * df['High'] + 4 * df['Low'] + df['Close']) / 3).rolling(window =n, center=False).mean(), name = 'KelChD_' + str(n))
return KelChM, KelChD, KelChU

этот код определяет функцию под названием KELCH (канал Кельтнера), которая вычисляет индикатор канала Кельтнера для заданного DataFrame финансовых данных. Канал Кельтнера — это инструмент технического анализа, используемый для выявления потенциальных ценовых прорывов и определения условий перекупленности или перепроданности.

Функция принимает два аргумента: df (DataFrame, содержащий финансовые данные) и n (количество периодов, которые следует учитывать для вычисления канала Кельтнера).

В рамках функции значения канала Кельтнера вычисляются по следующим формулам:

KelChM: Он рассчитывается как скользящее среднее значение средних цен максимума, минимума и закрытия каждого периода. KelChU: Он рассчитывается как скользящее среднее модифицированной формулы, основанной на максимальных, низких и закрытых ценах. KelChD: Он рассчитывается как скользящее среднее по другой модифицированной формуле, основанной на максимальных, низких и закрытых ценах. Скользящее среднее вычисляется с помощью функции rolling() в пандах с размером окна n периодов.

Вычисленные значения канала Кельтнера хранятся в объектах серии pandas с именами ‘KelChM’, ‘KelChD’ и ‘KelChU’.

Наконец, функция возвращает три объекта Series, представляющие значения канала Кельтнера: KelChM, KelChD и KelChU.

for stock in range(len(TechIndicator)):
KelchM, KelchD, KelchU = KELCH(TechIndicator[stock], 14)
TechIndicator[stock]['Kelch_Upper'] = KelchU
TechIndicator[stock]['Kelch_Middle'] = KelchM
TechIndicator[stock]['Kelch_Down'] = KelchD
TechIndicator[stock] = TechIndicator[stock].fillna(0)
TechIndicator[5].tail()

этот код вычисляет индикатор канала Кельтнера для каждой акции в списке TechIndicator и добавляет вычисленные значения в DataFrame.

Код выполняет итерации по диапазону фондовых индексов в списке TechIndicator. В рамках каждой итерации он выполняет следующие операции:

Он вызывает функцию KELCH() с текущими данными по акциям (TechIndicator[stock]) и периодом 14. Функция KELCH() возвращает три объекта pandas Series, представляющие значения канала Кельтнера: KelchM, KelchD и KelchU. Код присваивает значения из KelchU новому столбцу с именем «Kelch_Upper» в кадре данных TechIndicator[stock]. Точно так же он присваивает значения из KelchM новому столбцу с именем «Kelch_Middle», а значения из KelchD — новому столбцу с именем «Kelch_Down» в том же DataFrame. Он заполняет все отсутствующие значения или значения NaN (не число) в DataFrame 0. Процесс повторяется для каждой акции в списке TechIndicator. Наконец, в коде отображаются последние несколько строк данных для шестой акции в списке TechIndicator (TechIndicator[5]), который теперь включает недавно добавленные столбцы «Kelch_Upper», «Kelch_Middle» и «Kelch_Down».

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

Расчет индекса среднего направленного движения (ADX)

def DMI(df, period):
df['UpMove'] = df['High'] - df['High'].shift(1)
df['DownMove'] = df['Low'].shift(1) - df['Low']
df['Zero'] = 0

df['PlusDM'] = np.where((df['UpMove'] > df['DownMove']) & (df['UpMove'] > df['Zero']), df['UpMove'], 0)
df['MinusDM'] = np.where((df['UpMove'] < df['DownMove']) & (df['DownMove'] > df['Zero']), df['DownMove'], 0)

df['plusDI'] = 100 * (df['PlusDM']/df['ATR']).ewm(span=period,min_periods=0,adjust=True,ignore_na=False).mean()
df['minusDI'] = 100 * (df['MinusDM']/df['ATR']).ewm(span=period,min_periods=0,adjust=True,ignore_na=False).mean()

df['ADX'] = 100 * (abs((df['plusDI'] - df['minusDI'])/(df['plusDI'] + df['minusDI']))).ewm(span=period,min_periods=0,adjust=True,ignore_na=False).mean()

Код определяет функцию под названием DMI (Directional Movement Index), которая вычисляет несколько показателей, связанных с направленным движением для данного DataFrame финансовых данных.

Функция принимает два аргумента: df, который представляет DataFrame, содержащий финансовые данные, и period, который указывает период, за который должны быть рассчитаны показатели.

Внутри функции код выполняет следующие действия:

Он вычисляет разницу между самой высокой ценой текущего периода (High) и самой высокой ценой предыдущего периода, сохраняя результат в столбце «UpMove». Он вычисляет разницу между самой низкой ценой предыдущего периода (Low) и самой низкой ценой текущего периода, сохраняя результат в столбце «DownMove». Он создает новый столбец с именем «Ноль» со всеми значениями, установленными на 0. Он определяет значения для столбца «PlusDM» на основе условий. Если значение «UpMove» больше, чем «DownMove» и «Zero», столбцу «PlusDM» присваивается значение «UpMove»; в противном случае устанавливается значение 0. Он определяет значения для столбца «МинусDM» аналогичным образом. Если значение «UpMove» меньше значений «DownMove» и «Zero», столбцу «MinusDM» присваивается значение «DownMove»; в противном случае устанавливается значение 0. Он вычисляет столбец «plusDI», принимая экспоненциально взвешенную скользящую среднюю (ewm) отношения «PlusDM» к «ATR» (средний истинный диапазон). ewm вычисляется с диапазоном, равным указанному периоду. Он вычисляет столбец «minusDI» аналогичным образом, используя ewm отношения «MinusDM» к «ATR». Он вычисляет столбец «ADX» как экспоненциально взвешенную скользящую среднюю абсолютного значения разницы между «plusDI» и «minusDI», деленную на сумму «plusDI» и «minusDI». ewm вычисляется с диапазоном, равным указанному периоду. Таким образом, код определяет функцию, которая вычисляет несколько индикаторов, связанных с индексом направленного движения (DMI) для заданного DataFrame. К таким индикаторам относятся индикатор направления «плюс» (+DI), индикатор направления «минус» (-DI) и индекс среднего направления (ADX). Расчеты основаны на «Максимуме», «Минимуме», «ATR» и ранее рассчитанных значениях движения.

for stock in range(len(TechIndicator)):
DMI(TechIndicator[stock], 14)
TechIndicator[stock] = TechIndicator[stock].fillna(0)
TechIndicator[5].tail()

Код выполняет итерации по диапазону фондовых индексов в списке TechIndicator. В каждой итерации он применяет функцию DMI для расчета индикаторов индекса направленного движения (DMI) для соответствующей акции в списке TechIndicator. Период расчета показателей DMI установлен равным 14. Вычисленные индикаторы DMI не назначаются и не сохраняются напрямую, так как функция DMI изменяет DataFrame на месте. После вычисления показателей DMI для каждой акции код заполняет все отсутствующие значения в каждом кадре данных 0. Наконец, в коде отображаются последние несколько строк данных по шестой акции в списке TechIndicator (TechIndicator[5]), который теперь включает рассчитанные индикаторы DMI.

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

Визуализация технических индикаторов

for stock in range(len(TechIndicator)):
TechIndicator[stock].index = TechIndicator[stock]['Date']
TechIndicator[stock] = TechIndicator[stock].drop(labels = ['Date'], axis = 1)

предоставленный код выполняет итерации по диапазону фондовых индексов в списке TechIndicator. В рамках каждой итерации он выполняет следующие операции:

Он назначает столбец «Date» DataFrame TechIndicator[stock] в качестве нового индекса для этого DataFrame. Это означает, что индекс DataFrame будет равен значениям в столбце Date. Он удаляет столбец ‘Date’ из DataFrame TechIndicator[stock] с помощью функции drop(). Для параметра labels задано значение «Дата», а для параметра axis — значение 1, указывающее на удаление столбца. Установив индекс в столбец «Date» и удалив сам столбец «Date», этот код по существу преобразует DataFrame таким образом, что столбец «Date» больше не является отдельным столбцом, а вместо этого служит индексом для DataFrame.

%matplotlib inline

# RSI Plot

fig = plt.figure(figsize=(20,25))
for i in range(8):
ax = plt.subplot(4,2,i+1)
ax.plot(TechIndicator[i].index, TechIndicator[i]['RSI_14D'])
ax.set_title(str(TechIndicator[i]['Label'][0]))
ax.set_xlabel("Date")
ax.set_ylabel("Relative Strength Index")
plt.xticks(rotation=30)
fig.tight_layout()

этот код генерирует график индекса относительной силы (RSI) для нескольких акций с использованием данных TechIndicator.

Во-первых, %matplotlib inline — это директива, которая позволяет отображать графики в среде записной книжки Jupyter.

Затем код создает фигурный объект с заданным размером. На этом рисунке цикл выполняет итерацию в диапазоне 8, указывая количество создаваемых подграфиков.

Для каждой итерации с помощью функции plt.subplot() создается подграфик, а значения RSI (TechIndicator[i][‘RSI_14D’]) соответствующей акции строятся в зависимости от соответствующих дат (TechIndicator[i].index).

Заголовок каждого подучастка устанавливается в соответствии с первым значением столбца «Метка» для соответствующего запаса. Метка по оси X имеет значение «Дата», а метка по оси Y — «Индекс относительной силы». Метки тиков по оси X повернуты на 30 градусов для лучшей читаемости.

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке.

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

# Volume Plain plot
fig = plt.figure(figsize=(20,25))
for i in range(8):
ax = plt.subplot(8,1,i+1)
ax.plot(TechIndicator[i].index, TechIndicator[i]['Volume_plain'], 'b')
ax.set_title(str(TechIndicator[i]['Label'][0]))
ax.set_xlabel("Date")
ax.set_ylabel("Volume")
plt.xticks(rotation=30)
fig.tight_layout()

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

Код начинается с создания фигурного объекта с заданным размером. На этом рисунке цикл выполняет итерацию в диапазоне 8, указывая количество создаваемых подграфиков.

Для каждой итерации создается подграфик с помощью функции plt.subplot(). Данные об объеме (TechIndicator[i][‘Volume_plain’]) соответствующей акции строятся в зависимости от соответствующих дат (TechIndicator[i].index) с использованием синей линии.

Заголовок каждого подучастка устанавливается в соответствии с первым значением столбца «Метка» для соответствующего запаса. Метка по оси X имеет значение «Дата», а метка по оси Y — «Объем». Метки тиков по оси X повернуты на 30 градусов для лучшей читаемости.

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке.

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

plt.style.use('fivethirtyeight')

fig = plt.figure(figsize=(20,25))
for i in range(8):
ax = plt.subplot(4,2,i+1)
ax.fill_between(TechIndicator[i].index, TechIndicator[i]['BB_Upper_Band'], TechIndicator[i]['BB_Lower_Band'], color='grey', label="Band Range")
# Plot Adjust Closing Price and Moving Averages
ax.plot(TechIndicator[i].index, TechIndicator[i]['Close'], color='red', lw=2, label="Close")
ax.plot(TechIndicator[i].index, TechIndicator[i]['BB_Middle_Band'], color='black', lw=2, label="Middle Band")
ax.set_title("Bollinger Bands for " + str(TechIndicator[i]['Label'][0]))
ax.legend()
ax.set_xlabel("Date")
ax.set_ylabel("Close Prices")
plt.xticks(rotation=30)
fig.tight_layout()
#.dt.to_pydatetime()

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

Код начинается с установки стиля сюжета на «fivethirtyeight», что придает сюжету особый внешний вид.

Создается фигурный объект fig с заданным размером. На этом рисунке цикл выполняет итерацию в диапазоне 8, указывая количество создаваемых подграфиков.

Для каждой итерации создается подграфик с помощью функции plt.subplot(). Полосы Боллинджера отображаются на заднем плане в виде закрашенной области с помощью функции fill_between(). Значения верхнего канала берутся из столбца «BB_Upper_Band», а значения нижнего канала — из столбца «BB_Lower_Band». Цвет устанавливается на серый, а метка указывается как «Диапазон диапазонов».

Цены закрытия (Close) для соответствующей акции отображаются красным цветом в виде линейного графика, указывающего на движение цены во времени. Значения средней полосы (BB_Middle_Band) также отображаются в виде линейного графика черного цвета, представляющего средний ценовой тренд.

Заголовок каждого подучастка имеет значение «Полосы Боллинджера для [биржевой этикетки]», где биржевая метка извлекается из столбца «Метка» для соответствующей акции. К сюжету добавляется легенда для дифференциации линий.

Метка по оси X имеет значение «Дата», а метка по оси Y — «Цены закрытия». Метки тиков по оси X повернуты на 30 градусов для лучшей читаемости.

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке.

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

# Aroon Oscillator Plot
plt.style.use('seaborn-whitegrid')
fig = plt.figure(figsize=(20,25))
for i in range(8):
ax = plt.subplot(4,2,i+1)
ax.fill(TechIndicator[i].index, TechIndicator[i]['Aroon_Oscillator'],'g', alpha = 0.5, label = "Aroon Oscillator")
ax.plot(TechIndicator[i].index, TechIndicator[i]['Close'], 'r', label="Close")
ax.set_title("Aroon Oscillator for " +str(TechIndicator[i]['Label'][0]))
ax.legend()
ax.set_xlabel("Date")
ax.set_ylabel("Close Prices")
plt.xticks(rotation=30)
fig.tight_layout()

этот код генерирует график осциллятора Aroon для нескольких акций с использованием набора данных TechIndicator.

Код начинается с установки стиля графика на «seaborn-whitegrid», что придает сюжету особый внешний вид с белым фоном сетки.

Создается фигурный объект fig с заданным размером. На этом рисунке цикл выполняет итерацию в диапазоне 8, указывая количество создаваемых подграфиков.

Для каждой итерации создается подграфик с помощью функции plt.subplot(). Значения осциллятора Aroon (Aroon_Oscillator) заполняются зеленым цветом с помощью функции fill(). Прозрачность установлена на 0,5, чтобы обеспечить лучшую видимость базовых данных. Метка указывается как «Aroon Oscillator».

Цены закрытия (Close) для соответствующей акции отображаются красным цветом в виде линейного графика, указывающего на движение цены во времени.

Заголовок каждого подучастка устанавливается на «Aroon Oscillator for [stock label]», где биржевая метка извлекается из столбца «Метка» для соответствующей акции. К сюжету добавляется легенда для дифференциации линий.

Метка по оси X имеет значение «Дата», а метка по оси Y — «Цены закрытия». Метки тиков по оси X повернуты на 30 градусов для лучшей читаемости.

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке.

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

# PRice Volume Trend Plot
fig = plt.figure(figsize=(20,25))
for i in range(8):
ax = plt.subplot(8,1,i+1)
ax.plot(TechIndicator[i].index, TechIndicator[i]['PVT'], 'black')
ax.set_title("Price Volume Trend of " +str(TechIndicator[i]['Label'][0]))
ax.set_xlabel("Date")
ax.set_ylabel("Price Volume trend")
plt.xticks(rotation=30)
fig.tight_layout()

этот код генерирует график тренда ценового объема (PVT) для нескольких акций с использованием набора данных TechIndicator.

Код начинается с создания фигурного объекта fig с заданным размером. На этом рисунке цикл выполняет итерацию в диапазоне 8, указывая количество создаваемых подграфиков.

Для каждой итерации создается подграфик с помощью функции plt.subplot(). Значения PVT (PVT) для соответствующих акций отображаются в виде линейного графика черного цвета с помощью функции plot().

Заголовок каждого подучастка устанавливается на «Тренд объема цен [метка запаса]», где метка запаса извлекается из столбца «Метка» для соответствующей акции.

Метка по оси X имеет значение «Дата», а метка по оси Y — «Тренд объема цены». Метки тиков по оси X повернуты на 30 градусов для лучшей читаемости.

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке.

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

# Stochastic Oscillator plots
plt.style.use('seaborn-whitegrid')
fig = plt.figure(figsize=(20,25))
for i in range(8):
ax = plt.subplot(4,2,i+1)
ax.plot(TechIndicator[i].index, TechIndicator[i]['STOK'], 'blue', label="%K")
ax.plot(TechIndicator[i].index, TechIndicator[i]['STOD'], 'red', label="%D")
ax.plot(TechIndicator[i].index, TechIndicator[i]['Close'], color='black', lw=2, label = "Close")
ax.set_title("Stochastic Oscillators of " +str(TechIndicator[i]['Label'][0]))
ax.legend()
ax.set_xlabel("Date")
ax.set_ylabel("Close Price")
plt.xticks(rotation=30)
fig.tight_layout()

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

Код начинается с установки стиля графика на белую сетку с помощью plt.style.use(‘seaborn-whitegrid’). Затем создается фигурный объект fig с заданным размером.

На рисунке цикл выполняет итерацию в диапазоне 8, указывая количество создаваемых подграфиков.

Для каждой итерации создается подграфик с помощью функции plt.subplot(). Значения стохастического осциллятора %K (STOK) отображаются в виде линейного графика синим цветом, а значения %D (STOD) отображаются в виде линейного графика красным цветом. Кроме того, цена закрытия (Close) для соответствующей акции отображается в виде линейного графика черного цвета.

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

Отображается легенда, позволяющая различать %K, %D и цену закрытия. Метка по оси X имеет значение «Дата», а метка по оси Y — «Цена закрытия». Метки тиков по оси X повернуты на 30 градусов для лучшей читаемости.

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке.

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

# Chaikin Money Flow Plots
import matplotlib.gridspec as gridspec

fig = plt.figure(figsize=(25,40))
outer = gridspec.GridSpec(4, 2, wspace=0.2, hspace=0.2)

for i in range(8):
inner = gridspec.GridSpecFromSubplotSpec(2, 1,
subplot_spec=outer[i], wspace=0.1, hspace=0.1)

for j in range(2):
ax = plt.Subplot(fig, inner[j])
if j==0:
t = ax.fill(TechIndicator[i].index, TechIndicator[i]['Chaikin_MF'],'b', alpha = 0.5, label = "Chaikin MF")
ax.set_title("Chaikin Money Flow for " +str(TechIndicator[i]['Label'][0]))
t = ax.set_ylabel("Money Flow")
else:
t = ax.plot(TechIndicator[i].index, TechIndicator[i]['Close'], 'r', label="Close")
t = ax.set_ylabel("Close")
ax.legend()
ax.set_xlabel("Date")

fig.add_subplot(ax)
fig.tight_layout()

этот код генерирует графики индикатора денежного потока Чайкина (CMF) для нескольких акций с использованием набора данных TechIndicator.

Код начинается с импорта модуля gridspec из matplotlib и создания фигурного объекта fig с заданным размером.

Фигура разделена на сетку 4×2 с помощью gridspec. GridSpec(4, 2; wspace=0,2, hspace=0,2). Эта сетка будет содержать подучастки для каждого запаса.

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

Для каждого подграфика код проверяет значение j во внутреннем цикле. Если j равно 0, значения денежного потока Чайкина (Chaikin_MF) заполняются в виде синей области с помощью ax.fill(). Заголовок подграфика имеет значение «Денежный поток Чайкина для [биржевой этикетки]», где биржевая метка извлекается из столбца «Метка» для соответствующей акции. Метка по оси Y установлена на «Денежный поток».

Если j равно 1, то цена закрытия (Close) для соответствующей акции строится в виде линейного графика красным цветом с помощью ax.plot(). Метка по оси Y установлена на «Закрыть».

Отображается легенда, позволяющая отличить денежный поток Чайкина от цены закрытия. Метка по оси X установлена на «Дата».

Подсюжеты добавляются к рисунку с помощью fig.add_subplot(ax).

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке, обеспечивая правильный интервал и выравнивание.

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

# Parabolic SAR, Rate of Change, Momentum and VWAP Plots
fig = plt.figure(figsize=(20,25))
for i in range(8):
ax = plt.subplot(4,2,i+1)
ax.plot(TechIndicator[i].index, TechIndicator[i]['psar'], 'blue', label="PSAR", alpha = 0.5)
ax.plot(TechIndicator[i].index, TechIndicator[i]['ROC'], 'red', label="ROC", alpha = 0.5)
ax.plot(TechIndicator[i].index, TechIndicator[i]['Momentum'], 'green', label="Momentum", alpha = 0.5)
ax.plot(TechIndicator[i].index, TechIndicator[i]['VWAP'], 'cyan', label="VWAP", alpha = 0.5)
ax.set_title("PSAR, ROC, Momentum and VWAP of " +str(TechIndicator[i]['Label'][0]))
ax.legend()
ax.set_xlabel("Date")
ax.set_ylabel("Close Price")
plt.xticks(rotation=30)
fig.tight_layout()

этот код генерирует графики для нескольких технических индикаторов, включая Parabolic SAR (PSAR), Rate of Change (ROC), Momentum и Volume Weighted Average Price (VWAP), используя набор данных TechIndicator.

Код начинается с создания фигурного объекта с заданным размером.

Затем он входит в цикл, который перебирает каждую акцию в наборе данных TechIndicator. В каждой итерации создается подграфик с использованием plt.subplot(4, 2, i+1) для выделения определенной ячейки в сетке 4×2 для текущего запаса.

В рамках каждого подучастка построены четыре показателя:

Значения Parabolic SAR (psar) отображаются в виде графика синей линии с помощью ax.plot(). Значения скорости изменения (ROC) строятся в виде графика красной линии с помощью ax.plot(). Значения импульса отображаются в виде графика зеленой линии с помощью ax.plot(). Значения средневзвешенной цены по объему (VWAP) строятся в виде голубого линейного графика с помощью ax.plot(). Каждому подучастку присваивается заголовок «PSAR, ROC, Momentum и VWAP [биржевой этикетки]», где биржевая этикетка извлекается из столбца «Этикетка» для соответствующего запаса.

Отображается легенда, чтобы различать четыре индикатора. Метка по оси X имеет значение «Дата», а метка по оси Y — «Цена закрытия». Метки тиков по оси X повернуты на 30 градусов для лучшей читаемости.

Наконец, fig.tight_layout() используется для оптимизации расположения подучастков на рисунке, обеспечивая правильный интервал и выравнивание.

В целом, этот код генерирует визуализации индикаторов Parabolic SAR, Rate of Change, Momentum и Volume Weighted Average Price для нескольких акций. Эти индикаторы дают представление о тренде, импульсе и динамике объема акций, помогая трейдерам и аналитикам принимать обоснованные решения.

Источник