def main():
symbols = ["AAPL", "FB", "GOOG", "SPY"]
start_date = "01/01/2017"
end_date = "31/12/2017"
#Portfolio and SPY Dataframes
df_portfolio = get_data(symbols, start_date, end_date)
df_SPY = df_portfolio.ix[:, "SPY"]
df_SPY = df_SPY / df_SPY.ix[0]
#Optimized Allocations
optimized_allocations = compute_optimal_allocations(df_portfolio)
optimized_portfolio = compute_daily_portfolio_value(
df_portfolio, 100000, optimized_allocations)
optimized_portfolio = optimized_portfolio / optimized_portfolio.ix[0]
#Default Allocations
default_allocations = [0.25, 0.25, 0.25, 0.25]
default_portfolio = compute_daily_portfolio_value(df_portfolio, 100000,
default_allocations)
default_portfolio = default_portfolio / default_portfolio.ix[0]
df_comparsion = pd.concat(
[optimized_portfolio, default_portfolio, df_SPY],
keys=["Optimized Portfolio", "Default Portfolio", "S&P500"],
axis=1)
plot_data(df_comparsion, "Portfolio Optimization", "Date", "Price")
def assess_portfolio(start_date, end_date, symbols, allocs, start_val=1):
# Read in adjusted closing prices for given symbols, date range
dates = pd.date_range(start_date, end_date)
prices_all = get_data(symbols, dates) # automatically adds SPY
prices = prices_all[symbols] # only portfolio symbols
prices_SPY = prices_all['SPY'] # only SPY, for comparison later
# Get daily portfolio value
port_val = get_portfolio_value(prices, allocs, start_val)
#Get portfolio statistics (note: std_daily_ret = volatility)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
port_val)
# Print statistics
print "Start Date:", start_date
print "End Date:", end_date
print "Symbols:", symbols
print "Allocations:", allocs
print "Sharpe Ratio:", sharpe_ratio
print "Volatility (stdev of daily returns):", std_daily_ret
print "Average Daily Return:", avg_daily_ret
print "Cumulative Return:", cum_ret
# Compare daily portfolio value with SPY using a normalized plot
df_temp = pd.concat([port_val, prices_SPY],
keys=['Portfolio', 'SPY'],
axis=1)
plot_normalized_data(df_temp, title="Daily portfolio value and SPY")
def optimize_portfolio(start_date, end_date, symbols):
dates = pd.date_range(start_date, end_date)
prices_all = get_data(symbols, dates)
prices = prices_all[symbols] # only portfolio symbols
prices_SPY = prices_all['SPY'] # only SPY, for comparison later
# Get optimal allocations
allocs = find_optimal_allocations(prices)
allocs = allocs / np.sum(allocs) # normalize allocations, if they don't sum to 1.0
# Get daily portfolio value (already normalized since we use default start_val=1.0)
port_val = get_portfolio_value(prices, allocs)
# Get portfolio statistics (note: std_daily_ret = volatility)
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_val)
# Print statistics
print "Start Date:", start_date
print "End Date:", end_date
print "Symbols:", symbols
print "Optimal allocations:", allocs
print "Sharpe Ratio:", sharpe_ratio
print "Volatility (stdev of daily returns):", std_daily_ret
print "Average Daily Return:", avg_daily_ret
print "Cumulative Return:", cum_ret
# Compare daily portfolio value with normalized SPY
normed_SPY = prices_SPY / prices_SPY.ix[0, :]
df_temp = pd.concat([port_val, normed_SPY], keys=['Portfolio', 'SPY'], axis=1)
plot_data(df_temp, title="Daily Portfolio Value and SPY")
def run():
# Define default parameters
start_date = '2007-12-31'
end_date = '2009-12-31'
stock = 'IBM'
#check for user input of stocks and date range
if (len(sys.argv) > 1):
file_path = "data/" + sys.argv[1] + ".csv"
# Check if that file exists
if not os.path.exists(file_path) or not os.path.isfile(file_path):
print 'Data for the stock specified does not exist. Please reference stocks in the data folder, or run with no option provided (will display IBM data by default)'
return
stock = sys.argv[1]
if (len(sys.argv) > 3):
try:
pd.date_range(sys.argv[2], sys.argv[3])
except:
print "The arguments you input for the start and end dates are not valid dates. Please enter your input in the format like 'YYYY-MM-DD' or omit arguments for default value"
return
start_date = sys.argv[2]
end_date = sys.argv[3]
#note that this does not check if the dates are actually present in the stock data files. This should be implemented later.
dates = pd.date_range(start_date, end_date)
prices_all = get_data([stock], dates)
generate_orders_file(prices_all, dates, stock)
calculate_portfolio_value("Unit2/orders/orders_mystrategy.csv", prices_all,
dates, stock)
def main():
start_date = "01/01/2017"
end_date = "31/12/2017"
symbols = ["FB"]
stock_symbol = "FB"
df = get_data(symbols, start_date, end_date, include_SPY=False)
print(df.head())
print(df.tail())
window = 20
rolling_mean = df[stock_symbol].rolling(window=window).mean()
rolling_std = df[stock_symbol].rolling(window=window).std()
df["Rolling Mean"] = rolling_mean
df["Upper Bollinger Band"], df[
"Lower Bollinger Band"] = get_bollinger_bands(rolling_mean,
rolling_std)
plot_data(df, stock_symbol + " Bollinger Bands", "Date", "Price")
def train(self):
@tf.function
def train_step(image_batch):
noise = tf.random.normal((self.configs.data.batch_size,
eval(self.configs.noise_dim)[0]))
with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
generated_images = self.generator(noise, training=True)
real_output = self.discriminator(image_batch, training=True)
fake_output = self.discriminator(generated_images,
training=True)
generator_loss = self.get_generator_loss(fake_output)
discriminator_loss = self.get_discriminator_loss(
real_output, fake_output)
gradients_of_generator = gen_tape.gradient(
generator_loss, self.generator.trainable_variables)
self.generator_opt.apply_gradients(
zip(gradients_of_generator,
self.generator.trainable_variables))
gradients_of_discriminator = disc_tape.gradient(
discriminator_loss, self.discriminator.trainable_variables)
self.discriminator_opt.apply_gradients(
zip(gradients_of_discriminator,
self.discriminator.trainable_variables))
return [('generator_loss', generator_loss.numpy()),
('discriminator_loss', discriminator_loss.numpy())]
data = get_data(self.configs.data.path, self.configs.data.batch_size)
for i in range(self.num_epochs):
print("\nepoch {}/{}".format(i + 1, self.num_epochs))
prog_bar = Progbar(
None,
stateful_metrics=['generator_loss', 'discriminator_loss'])
for idx, im_batch in enumerate(data):
losses = train_step(im_batch)
prog_bar.update(idx + 1, values=losses)
self.save_results(i)
if self.__save_model and (i + 1) % self.__save_interval == 0:
self.save_models()
def main():
capital = 100000
symbols = ["AAPL", "FB", "GOOG", "SPY"]
allocations = [0.25, 0.25, 0.25, 0.25]
start_date = "01/01/2017"
end_date = "31/12/2017"
#Portfolio Dataframe
df_portfolio = get_data(symbols, start_date, end_date)
df_SPY = df_portfolio.ix[:, "SPY"]
#Daily Portfolio Value
daily_portfolio_value = compute_daily_portfolio_value(df_portfolio, capital, allocations)
print(daily_portfolio_value.head())
#Daily Portfolio Return
daily_portfolio_return = compute_daily_portfolio_return(daily_portfolio_value)
#Cummulative Portfolio Return
cummulative_portfolio_return = compute_cummulative_portfolio_return(daily_portfolio_value)
print("Cummulative Portfolio Return:", cummulative_portfolio_return)
#Daily Portfolio Return Mean
mean_daily_portfolio_return = compute_mean_daily_portfolio_return(daily_portfolio_return)
print("Daily Portfolio Return Mean:", mean_daily_portfolio_return)
#Daily Portfolio Return Standard Deviation
std_daily_portfolio_return = compute_std_daily_portfolio_return(daily_portfolio_return)
print("Daily Portfolio Return Standard Deviation:", std_daily_portfolio_return)
#Daily Sampled Sharpe Ratio
daily_sampled_sharpe_ratio = compute_daily_sampled_sharpe_ratio(mean_daily_portfolio_return, std_daily_portfolio_return)
print("Daily Sampled Sharpe Ratio:", daily_sampled_sharpe_ratio)
#Comparing between the portfolio and S&P500
daily_portfolio_value_normalized = daily_portfolio_value/daily_portfolio_value.ix[0]
df_SPY_normalized = df_SPY/df_SPY.ix[0]
df_comparsion = pd.concat([daily_portfolio_value_normalized, df_SPY_normalized], keys=["Portfolio", "SPY"], axis=1)
plot_data(df_comparsion, "Portfolio 2017 Normalized Price", "Date", "Price")
def simulate_strategy(date_start, date_end, folder_strategy, file_strategy, events=True):
dates = pd.date_range(date_start, date_end)
file_name = os.path.join(folder_strategy, '{}.csv'.format(file_strategy))
# Load orders
orders = pd.read_csv(file_name, index_col=0, parse_dates=True)
stock = orders.ix[0]['Symbol']
# Load stock data and join orders in the same DataFrame
prices_all = get_data([stock], dates)
df = prices_all[[stock]]
df = df.join(orders[['Order', 'Shares']])
# Back-Testing Algorithm
df['daily_val'] = 0.0
df['shorting'] = 1.0
hold = False
shorting = False
# Compute portfolio daily value
for i, row in df.iterrows():
if (row['Order'] == 'BUY LONG') | (row['Order'] == 'SELL SHORT'):
hold = True
n_stocks = row['Shares']
if row['Order'] == 'SELL SHORT':
shorting = True
if hold == True:
df.loc[i, 'Shares'] = n_stocks # replicate shares when stock is hold
df.loc[i, 'daily_val'] = n_stocks * row[stock]
if shorting:
df.loc[i, 'shorting'] = -1.0
if (row['Order'] == 'EXIT LONG') | (row['Order'] == 'EXIT SHORT'):
hold = False
shorting = False
# Compute daily returns
df['daily_return'] = df['daily_val'].diff()
df['daily_return'] = df['daily_return'] * df['shorting']
# Reset to 0 NaN and not valid daily_returns
df.ix[0, 'daily_return'] = 0
for (index1, row1),(index2, row2) in izip(df.iterrows(), df[1:].iterrows()):
if np.isnan(row1['Shares']) or np.isnan(row2['Shares']):
df.loc[index2, 'daily_return'] = 0.0
df['cum_return'] = df['daily_return'].cumsum()
# Compute cumulative portfolio value
T0 = df[~pd.isnull(df['Order'])].index[0] # Timestamp @ first investment
Val0 = df.ix[T0]['daily_val'] # Initial portfolio value
df['port_val'] = df['cum_return'] + Val0
# Plot Section
df_temp = pd.concat([df[stock]/df.ix[0][stock], df['port_val']/df.ix[T0]['port_val']], keys=[stock, 'Portfolio'], axis=1)
ax = df_temp.plot(figsize=(15, 10))
# Plot events
if events:
for day, key in orders.iterrows():
if key['Order'] == 'BUY LONG':
ax.axvline(x=day, color='green')
elif key['Order'] == 'SELL SHORT':
ax.axvline(x=day, color='red')
elif (key['Order'] == 'EXIT LONG') | (key['Order'] == 'EXIT SHORT'):
ax.axvline(x=day, color='black')
plt.show()
# Compute stats sections
sharpe_ratio, cum_ret, avg_daily_ret, std_daily_ret = get_portfolio_stats(df['port_val'])
sharpe_ratio_stock, cum_ret_stock, avg_daily_ret_stock, std_daily_ret_stock = get_portfolio_stats(df[stock])
# Compare portfolio against stock
print "Cumulative Return of Fund: {}".format(cum_ret)
print "Cumulative Return of {}: {}".format(stock, cum_ret_stock)
print
print "Standard Deviation of Fund: {}".format(std_daily_ret)
print "Standard Deviation of {}: {}".format(stock, std_daily_ret_stock)
print
print "Average Daily Return of Fund: {}".format(avg_daily_ret)
print "Average Daily Return of {}: {}".format(stock, avg_daily_ret_stock)
print
print "Sharpe Ratio of Fund: {}".format(sharpe_ratio)
print "Sharpe Ratio of {}: {}".format(stock, sharpe_ratio_stock)
print
print "Initial Portfolio Value: {}".format(df['port_val'][0])
print "Final Portfolio Value: {}".format(df['port_val'][-1])
print "Final Portfolio Return: {}".format(df['cum_return'][-1])
print "Final {} Return: {}".format(stock, (df[stock][-1]-df[stock][0])*n_stocks)
from selenium import webdriver
from selenium.webdriver.support.select import Select
import sys, time, unittest, re
import common.ReadConfig as co
sys.path.append('..')
from pages.loginpage import LoginPage
from pages.zf_userpage import UserPagezf
from pages.jqxxpage import JqxxPage
from pages.xfgk1cyed1xfedpage import Cyed1xfedPage
import utils.util as ut
file1 = ut.DATA_PATH + '/user_data.csv'
data1 = ut.get_data(file1)
file2 = ut.DATA_PATH + '/zfzjq_data.csv'
data2 = ut.get_data(file2)
url = co.getbrowsername('Url')
mark1 = 1
class TestCyed(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Firefox()
cls.driver.maximize_window()
cls.driver.get(url)
time.sleep(3)
cls.dl = LoginPage(cls.driver, Select)
cls.zfuser = UserPagezf(cls.driver, Select)
cls.jqxx = JqxxPage(cls.driver, Select)
cls.cyed1 = Cyed1xfedPage(cls.driver, Select)
@classmethod
from selenium import webdriver
from selenium.webdriver.support.select import Select
import sys, time, unittest
import common.ReadConfig as co
sys.path.append('..')
from pages.loginpage import LoginPage
from pages.jc_userpage import UserPage
import utils.util as ut
file1 = ut.DATA_PATH + '/user_data.csv'
data1 = ut.get_data(file1)
url = co.getbrowsername('Url')
#dri=co.getbrowsername('BrowserName')
mark1 = 1
class TestUser(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Firefox()
self.driver.maximize_window()
self.driver.get(url)
time.sleep(2)
self.dl = LoginPage(self.driver, Select)
self.user = UserPage(self.driver, Select)
def tearDown(self):
global mark1
mark1 += 1
self.driver.quit()
def testcase1(self):
'''用例1，新增用户成功'''
def run():
# Define default parameters
start_date = '2008-01-01'
end_date = '2009-12-31'
start_test_date = '2010-01-01'
end_test_date = '2010-12-31'
stock = 'IBM'
#check for user input of stocks and date range
if (len(sys.argv) > 1):
file_path = "data/" + sys.argv[1] + ".csv"
# Check if that file exists
if not os.path.exists(file_path) or not os.path.isfile(file_path):
print 'Data for the stock specified does not exist. Please reference stocks in the data folder, or run with no option provided (will display IBM data by default)'
return
stock = sys.argv[1]
dates = pd.date_range(start_date, end_date)
test_dates = pd.date_range(start_test_date, end_test_date)
#read in data that you're going to use
prices_all = get_data([stock], dates) # automatically adds SPY
test_prices_all = get_data([stock], test_dates)
#set up dataframe to train learner over
data = pd.DataFrame(index=dates)
data['actual_prices'] = prices_all[stock]
data['bb_value'] = prices_all[stock] - pd.rolling_mean(prices_all[stock],
window=5)
data['bb_value'] = data['bb_value'] / (
pd.rolling_std(prices_all[stock], window=5) * 2)
data['momentum'] = (prices_all[stock] /
prices_all[stock].shift(periods=-5)) - 1
data['volatility'] = pd.rolling_std(
((prices_all[stock] / prices_all[stock].shift(periods=-1)) - 1),
window=5)
data['y_values'] = prices_all[stock].shift(periods=-5)
data = data.dropna(subset=['actual_prices'])
trainX = data.iloc[4:, 0:-1]
trainY = data.iloc[4:, -1]
#set up data frame to test learner over
test_data = pd.DataFrame(index=test_dates)
test_data['actual_prices'] = test_prices_all[stock]
test_data['bb_value'] = test_prices_all[stock] - pd.rolling_mean(
test_prices_all[stock], window=5)
test_data['bb_value'] = test_data['bb_value'] / (
pd.rolling_std(test_prices_all[stock], window=5) * 2)
test_data['momentum'] = (test_prices_all[stock] /
test_prices_all[stock].shift(periods=-5)) - 1
test_data['volatility'] = pd.rolling_std(
((test_prices_all[stock] / test_prices_all[stock].shift(periods=-1)) -
1),
window=5)
test_data['y_values'] = test_prices_all[stock].shift(periods=-5)
test_data = test_data.dropna(subset=['actual_prices'])
testX = test_data.iloc[:, 0:-1]
testY = test_data.iloc[:, -1]
#create a KNN Learner for the data and add evidence to it
learner = knn.KNNLearner(3)
learner.addEvidence(trainX, trainY)
#run a simulation of the trading strategy based on predicted future values over training data
print "\nTraining Data Results:"
run_simulation(learner, prices_all, stock, trainX, trainY, dates,
"Unit3/orders/orders_trainingdata.csv")
calculate_portfolio_value("Unit3/orders/orders_trainingdata.csv",
prices_all, dates, stock)
#run a simulation of the trading strategy over previously unseen testing data to test it's performance
print "\nTest Data Results:"
run_simulation(learner, test_prices_all, stock, testX, testY, test_dates,
"Unit3/orders/orders_testdata.csv")
calculate_portfolio_value("Unit3/orders/orders_testdata.csv",
test_prices_all, test_dates, stock)
def calculate_portfolio_value(datafile, prices_all, dates, stock):
#read in the data from the order file
orders_df = pd.read_csv(datafile, index_col='Date', parse_dates=True)
orders_df = orders_df.sort_index(kind='mergesort')
#set up the data frame for the stocks over the period
daily_prices_df = pd.DataFrame(index=dates)
daily_prices_df = daily_prices_df.join(prices_all[stock])
daily_prices_df.dropna(inplace=True)
daily_prices_df['Cash'] = 1.0
#make an additional data frame called trades
trades_df = daily_prices_df.copy()
trades_df[0:] = 0.0
trades_df.loc[0:, 'Cash'] = 10000
#step through the orders frame and for each order update the trades table
for index, row in orders_df.iterrows():
symbol_to_update = row['Symbol']
amount_to_update = row['Shares']
if row['Order'] == "SELL":
amount_to_update = amount_to_update * -1.0
cash_gained_or_lost = amount_to_update * -1.0 * daily_prices_df.loc[
index, symbol_to_update]
current_holdings = amount_to_update + trades_df.loc[index,
symbol_to_update]
current_cash = cash_gained_or_lost + trades_df.loc[index, 'Cash']
trades_df.loc[index:, symbol_to_update] = current_holdings
trades_df.loc[index:, 'Cash'] = current_cash
value_of_portfolio = trades_df * daily_prices_df
portvals = value_of_portfolio.sum(axis=1)
if isinstance(portvals, pd.DataFrame):
portvals = portvals[portvals.columns[0]]
cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(
portvals)
# Simulate a $SPX-only reference portfolio to get stats
prices_SPX = get_data(['$SPX'], dates)
prices_SPX = prices_SPX[['$SPX']] # remove SPY
portvals_SPX = get_portfolio_value(prices_SPX, [1.0])
cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(
portvals_SPX)
# Compare portfolio against $SPX
print "Sharpe Ratio of Fund: {}".format(sharpe_ratio)
print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX)
print
print "Cumulative Return of Fund: {}".format(cum_ret)
print "Cumulative Return of $SPX: {}".format(cum_ret_SPX)
print
print "Standard Deviation of Fund: {}".format(std_daily_ret)
print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX)
print
print "Average Daily Return of Fund: {}".format(avg_daily_ret)
print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX)
print
print "Final Portfolio Value: {}".format(portvals[-1])
# Plot computed daily portfolio value
df_temp = pd.concat([portvals, prices_SPX['$SPX']],
keys=['Portfolio', '$SPX'],
axis=1)
plot_normalized_data(df_temp, title="Daily portfolio value and $SPX")
