Моделирование опции Используя модель Мертона Блэка-Шоулза

Модель Black-Scholes-Merton (BSM), которая заработала для ее создателей Нобелевскую премию в Экономике в 1 997, служит основой моделирования для оценки и анализа финансовых производных или опций. Опции являются финансовыми инструментами, которые получают их значение на конкретный базовый актив. Концепцией динамического хеджирования является основной принцип модели BSM. Динамическое хеджирование является идеей, что, путем непрерывной покупки и продажи акций в соответствующем базовом активе, можно застраховать риск производного инструмента, таким образом, что риск является нулем. Эта "нейтральная к риску" среда оценки используется, чтобы вывести формулы оценки для многих различных финансовых инструментов.

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

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

Динамическая стратегия хеджирования BSM также называется "хеджированием дельты" после количества Delta, которая является чувствительностью опции относительно базового актива. В среде, которая соответствует ранее установленным предположениям BSM, с помощью страхующей дельту стратегии, оптимальный подход к хеджированию опции. Однако это известно, который в среде с операционными издержками, использование модели BSM приводит к неэффективной стратегии хеджирования. Цель этого примера состоит в том, чтобы использовать Reinforcement Learning Toolbox™, чтобы изучить стратегию, которая превосходит BSM по характеристикам хеджирование стратегии, в присутствии операционных издержек.

Цель обучения с подкреплением (RL) состоит в том, чтобы обучить агента выполнять задачу в неизвестной среде. Агент получает наблюдения и вознаграждение от окружения и посылает туда действия. Вознаграждение является мерой того, насколько успешно действие относительно выполнения цели задачи.

Агент содержит два компонента: политика и алгоритм обучения.

Другими словами, обучение с подкреплением включает агента, изучая оптимальное поведение через повторные эмпирические взаимодействия со средой без человеческого участия. Для получения дополнительной информации об обучении с подкреплением смотрите то, Что Обучение с подкреплением? (Reinforcement Learning Toolbox).

Главный администратор [2] описывает настройку для обучения с подкреплением как:

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

Этот пример следует за средой, обрисованной в общих чертах в Као [2]. А именно, используются бухгалтерская прибыль и потеря (P&L), формулировка из той бумаги используется, чтобы настроить проблему обучения с подкреплением и агента глубоко детерминированного градиента политики (DDPG). Этот пример точно не воспроизводит подход от [2] потому что Као и. al. рекомендуют подход Q-изучения с двумя отдельными Q-функциями (один для стоимости хеджирования и один для ожидаемого квадрата стоимости хеджирования), но этот пример использует вместо этого упрощенную премиальную функцию.

Задайте параметры обучения

Затем укажите, что опция в деньгах с тремя месяцами к зрелости застрахована. Для простоты и процентная ставка и дивидендная доходность установлены в 0.

% Option parameters
Strike = 100;
Maturity = 21*3/250;

% Asset parameters
SpotPrice = 100;
ExpVol = .2;
ExpReturn = .05;

% Simulation parameters
rfRate = 0;
dT = 1/250;
nSteps = Maturity/dT;
nTrials = 5000;

% Transacation cost and cost function parameters
c = 1.5;
kappa = .01;
InitPosition = 0;

% Set the random generator seed for reproducibility.
rng(3)

Задайте среду

В этом разделе, параметрах действия и наблюдения, actInfo и obsInfo. Действие агента является текущим hedge значение, которое может расположиться между 0 и 1. В наблюдении агента существует три переменные:

ObservationInfo             = rlNumericSpec([3 1],'LowerLimit',0,'UpperLimit',[10 Maturity 1]');
ObservationInfo.Name        = 'Hedging State';
ObservationInfo.Description = ['Moneyness', 'TimeToMaturity','Position'];

ActionInfo = rlNumericSpec([1 1],'LowerLimit',0,'UpperLimit',1);
ActionInfo.Name = 'Hedge';

Задайте вознаграждение

От главного администратора [2], учет формулировка P&L и вознаграждения (отрицательные затраты)

${\mathit{R}}_{\mathit{i}+1}={\mathit{V}}_{\mathit{i}+1}-{\mathit{V}}_{\mathit{i}}$ + ${\mathit{H}}_{\mathit{i}+1}$(${\mathit{S}}_{\mathit{i}+1}$ - ${\mathit{S}}_{\mathit{i}}$) - ${\kappa \left|{\mathit{S}}_{\mathit{i}+1}\left({\mathit{H}}_{\mathit{i}+1}-{\mathit{H}}_{\mathit{i}}\right)\right|}_{}$

где

Итоговое вознаграждение на последнем временном шаге ликвидирует преграду, которая является ${\kappa \left|{\mathit{S}}_{\mathit{n}}\left({\mathit{H}}_{\mathit{n}}\right)\right|.}_{}$

В этой реализации, вознаграждение (${\mathit{R}}_{\mathit{i}}$) оштрафован квадратом вознаграждения, умноженного на константу, чтобы наказать большое колебание в значении застрахованного положения:

Вознаграждение задано в stepFcn который называется на каждом шаге симуляции.

env = rlFunctionEnv(ObservationInfo,ActionInfo, ...
    @(Hedge, LoggedSignals) stepFcn(Hedge,LoggedSignals,rfRate,ExpVol,dT,Strike,ExpReturn,c,kappa), ...
    @() resetFcn(SpotPrice/Strike,Maturity,InitPosition));

obsInfo = getObservationInfo(env);
actInfo = getActionInfo(env);

Создайте интерфейс среды для агента RL

Создайте агента DDPG с помощью rlDDPGAgent (Reinforcement Learning Toolbox). В то время как возможно создать пользовательского агента и сети критика, этот пример использует сети по умолчанию.

initOpts = rlAgentInitializationOptions('NumHiddenUnit',64);

agent = rlDDPGAgent(obsInfo,actInfo,initOpts);

critic = getCritic(agent);
critic.Options.LearnRate = 1e-4;
% critic.Options.UseDevice = "gpu";
agent  = setCritic(agent,critic);

actor = getActor(agent);
actor.Options.LearnRate = 1e-4;
% actor.Options.UseDevice = "gpu";
agent  = setActor(agent,actor);

agent.AgentOptions.DiscountFactor = .9995;
agent.AgentOptions.TargetSmoothFactor = 5e-4;

Визуализируйте сети агента и критика

Визуализируйте агента и сети критика с помощью Deep Network Designer.

deepNetworkDesigner(layerGraph(getModel(actor)))

Обучите агента

Обучите агента с помощью train (Reinforcement Learning Toolbox) функция.

trainOpts = rlTrainingOptions( ...
    'MaxEpisodes', nTrials, ...
    'MaxStepsPerEpisode',nSteps, ...
    'Verbose', false, ...
    'ScoreAveragingWindowLength',200,...
    'StopTrainingCriteria',"AverageReward", ...
    'StopTrainingValue',-40, ...
    'StopOnError',"on", ...
    "UseParallel",false);

doTraining = false;
if doTraining
    % Train the agent.
    trainingStats = train(agent,env,trainOpts);
else
    % Load the pretrained agent for the example.
    load('DeepHedgingDDPG.mat','agent')
end

Чтобы постараться не ожидать обучения, загрузите предварительно обученные сети путем установки doTraining отметьте к false. Если вы устанавливаете doTraining к true, менеджер по Эпизоду Обучения с подкреплением отображает прогресс обучения.

Подтвердите агента

Используйте функции Financial Toolbox™ blsdelta (Financial Toolbox) и blsprice (Financial Toolbox) для coventional приближается к caculate к цене как к европейскому колл-опциону. При сравнении обычного подхода к подходу RL результаты похожи на результаты Као [2] в приложении 4. Этот пример демонстрирует, что подход RL значительно уменьшает затраты на хеджирование.

% Simulation parameters
nTrials = 1000;

policy_BSM = @(mR,TTM,Pos) blsdelta(mR,1,rfRate,max(TTM,eps),ExpVol);
policy_RL = @(mR,TTM,Pos) arrayfun(@(mR,TTM,Pos) cell2mat(getAction(agent,[mR TTM Pos])),mR,TTM,Pos);

OptionPrice = blsprice(SpotPrice,Strike,rfRate,Maturity,ExpVol);

Costs_BSM = computeCosts(policy_BSM,nTrials,nSteps,SpotPrice,Strike,Maturity,rfRate,ExpVol,InitPosition,dT,ExpReturn,kappa);
Costs_RL = computeCosts(policy_RL,nTrials,nSteps,SpotPrice,Strike,Maturity,rfRate,ExpVol,InitPosition,dT,ExpReturn,kappa);

HedgeComp = table(100*[-mean(Costs_BSM) std(Costs_BSM)]'/OptionPrice, ...
    100*[-mean(Costs_RL) std(Costs_RL)]'/OptionPrice, ...
    'RowNames',["Average Hedge Cost (% of Option Price)","STD Hedge Cost (% of Option Price)"], ...
    'VariableNames',["BSM","RL"]);
disp(HedgeComp)

                                               BSM        RL  
                                              ______    ______

    Average Hedge Cost (% of Option Price)    91.259    47.022
    STD Hedge Cost (% of Option Price)        35.712    68.119

Следующая гистограмма показывает область значений различных затрат на хеджирование для обоих подходов. Подход RL выполняет лучше, но с большим отклонением, чем подход BSM. Подход RL в этом примере, вероятно, извлек бы выгоду из двух подходов Q-функции, которые Као [2] обсуждает и реализует.

figure
numBins = 10;
histogram(-Costs_RL,numBins,'FaceColor','r','FaceAlpha',.5)
hold on
histogram(-Costs_BSM,numBins,'FaceColor','b','FaceAlpha',.5)
xlabel('Hedging Costs')
ylabel('Number of Trials')
title('RL Hedge Costs vs. BLS Hedge Costs')
legend('RL Hedge','Theoretical BLS Delta','location','best')

График Отношения преграды относительно денежности показывает различия между подходами RL и BSM. Как обсуждено в Као [2], в присутствии операционных издержек, агент узнает, что, "когда хеджирование дельты потребовало бы, чтобы доли были куплены, это имеет тенденцию быть оптимальным для торговца, чтобы быть underhedged относительно дельты. Точно так же, когда хеджирование дельты потребовало бы, чтобы доли были проданы, оно имеет тенденцию быть оптимальным для торговца, чтобы быть сверхзастрахованным относительно дельты".

policy_RL_mR = @(mR,TTM,Pos) cell2mat(getAction(agent,[mR TTM Pos]));
mRange = (.8:.01:1.2)';

figure
t_plot = 2/12;
plot(mRange,blsdelta(mRange,1,rfRate,t_plot,ExpVol),'b')
hold on
plot(mRange,arrayfun(@(mR) policy_RL_mR(mR,t_plot,blsdelta(mR,1,rfRate,t_plot,ExpVol)),mRange),'r')
plot(mRange,arrayfun(@(mR) policy_RL_mR(mR,t_plot,blsdelta(mR+.1,1,rfRate,t_plot,ExpVol)),mRange),'g')
plot(mRange,arrayfun(@(mR) policy_RL_mR(mR,t_plot,blsdelta(mR-.1,1,rfRate,t_plot,ExpVol)),mRange),'m')
legend('Theoretical BLS Delta','RL Hedge -- ATM','RL Hedge -- Selling','RL Hedge -- Buying', ...
    'location','best')
xlabel('Moneyness')
ylabel('Hedge Ratio')
title('RL Hedge vs. BLS Delta for TTM of 2/12')

Ссылки

[1] Буехлер Х., Л. Гонон, Дж. Тайхманн и Б. Вуд. "Глубоко хеджирование". Количественные Финансы. Издание 19, № 8, 2019, стр 1271–91.

[2] Као Х., Дж. Чен, J. Оболочка и З. Пулос. "Глубоко Хеджирование Производных Используя Обучение с подкреплением". Журнал Науки Финансовых данных. Издание 3, № 1, 2021, стр 10–27.

[3] Хальперин Ай. "QLBS: Q-ученик в Блэка-Шоулза (-Мертон) Миры". Журнал Производных. Издание 28, № 1, 2020, стр 99–122.

[4] Колм П.Н. и Г. Риттер. "Динамическая Репликация и Хеджирование: Подход Обучения с подкреплением". Журнал Науки Финансовых данных. Издание 1, № 1, 2019, стр 159–71.

Локальные функции

function [InitialObservation,LoggedSignals] = resetFcn(Moneyness,TimeToMaturity,InitPosition)
% Reset function to reset at the beginning of each episode.

LoggedSignals.State = [Moneyness TimeToMaturity InitPosition]';
InitialObservation  = LoggedSignals.State;

end

function [NextObs,Reward,IsDone,LoggedSignals] = stepFcn(Position_next,LoggedSignals,r,vol,dT,X,mu,c,kappa)
% Step function to evaluate at each step of the episode.

Moneyness_prev = LoggedSignals.State(1);
TTM_prev = LoggedSignals.State(2);
Position_prev = LoggedSignals.State(3);

S_prev = Moneyness_prev*X;

% GBM Motion
S_next = S_prev*((1 + mu*dT) + (randn* vol).*sqrt(dT));
TTM_next = max(0,TTM_prev - dT);

IsDone = TTM_next < eps;

stepReward = (S_next - S_prev)*Position_prev - abs(Position_next - Position_prev)*S_next*kappa - ...
    blsprice(S_next,X,r,TTM_next,vol) + blsprice(S_prev,X,r,TTM_prev,vol);

if IsDone
    stepReward = stepReward - Position_next*S_next*kappa;
end

Reward = stepReward - c*stepReward.^2;

LoggedSignals.State = [S_next/X;TTM_next;Position_next];
NextObs = LoggedSignals.State;

end

function perCosts = computeCosts(policy,nTrials,nSteps,SpotPrice,Strike,T,r,ExpVol,InitPos,dT,mu,kappa)
% Helper function to compute costs for any hedging approach.

rng(0)

simOBJ = gbm(mu,ExpVol,'StartState',SpotPrice);
[simPaths,simTimes] = simulate(simOBJ,nSteps,'nTrials',nTrials,'deltaTime',dT);
simPaths = squeeze(simPaths);

rew = zeros(nSteps,nTrials);

Position_prev = InitPos;
Position_next = policy(simPaths(1,:)/Strike,T*ones(1,nTrials),InitPos*ones(1,nTrials));
for timeidx=2:nSteps+1
    rew(timeidx-1,:) = (simPaths(timeidx,:) - simPaths(timeidx-1,:)).*Position_prev - ...
        abs(Position_next - Position_prev).*simPaths(timeidx,:)*kappa - ...
        blsprice(simPaths(timeidx,:),Strike,r,max(0,T - simTimes(timeidx)),ExpVol) + ...
        blsprice(simPaths(timeidx-1,:),Strike,r,T - simTimes(timeidx-1),ExpVol);

    if timeidx == nSteps+1
         rew(timeidx-1,:) =  rew(timeidx-1,:) - Position_next.*simPaths(timeidx,:,:)*kappa;
    else
        Position_prev = Position_next;
        Position_next = policy(simPaths(timeidx,:,:)/Strike,(T - simTimes(timeidx)).*ones(1,nTrials),Position_prev);
    end
end

perCosts = sum(rew);

end