def create_portfolio(data):
print("CREATING PORTFOLIO")
pf = Portfolio()
for index, row in data.iterrows():
ticker = row['Verdipapir']
amount = float(row['Antall'].replace(',', '.').replace(' ', ''))
kurs = float(row['Kurs'].replace(',', '.').replace(' ', ''))
vekslingskurs = float(row['Vekslingskurs'].replace(',', '.').replace(
' ', ''))
transaksjonstype = row['Transaksjonstype']
belop = float(row['Beløb'].replace(',', '.').replace(' ', ''))
# Deposit and withdraw cash
if transaksjonstype == 'INNSKUDD' or transaksjonstype == 'UTTAK INTERNET':
if transaksjonstype == 'INNSKUDD':
pf.deposit(belop)
if transaksjonstype == 'UTTAK INTERNET':
pf.withdraw(belop)
if transaksjonstype == 'KJØPT' or transaksjonstype == 'SALG':
a = Asset(ticker)
pf.buy(a, amount,
(kurs * vekslingskurs)) if belop < 0 else pf.sell(
a, amount, (kurs * vekslingskurs))
return pf
def test_update_befor_trade(self):
p = Portfolio(
buy_commission_rate=0.001,
sell_commission_rate=0.0015,
min_commission=5.0, round_lot=100)
p.buy(price=10.0, volume=1000)
p.update_before_trade(divide_rate=1.0)
self.assertEqual(1000, p.sellable)
self.assertEqual(0, p.frozen_volume)
self.assertEqual(0, p.transaction_cost)
p = Portfolio(
buy_commission_rate=0.001,
sell_commission_rate=0.0015, min_commission=5.0, round_lot=100,
divide_rate_threshold=1.005)
p.buy(price=10.0, volume=1000)
p.update_before_trade(divide_rate=1.1)
self.assertEqual(1100, p.volume)
self.assertEqual(1100, p.sellable)
# 有拆分
p.update_before_trade(divide_rate=1.006)
self.assertEqual(1106, p.volume)
self.assertEqual(1106, p.sellable)
# 没有拆分
p.update_before_trade(divide_rate=1.005)
self.assertEqual(1106, p.volume)
self.assertEqual(1106, p.sellable)
def trade_thresholds(prices_o, coins, start_amt, start_t, end_t, min_buy = -np.inf,
max_buy = np.inf, min_sell = -np.inf, max_sell = np.inf, fee = 0):
# buy/sell if change above/below some threshold % change
#
# input:
# prices : dataframe of price history
# coins : list of coins (by symbol) available to buy
# start_amt : initial investment amount
# choices : list of chosen coins by rank
# start_t, end_t : start and ending indices in price
# lag : the number of periods to look back to determine % gain (default 1)
# fee : trading fee as a fraction of total transaction (default 0)
#
# output:
# list with total value and amount of each coin held for each time t
pct_chg = pd.DataFrame(index = prices_o.index, columns = prices_o.columns)
for c in prices_o.columns:
pct_chg[c] = prices_o[c] / prices_o[c].shift(1) - 1
prices = prices_o.loc[start_t:end_t]
pct_chg = pct_chg.loc[start_t:end_t]
p = Portfolio(start_amt, coins, 0)
c_held = []
for i in range(len(prices.index)):
a = pct_chg.iloc[i]
a = a[a != np.inf]
a = a[~pd.isnull(a)]
for c in a.index:
p.update_price(c, pct_chg.iloc[i][c])
c_buy = [c for c in a.index if a[c] <= max_buy and a[c] >= min_buy]
c_sell = [c for c in a.index if a[c] <= max_sell and a[c] >= min_sell]
c_held = [c for c in set(c_held+c_buy) if c not in c_sell]
#print(c_buy, c_sell, c_held, a)
for c in c_sell:
p.sell(c, p.held[c])
if len(c_held) > 0:
amt_each = p.value() / len(c_held)
#print(p.value(), p.cash, amt_each)
for c in c_held:
if p.held[c] > amt_each:
p.sell(c, p.held[c] - amt_each)
for c in c_held:
if p.held[c] < amt_each:
p.buy(c, amt_each - p.held[c])
p.snapshot(i)
return p.hist
def hold_rebalance(prices_o, coins, start_amt, start_t, end_t, rebal_rate=1, fee=0):
# distribute cash evenly across available coins
#
# input:
# prices : dataframe of price history
# coins : list of coins (by symbol) available to buy
# start_amt : initial investment amount
# start_t, end_t : start and ending indices in price
# fee : trading fee as a fraction of total transaction (default 0)
#
# output:
# list with total value and amount of each coin held for each time t
pct_chg = pd.DataFrame(index = prices_o.index, columns = prices_o.columns)
for c in prices_o.columns:
pct_chg[c] = prices_o[c] / prices_o[c].shift(1) - 1
prices = prices_o.loc[start_t:end_t]
pct_chg = pct_chg.loc[start_t:end_t]
p = Portfolio(start_amt, coins, 0)
for i in range(len(prices.index)):
a = pct_chg.iloc[i]
a = a[a != np.inf]
a = a[~pd.isnull(a)]
for c in a.index:
p.update_price(c, pct_chg.iloc[i][c])
if i % rebal_rate == 0:
amt_each = p.value() / np.sum(prices.iloc[i] > 0)
for c in a.index:
if p.held[c] > amt_each:
p.sell(c, p.held[c] - amt_each)
for c in a.index:
if p.held[c] < amt_each:
p.buy(c, amt_each - p.held[c])
p.snapshot(i)
# confirm via averages
cash = [start_amt]
for i in range(1, len(prices.index)):
a = pct_chg.iloc[i]
a = a[a != np.inf]
a = a[~pd.isnull(a)]
avg_chg = np.average(a)
new_amt = cash[-1] * (avg_chg+1)
cash.append(new_amt)
return p.hist
class Simulator:
def __init__(self,
num_coins_per_order=1,
portfolio_cash=1000.0,
coin=Coin("ethereum"),
features=[
"rolling_mean", "rolling_std", "sharpe_ratio",
"bollinger_upper", "bollinger_lower"
]):
self.num_coins_per_order = num_coins_per_order
self.coin = coin
self.portfolio = Portfolio(portfolio_cash=portfolio_cash, coin=coin)
self.features = features
def get_current_state(self):
return self.portfolio.getCurrentState(self.features)
def get_current_holdings(self):
return self.portfolio.getCurrentHoldings()
def get_ran_action(self):
return Action(randint(0, 2))
def act_and_step(self, action):
#print 'Taking action:', action
if action == Action.BUY:
self.portfolio.buy(self.num_coins_per_order)
elif action == Action.SELL:
self.portfolio.sell(self.num_coins_per_order)
state = self.get_current_state()
reward = self.portfolio.getReturnsPercent()
if self.portfolio.step() is False:
return [state, reward, True]
return [state, reward, False]
def reset(self):
self.portfolio.reset()
def get_state_size(self):
return len(self.get_current_state())
def get_action_size(self):
return len(Action)
def plot_coin_price(self):
self.coin.plot()
def test_buy(self):
p = Portfolio(
buy_commission_rate=0.001,
sell_commission_rate=0.0015,
min_commission=5.0, round_lot=100)
self.assertEqual((-10010.0, 10.0, 1000),
p.buy(price=10.0, volume=1000))
self.assertEqual(10.0, p.transaction_cost)
self.assertEqual(10.01, p.avg_price)
self.assertEqual(10.0, p._price)
self.assertEqual(1000, p.volume)
self.assertEqual(1000, p.frozen_volume)
self.assertEqual(10.0, p.all_transaction_cost)
self.assertEqual((-10010.0, 10.0, 1000),
p.buy(price=10.0, volume=1000))
self.assertEqual(20.0, p.transaction_cost)
self.assertEqual(10.01, p.avg_price)
self.assertEqual(10.0, p._price)
self.assertEqual(2000, p.volume)
self.assertEqual(2000, p.frozen_volume)
self.assertEqual(20.0, p.all_transaction_cost)
def buy_and_hold(prices_o, coins, start_amt, start_t, end_t, fee=0):
# invest an equal amount in each coin and hodl
#
# input:
# prices_o : dataframe of price history
# coins : list of coins (by symbol) available to buy
# start_amt : initial investment amount
# start_t, end_t : start and ending indices in price
# fee : trading fee as a fraction of total transaction (default 0)
#
# output:
# list with total value and amount of each coin held for each time t
pct_chg = pd.DataFrame(index = prices_o.index, columns = prices_o.columns)
for c in prices_o.columns:
pct_chg[c] = prices_o[c] / prices_o[c].shift(1) - 1
prices = prices_o.loc[start_t:end_t]
pct_chg = pct_chg.loc[start_t:end_t]
p = Portfolio(start_amt, coins, fee)
amt_each = start_amt / len(coins)
for c in coins:
if prices.iloc[0][c] > 0:
p.buy(c, amt_each, 0)
p.snapshot(0)
for i in range(1, len(prices.index)):
for c in coins:
if prices.iloc[i-1][c] > 0:
p.update_price(c, pct_chg.iloc[i][c])
elif prices.iloc[i][c] > 0:
p.buy(c, amt_each, 0)
p.snapshot(i)
return p.hist
def test_sell(self):
p = Portfolio(
buy_commission_rate=0.001,
sell_commission_rate=0.0015, min_commission=5.0, round_lot=100)
self.assertEqual((-10010.0, 10.0, 1000),
p.buy(price=10.0, volume=1000))
p.update_before_trade(divide_rate=1.0)
p.sell(price=11, volume=500)
self.assertEqual(8.25, p.transaction_cost)
self.assertEqual(9.0365, p.avg_price)
self.assertEqual(11.0, p._price)
self.assertEqual(500, p.volume)
self.assertEqual(500, p.sellable)
self.assertEqual(18.25, p.all_transaction_cost)
p.sell(price=11, volume=500)
self.assertEqual(16.5, p.transaction_cost)
self.assertEqual(0, p.avg_price)
self.assertEqual(11, p._price)
self.assertEqual(0, p.volume)
self.assertEqual(0, p.sellable)
self.assertEqual(26.5, p.all_transaction_cost)
def test_buy_two_stock(self):
p = Portfolio()
p.buy('IBM',100, 176.48)
p.buy('HPQ',100, 36.15)
assert p.cost() == 21263.0
def test_buy_two_stock(self):
p = Portfolio()
p.buy('IBM',100, 176.48)
p.buy('HPQ',100, 36.15)
assert p.cost() == 21263.0
def test_buy_two_stock(self):
p = Portfolio()
p.buy('IBM',100, 176.48)
p.buy('HPQ',100, 36.15)
self.assertEqual(p.cost(),21263.0)
def test_buy_two_stock(self):
p = Portfolio()
p.buy('IBM', 100, 176.48)
p.buy('HPQ', 100, 36.15)
self.assertEqual(p.cost(), 21263.0)
def trade_top_n_except(prices_o, coins, start_amt, choices, start_t, end_t, bear_thresh=-0.1, lag = 1, hold_for = 1, fee=0):
# distribute investment across coins by rank in % gain
#
# input:
# prices : dataframe of price history
# coins : list of coins (by symbol) available to buy
# start_amt : initial investment amount
# choices : list of chosen coins by rank
# start_t, end_t : start and ending indices in price
# lag : the number of periods to look back to determine % gain (default 1)
# fee : trading fee as a fraction of total transaction (default 0)
#
# output:
# list with total value and amount of each coin held for each time t
pct_chg = pd.DataFrame(index = prices_o.index, columns = prices_o.columns)
for c in prices_o.columns:
pct_chg[c] = prices_o[c] / prices_o[c].shift(1) - 1
prices = prices_o.loc[start_t:end_t]
pct_chg = pct_chg.loc[start_t:end_t]
p = Portfolio(start_amt, coins, 0)
if lag > 1:
for i in range(lag-1):
p.snapshot(i)
amt_each = p.value() / len(choices)
a = pct_chg.iloc[0]
a = a[a != np.inf]
a = a[~pd.isnull(a)]
cnt = 0
avg = np.average(a)
#print(avg)
c_choose = []
if avg < bear_thresh:
cnt += 1
for c in choices:
c_choose.append(a.sort_values(ascending=True).index[c])
#print(a.sort_values(ascending=True))
else:
for c in choices:
c_choose.append(a.sort_values(ascending=False).index[c])
#print(a.sort_values(ascending=False))
for c in c_choose:
p.buy(c, amt_each, 0)
p.snapshot(lag-1)
for i in range(lag, len(prices.index)):
a = [1 for x in pct_chg.iloc[i]]
for j in range(lag):
a *= 1 + pct_chg.iloc[i-j]
a = a[a != np.inf]
a = a[~pd.isnull(a)]
avg = np.average(a)
#print(avg)
c_choose = []
if avg < 1+bear_thresh:
cnt += 1
for c in choices:
c_choose.append(a.sort_values(ascending=True).index[c])
#print(a.sort_values(ascending=True))
else:
for c in choices:
c_choose.append(a.sort_values(ascending=False).index[c])
#print(a.sort_values(ascending=False))
for c in a.index:
p.update_price(c, pct_chg.iloc[i][c])
if i % hold_for != 0:
p.snapshot(i)
continue
amt_each = p.value() / len(choices)
for c in a.index:
if c not in c_choose:
p.sell(c)
elif p.held[c] > amt_each:
p.sell(c, p.held[c] - amt_each)
for c in c_choose:
if p.held[c] < amt_each:
p.buy(c, amt_each - p.held[c])
p.snapshot(i)
#print(cnt)
return p.hist
def test_buy_two_stock(self):
p = Portfolio()
p.buy('IBM', 100, 176.48)
p.buy('HPQ', 100, 36.15, 'blah')
self.assertCostEqual(p, 21263.0)
def test_buy_one_stock(self):
p = Portfolio()
p.buy('IBM', 100, 176.48)
self.assertEqual(p.cost(), 17648.0)
selected_portfolio = Strategies.embedding_classification(
PORTFOLIO_SIZE, model, embedding_matrix, embedding_list)
# print("=============================================================================================")
# print("Stock Network: {}".format(NETWORK_NAME))
# print("\nselected_portfolio: ", selected_portfolio)
# print("\nBuy at: {}, Sell at {}".format(BUY_DATE, SELL_DATE))
# print("\nCurrent cash: {}".format(STOCK_PORTFOLIO.cash))
# print("number of node: {}".format(len(STOCK_NETWORK)))
## Buy assets
for asset in selected_portfolio:
stock = asset[0]
weight = asset[1]
date_index = get_date_index(STOCK_MAP, stock, BUY_DATE)
price = STOCK_MAP[stock]['price'][date_index]
STOCK_PORTFOLIO.buy(stock, price, weight)
## Sell assets
for asset in selected_portfolio:
stock = asset[0]
date_index = get_date_index(STOCK_MAP, stock, SELL_DATE)
price = STOCK_MAP[stock]['price'][date_index]
STOCK_PORTFOLIO.sell(stock, price)
PORTFOLIO_VALUE.append(STOCK_PORTFOLIO.cash)
## Buy assets
_index_portfolio = [('SPY', 1)]
for asset in _index_portfolio:
stock = asset[0]
weight = asset[1]
from portfolio import Portfolio
p = Portfolio()
print("Empty portfolio cost: {}".format(p.cost()))
p.buy('IBM', 100, 176.48)
print("With 100 IBM @ 176.48: {}".format(p.cost()))
p.buy("HPQ", 100, 36.15)
print("With 100 HPQ @ 36.15: {}".format(p.cost()))
def test_buy_one_stock(self):
p = Portfolio()
p.buy('IBM',100, 176.48)
self.assertEqual(p.cost(),17648.0)
def test_buy_two_stocks(self):
p = Portfolio()
p.buy("IBM", 100, 176.48)
p.buy("HPQ", 100, 36.15)
assert p.cost() == 21263.0
def test_buy_one_stock(self):
p = Portfolio()
p.buy("IBM", 100, 176.48)
assert p.cost() == 17648.0
from portfolio import Portfolio
p = Portfolio()
print("Empty portfolio cost: {}, should be 0.0".format(p.cost()))
assert p.cost() == 0
p.buy('IBM', 100, 176.48)
print("With 100 IBM @ 176.48: {}, should be 17648.0".format(p.cost()))
assert p.cost() == 17648.0
p.buy("HPQ", 100, 36.15)
print("With 100 HPQ @ 36.15: {}, should be 21263.0".format(p.cost()))
assert p.cost() == 21263.0
def test_buy_one_stock(self):
p = Portfolio()
p.buy('IBM',100, 176.48)
assert p.cost() == 17648.0
def test_buy_two_stock(self):
p = Portfolio()
p.buy('IBM',100, 176.48)
p.buy('HPQ',100, 36.15, 'blah')
self.assertCostEqual(p,21263.0)
