Ejemplo n.º 1
0
def handle_data(context, data):
    print context.portfolio.portfolio_value
    # Skip first 300 days to get full windows
    context.i += 1
    if context.i < 300:
        return

    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    short_mavg = history(100, '1d', 'price').mean()
    long_mavg = history(300, '1d', 'price').mean()

    sym = symbol('AAPL')

    # Trading logic
    if short_mavg[sym] > long_mavg[sym]:
        # order_target orders as many shares as needed to
        # achieve the desired number of shares.
        order_target(sym, 100)
    elif short_mavg[sym] < long_mavg[sym]:
        order_target(sym, 0)

    # Save values for later inspection
    record(AAPL=data[sym].price,
           short_mavg=short_mavg[sym],
           long_mavg=long_mavg[sym])
Ejemplo n.º 2
0
def handle_data(context, data):
    # Skip first 300 days to get full windows
    context.i += 1
    if context.i < 300:
        return

    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    short_mavg = history(100, '1d', 'price').mean()
    long_mavg = history(300, '1d', 'price').mean()
    # price_history = data.history(assets=symbol('TEST'), fields="price", bar_count=5, frequency="1d")

    # Trading logic
    if short_mavg[0] > long_mavg[0]:
        # order_target orders as many shares as needed to
        # achieve the desired number of shares.
        order_target(symbol('AAPL'), 100)
    elif short_mavg[0] < long_mavg[0]:
        order_target(symbol('AAPL'), 0)

    # Save values for later inspection
    record(AAPL=data[symbol('AAPL')].price,
           short_mavg=short_mavg[0],
           long_mavg=long_mavg[0])
Ejemplo n.º 3
0
def handle_data(context, data):

    context.i += 1
    if context.i < 20:
        return

    ma5 = history(5, '1d', 'price').mean()
    ma20 = history(20, '1d', 'price').mean()
    buy = False
    sell = False

    sym = symbol('HMD')
    if ma5[sym] > ma20[sym] and context.investment == False:
        order_target(sym, 1)
        context.investment = True
        buy = True

    elif ma5[sym] < ma20[sym] and context.investment == True:
        order_target(sym, -1)
        context.investment = False
        sell = True

    record(HMD=data[sym].price,
           ma5=ma5[sym],
           ma20=ma20[sym],
           buy=buy,
           sell=sell)
Ejemplo n.º 4
0
def handle_data(context, data):
    # Skip first 300 days to get full windows
    context.i += 1
    dp = context.history_container.digest_panels
    for k in dp.keys():
        df = dp[k].buffer['price']
        a = df.dropna()
        print('No.', context.i, ':Len.', len(a))
        print('Contents:')
        print(a)

    print(context.history_container.buffer_panel.buffer['price'])

    if context.i < 40:
        return

    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    short_mavg = history(20, '1d', 'price').mean()
    long_mavg = history(40, '1d', 'price').mean()

    # Trading logic
    if short_mavg[context.sym] > long_mavg[context.sym]:
        # order_target orders as many shares as needed to
        # achieve the desired number of shares.
        order_target(context.sym, 100)
    elif short_mavg[context.sym] < long_mavg[context.sym]:
        order_target(context.sym, 0)

    # Save values for later inspection
    record(AAPL=data[context.sym].price,
           short_mavg=short_mavg[context.sym],
           long_mavg=long_mavg[context.sym])
Ejemplo n.º 5
0
def handle_data(context, data):
    # Skip first 300 days to get full windows
    context.i += 1
    if context.i < context.N:
        return

    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    c = history(context.N, '1d', 'close')
    o = history(context.N, '1d', 'open')
    h = history(context.N, '1d', 'high')
    l = history(context.N, '1d', 'low')
    for sym in data:
        # Trading logic
        hh = h[sym].ix[:-1].max()
        hc = c[sym].ix[:-1].max()
        lc = c[sym].ix[:-1].min()
        ll = l[sym].ix[:-1].min()
        r = max(hh-lc, hc-ll)
        upper = data[sym].open + context.k * r
        lower = data[sym].open - context.k * r

        if short_mavg[sym] > long_mavg[sym] and not context.invested:
            # order_target orders as many shares as needed to
            # achieve the desired number of shares.
            order(sym, 10000, limit_price=data[sym].price)
            context.invested = True
        elif short_mavg[sym] < long_mavg[sym] and context.invested:
            order(sym, -10000, limit_price=data[sym].price)
            context.invested = False
Ejemplo n.º 6
0
def handle_data_magc(context, data):
    context.i += 1
    if context.i < 60:
        return

    ma20 = history(20, '1d', 'price').mean()
    ma60 = history(60, '1d', 'price').mean()

    buy = False
    sell = False

    sym = symbol(code)

    count = int(100000 /  data[sym].price)
    
    if context.investment == False:
        if ma20[sym] > ma60[sym] :
            order_target(sym, count)
            context.investment = True
            context.buy_price = data[sym].price
            buy = True
    else:
        if (data[sym].price > context.buy_price + (context.buy_price * sell_point)):
            order_target(sym, -count)
            context.investment = False
            sell = True
            
    record(code=data[sym].price, ma20=ma20[sym], ma60=ma60[sym], buy=buy, sell=sell)
Ejemplo n.º 7
0
def handle_data(context, data):
    rebalance_period = 20

    context.tick += 1
    if context.tick < 120 :
        return
    if context.tick % rebalance_period != 0:
        return


    # Get rolling window of past prices and compute returns
    prices_6m = history(120, '1d', 'price').dropna()
    returns_6m = prices_6m.pct_change().dropna()
    prices_60d = history(60, '1d', 'price').dropna()
    returns_60d = prices_60d.pct_change().dropna()



    try:
        # Get the strongest 5 in momentum
        mom = returns_6m.T.sum(axis=1)
        selected_indices = mom[mom>0].order().tail(len(mom) /2).index
#         selected_indices = mom.index
#         selected_indices = mom[mom > 0 ].index
        selected_returns = returns_60d[selected_indices]

        weights = minimize_vol(selected_returns.T)
#         weights = minimize_vol(returns_60d.T)
        # Rebalance portfolio accordingly
        for stock, weight in zip(selected_returns.columns, weights):
            order_target_percent(stock, weight)
    except :
        # Sometimes this error is thrown
        # ValueError: Rank(A) < p or Rank([P; A; G]) < n
        pass
Ejemplo n.º 8
0
    def handle_data(self, context, data):
        rebalance_period = 20

        context.tick += 1
        if context.tick < 120:
            return
        if context.tick % rebalance_period != 0:
            return

        # Get rolling window of past prices and compute returns
        prices_6m = history(120, '1d', 'price').dropna()
        returns_6m = prices_6m.pct_change().dropna()
        prices_60d = history(60, '1d', 'price').dropna()
        returns_60d = prices_60d.pct_change().dropna()

        try:
            # Get the strongest 5 in momentum
            mom = returns_6m.T.sum(axis=1)
            #selected_indices = mom[mom>0].order().tail(len(mom) /2).index
            selected_indices = mom.index
            #selected_indices = mom[mom > 0 ].index
            selected_returns = returns_60d[selected_indices]

            weights = self.minimize_vol(selected_returns.T)
            #         weights = minimize_vol(returns_60d.T)
            # Rebalance portfolio accordingly
            for stock, weight in zip(selected_returns.columns, weights):
                order_target_percent(stock, weight)
        except:
            # Sometimes this error is thrown
            # ValueError: Rank(A) < p or Rank([P; A; G]) < n
            pass
Ejemplo n.º 9
0
def handle_data(context, data):
    
    #trading algorithm (executed on every event)
    
    #skip first 300 days to get full windows
    context.i += 1
    if context.i < 300:
        return
    
    #compute short and long moving averages:
    short_mavg = history(100, '1d', 'price').mean()
    long_mavg = history(300, '1d', 'price').mean()
    
    buy = False
    sell = False
    
    #trading logic
    if (short_mavg[0] > long_mavg[0]) and not context.invested:
        buy = True
        context.invested = True
        order_target(symbol('AAPL'), 100)        
    elif (short_mavg[0] < long_mavg[0]) and context.invested:
        sell = True
        context.invested = False
        order_target(symbol('AAPL'), -100)
    
    #save values for plotting
    record(AAPL = data[symbol('AAPL')].price,
           short_mavg = short_mavg[0],
           long_mavg = long_mavg[0],
           buy=buy,
           sell=sell)
Ejemplo n.º 10
0
    def handle_data(self, context, data):
        rebalance_period = 20

        context.tick += 1
        if context.tick % rebalance_period != 0:
            return


        # Get rolling window of past prices and compute returns
        prices_6m = history(120, '1d', 'price').dropna()
        returns_6m = prices_6m.pct_change().dropna()
        prices_60d = history(60, '1d', 'price').dropna()
        returns_60d = prices_60d.pct_change().dropna()

        try:
            # Get the strongest 5 in momentum
            mom = returns_6m.T.sum(axis=1)
            selected = (mom > np.median(mom)) * 1

            # 60 days volatility
            vol = np.std(returns_60d.T, axis=1)
            vol_target = 0.01
            wt = vol_target / vol * 0.2
            wt[wt > 0.2] = 0.2
            #
            weights = wt * selected
            # Rebalance portfolio accordingly
            for stock, weight in zip(prices_60d.columns, weights):
                order_target_percent(stock, weight)
        except ValueError as e:
            # Sometimes this error is thrown
            # ValueError: Rank(A) < p or Rank([P; A; G]) < n
            pass
Ejemplo n.º 11
0
def handle_data(context, data):
    # Skip first 300 days to get full windows
    context.i += 1
    dp = context.history_container.digest_panels
    for k in dp.keys():
        df = dp[k].buffer['price']
        a = df.dropna()
        print('No.',context.i,':Len.',len(a))
        print('Contents:')        
        print(a)
        
    print(context.history_container.buffer_panel.buffer['price'])

    if context.i < 40:
        return

    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    short_mavg = history(20, '1d', 'price').mean()
    long_mavg = history(40, '1d', 'price').mean()

    # Trading logic
    if short_mavg[context.sym] > long_mavg[context.sym]:
        # order_target orders as many shares as needed to
        # achieve the desired number of shares.
        order_target(context.sym, 100)
    elif short_mavg[context.sym] < long_mavg[context.sym]:
        order_target(context.sym, 0)

    # Save values for later inspection
    record(AAPL=data[context.sym].price,
           short_mavg=short_mavg[context.sym],
           long_mavg=long_mavg[context.sym])
Ejemplo n.º 12
0
    def handle_data(self, context, data):
        rebalance_period = 20

        context.tick += 1
        if context.tick % rebalance_period != 0:
            return

        # Get rolling window of past prices and compute returns
        prices_6m = history(120, '1d', 'price').dropna()
        returns_6m = prices_6m.pct_change().dropna()
        prices_60d = history(60, '1d', 'price').dropna()
        returns_60d = prices_60d.pct_change().dropna()

        try:
            # Get the strongest 5 in momentum
            mom = returns_6m.T.sum(axis=1)
            selected = (mom > np.median(mom)) * 1

            # 60 days volatility
            vol = np.std(returns_60d.T, axis=1)
            vol_target = 0.01
            wt = vol_target / vol * 0.2
            wt[wt > 0.2] = 0.2
            #
            weights = wt * selected
            # Rebalance portfolio accordingly
            for stock, weight in zip(prices_60d.columns, weights):
                order_target_percent(stock, weight)
        except ValueError as e:
            # Sometimes this error is thrown
            # ValueError: Rank(A) < p or Rank([P; A; G]) < n
            pass
Ejemplo n.º 13
0
def handle_data(context, data):
    # Skip first 300 days to get full windows
    context.i += 1
    if context.i < 10:
        return

    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    short_mavg = history(5, '1d', 'price').mean()
    long_mavg = history(10, '1d', 'price').mean()

    for sym in data:
        # sym = data.keys()[0]
        # sym = data.keys()[0]

        # Trading logic
        if short_mavg[sym] > long_mavg[sym] and not context.invested:
            # order_target orders as many shares as needed to
            # achieve the desired number of shares.
            order_target(sym, 5000)
            context.invested = True
        elif short_mavg[sym] < long_mavg[sym] and context.invested:
            order_target(sym, 0)
            context.invested = False
Ejemplo n.º 14
0
def handle_data(context, data):
    # Skip first 300 days to get full windows
    context.i += 1
    if context.i < 300:
        return

    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    short_mavg = history(100, '1d', 'price').mean()
    long_mavg = history(300, '1d', 'price').mean()

    sym = symbol('AAPL')

    # Trading logic
    if short_mavg[sym] > long_mavg[sym]:
        # order_target orders as many shares as needed to
        # achieve the desired number of shares.
        order_target(sym, 100)
    elif short_mavg[sym] < long_mavg[sym]:
        order_target(sym, 0)

    # Save values for later inspection
    record(AAPL=data[sym].price,
           short_mavg=short_mavg[sym],
           long_mavg=long_mavg[sym])
Ejemplo n.º 15
0
def handle_data(context, data):
    
    # context.i+=1
    # if context.i<=5:
    #     return
    # 循环每只股票

    closeprice= history(5,'1d','close')
    for security in context.stocks:
        vwap=(closeprice[symbol(security)][-2]+closeprice[symbol(security)][-3]+closeprice[symbol(security)][-4])/3
        price = closeprice[symbol(security)][-2]
        print get_datetime(),security,vwap,price
        # # 如果上一时间点价格小于三天平均价*0.995,并且持有该股票,卖出
        if price < vwap * 0.995:
            # 下入卖出单
            order(symbol(security),-300)
            print get_datetime(),("Selling %s" % (security))
            # 记录这次卖出
            #log.info("Selling %s" % (security))
        # 如果上一时间点价格大于三天平均价*1.005,并且有现金余额,买入
        elif price > vwap * 1.005:
            # 下入买入单
            order(symbol(security),300)
            # 记录这次买入
            print get_datetime(),("Buying %s" % (security))
Ejemplo n.º 16
0
    def top_rets(self, tickers, win):
        hist = history(bar_count=241, frequency='1d', field='price')

        ret = ((hist / hist.shift(win)) - 1).tail(1)
        mean_ret = float(np.median(ret))
        max_ret = float(ret.max(axis=1))
        spy_ret = float(ret[symbol(self.ticker_spy)])

        lst = {}
        lst['mean'] = []
        lst['spy'] = []
        lst['zero'] = []
        lst['max'] = []

        for ticker in tickers:
            ticker_ret = float(ret[ticker])
            if ticker_ret > mean_ret:
                lst['mean'].append(ticker)
            if ticker_ret > spy_ret:
                lst['spy'].append(ticker)
            if ticker_ret > 0:
                lst['zero'].append(ticker)
            if ticker_ret >= max_ret:
                lst['max'].append(ticker)
        return lst
Ejemplo n.º 17
0
def handle_data_macd(context, data):
    context.i += 1
    if context.i < 60:
        return

    buy = False
    sell = False

    sym = symbol(code)

    count = int(100000 /  data[sym].price)

    prices = history(40, '1d', 'price')
    macd = prices.apply(MACD, fastperiod=12, slowperiod=26, signalperiod=9)
 
    if context.investment == False:
        if macd[sym] > 0 and context.position == -1:
            order_target(sym, count)
            context.investment = True
            context.buy_price = data[sym].price
            buy = True
            context.position = 1
    else:
        if (data[sym].price > context.buy_price + (context.buy_price * sell_point)):
            order_target(sym, -count)
            context.investment = False
            sell = True

    if macd[sym] < 0 :
        context.position = -1
    
    if macd[sym] > 0 :
        context.position = 1
            
    record(code=data[sym].price, macd=macd[sym], buy=buy, sell=sell)
Ejemplo n.º 18
0
def handle_data(context, data):

    #Get a trailing window of data
    prices = history(15, '1d', 'price')


    # Use pandas dataframe.apply to get the last RSI value
    # for for each stock in our basket
    rsi_data = prices.apply(talib.RSI, timeperiod=14).iloc[-1]

    intc_rsi = rsi_data[context.intc]

    # check how many shares of Intel we currently own
    current_intel_shares = context.portfolio.positions[context.intc].amount

    # until 14 time periods have gone by, the rsi value will be numpy.nan

    # RSI is above 70 and we own GOOG, time to close the position.
    if intc_rsi > context.HIGH_RSI and current_intel_shares > 0:
        order_target(context.intc, 0)
        log.info('RSI is at ' + str(intc_rsi) + ', selling ' + str(current_intel_shares) + ' shares')

    # RSI is below 30 and we don't have any Intel stock, time to buy.
    elif intc_rsi < context.LOW_RSI and current_intel_shares == 0:
        num_shares = math.floor(context.max_notional / data[context.intc].close_price)
        order(context.intc, num_shares)
        log.info('RSI is at ' + str(intc_rsi) + ', buying ' + str(num_shares)  + ' shares')

    # record the current RSI value and the current price of INTC.
    record(intcRSI=intc_rsi, intcPRICE=data[context.intc].close_price)
Ejemplo n.º 19
0
    def handle_data(context, data):
        context.iwarmup = context.iwarmup + 1

        if context.iwarmup <= (context.history_depth + 1):
            return

        dfHistD = history(30, '1d', 'price')

        S = context.secs[0]

        CurP = data[S].price
        BolU, BolM, BolL = talib.BBANDS(dfHistD[S].values,
                                        timeperiod=context.BBANDS_timeperiod,
                                        nbdevup=context.BBANDS_nbdevup,
                                        nbdevdn=context.BBANDS_nbdevdn,
                                        matype=0)

        record(CurP=CurP, BolU=BolU[-1], BolM=BolM[-1], BolL=BolL[-1])

        if CurP < BolL[-1]:

            order_target_percent(S, +0.97)

        elif CurP > BolU[-1]:
            order_target_percent(S, -0.97)

        return
Ejemplo n.º 20
0
def handle_data(context, data):
    print context
    #raw_input()

    #输出每天持仓情况

    if not context.has_ordered:
        for stock in data:
            #openprice=history(3, '1d', 'open')
            closeprice = history(5, '1d', 'close')
            #-2:昨天,-3 前天.-4 大前天
            print get_datetime(), closeprice[sid(stock)][0], closeprice[sid(
                stock)][1], closeprice[sid(stock)][2], closeprice[sid(
                    stock)][3], closeprice[sid(stock)][4]
            #print closeprice,closeprice[sid(stock)][1]
            if closeprice[sid(stock)][-2] > closeprice[sid(
                    stock)][-3] and closeprice[sid(stock)][-3] > closeprice[
                        sid(stock)][-4]:
                print "buy", get_datetime()
                order(stock, 300)
            elif closeprice[sid(stock)][-2] < closeprice[sid(
                    stock)][-3] and closeprice[sid(stock)][-3] < closeprice[
                        sid(stock)][-4]:
                print "sell", get_datetime()
                order(stock, -300)
Ejemplo n.º 21
0
def handle_data(context, data):
    logging.debug('enter handle_data')
    context.i += 1
    if context.i < context.rsi_window:
        return

    # get the last RSI value
    prices = history(context.rsi_window, '1d', 'price')
    sec_rsi = talib.RSI(prices[context.security].values,
                        timeperiod=context.rsi_window - 1)

    # buy and sell flags
    buy = False
    sell = False

    if sec_rsi[-1] < context.LOW_RSI and not context.invested:
        # RSI under 30 indicates oversold, time to buy
        order_target(context.security, 1000)
        logging.debug('Buying {}'.format(context.security))
        context.invested = True
        buy = True

    elif sec_rsi[-1] > context.HIGH_RSI and context.invested:
        # RSI over 70 indicates overbought, sell everything
        order_target(context.security, 0)
        logging.debug('Selling {}'.format(context.security))
        context.invested = False
        sell = True

    # record data for each time increment
    record(secRSI=sec_rsi[-1],
           price=data[context.security].price,
           buy=buy,
           sell=sell)
    logging.info(context.portfolio.cash)
Ejemplo n.º 22
0
def handle_data(context, data):
    # Skip first 300 days to get full windows

    date = get_datetime()
    context.i += 1
    if context.i < 10:
        return

    prices = history(25, '1d', 'price')

    for sym in data:
        upper, middle, lower = talib.BBANDS(
            np.array(prices[sym]),
            timeperiod=20,
            nbdevup=2,
            nbdevdn=2,
            matype=0
        )

        potential_buy = []

        buy = False
        sell = False
        if data[sym].price > upper[-1] and context.portfolio.positions[sym].amount == 0:
            # log.info('buy')
            # log.info(get_datetime())
            # log.info(data[sym].price)
            # log.info(upper[-1])
            order_target_percent(sym, 1.0, limit_price=data[sym].price)
        elif data[sym].price < middle[-1] and context.portfolio.positions[sym].amount > 0:
            # log.info('sell')
            # log.info(get_datetime())
            # log.info(data[sym].price)
            # log.info(middle[-1])
            order_target(sym, 0, limit_price=data[sym].price)
Ejemplo n.º 23
0
def handle_data_bband(context, data):
    context.i += 1
    if context.i < 20:
        return

    buy = False
    sell = False

    sym = symbol(code)

    count = int(100000 /  data[sym].price)

    prices = history(20, '1d', 'price')
    upper, middle, lower = ta.BBANDS(
        prices[sym].values,
        timeperiod=20,
        nbdevup=2,
        nbdevdn=2,
        matype=0)
 
    if context.investment == False:
        if lower[-1] > data[sym].price:
            order_target(sym, count)
            context.investment = True
            context.buy_price = data[sym].price
            buy = True
            context.position = 1
    else:
        if (data[sym].price > context.buy_price + (context.buy_price * sell_point)):
            order_target(sym, -count)
            context.investment = False
            sell = True
            
    record(code=data[sym].price, upper=upper[-1], lower=lower[-1], makeBacktestingDataFrame=middle[-1], buy=buy, sell=sell)
Ejemplo n.º 24
0
def handle_data(context, data):
    '''
    Called when a market event occurs for any of the algorithm's 
    securities. 

    Parameters

    data: A dictionary keyed by security id containing the current 
          state of the securities in the algo's universe.

    context: The same context object from the initialize function.
             Stores the up to date portfolio as well as any state 
             variables defined.

    Returns None
    '''
    # Allow history to accumulate 100 days of prices before trading
    # and rebalance every day thereafter.
    context.tick += 1
    if context.tick < 100:
        return
    # Get rolling window of past prices and compute returns
    prices = history(100, '1d', 'price').dropna()
    returns = prices.pct_change().dropna()
    try:
        # Perform Markowitz-style portfolio optimization
        weights, _, _ = optimal_portfolio(returns.T)
        # Rebalance portfolio accordingly
        for stock, weight in zip(prices.columns, weights):
            order_target_percent(stock, weight)
    except ValueError as e:
        # Sometimes this error is thrown
        # ValueError: Rank(A) < p or Rank([P; A; G]) < n
        pass
Ejemplo n.º 25
0
def handle_data(context, data):
#     order(symbol('035720'), 1)

    context.i += 1
    if context.i < 20:
        return

    ma5 = history(5, '1d', 'price').mean()
    ma20 = history(20, '1d', 'price').mean()
    sym = symbol(context.stockCd)
    record(kakao=data[sym].price, ma5=ma5[sym], ma20=ma20[sym])
    
    if ma5[sym] > ma20[sym]:
        order_target(sym, 1)
    else:
        order_target(sym, -1)
def handle_data(context, data):
    '''
    Called when a market event occurs for any of the algorithm's 
    securities. 

    Parameters

    data: A dictionary keyed by security id containing the current 
          state of the securities in the algo's universe.

    context: The same context object from the initialize function.
             Stores the up to date portfolio as well as any state 
             variables defined.

    Returns None
    '''
    # Allow history to accumulate 100 days of prices before trading
    # and rebalance every day thereafter.
    context.tick += 1
    if context.tick < 100:
        return
    # Get rolling window of past prices and compute returns
    prices = history(100, '1d', 'price').dropna()
    returns = prices.pct_change().dropna()
    try:
        # Perform Markowitz-style portfolio optimization
        weights, _, _ = optimal_portfolio(returns.T)
        # Rebalance portfolio accordingly
        for stock, weight in zip(prices.columns, weights):
            order_target_percent(stock, weight)
    except ValueError as e:
        # Sometimes this error is thrown
        # ValueError: Rank(A) < p or Rank([P; A; G]) < n
        pass
Ejemplo n.º 27
0
    def top_rets(self, tickers, win) :
        hist = history(bar_count = 241, frequency='1d', field='price')

        ret = ((hist/hist.shift(win)) - 1).tail(1)
        mean_ret = float(np.median(ret))
        max_ret = float(ret.max(axis=1))
        spy_ret = float(ret[symbol(self.ticker_spy)])

        lst = {}
        lst['mean'] = []
        lst['spy'] = []
        lst['zero'] = []
        lst['max'] = []

        for ticker in tickers :
            ticker_ret = float(ret[ticker])
            if ticker_ret > mean_ret :
                lst['mean'].append(ticker)
            if ticker_ret > spy_ret:
                lst['spy'].append(ticker)
            if ticker_ret > 0:
                lst['zero'].append(ticker)
            if ticker_ret >= max_ret:
                lst['max'].append(ticker)
        return lst
def handle_data(context, data):
    context.i += 1
    if context.i < 300:
        return

    short_mvag = history(100, '1d', 'price').mean()
    long_mvad = history(300, '1d', 'price').mean()

    sym = symbol('AAPL')

    if short_mvag[sym] > long_mvad[sym]:
        order_target(sym, 100)
    elif short_mvag[sym] < long_mvad[sym]:
        order_target(sym, 0)

    record(AAPL=data[sym].price,
           short_mvag=short_mvag[sym],
           long_mvad=long_mvad[sym])
Ejemplo n.º 29
0
    def handle_data(self, context, data):
        rebalance_period = 20
        context.tick += 1

        if context.tick < 200:
            return
        if context.tick % rebalance_period != 0:
            return

        # condition 1: momentum conditons, current monthly prices > 10 months MA
        prices_200d = history(200, '1d', 'price').dropna()
        prices_m = self.filtering(prices_200d, rebalance_period)
        prices_ma_10m = pd.rolling_mean(prices_m, 10)
        con1 = prices_m.tail(1) > prices_ma_10m.tail(1)

        # condition 2: picking up the ETF, which outperforms the SPY
        moving_win = 3
        symbol_spy = symbol(self.ticker_spy)
        rets_3m = (prices_m / prices_m.shift(moving_win) - 1)
        rets_spy_3m = (
            prices_m[symbol_spy] / prices_m[symbol_spy].shift(moving_win) - 1)
        con2 = rets_3m.tail(1) > np.asarray(rets_spy_3m.tail(1))

        # condition 3: picking up the ETF, which have positive returns
        rets = prices_m.pct_change()
        con3 = rets.tail(1) > 0

        # signals
        sig1 = con1
        sig2 = con1 & con2
        sig3 = con2 & con3
        sig4 = con1 & con3
        sig5 = con1 & con2 & con3

        sig = sig1

        # Trading
        count = np.asarray(sig.sum(axis=1))
        if count == 0:
            weights = sig * 0.0
        else:
            weights = sig * 1.0 / count
        weights = np.asarray(weights.fillna(0))
        stocks = np.asarray(sig.columns)

        try:
            # Rebalance portfolio accordingly
            for stock, weight in zip(stocks, weights.T):
                #print 'stock={stock}:weight={weight}'.format(stock=stock, weight=weight)

                order_target_percent(stock, weight)
        except:
            # Sometimes this error is thrown
            # ValueError: Rank(A) < p or Rank([P; A; G]) < n
            pass
Ejemplo n.º 30
0
    def handle_data(self, context, data):
        rebalance_period = 20
        context.tick += 1

        if context.tick < 200 :
            return
        if context.tick % rebalance_period != 0:
            return

        # condition 1: momentum conditons, current monthly prices > 10 months MA
        prices_200d = history(200, '1d', 'price').dropna()
        prices_m = self.filtering(prices_200d, rebalance_period)
        prices_ma_10m = pd.rolling_mean(prices_m, 10)
        con1 = prices_m.tail(1) > prices_ma_10m.tail(1)


        # condition 2: picking up the ETF, which outperforms the SPY
        moving_win = 3
        symbol_spy = symbol(self.ticker_spy)
        rets_3m = (prices_m / prices_m.shift(moving_win) - 1)
        rets_spy_3m = (prices_m[symbol_spy] / prices_m[symbol_spy].shift(moving_win) - 1)
        con2 = rets_3m.tail(1) > np.asarray(rets_spy_3m.tail(1))

        # condition 3: picking up the ETF, which have positive returns
        rets = prices_m.pct_change()
        con3 = rets.tail(1) >  0

        # signals
        sig1 = con1
        sig2 = con1 & con2
        sig3 = con2 & con3
        sig4 = con1 & con3
        sig5 = con1 & con2 & con3

        sig = sig1

        # Trading
        count = np.asarray(sig.sum(axis=1))
        if count == 0:
            weights = sig * 0.0
        else :
            weights = sig * 1.0 / count
        weights = np.asarray(weights.fillna(0))
        stocks = np.asarray(sig.columns)

        try:
            # Rebalance portfolio accordingly
            for stock, weight in zip(stocks, weights.T):
               #print 'stock={stock}:weight={weight}'.format(stock=stock, weight=weight)

                order_target_percent(stock, weight)
        except :
            # Sometimes this error is thrown
            # ValueError: Rank(A) < p or Rank([P; A; G]) < n
            pass
Ejemplo n.º 31
0
def handle_data(context, data):
    # check if the spot is outside CI of MPP
    day_option_df = context.options[context.options['date'] == get_datetime()]
    call_sums = call_otm(day_option_df, 'FB', get_datetime())
    put_sums = put_otm(day_option_df, 'FB', get_datetime())

    add_to_window(context, 10, max_pain_strike(call_sums, put_sums), 'FB')
    ci = CI(context.window, 1)

    price = history(1, '1d', 'price').iloc[0, 0]
    if price < ci[0]: order_target_percent(symbol('FB'), 1)
    elif price > ci[1]: order_target_percent(symbol('FB'), 0)
Ejemplo n.º 32
0
def handle_data(context, data):
	# check if the spot is outside CI of MPP
	day_option_df = context.options[context.options['date'] == get_datetime()]
	call_sums = call_otm(day_option_df, 'FB', get_datetime())
	put_sums = put_otm(day_option_df, 'FB', get_datetime())
	
	add_to_window(context, 10, max_pain_strike(call_sums, put_sums), 'FB')
	ci = CI(context.window, 1)

	price = history(1, '1d', 'price').iloc[0,0]
	if price < ci[0]: order_target_percent(symbol('FB'), 1)
	elif price > ci[1]: order_target_percent(symbol('FB'), 0)
Ejemplo n.º 33
0
def handle_data(context, data):
    
    #On-Line Moving Average Reversal (OLMAR)
    
    context.days += 1
    if context.days < context.window_length:
        return
    
    if context.init:
        rebalance_portfolio(context, data, context.b_t)
        context.init=False
        return
    
    m = context.m            #num assets
    x_tilde = np.zeros(m)    #relative mean deviation
    b = np.zeros(m)          #weights
    
    #compute moving average price for each asset
    mavgs = history(context.window_length, '1d', 'price').mean()    
    #mavgs = data.history(context.sids, 'price', context.window_length, '1d').mean()
    
    for i, stock in enumerate(context.stocks):
        price = data[stock]['price']
        x_tilde[i] = mavgs[i] / price
    
    x_bar = x_tilde.mean()
    
    market_rel_dev = x_tilde - x_bar  #relative deviation
    
    exp_return = np.dot(context.b_t, x_tilde)
    weight = context.eps - exp_return
    variability = (np.linalg.norm(market_rel_dev))**2
    
    if variability == 0.0:
        step_size = 0
    else:
        step_size = np.max((0, weight/variability))
    
    
    b = context.b_t + step_size * market_rel_dev
    b_norm = simplex_projection(b)
    
    rebalance_portfolio(context, data, b_norm)

    context.b_t = b_norm
                    
    #save values for plotting
    record(AAPL = data[symbol('AAPL')].price,
           MSFT = data[symbol('MSFT')].price,
           step_size = step_size,
           variability = variability
           )
Ejemplo n.º 34
0
def wait_for_data (context, data):
    if context.waiting_for_data :
        print ('\n{} WAITING FOR DATA...'.format(get_datetime().date()))
        # wait for history to fill
        max_lookback = context.max_lookback
        highs = history (max_lookback, '1d', 'high')

        if not highs.ix[0].sum() > 0 : 
            return

        else:
            context.waiting_for_data = False
            return
Ejemplo n.º 35
0
def handle_data(context, data):

    #On-Line Moving Average Reversal (OLMAR)

    context.days += 1
    if context.days < context.window_length:
        return

    if context.init:
        rebalance_portfolio(context, data, context.b_t)
        context.init = False
        return

    m = context.m  #num assets
    x_tilde = np.zeros(m)  #relative mean deviation
    b = np.zeros(m)  #weights

    #compute moving average price for each asset
    mavgs = history(context.window_length, '1d', 'price').mean()
    #mavgs = data.history(context.sids, 'price', context.window_length, '1d').mean()

    for i, stock in enumerate(context.stocks):
        price = data[stock]['price']
        x_tilde[i] = mavgs[i] / price

    x_bar = x_tilde.mean()

    market_rel_dev = x_tilde - x_bar  #relative deviation

    exp_return = np.dot(context.b_t, x_tilde)
    weight = context.eps - exp_return
    variability = (np.linalg.norm(market_rel_dev))**2

    if variability == 0.0:
        step_size = 0
    else:
        step_size = np.max((0, weight / variability))

    b = context.b_t + step_size * market_rel_dev
    b_norm = simplex_projection(b)

    rebalance_portfolio(context, data, b_norm)

    context.b_t = b_norm

    #save values for plotting
    record(AAPL=data[symbol('AAPL')].price,
           MSFT=data[symbol('MSFT')].price,
           step_size=step_size,
           variability=variability)
Ejemplo n.º 36
0
def handle_data(context, data):
    
    context.i += 1
    if context.i < 20:    
        return
        
    ma5 = history(5,'1d','price').mean()
    ma20 = history(20, '1d', 'price').mean()
    buy = False
    sell = False
    
    sym = symbol('HMD')
    if ma5[sym] > ma20[sym] and context.investment == False:
        order_target(sym, 1)
        context.investment = True
        buy = True

    elif ma5[sym] < ma20[sym] and context.investment == True:
        order_target(sym, -1)
        context.investment = False
        sell = True
        
    record(HMD=data[sym].price, ma5=ma5[sym], ma20=ma20[sym], buy=buy, sell=sell)
Ejemplo n.º 37
0
    def handle_data(self, context, data):
        # Implement your algorithm logic here.

        # data[sid(X)] holds the trade event data for that security.
        # context.portfolio holds the current portfolio state.

        # Place orders with the order(SID, amount) method.

        # TODO: implement your own logic here.
        context.trade_days += 1
        if context.trade_days <> 5 :
           return
        context.trade_days = 0


        ## checking the market status:
        ## if SPY > price one year ago, Market is in uptrend
        ## otherwise, market is in downtrend
        hist = history(bar_count = 241, frequency='1d', field='price')
        cash = context.portfolio.cash
        current_price_spy = data[symbol(self.ticker_spy)].price


        try:
            if current_price_spy > hist[symbol(self.ticker_spy)][200] :

                lst = self.top_rets(context.equities, 240)
                lst_mean = lst['zero']
                count = len(lst_mean)



                for ticker in sector_tickers:
                    if ticker in lst_mean:
                        order_target_percent(symbol(ticker), 1.0/count)
                    else :
                        order_target_percent(symbol(ticker), 0)

                order_target_percent(symbol(self.ticker_gld),  0)
                order_target_percent(symbol(self.ticker_tlt), 0)
            else :
                for ticker in sector_tickers:
                    order_target_percent(symbol(ticker), 0)

                order_target_percent(symbol(self.ticker_spy),  0)
                order_target_percent(symbol(self.ticker_gld),  0.5)
                order_target_percent(symbol(self.ticker_tlt),  0.5)
        except:
            pass
Ejemplo n.º 38
0
def handle_data(context, data):
    prices = history(bar_count = context.historical_bars, frequency='1d', field='price')
    print prices
    ##Carrying last 100d prices
    for stock in context.stocks:
        try:
            ma1 = data[stock].mavg(50)
            ma2 = data[stock].mavg(200)
            start_bar = context.feature_window
            price_list = prices[stock].tolist()
            X = []
            y = []
            bar = start_bar
            # feature creation
            while bar < len(price_list)-1:
                try:
                    end_price = price_list[bar+1]
                    begin_price = price_list[bar]
                    pricing_list = []
                    xx = 0
                    for _ in range(context.feature_window):
                        price = price_list[bar-(context.feature_window-xx)]
                        pricing_list.append(price)
                        xx += 1
                    features = np.around(np.diff(pricing_list) / pricing_list[:-1] * 100.0, 1)
                    #print(features)
                    if end_price > begin_price:
                        label = 1
                    else:
                        label = -1
                    bar += 1
                    X.append(features)
                    y.append(label)
                except Exception as e:
                    bar += 1
                    print(('feature creation',str(e)))
            clf = RandomForestClassifier()
            last_prices = price_list[-context.feature_window:]
            current_features = np.around(np.diff(last_prices) / last_prices[:-1] * 100.0, 1)
            X.append(current_features)
            X = preprocessing.scale(X)
            current_features = X[-1]
            X = X[:-1]
            clf.fit(X,y)
            p = clf.predict(current_features)[0]
            print(('Prediction',p))
        except Exception as e:
            print(str(e))
Ejemplo n.º 39
0
    def handle_data(self, context, data):
        rebalance_period = 20

        context.tick += 1
        if context.tick % rebalance_period != 0:
            return

        # Get rolling window of past prices and compute returns
        prices = history(120, '1d', 'price').dropna()
        returns = prices.pct_change().dropna()
        try:
            weights = self.MOM(returns.T)
            for stock, weight in zip(prices.columns, weights):
                order_target_percent(stock, weight)
        except ValueError as e:
            pass
Ejemplo n.º 40
0
    def handle_data(self, context, data):
        rebalance_period = 20

        context.tick += 1
        if context.tick % rebalance_period != 0:
            return

        # Get rolling window of past prices and compute returns
        prices = history(120, '1d', 'price').dropna()
        returns = prices.pct_change().dropna()
        try:
            weights = self.MOM(returns.T)
            for stock, weight in zip(prices.columns, weights):
                order_target_percent(stock, weight)
        except ValueError as e:
            pass
Ejemplo n.º 41
0
def handle_data(context, data):
    context.day_count += 1
    if context.day_count < 100:
        return

    prices = history(950, '1d', 'price').dropna()

    security_index = 0;
    daily_returns = np.zeros((len(context.stocks), 950))
    for security in context.stocks:
        if data.has_key(security):
            for day in range(0, 99):
                day_of = prices[security][day]
                day_before = prices[security][day - 1]
                daily_returns[security_index][day] = (day_of - day_before) / day_before
            security_index = security_index + 1
    covars = cov(daily_returns)

    covars = covars * 250

###########################################################
    returns = prices.pct_change().dropna()

    bnds = ((0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1))
    cons = ({'type': 'eq', 'fun': lambda x:  np.sum(x)-1.0})

    res = scipy.optimize.minimize(compute_var,
                                  context.x0,
                                  cov(daily_returns)*255,
                                  method='SLSQP',
                                  constraints=cons,
                                  bounds=bnds)

    allocation = res.x
    allocation[allocation < 0] = 0  # jamais de vente, que des achats
    denom = np.sum(allocation)
    if denom != 0:
        allocation = allocation/denom

    context.x0 = allocation

    record(stocks=np.sum(allocation[0:-1]))
    record(bonds=allocation[-1])

    for i, stock in enumerate(context.stocks):
        order_target_percent(stock, allocation[i])
Ejemplo n.º 42
0
    def handle_data(self, context, data):
        # Implement your algorithm logic here.

        # data[sid(X)] holds the trade event data for that security.
        # context.portfolio holds the current portfolio state.

        # Place orders with the order(SID, amount) method.

        # TODO: implement your own logic here.
        context.trade_days += 1
        if context.trade_days <> 5:
            return
        context.trade_days = 0

        ## checking the market status:
        ## if SPY > price one year ago, Market is in uptrend
        ## otherwise, market is in downtrend
        hist = history(bar_count=241, frequency='1d', field='price')
        cash = context.portfolio.cash
        current_price_spy = data[symbol(self.ticker_spy)].price

        try:
            if current_price_spy > hist[symbol(self.ticker_spy)][200]:

                lst = self.top_rets(context.equities, 240)
                lst_mean = lst['zero']
                count = len(lst_mean)

                for ticker in sector_tickers:
                    if ticker in lst_mean:
                        order_target_percent(symbol(ticker), 1.0 / count)
                    else:
                        order_target_percent(symbol(ticker), 0)

                order_target_percent(symbol(self.ticker_gld), 0)
                order_target_percent(symbol(self.ticker_tlt), 0)
            else:
                for ticker in sector_tickers:
                    order_target_percent(symbol(ticker), 0)

                order_target_percent(symbol(self.ticker_spy), 0)
                order_target_percent(symbol(self.ticker_gld), 0.5)
                order_target_percent(symbol(self.ticker_tlt), 0.5)
        except:
            pass
Ejemplo n.º 43
0
def handle_data(context, data):
	day_option_df = context.options[context.options['date'] == get_datetime()]
	call_options = day_option_df[day_option_df['type'] == 'C']

	################################## classifier stuff happens somewhere here
	call_options_good = call_options # call_options_good is the classified call_options
	##################################

	# purchase the options that we think will end up in the money (could also modify this to give weight to it)
	for index, row in call_options_good.iterrows():
		context.bought_options = rbind(context.bought_options, row)
		cash -= row['price']

	# exercise expiring options that we've bought (assuming strike price is lower than expiration price)
	expiring_calls = context.bought_options[context.bought_options['expiration'] == get_datetime()]
	for index, row in expiring_calls.iterrows():
		price = history(symbol(row['ticker']), '1d', 'price').iloc[0,0]
        cash += 100*max(price - row['strike'], 0) # assuming 100:1 ratio equity:option
Ejemplo n.º 44
0
def handle_data(context, data):
    # 获取股票的收盘价
    close_data = history(12,'1d','close')
    # 取得过去五天的平均价格
    ma5 = close_data[-6:-2].mean()
    # 取得过去10天的平均价格
    ma10 = close_data[-11:-2].mean()
    # 取得当前的现金

    print get_datetime(),ma5,ma10
    cash = context.portfolio.cash
    
    #print ma5[sid(symbol(context.security))],ma10[sid(stock)],cash,symbol(context.security)
    #如果当前有余额,并且五日均线大于十日均线
    if ma5[sid(symbol(context.security))] > ma10[sid(symbol(context.security))]:
         order_value(symbol(context.security), cash)
    # 如果五日均线小于十日均线,并且目前有头寸
    elif ma5[sid(symbol(context.security))] < ma10[sid(symbol(context.security))]:
        # 全部卖出
        order_target(symbol(context.security), 0)
Ejemplo n.º 45
0
    def handle_data(self, context, data):
        rebalance_period = 20

        context.tick += 1
        if context.tick % rebalance_period != 0:
            return

        # Get rolling window of past prices and compute returns
        prices = history(60, '1d', 'price').dropna()
        returns = prices.pct_change().dropna()
        try:
            # Perform Markowitz-style portfolio optimization
            weights = self.vol_weighting(returns.T)
            # Rebalance portfolio accordingly
            for stock, weight in zip(prices.columns, weights):
                order_target_percent(stock, weight)
        except ValueError as e:
            # Sometimes this error is thrown
            # ValueError: Rank(A) < p or Rank([P; A; G]) < n
            pass
Ejemplo n.º 46
0
def generate_strat_data (context, data) :

    print ('\n{} GENERATING STRAT_DATA...'.format(get_datetime().date()))
    
#     if ENVIRONMENT != 'IDE':
#         wait_for_data(context, data)
#     if context.waiting_for_data :
#         return

    for item in ['high', 'open_price', 'low', 'close_price', 'volume', 'price']:
        context.strat_data[item] = history(context.max_lookback, '1d', item)

    # need to do this to keep talib happy
    context.strat_data['open'] = context.strat_data['open_price']
    context.strat_data['close'] = context.strat_data['close_price']

    # return a dataframe for each transform
    for transform in context.algo_transforms :       
        panel = apply_transform(context, transform)
        context.strat_data = {i: panel[i] for i in panel.items}
Ejemplo n.º 47
0
    def handle_data(self, context, data):
        rebalance_period = 20

        context.tick += 1
        if context.tick % rebalance_period != 0:
            return


        # Get rolling window of past prices and compute returns
        prices = history(60, '1d', 'price').dropna()
        returns = prices.pct_change().dropna()
        try:
            # Perform Markowitz-style portfolio optimization
            weights = self.vol_weighting(returns.T)
            # Rebalance portfolio accordingly
            for stock, weight in zip(prices.columns, weights):
                order_target_percent(stock, weight)
        except ValueError as e:
            # Sometimes this error is thrown
            # ValueError: Rank(A) < p or Rank([P; A; G]) < n
            pass
Ejemplo n.º 48
0
def handle_data(context, data):
    logging.debug('enter handle_data')
    context.i += 1
    if context.i < context.rsi_window:
        return

    # get the last RSI value
    prices = history(context.rsi_window, '1d', 'price')
    sec_rsi = talib.RSI(
        prices[context.security].values,
        timeperiod=context.rsi_window - 1)

    # buy and sell flags
    buy = False
    sell = False

    if sec_rsi[-1] < context.LOW_RSI and not context.invested:
        # RSI under 30 indicates oversold, time to buy
        order_target(context.security, 1000)
        logging.debug('Buying {}'.format(context.security))
        context.invested = True
        buy = True

    elif sec_rsi[-1] > context.HIGH_RSI and context.invested:
        # RSI over 70 indicates overbought, sell everything
        order_target(context.security, 0)
        logging.debug('Selling {}'.format(context.security))
        context.invested = False
        sell = True

    # record data for each time increment
    record(secRSI=sec_rsi[-1],
           price=data[context.security].price,
           buy=buy,
           sell=sell)
    logging.info(context.portfolio.cash)
Ejemplo n.º 49
0
def handle_data(context, data):
    prices = history(bar_count = context.historical_bars, frequency='1d', field='open')
    print prices
Ejemplo n.º 50
0
def handle_data(context, data):

    # Skip first 300 days to get full windows
    context.n += 1
    if context.n < 359:
        return
    context.day += 1

    if context.day < 7:
        return 
    # Compute averages
    # history() has to be called with the same params
    # from above and returns a pandas dataframe.
    historical_data =history(365, '1d', 'price')


    pastReturns = (historical_data - historical_data.shift(-1)) / historical_data.shift(-1)

    short_mavg = history(42, '1d', 'price').mean()
    long_mavg = history(84, '1d', 'price').mean()

    diff = short_mavg / long_mavg - 1

    diff = diff.dropna()
    diff.sort()


    buys = diff [diff > 0.03]
    sells = diff[diff < -0.03]
    

    buy_length = min(context.stocks_to_long, len(buys))
    short_length = min(context.stocks_to_short, len(sells))
    buy_weight = 1.0/buy_length if buy_length != 0 else 0 
    short_weight = -1.0/short_length if short_length != 0 else 0 

    buys.sort(ascending=False)
    sells.sort()
    buys = buys.iloc[:buy_length] if buy_weight != 0 else None
    sells = sells.iloc[:short_length] if short_weight != 0 else None




    stops =  historical_data.iloc[-1] * 0.05
    
    for i in range(len(context.syms)):

        #: If the security exists in our sells.index then sell
        if sells is not None and context.syms[i] in sells.index:
            
            #print ('SHORT: %s'%context.syms[i])
           order_target_percent(context.syms[i], short_weight)
            #print 'sell'
            
        #: If the security instead, exists in our buys index, buy
        elif buys is not None and context.syms[i] in buys.index:
           # print ('BUYS: %s'%context.syms[i])
            order_target_percent(context.syms[i], buy_weight)
            #print 'nothing' 
            

        #: If the security is in neither list, exit any positions we might have in that security
        else:
            order_target(context.syms[i], 0)
    
       
    context.day = 0

    # Keep track of the number of long and short positions in the portfolio

    longs = shorts = 0
    for position in context.portfolio.positions.itervalues():
        if position.amount > 0:
            longs += 1
        if position.amount < 0:
            shorts += 1
    

    record(short_mavg=short_mavg[context.syms[1]], long_mavg=long_mavg[context.syms[1]], portfoliovalue = (context.portfolio.returns), long_count=longs, short_count=shorts)
Ejemplo n.º 51
0
def svr_trading(context, data):

    # Historical data, lets get the past days close prices for
    pastPrice = history(bar_count=context.history_len, frequency='1d', field='price')

    # Make predictions on universe
    for stock in data:
        # Make sure this stock has no existing orders or positions to simplify our portfolio handling.
        if check_if_no_conflicting_orders(stock) and context.portfolio.positions[stock].amount == 0:
            
            #This is a scoring system for our model, we only trade when confident our model is wicked awesome 
            full_series = np.array(pastPrice[stock].values)
            l           = context.out_of_sameple_bin_size
            power = 1 #N where X^n for weight function
            
            # Create bins of X len to hold as out of sample data, average score(error) of these is a decent measure of fit.
            prediction_history = []
            for i in np.arange(context.history_len/context.out_of_sameple_bin_size):
                #Index of current in same, and out of sample data.
                # 3 cases of this slicing
                if   i == 0:
                    #First run, only two bins to work with(First OOSD bin, and the rest of the data)
                    ISD = full_series[l:]
                    OOSD = full_series[:l]
                    X = np.arange(l,len(full_series))

                    # use a variable weight (~0 - 1.0)
                    weight_training = np.power(np.arange(l,len(full_series),dtype=float), power)[::-1]/np.power(np.arange(l,len(full_series),dtype=float), power)[::-1].max()
                    # use a variable weight, focus on next day prediction (~0 - 1.0 - ~0)
                    weight_score = np.concatenate((np.power(np.arange(1,l+1,dtype=float), power)/np.power(np.arange(1,l+1,dtype=float), power).max(),
                                                   np.power(np.arange(l+1,len(full_series)+1,dtype=float), power)[::-1]/np.power(np.arange(l+1,len(full_series)+2,dtype=float), power)[::-1].max()))
                    """print len (weight_training)
                    print weight_training
                    print len (weight_score)
                    print weight_score
                    print exit()"""
                elif i == context.history_len/context.out_of_sameple_bin_size - 1:
                    #Last run, only two bins to work with(Last OOSD bin, and the rest of the data)
                    ISD = full_series[:-l]
                    OOSD = full_series[-l:]
                    X = np.arange(0,len(full_series)-l)

                    # use a variable weight (~0 - 1.0)
                    weight_training = np.power(np.arange(l,len(full_series),dtype=float)+1, power)/np.power(np.arange(l,len(full_series),dtype=float)+1, power).max()
                    # use a variable weight, focus on next day prediction (~0 - 1.0 - ~0)
                    weight_score = np.concatenate((np.power(np.arange(1,len(full_series)-l+1,dtype=float), power)/np.power(np.arange(1,len(full_series)-l+2,dtype=float), power).max(),
                                                   np.power(np.arange(1,l+1,dtype=float), power)[::-1]/np.power(np.arange(1,l+1,dtype=float), power)[::-1].max()))
                    """print len (weight_training)
                    print weight_training
                    print len (weight_score)
                    print weight_score
                    print exit()"""
                else:
                    #Any other run, we have a sandwhich of OOSD in the middle of two ISD sets so we need to aggregate.
                    ISD = np.concatenate((full_series[:(l*i)], full_series[l*(i+1):]))
                    OOSD = full_series[l*i:l*(i+1)]
                    X = np.concatenate(( np.arange(0,(l*i)), np.arange(l*(i+1),len(full_series)) ))

                    # use a variable weight (~0 - 1.0)
                    weight_training = np.concatenate(( np.power(np.arange(1, l*i+1, dtype=float), power)/np.power(np.arange(1, l*i+1, dtype=float), power).max(),
                                                       np.power(np.arange(l*(i+1), len(full_series), dtype=float), power)[::-1]/np.power(np.arange(l*(i+1), len(full_series),dtype=float), power)[::-1].max() ))
                    # use a variable weight, focus on next day prediction (~0 - 1.0 - ~0)
                    weight_score = np.concatenate(( np.power(np.arange(1, l*(i+1)+1, dtype=float), power)/np.power(np.arange(1, l*(i+1)+1, dtype=float), power).max(),
                                                    np.power(np.arange(l*(i+1), len(full_series), dtype=float), power)[::-1]/np.power(np.arange(l*(i+1), len(full_series)+1, dtype=float), power)[::-1].max() ))
                    """print len (weight_training)
                    print weight_training
                    print len (weight_score)
                    print weight_score
                    exit()"""
                
                # Domain and range of training data
                #X = np.arange(len(ISD))
                X = np.atleast_2d(X).T
                y = ISD

                # Domain of prediction set
                #x = np.atleast_2d(np.linspace(0, len(ISD)+len(OOSD)-1, len(ISD)+len(OOSD))).T
                #x = np.atleast_2d(np.linspace(len(ISD) ,len(ISD)+len(OOSD)-1, len(OOSD))).T
                x = np.atleast_2d(np.linspace(0, len(full_series)-1, len(full_series))).T
                
                # epsilon-Support Vector Regression using scikit-learn
                # Read more here: http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html
                SVR_model = SVR(kernel='rbf', C=100, gamma=.01)
                SVR_model.fit(X,y, weight_training)
                y_predSVR = SVR_model.predict(x)
                
                if np.isnan(full_series).any() or np.isinf(full_series).any():
                    print(stock + " Failed due to data INF or NAN")
                    y_score = 0
                    break
                else:
                    y_score = SVR_model.score(x, full_series)#, sample_weight=weight_score) #y_predSVR[-len(OOSD):] np.atleast_2d(y_predSVR).T

                    #log.debug(y_score)
                
                prediction_history.append(y_score)
                
            score = np.mean(y_score)

            # If we are studying one stock, lets plot its correlation regression results
            if len(data) == 1:
                record(Ideal=1.0, Score=score) #Slope=slope, R_value=r

            
            # Store the prediction for comparison with the rest of the universe
            #   Measure accuracy as the mean of the distance to the ideal value of 
            #   the r2 and slope from past vs predicted price correlation regression
            if score >= context.score_filter:
                
                #The model was accepted, make a forecast
                
                #form domain and range of test data(we leave no out of sameple data out since we already scored the model)
                X = np.arange(context.history_len)
                X = np.atleast_2d(X).T
                y = np.array(pastPrice[stock].values)

                # Domain of predection set. We only need to predict the next close price.
                x = np.atleast_2d(np.linspace(len(y), len(y), 1)).T
                """log.debug(X)
                log.debug(len(X))
                log.debug(x)
                log.debug(len(x))
                exit()"""
                
                # use a linearly peaking weight, focus on next day prediction (~0 - 1.0 - ~0)
                #weight_training = np.power(np.arange(1,context.history_len+1, dtype=float), power)/np.power(np.arange(1,context.history_len+1, dtype=float), power).max()
                #weight_training = np.exp(np.arange(1,context.history_len+1, dtype=float))/np.exp(np.arange(1,context.history_len+1, dtype=float)).max()
                
                # epsilon-Support Vector Regression using scikit-learn
                # Read more here: http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html
                SVR_model = SVR(kernel='rbf', C=100, gamma=.01)
                SVR_model.fit(X, y)#, weight_training)
                y_predSVR = SVR_model.predict(x)
                
                context.next_pred_price[stock] = y_predSVR[-1]
            else:
                #Case where stock is left in dict and we dont want to use it, so remove it.
                if stock in context.next_pred_price:
                    del context.next_pred_price[stock]
            

    # Count number of trades so we can split the availible cash properly
    number_of_trades_today = 0
    for stock in data:
        # Make sure this stock has no existing orders or positions to simplify our portfolio handling
        # Also check that we have a prediction stored in the dict
        if check_if_no_conflicting_orders(stock) and \
           context.portfolio.positions[stock].amount == 0 and \
           stock in context.next_pred_price:
            # If we plan to move on this stock, take count of it(explained more in actual buy statement below)(Make sure these match both buy statements.
            if (percent_change(context.next_pred_price[stock], pastPrice[stock][-1])  >= context.action_to_move_percent and \
               percent_change(context.next_pred_price[stock], data[stock]['price'])   >= context.action_to_move_percent) or \
               (percent_change(context.next_pred_price[stock], pastPrice[stock][-1])  <= -context.action_to_move_percent and \
                 percent_change(context.next_pred_price[stock], data[stock]['price']) <= -context.action_to_move_percent):
                number_of_trades_today += 1
    #

    #Lets use record to plot how  many securities are traded on each day.       
    if len(data) >= 2:
        record(number_of_stocks_traded=number_of_trades_today)

    #Make buys and shorts if the predicted close change is bigger than our tollerance, same with current price to avoid opening gaps.
    for stock in data:
        # Make sure this stock has no existing orders or positions to simplify our portfolio handling
        # Also check that we have a prediction stored in the dict
        if check_if_no_conflicting_orders(stock) and context.portfolio.positions[stock].amount == 0 and stock in context.next_pred_price:

            #Go long if we predict the close price will change more(upward) than our tollerance, 
            # apply same filter against current price vs predicted close in case of gap up/down.
            if percent_change(context.next_pred_price[stock], pastPrice[stock][-1]) >= context.action_to_move_percent and \
               percent_change(context.next_pred_price[stock], data[stock]['price']) >= context.action_to_move_percent:

                # Place an order, and store the ID to fetch order info
                orderId    = order_target_percent(stock, 1.0/number_of_trades_today)
                # How many shares did we just order, since we used target percent of availible cash to place order not share count.
                shareCount = get_order(orderId).amount

                # We can add a timeout time on the order.
                #context.duration[orderId] = exchange_time + timedelta(minutes=5)

                # We need to calculate our own inter cycle portfolio snapshot as its not updated till next cycle.
                value_of_open_orders(context, data)
                availibleCash = context.portfolio.cash-context.cashCommitedToBuy-context.cashCommitedToSell

                print("+ BUY {0:,d} of {1:s} at ${2:,.2f} for ${3:,.2f} / ${4:,.2f} @ {5:s}"\
                         .format(shareCount,
                                 stock,data[stock]['price'],
                                 data[stock]['price']*shareCount, 
                                 availibleCash,
                                 context.exchange_time))

            #Go short if we predict the close price will change more(downward) than our tollerance, 
            # apply same filter against current price vs predicted close incase of gap up/down.
            elif percent_change(context.next_pred_price[stock], pastPrice[stock][-1]) <= -context.action_to_move_percent and \
                 percent_change(context.next_pred_price[stock], data[stock]['price']) <= -context.action_to_move_percent:

                #orderId    = order_target_percent(stock, -1.0/len(data))
                orderId    = order_target_percent(stock, -1.0/number_of_trades_today)
                # How many shares did we just order, since we used target percent of availible cash to place order not share count.
                shareCount = get_order(orderId).amount

                # We can add a timeout time on the order.
                #context.duration[orderId] = exchange_time + timedelta(minutes=5)

                # We need to calculate our own inter cycle portfolio snapshot as its not updated till next cycle.
                value_of_open_orders(context, data)
                availibleCash = context.portfolio.cash-context.cashCommitedToBuy+context.cashCommitedToSell

                print("- SHORT {0:,d} of {1:s} at ${2:,.2f} for ${3:,.2f} / ${4:,.2f} @ {5:s}"\
                         .format(shareCount,
                                 stock,data[stock]['price'],
                                 data[stock]['price']*shareCount, 
                                 availibleCash,
                                 context.exchange_time))
Ejemplo n.º 52
0
def svr_trading(context, data):

    # Historical data, lets get the past days close prices for
    pastPrice = history(bar_count=context.history_len,
                        frequency='1d',
                        field='price')

    # Make predictions on universe
    for stock in data:
        # Make sure this stock has no existing orders or positions to simplify our portfolio handling.
        if check_if_no_conflicting_orders(
                stock) and context.portfolio.positions[stock].amount == 0:

            #This is a scoring system for our model, we only trade when confident our model is wicked awesome
            full_series = np.array(pastPrice[stock].values)
            l = context.out_of_sameple_bin_size
            power = 1  #N where X^n for weight function

            # Create bins of X len to hold as out of sample data, average score(error) of these is a decent measure of fit.
            prediction_history = []
            for i in np.arange(context.history_len /
                               context.out_of_sameple_bin_size):
                #Index of current in same, and out of sample data.
                # 3 cases of this slicing
                if i == 0:
                    #First run, only two bins to work with(First OOSD bin, and the rest of the data)
                    ISD = full_series[l:]
                    OOSD = full_series[:l]
                    X = np.arange(l, len(full_series))

                    # use a variable weight (~0 - 1.0)
                    weight_training = np.power(
                        np.arange(l, len(full_series), dtype=float),
                        power)[::-1] / np.power(
                            np.arange(l, len(full_series), dtype=float),
                            power)[::-1].max()
                    # use a variable weight, focus on next day prediction (~0 - 1.0 - ~0)
                    weight_score = np.concatenate((
                        np.power(np.arange(1, l + 1, dtype=float), power) /
                        np.power(np.arange(1, l + 1, dtype=float),
                                 power).max(),
                        np.power(
                            np.arange(l + 1, len(full_series) + 1,
                                      dtype=float), power)[::-1] /
                        np.power(
                            np.arange(l + 1, len(full_series) + 2,
                                      dtype=float), power)[::-1].max()))
                    """print len (weight_training)
                    print weight_training
                    print len (weight_score)
                    print weight_score
                    print exit()"""
                elif i == context.history_len / context.out_of_sameple_bin_size - 1:
                    #Last run, only two bins to work with(Last OOSD bin, and the rest of the data)
                    ISD = full_series[:-l]
                    OOSD = full_series[-l:]
                    X = np.arange(0, len(full_series) - l)

                    # use a variable weight (~0 - 1.0)
                    weight_training = np.power(
                        np.arange(l, len(full_series), dtype=float) + 1,
                        power) / np.power(
                            np.arange(l, len(full_series), dtype=float) + 1,
                            power).max()
                    # use a variable weight, focus on next day prediction (~0 - 1.0 - ~0)
                    weight_score = np.concatenate((
                        np.power(
                            np.arange(1, len(full_series) - l + 1,
                                      dtype=float), power) /
                        np.power(
                            np.arange(1, len(full_series) - l + 2,
                                      dtype=float), power).max(),
                        np.power(np.arange(1, l + 1, dtype=float), power)[::-1]
                        / np.power(np.arange(1, l + 1, dtype=float),
                                   power)[::-1].max()))
                    """print len (weight_training)
                    print weight_training
                    print len (weight_score)
                    print weight_score
                    print exit()"""
                else:
                    #Any other run, we have a sandwhich of OOSD in the middle of two ISD sets so we need to aggregate.
                    ISD = np.concatenate(
                        (full_series[:(l * i)], full_series[l * (i + 1):]))
                    OOSD = full_series[l * i:l * (i + 1)]
                    X = np.concatenate((np.arange(0, (l * i)),
                                        np.arange(l * (i + 1),
                                                  len(full_series))))

                    # use a variable weight (~0 - 1.0)
                    weight_training = np.concatenate((
                        np.power(np.arange(1, l * i + 1, dtype=float), power) /
                        np.power(np.arange(1, l * i + 1, dtype=float),
                                 power).max(),
                        np.power(
                            np.arange(
                                l * (i + 1), len(full_series), dtype=float),
                            power)[::-1] / np.power(
                                np.arange(l * (i + 1),
                                          len(full_series),
                                          dtype=float), power)[::-1].max()))
                    # use a variable weight, focus on next day prediction (~0 - 1.0 - ~0)
                    weight_score = np.concatenate(
                        (np.power(np.arange(1, l *
                                            (i + 1) + 1, dtype=float), power) /
                         np.power(np.arange(1, l * (i + 1) + 1, dtype=float),
                                  power).max(),
                         np.power(
                             np.arange(
                                 l * (i + 1), len(full_series), dtype=float),
                             power)[::-1] / np.power(
                                 np.arange(l * (i + 1),
                                           len(full_series) + 1,
                                           dtype=float), power)[::-1].max()))
                    """print len (weight_training)
                    print weight_training
                    print len (weight_score)
                    print weight_score
                    exit()"""

                # Domain and range of training data
                #X = np.arange(len(ISD))
                X = np.atleast_2d(X).T
                y = ISD

                # Domain of prediction set
                #x = np.atleast_2d(np.linspace(0, len(ISD)+len(OOSD)-1, len(ISD)+len(OOSD))).T
                #x = np.atleast_2d(np.linspace(len(ISD) ,len(ISD)+len(OOSD)-1, len(OOSD))).T
                x = np.atleast_2d(
                    np.linspace(0,
                                len(full_series) - 1, len(full_series))).T

                # epsilon-Support Vector Regression using scikit-learn
                # Read more here: http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html
                SVR_model = SVR(kernel='rbf', C=100, gamma=.01)
                SVR_model.fit(X, y, weight_training)
                y_predSVR = SVR_model.predict(x)

                if np.isnan(full_series).any() or np.isinf(full_series).any():
                    print(stock + " Failed due to data INF or NAN")
                    y_score = 0
                    break
                else:
                    y_score = SVR_model.score(
                        x, full_series
                    )  #, sample_weight=weight_score) #y_predSVR[-len(OOSD):] np.atleast_2d(y_predSVR).T

                    #log.debug(y_score)

                prediction_history.append(y_score)

            score = np.mean(y_score)

            # If we are studying one stock, lets plot its correlation regression results
            if len(data) == 1:
                record(Ideal=1.0, Score=score)  #Slope=slope, R_value=r

            # Store the prediction for comparison with the rest of the universe
            #   Measure accuracy as the mean of the distance to the ideal value of
            #   the r2 and slope from past vs predicted price correlation regression
            if score >= context.score_filter:

                #The model was accepted, make a forecast

                #form domain and range of test data(we leave no out of sameple data out since we already scored the model)
                X = np.arange(context.history_len)
                X = np.atleast_2d(X).T
                y = np.array(pastPrice[stock].values)

                # Domain of predection set. We only need to predict the next close price.
                x = np.atleast_2d(np.linspace(len(y), len(y), 1)).T
                """log.debug(X)
                log.debug(len(X))
                log.debug(x)
                log.debug(len(x))
                exit()"""

                # use a linearly peaking weight, focus on next day prediction (~0 - 1.0 - ~0)
                #weight_training = np.power(np.arange(1,context.history_len+1, dtype=float), power)/np.power(np.arange(1,context.history_len+1, dtype=float), power).max()
                #weight_training = np.exp(np.arange(1,context.history_len+1, dtype=float))/np.exp(np.arange(1,context.history_len+1, dtype=float)).max()

                # epsilon-Support Vector Regression using scikit-learn
                # Read more here: http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html
                SVR_model = SVR(kernel='rbf', C=100, gamma=.01)
                SVR_model.fit(X, y)  #, weight_training)
                y_predSVR = SVR_model.predict(x)

                context.next_pred_price[stock] = y_predSVR[-1]
            else:
                #Case where stock is left in dict and we dont want to use it, so remove it.
                if stock in context.next_pred_price:
                    del context.next_pred_price[stock]

    # Count number of trades so we can split the availible cash properly
    number_of_trades_today = 0
    for stock in data:
        # Make sure this stock has no existing orders or positions to simplify our portfolio handling
        # Also check that we have a prediction stored in the dict
        if check_if_no_conflicting_orders(stock) and \
           context.portfolio.positions[stock].amount == 0 and \
           stock in context.next_pred_price:
            # If we plan to move on this stock, take count of it(explained more in actual buy statement below)(Make sure these match both buy statements.
            if (percent_change(context.next_pred_price[stock], pastPrice[stock][-1])  >= context.action_to_move_percent and \
               percent_change(context.next_pred_price[stock], data[stock]['price'])   >= context.action_to_move_percent) or \
               (percent_change(context.next_pred_price[stock], pastPrice[stock][-1])  <= -context.action_to_move_percent and \
                 percent_change(context.next_pred_price[stock], data[stock]['price']) <= -context.action_to_move_percent):
                number_of_trades_today += 1
    #

    #Lets use record to plot how  many securities are traded on each day.
    if len(data) >= 2:
        record(number_of_stocks_traded=number_of_trades_today)

    #Make buys and shorts if the predicted close change is bigger than our tollerance, same with current price to avoid opening gaps.
    for stock in data:
        # Make sure this stock has no existing orders or positions to simplify our portfolio handling
        # Also check that we have a prediction stored in the dict
        if check_if_no_conflicting_orders(
                stock) and context.portfolio.positions[
                    stock].amount == 0 and stock in context.next_pred_price:

            #Go long if we predict the close price will change more(upward) than our tollerance,
            # apply same filter against current price vs predicted close in case of gap up/down.
            if percent_change(context.next_pred_price[stock], pastPrice[stock][-1]) >= context.action_to_move_percent and \
               percent_change(context.next_pred_price[stock], data[stock]['price']) >= context.action_to_move_percent:

                # Place an order, and store the ID to fetch order info
                orderId = order_target_percent(stock,
                                               1.0 / number_of_trades_today)
                # How many shares did we just order, since we used target percent of availible cash to place order not share count.
                shareCount = get_order(orderId).amount

                # We can add a timeout time on the order.
                #context.duration[orderId] = exchange_time + timedelta(minutes=5)

                # We need to calculate our own inter cycle portfolio snapshot as its not updated till next cycle.
                value_of_open_orders(context, data)
                availibleCash = context.portfolio.cash - context.cashCommitedToBuy - context.cashCommitedToSell

                print("+ BUY {0:,d} of {1:s} at ${2:,.2f} for ${3:,.2f} / ${4:,.2f} @ {5:s}"\
                         .format(shareCount,
                                 stock,data[stock]['price'],
                                 data[stock]['price']*shareCount,
                                 availibleCash,
                                 context.exchange_time))

            #Go short if we predict the close price will change more(downward) than our tollerance,
            # apply same filter against current price vs predicted close incase of gap up/down.
            elif percent_change(context.next_pred_price[stock], pastPrice[stock][-1]) <= -context.action_to_move_percent and \
                 percent_change(context.next_pred_price[stock], data[stock]['price']) <= -context.action_to_move_percent:

                #orderId    = order_target_percent(stock, -1.0/len(data))
                orderId = order_target_percent(stock,
                                               -1.0 / number_of_trades_today)
                # How many shares did we just order, since we used target percent of availible cash to place order not share count.
                shareCount = get_order(orderId).amount

                # We can add a timeout time on the order.
                #context.duration[orderId] = exchange_time + timedelta(minutes=5)

                # We need to calculate our own inter cycle portfolio snapshot as its not updated till next cycle.
                value_of_open_orders(context, data)
                availibleCash = context.portfolio.cash - context.cashCommitedToBuy + context.cashCommitedToSell

                print("- SHORT {0:,d} of {1:s} at ${2:,.2f} for ${3:,.2f} / ${4:,.2f} @ {5:s}"\
                         .format(shareCount,
                                 stock,data[stock]['price'],
                                 data[stock]['price']*shareCount,
                                 availibleCash,
                                 context.exchange_time))
Ejemplo n.º 53
0
    def handle_data(self, context, data):

        context.tick += 1
        total_window = self.train_win + self.nn_win + 1

        if context.tick < (total_window):
            return

        try :
#             print 'tick = {t}'.format(t = context.tick)
            price = history(total_window - 1, '1d', 'price').dropna()
            df_price = pd.DataFrame(data=price.values, index=price.index, columns=['close'])

            features, target = self.create_features(df_price, self.nn_win)
            features_insample = features.iloc[(self.nn_win -1):-1, :].values
            target_insample = target.iloc[(self.nn_win -1):-1, :].values.ravel()

            features_oosample = features.iloc[-1, :]
            features_oosample = features_oosample.values.reshape([1, len(features_oosample)])

            ATR = self.atr.loc[price.index[-1], :][0]

            symbol = price.columns[0]


            if self.enable_stoploss:
                if data[symbol].price < context.longstop:
                    print 'Stop Loss '
                    order_target_percent(symbol, 0.0)
                    context.longstop = 0.0
                    return

            if self.ml == 'SVM' :
                ### Training the SVM
                from sklearn import svm
                model_svm = svm.SVC()
                model_svm.fit(features_insample, target_insample)

                preds_svm = model_svm.predict(features_oosample)[0]
                if preds_svm < 0.5:
                    #print "Sell "
                    order_target_percent(symbol, 0.0)
                    context.longstop = 0.0

                else :
                    #print "Buy"
                    order_target_percent(symbol, 1.0)
                    context.longstop = max(context.longstop, data[symbol].price * (1 - 0.7*ATR))
                    print "target sl = {n}".format(n=context.longstop)

            if self.ml == 'KNN' :
                ### Training the SVM
                from sklearn import neighbors
                k = 10

                model_knn = neighbors.KNeighborsClassifier(k, 'distance')
                model_knn.fit(features_insample, target_insample)

                preds_knn = model_knn.predict(features_oosample)[0]

                if preds_knn < 0.5:
                    #print "Sell "
                    order_target_percent(symbol, 0.0)
                else :
                    #print "Buy"
                    order_target_percent(symbol, 1.0)

            record('price', data[symbol]['price'])
        except :
            pass