def __init__(self,
risk_estimation_factor: float,
data_provider: DataHandler,
start_date: datetime,
end_date: datetime,
tickers: Sequence[Ticker],
number_of_trades: int,
time_in_the_market: float,
exposure: Exposure = Exposure.LONG,
frequency: Frequency = Frequency.DAILY,
seed: Optional[int] = None):
super().__init__(risk_estimation_factor, data_provider)
self.timer = data_provider.timer
self.start_date = start_date
self.end_date = end_date
self.frequency = frequency
scenarios_generator = ScenariosGenerator()
self.trading_scenarios = QFDataFrame(
columns=tickers,
data={
ticker: scenarios_generator.make_exposure_scenarios(
start_date, end_date, number_of_trades, time_in_the_market,
exposure, frequency, seed and seed + i)
for i, ticker in enumerate(tickers)
})
class TestScenariosGenerator(TestCase):
def setUp(self):
self.generator = ScenariosGenerator()
self.num_of_scenarios = 100000
self.scenarios_length = 7
def test_make_scenarios(self):
first_ret_value = 0.05
second_ret_value = 0.1
trade_rets = QFSeries([first_ret_value, second_ret_value])
scenarios_df = self.generator.make_scenarios(trade_rets,
self.scenarios_length,
self.num_of_scenarios)
expected_shape = (self.scenarios_length, self.num_of_scenarios)
actual_shape = scenarios_df.shape
self.assertAlmostEqual(expected_shape, actual_shape)
values_count = scenarios_df.iloc[0, :].value_counts(normalize=True)
first_return_freq = values_count[first_ret_value]
second_return_freq = values_count[second_ret_value]
expected_frequency = 0.5
self.assertAlmostEqual(first_return_freq,
expected_frequency,
delta=0.01)
self.assertAlmostEqual(second_return_freq,
expected_frequency,
delta=0.01)
def _get_scenarios(self, num_of_scenarios: int = 2500) -> Tuple[PricesDataFrame, SimpleReturnsSeries]:
# Generate scenarios, each of which consists of a certain number of trades, equal to the average number
# of trades per year
scenarios_generator = ScenariosGenerator()
trade_returns = [trade.percentage_pnl for trade in self.trades]
# Generate the scenarios
scenarios_df = scenarios_generator.make_scenarios(
trade_returns,
scenarios_length=int(self._average_number_of_trades_per_year()),
num_of_scenarios=num_of_scenarios
)
scenarios_df = scenarios_df.to_prices()
return scenarios_df, scenarios_df.iloc[-1] / scenarios_df.iloc[0] - 1.0
def main():
stats_factory = InitialRiskStatsFactory(max_accepted_dd=0.1,
target_return=0.02)
initial_risks_list = [0.001, 0.005, 0.01, 0.02, 0.03, 0.05, 0.1]
scenarios_generator = ScenariosGenerator()
scenarios_df_list = []
nr_of_param_sets = len(initial_risks_list)
test_start_time = time()
print("{} parameters sets to be tested".format(nr_of_param_sets))
param_set_ctr = 1
for init_risk in initial_risks_list:
start_time = time()
ts = _create_trading_session(init_risk)
data_handler = ts.data_handler
alpha_model = MovingAverageAlphaModel(
5, 20, 1.25,
data_handler) # Change to a different alpha model to test it
trade_rets_values = get_trade_rets_values(ts, alpha_model)
scenarios_df = scenarios_generator.make_scenarios(
trade_rets_values, scenarios_length=100, num_of_scenarios=10000)
end_time = time()
print("{} / {} initial risk parameters tested".format(
param_set_ctr, nr_of_param_sets))
print("iteration time = {:5.2f} minutes".format(
(end_time - start_time) / 60))
param_set_ctr += 1
scenarios_df_list.append(scenarios_df)
print("\nGenerating stats...")
start_time = time()
stats = stats_factory.make_stats(initial_risks_list, scenarios_df_list)
print(stats)
end_time = time()
print("iteration time = {:5.2f} minutes".format(
(end_time - start_time) / 60))
test_end_time = time()
print("test duration time = {:5.2f} minutes".format(
(test_end_time - test_start_time) / 60))
def main():
alpha_model_type = None # Set Alpha model that you wish to test
stats_factory = InitialRiskStatsFactory(max_accepted_dd=0.1, target_return=0.02)
initial_risks_list = [0.001, 0.005, 0.01, 0.02, 0.03, 0.05, 0.1]
scenarios_generator = ScenariosGenerator()
scenarios_df_list = []
nr_of_param_sets = len(initial_risks_list)
test_start_time = time()
print("{} parameters sets to be tested".format(nr_of_param_sets))
param_set_ctr = 1
for init_risk in initial_risks_list:
start_time = time()
trade_rets_values = get_trade_rets_values(init_risk, alpha_model_type)
scenarios_df = scenarios_generator.make_scenarios(
trade_rets_values, scenarios_length=100, num_of_scenarios=10000
)
end_time = time()
print("{} / {} initial risk parameters tested".format(param_set_ctr, nr_of_param_sets))
print("iteration time = {:5.2f} minutes".format((end_time - start_time) / 60))
param_set_ctr += 1
scenarios_df_list.append(scenarios_df)
print("\nGenerating stats...")
start_time = time()
stats = stats_factory.make_stats(initial_risks_list, scenarios_df_list)
print(stats)
end_time = time()
print("iteration time = {:5.2f} minutes".format((end_time - start_time) / 60))
test_end_time = time()
print("test duration time = {:5.2f} minutes".format((test_end_time - test_start_time) / 60))
def setUp(self):
self.generator = ScenariosGenerator()
self.num_of_scenarios = 100000
self.scenarios_length = 7