Использование TensorFlow для количественного инвестирования

Освоение алгоритмической торговли на Python

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

Базовая торговая стратегия

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

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

Введение в TensorFlow

TensorFlow — библиотека с открытым исходным кодом для численных вычислений, включая машинное обучение. Это позволяет пользователям создавать направленный граф или ГРУППУ обеспечения доступности баз данных для представления вычислений, которые они хотят выполнить. Узлы в графе представляют математические операции, в то время как ребра представляют входные и выходные данные этих операций. TensorFlow использует тензоры, или N-мерные массивы данных, для прохождения через график. Использование направленных графов и тензоров обеспечивает переносимость языка и оборудования, поскольку один и тот же код может выполняться на разных платформах, включая процессоры, графические процессоры и TPU. API tf.data в TensorFlow позволяет пользователям создавать входные конвейеры для моделей и работать с данными в памяти или в нескольких файлах. Векторные столбцы используются для обработки и подготовки данных для использования в обучении моделей нейронных сетей.

TensorFlow позволяет разработчикам писать код на языке высокого уровня, таком как Python, и эффективно выполнять его во время выполнения. TensorFlow работает путем создания направленного графа, или DAG, для представления вычислений, которые необходимо выполнить. Узлы в графе представляют математические операции, а ребра представляют входные и выходные данные этих операций. Ребра можно рассматривать как массивы данных, проходящие через график. Эти массивы, называемые тензорами, могут быть любой размерности или ранга от скаляров (ранг 0) до массивов более высокой размерности, таких как матрицы (ранг 2) и тензоры 3D (ранг 3).

В TensorFlow существует несколько уровней абстракции, начиная от низкоуровневых API для аппаратного обеспечения до высокоуровневых API для более абстрактных задач. Core Python API содержит большую часть кода обработки чисел и функций для работы с переменными и тензорами. Существует также несколько модулей Python, которые обеспечивают высокоуровневые представления полезных компонентов нейронной сети, таких как слои, метрики и потери. Для многих приложений использования одного из высокоуровневых API, таких как Estimators или Keras, достаточно для обучения, оценки и обслуживания моделей машинного обучения. Эти API обрабатывают такие задачи, как распределенное обучение, предварительная обработка данных, определение модели, компиляция и обучение, а также оценка, контрольные точки и обслуживание моделей.

Cloud AI Platform — это управляемый сервис, который позволяет разработчикам запускать TensorFlow на кластере машин в облаке без необходимости установки какого-либо программного обеспечения или управления какими-либо серверами. В этом модуле мы сосредоточимся на трех основных API: Core Python, TF Layers и Estimator API. Однако, прежде чем погрузиться в код, важно понять фрагменты данных, с которыми мы будем работать, включая переменные, тензоры и столбцы объектов.

Тензор?

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

Пример использования

TensorFlow Financial – это библиотека, предназначенная для использования в области количественных финансов. Он предоставляет высокопроизводительные инструменты для математических и статистических операций, а также конкретные модели ценообразования и другие утилиты, имеющие отношение к финансовому анализу. Библиотека организована в три уровня: основополагающие методы, методы среднего уровня и методы ценообразования и другие количественные финансовые утилиты. Основополагающие методы включают основные математические операции, такие как оптимизация, интерполяция и линейная алгебра, в то время как методы среднего уровня включают решатели ODE и PDE и фреймворки процессов Ito. Методы ценообразования и коммунальные услуги включают в себя конкретные модели ценообразования для локального vol, стохастического vol, стохастического локального vol и Hull-White, а также построение кривой скорости, описания выплат и генерацию графика. Библиотека спроектирована так, чтобы быть легко доступной и сопровождаться многочисленными примерами на каждом уровне.

Ценообразование опционов по модели Блэка-Шоулза

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

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

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

Модель Блэка-Шоулза

Модель Блэка-Шоулза – это математическая модель ценообразования опционов, которая учитывает факторы, упомянутые выше. Модель была разработана в 1970-х годах Фишером Блэком, Майроном Скоулзом и Робертом Мертоном, которые были удостоены Нобелевской премии по экономическим наукам за свою работу.

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

При этих допущениях модель Блэка-Шоулза предоставляет решение закрытой формы для цены европейского опциона колл или пут, которое задается следующими формулами:

Цена колл-опциона:

C = S * N(d1) — K * exp(-r * T) * N(d2)

Цена опциона пут:

P = K * exp(-r * T) * N(-d2) — S * N(-d1)

где:

C: цена опциона колл P: цена опциона пут S: цена базового актива K: цена исполнения T: время до экспирации

импорт тензорпотока как tf

# Задать параметры для модели
Блэка-Шоулза S0 = 100.0 # начальная цена
акций K = 105.0 # цена
исполнения T = 1.0 # время до истечения срока действия (в годах)
r = 0.05 # безрисковая процентная ставка
сигма = 0.2 # волатильность

# Определите входные данные в модель как заполнители
S = tf.placeholder(tf.float32, shape=[], name='S')
K = tf.placeholder(tf.float32, shape=[], name='K')
T = tf.placeholder(tf.float32, shape=[], name='T')
r = tf.placeholder(tf.float32, shape=[], name='r')
sigma = tf.placeholder(tf.float32, shape=[], name='sigma')

# Вычислить члены d1 и d2, как определено в формуле Блэка-Шоулза
d1 = (tf.log(S/K) + (r + 0,5 * sigma**2) * T) / (sigma * tf.sqrt(T))
d2 = d1 - sigma * tf.sqrt(T)

# Рассчитать цену опциона по формуле Блэка-Шоулза
call_price = S * tf.norm.cdf(d1) - K * tf.exp(-r * T) * tf.norm.cdf(d2)
put_price = K * tf.exp(-r * T) * tf.norm.cdf(-d2) - S * tf.norm.cdf(-d1)


# Создайте сеанс и запустите модель, чтобы оценить параметры
с помощью tf. Session() as sess:
call_price_val = sess.run(call_price, feed_dict={S: S0, K: K, T: T, r: r, sigma: sigma})
put_price_val = sess.run(put_price, feed_dict={S: S0, K: K, T: T, r: r, sigma: sigma})

# Печать результатов
print("Call price:", call_price_val)
print("Put price:", put_price_val)

Вы можете предсказать цену опциона в качестве примера по этой ссылке.

Монте-Карло через схему Эйлера

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

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

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

импорт тензорпотока как tf

# Определите ODE и начальные условия как константы
TensorFlow def derivative(t, y):
return -y

t0 = tf.constant(0.0)
y0 = tf.constant(1.0)

# Задайте размер шага времени и количество временных шагов как константы
TensorFlow dt = tf.constant(0.1)
n_steps = 10

# Инициализируйте время и интересующую величину как переменные
TensorFlow t = tf. Переменная(t0)
y = tf. Переменная(y0)

# Задайте число симуляций Монте-Карло в качестве константы
TensorFlow n_simulations = 1000

# Инициализируйте массивы для хранения результатов
ts = tf.zeros((n_simulations, n_steps+1))
ys = tf.zeros((n_simulations, n_steps+1))

# Запустите моделирование Монте-Карло с помощью цикла

для i в диапазоне(n_simulations):
# Задать начальные условия для данного моделирования
t.assign(t0)
y.assign(y0)

# Сохранить начальные условия
ts = ts.write(i, 0, t)
ys = ys.write(i, 0, y)

# Итерация по шагам времени с помощью цикла
TensorFlow для j в диапазоне(n_steps):
# Используйте схему Эйлера для оценки производной в данный момент времени шаг
dy = производная(t, y) * dt

# Обновить значение интересующей
величины y.assign_add(dy)

# Обновить время
t.assign_add(dt)

# Сохранить результаты для этого шага
времени ts = ts.write(i, j+1, t)
ys = ys.write(i, j+1, y)

# Вычислить среднее и стандартное отклонение величины интересующего
среднего = tf.reduce_mean(ys, axis=0)
std = tf.math.reduce_std(ys, axis=0)

# Печать результатов
print("Time:", ts.read(0))
print ("Среднее:", среднее)
печать("Std:", std)

Оптимизация

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

https://medium.com/stack-me-up/crypto-portfolio-optimization-with-python-and-tensorflow-an-approach-aa504578c799

В Tensorflow мы не можем присваивать значения переменным, таким как . Значения могут быть объявлены через , как значение по умолчанию или назначены через , что создает операцию, которую необходимо выполнить.var = valtf.constant(...)tf.Variable(...)my_tensor.assign(...)

Давайте добавим ограничения и запустим их после каждого шага обучения:coin_weights

# Оптимизировать веса для минимизации волатильности

def minimize_volatility():

# Определить модель
# Волатильность портфеля = Sqrt (Transpose (Wt.SD) * Матрица корреляции * Wt. SD)

coin_weights = tf. Переменная(np.full((лен(монеты), 1), 1.0 / лен(монеты))) # наши переменные
weighted_std_devs = tf.multiply(coin_weights, std_deviations)

product_1 = tf.transpose(weighted_std_devs)
product_2 = tf.matmul(product_1, correlation_matrix)

portfolio_variance = tf.matmul(product_2, weighted_std_devs)
portfolio_volatility = tf.sqrt(tf.reduce_sum(portfolio_variance))

# Ограничения: sum([0..1, 0..1, ...]) = 1

lower_than_zero = tf.greater( np.float64(0), coin_weights )
zero_minimum_op = coin_weights.assign( tf.where (lower_than_zero, tf.zeros_like(coin_weights), coin_weights) )

greater_than_one = tf.greater( coin_weights, np.float64(1) )
unity_max_op = coin_weights.assign( tf.where (greater_than_one, tf.ones_like(coin_weights), coin_weights) )

result_sum = tf.reduce_sum(coin_weights)
unity_sum_op = coin_weights.assign(tf.divide(coin_weights, result_sum))

constraints_op = tf.group(zero_minimum_op, unity_max_op, unity_sum_op)

# Выполнить
learning_rate = 0,01
шага = 5000

init = tf.global_variables_initializer()

# Тренировка с использованием градиентного спуска для минимизации дисперсии
optimize_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(portfolio_volatility)

с tf. Session() as sess:
sess.run(init)
for i in range(steps):
sess.run(optimize_op)
sess.run(constraints_op),
если i % 2500 == 0 :
print("[round {:d}]". формат(i))
печать("Веса", coin_weights. eval())
print("Волатильность: {:.2f}%". формат(portfolio_volatility. eval() * 100))
print("")

sess.run(constraints_op)
вернуть coin_weights. eval()

weights = minimize_volatility()

pretty_weights = pd. DataFrame(вес * 100, индекс = монеты, столбцы = ["Вес %"])
pretty_weights
# Оптимизируйте веса для максимизации доходности/риска

def maximize_sharpe_ratio():

# Определите модель

# 1) Дисперсия

coin_weights = tf. Переменная(np.full((len(монеты), 1), 1.0 / len(монеты))) # наши переменные
weighted_std_devs = tf.multiply(coin_weights, std_deviations)

product_1 = tf.transpose(weighted_std_devs)
product_2 = tf.matmul(product_1, correlation_matrix)

portfolio_variance = tf.matmul(product_2, weighted_std_devs)
portfolio_volatility = tf.sqrt(tf.reduce_sum(portfolio_variance))

# 2) Возврат

возвращает = np.full((len(coins), 1), 0.0) # такой же, как coin_weights
для coin_idx в диапазоне(0, len(coins)):
returns[coin_idx] = cumulative_returns[coins[coin_idx]]

portfolio_return = tf.reduce_sum(tf.multiply(coin_weights, returns))

# 3) Доходность / sharpe_ratio риска

= tf.divide(portfolio_return, portfolio_volatility)


Optimizer(...). минимизировать(tf.отрицательный(sharpe_ratio))

Подгонка кривой свопов

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

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

Например, мы можем представить кривую свопа как линейную функцию сроков погашения облигаций, с формой , где — ставка облигации, — срок погашения облигаций и параметры модели. Затем мы можем определить функцию потерь как среднюю квадратичную ошибку между предсказаниями модели и входными данными.y = a + b * xyxab

импорт tensorflow как tf

# Определите входные данные как постоянную
зрелость TensorFlow = tf.constant([1, 2, 3, 5, 7, 10, 30]) # в годах
rate = tf.constant([0.01, 0.02, 0.03, 0.05, 0.07, 0.1, 0.3]) # в годовом исчислении процентные пункты

# Задайте число параметров модели в качестве константы
TensorFlow n_params = 2

# Инициализируйте параметры модели как параметры переменных
TensorFlow = tf. Переменная(tf.zeros((n_params,)))#

Определите модель как функцию
TensorFlow def swap_curve(maturity, params):
a, b = params
return a + b * maturity

# Определите функцию потерь как функцию
TensorFlow def loss(rate, maturity, params):
return tf.reduce_mean((rate - swap_curve(maturity, params)) ** 2)

# Установите скорость обучения и количество шагов обучения в качестве констант TensorFlow
learning_rate = 0,01
n_steps = 1000

# Используйте оптимизатор градиентного спуска TensorFlow для минимизации оптимизатора потерь
= tf.optimizers.SGD(learning_rate)

for i в range(n_steps):
# Вычислить градиент потерь относительно параметров
модели с tf. GradientTape() как лента:
loss_value = loss(rate, maturity, params)
grads = tape.gradient(loss_value, params)

# Обновить параметры модели с помощью оптимизатора
градиентного спуска optimizer.apply_gradients(zip([grads], [params]))

# Печать оптимальных параметров
модели print("Оптимальные параметры модели:", params.numpy())

Заключение

TensorFlow — это библиотека машинного обучения, которая может быть использована в количественной торговле для построения и оптимизации торговых моделей, анализа рыночных данных и принятия обоснованных инвестиционных решений. Он позволяет создавать направленные графы, или DAG, для представления математических операций и потока данных через эти операции в виде тензоров. В контексте торговли сигналы входа и выхода используются для определения того, когда инициировать или закрывать сделку, и могут основываться на эндогенных правилах, связанных с торгуемой ценной бумагой, или экзогенных правилах, связанных с другими ценными бумагами или макроэкономическими показателями. Стоп-лосс ордера используются для управления рисками в торговле и могут быть установлены как статические или динамические. API TensorFlow neural.data и векторные столбцы можно использовать для манипулирования и подготовки данных для использования в обучении моделей нейронных сетей. TensorFlow также может быть использован для реализации моделирования Монте-Карло и схемы Эйлера для решения обыкновенных дифференциальных уравнений.

ССЫЛКА:

https://www.tensorflow.org/

Источник