Esempio n. 1
0
    def test_rsi_same_returns(self):
        """
        RSI indicator should be the same for two price series with the same
        returns, even if the prices are different.
        """
        rsi = RSI()

        today = np.datetime64(1, "ns")
        assets = np.arange(2)
        out = np.empty((2, ), dtype=float)

        example_case = np.array([
            46.125,
            47.125,
            46.4375,
            46.9375,
            44.9375,
            44.25,
            44.625,
            45.75,
            47.8125,
            47.5625,
            47.0,
            44.5625,
            46.3125,
            47.6875,
            46.6875,
        ])
        double = example_case * 2

        closes = np.vstack((example_case, double)).T
        rsi.compute(today, assets, out, closes)
        np.testing.assert_almost_equal(out[0], out[1], decimal=8)
Esempio n. 2
0
def make_pipeline():
    rsi = RSI()
    return Pipeline(
        columns={
            'longs': rsi.top(3),
            'shorts': rsi.bottom(3),
        },
    )
def make_pipeline():
    rsi = RSI()
    return Pipeline(
        columns={
            "longs": rsi.top(3),
            "shorts": rsi.bottom(3),
        },
    )
Esempio n. 4
0
def make_pipeline():
    rsi = RSI()
    fd = Fundamentals()
    sectors = NASDAQSectorCodes()

    return Pipeline(
        columns={
            'longs': rsi.top(3),
            'shorts': rsi.bottom(3),
            'ROE': fd.ROE_ART,
            #  'CAPEX': fd.CAPEX_MRQ,
            'sector': sectors,
        }, )
Esempio n. 5
0
def make_pipeline(asset_finder):

    private_universe = private_universe_mask( hs300.tolist(),asset_finder=asset_finder)
    #print private_universe_mask(['000001','000002','000005'],asset_finder=asset_finder)
    ######################################################################################################
    returns = Returns(inputs=[USEquityPricing.close], window_length=5)  # 预测一周数据
    ######################################################################################################
    ep = 1/Fundamental(mask = private_universe,asset_finder=asset_finder).pe
    bp = 1/Fundamental(mask = private_universe,asset_finder=asset_finder).pb
    bvps = Fundamental(mask = private_universe,asset_finder=asset_finder).bvps
    market = Fundamental(mask = private_universe,asset_finder=asset_finder).outstanding

    rev20 = Returns(inputs=[USEquityPricing.close], window_length=20,mask = private_universe)
    vol20 = AverageDollarVolume(window_length=20,mask = private_universe)

    illiq = ILLIQ(window_length=22,mask = private_universe)
    rsi = RSI(window_length=22,mask = private_universe)
    mom = Momentum(window_length=252,mask = private_universe)

    sector = get_sector(asset_finder=asset_finder,mask=private_universe)
    ONEHOTCLASS,sector_indict_keys = get_sector_by_onehot(asset_finder=asset_finder,mask=private_universe)


    pipe_columns = {

        'ep':ep.zscore(groupby=sector).downsample('month_start'),
        'bp':bp.zscore(groupby=sector).downsample('month_start'),
        'bvps':bvps.zscore(groupby=sector).downsample('month_start'),
        'market_cap': market.zscore(groupby=sector).downsample('month_start'),

        'vol20':vol20.zscore(groupby=sector),
        'rev20':rev20.zscore(groupby=sector),

        'ILLIQ':illiq.zscore(groupby=sector,mask=illiq.percentile_between(1, 99)),
        'mom'  :mom.zscore(groupby=sector,mask=mom.percentile_between(1, 99)),
        'rsi'  :rsi.zscore(groupby=sector,mask=rsi.percentile_between(1, 99)),
        #'sector':sector,
        #'returns':returns.quantiles(100),
        'returns': returns.zscore(),
    }
    # pipe_screen = (low_returns | high_returns)
    pipe = Pipeline(columns=pipe_columns,
           screen=private_universe,
           )
    i = 0
    for c in ONEHOTCLASS:
        pipe.add(c,sector_indict_keys[i])
        i +=1
    return pipe
Esempio n. 6
0
    def test_rsi(self, seed_value, expected):

        rsi = RSI()

        today = datetime64(1, 'ns')
        assets = arange(3)
        out = empty((3, ), dtype=float)

        seed(seed_value)  # Seed so we get deterministic results.
        test_data = abs(randn(15, 3))

        out = empty((3, ), dtype=float)
        rsi.compute(today, assets, out, test_data)

        check_allclose(expected, out)
Esempio n. 7
0
    def test_rsi_all_positive_returns(self):
        """
        RSI indicator should be 100 in the case of 14 days of positive returns.
        """

        rsi = RSI()

        today = np.datetime64(1, 'ns')
        assets = np.arange(1)
        out = np.empty((1,), dtype=float)

        closes = np.linspace(46, 60, num=15)
        closes.shape = (15, 1)
        rsi.compute(today, assets, out, closes)
        self.assertEqual(out[0], 100.0)
Esempio n. 8
0
    def test_rsi_all_negative_returns(self):
        """
        RSI indicator should be 0 in the case of 14 days of negative returns.
        """
        rsi = RSI()

        today = np.datetime64(1, "ns")
        assets = np.arange(1)
        out = np.empty((1, ), dtype=float)

        closes = np.linspace(46, 32, num=15)
        closes.shape = (15, 1)

        rsi.compute(today, assets, out, closes)
        assert out[0] == 0.0
Esempio n. 9
0
    def test_rsi(self, seed_value, expected):

        rsi = RSI()

        today = datetime64(1, 'ns')
        assets = arange(3)
        out = empty((3,), dtype=float)

        seed(seed_value)  # Seed so we get deterministic results.
        test_data = abs(randn(15, 3))

        out = empty((3,), dtype=float)
        rsi.compute(today, assets, out, test_data)

        check_allclose(expected, out)
Esempio n. 10
0
    def test_rsi(self, seed_value, expected):

        rsi = RSI()

        today = np.datetime64(1, "ns")
        assets = np.arange(3)
        out = np.empty((3, ), dtype=float)

        np.random.seed(seed_value)  # Seed so we get deterministic results.
        test_data = np.abs(np.random.randn(15, 3))

        out = np.empty((3, ), dtype=float)
        rsi.compute(today, assets, out, test_data)

        check_allclose(expected, out)
    def test_rsi_all_negative_returns(self):
        """
        RSI indicator should be 0 in the case of 14 days of negative returns.
        """
        rsi = RSI()

        today = np.datetime64(1, 'ns')
        assets = np.arange(1)
        out = np.empty((1,), dtype=float)

        closes = np.linspace(46, 32, num=15)
        closes.shape = (15, 1)

        rsi.compute(today, assets, out, closes)
        self.assertEqual(out[0], 0.0)
Esempio n. 12
0
def make_pipeline():
    """Sets up the pipeline"""
    dollar_volume = AverageDollarVolume(window_length=20)
    adv1000 = dollar_volume.top(1000)
    fd = Fundamentals(mask=adv1000)
    market_cap = fd.cshoq * fd.prccq  # this is how to calculate market cap with Computstat fields
    book_equity = fd.seqq - fd.PS  # this is a quick way to calculate book_equity
    book_to_price = book_equity / market_cap
    biggest = market_cap.top(500, mask=adv1000)
    smallest = market_cap.bottom(500, mask=adv1000)

    highpb = book_to_price.top(500, mask=adv1000)
    lowpb = book_to_price.bottom(500, mask=adv1000)

    momentum = Momentum(mask=adv1000)  # momentum
    high_momentum = momentum.top(500, mask=adv1000)
    low_momentum = momentum.bottom(500, mask=adv1000)

    volatility = Volatility(mask=adv1000)
    highvol = volatility.top(500, mask=adv1000)
    lowvol = volatility.bottom(500, mask=adv1000)

    streversal = RSI(window_length=14, mask=adv1000)
    high_streversal = streversal.top(500, mask=adv1000)
    low_streversal = streversal.bottom(500, mask=adv1000)

    universe = biggest | smallest | highpb | lowpb | low_momentum | high_momentum

    return Pipeline(
        columns={
            'returns': Returns(window_length=2),
            # 'market_cap': market_cap,  # not needed
            # 'book_to_price': book_to_price,  # not needed
            'biggest': biggest,
            'smallest': smallest,
            'highpb': highpb,
            'lowpb': lowpb,
            # 'momentum': momentum,  # not needed
            'low_momentum': low_momentum,
            'high_momentum': high_momentum,
            # 'volatility': volatility, # not needed
            'highvol': highvol,
            'lowvol': lowvol,
            # 'streversal': streversal,  # not needed
            'high_streversal': high_streversal,
            'low_streversal': low_streversal
        },
        screen=universe)
Esempio n. 13
0
def make_pipeline():
    all_assets_filter = (USEquityPricing.close.latest > 0)
    returns_5 = Returns(window_length=5)
    rsi = RSI(inputs=[USEquityPricing.close])
    macd = MovingAverageConvergenceDivergenceSignal(mask=all_assets_filter)
    ema = ExponentialWeightedMovingAverage(mask=all_assets_filter,
                                           inputs=[USEquityPricing.close],
                                           window_length=30,
                                           decay_rate=(1 - (2.0 / (1 + 15.0))))
    mean_5 = SimpleMovingAverage(inputs=[USEquityPricing.close],
                                 window_length=5,
                                 mask=all_assets_filter)
    mean_10 = SimpleMovingAverage(inputs=[USEquityPricing.close],
                                  window_length=10,
                                  mask=all_assets_filter)
    bb = BollingerBands(inputs=[USEquityPricing.close], window_length=20, k=2)
    return Pipeline(
        columns={
            'returns_5': returns_5,
            'RSI': rsi,
            'MACD': macd,
            'EMA': ema,
            'SMA_5': mean_5,
            'SMA_10': mean_10,
            'bb_upper': bb.upper,
            'bb_middle': bb.middle,
            'bb_lower': bb.lower
        },
        screen=all_assets_filter,
    )
    def make_pipeline(self):
        macd = MovingAverageConvergenceDivergence()
        rsi = RSI()
        adx = ADX()
        cci = CCI()
        bol_band = BollingerBands(k=2.0)
        latest = Latest()
        stoch = Stochastic()
        momentum = Momentum()
        ewma = EWMA()

        return Pipeline(
            columns={
                'RSI':
                rsi,  # Default Inputs: [USEquityPricing.close]  Default Window Length: 15-day
                'MACD': macd,  # Moving average convergence divergence
                'ADX': adx,
                'Commodity Channel Index': cci,
                'Bollinger Bands':
                bol_band,  # Default Window Length: 20-day     Default K=2 (Coefficient of Standard diviation)
                'latest close':
                latest,  # Default Window Length: 2-day      generate last 2 close prices
                'Stochastic':
                stoch,  # Default Window Length: 5-day      generte %K lines of today and yesterday
                'Momentum':
                momentum,  # Default Window Length: 20-day     geneate the Momentum of yesterday and today related to close price of 20days ago
                'EWMA':
                ewma,  # Default Window Length: 38       span = 7 (one week)
                'CHO': AD(),  # Default Window Length: 14-day
                'MFI': MFI()  # Default Window Length: 14-day
            })
    def test_rsi_same_returns(self):
        """
        RSI indicator should be the same for two price series with the same
        returns, even if the prices are different.
        """
        rsi = RSI()

        today = np.datetime64(1, 'ns')
        assets = np.arange(2)
        out = np.empty((2,), dtype=float)

        example_case = np.array([46.125, 47.125, 46.4375, 46.9375, 44.9375,
                                 44.25, 44.625, 45.75, 47.8125, 47.5625, 47.,
                                 44.5625, 46.3125, 47.6875, 46.6875])
        double = example_case * 2

        closes = np.vstack((example_case, double)).T
        rsi.compute(today, assets, out, closes)
        self.assertAlmostEqual(out[0], out[1])
def make_pipeline():
    rsi = RSI()
    return Pipeline(
        columns={
            'longs': rsi.top(3),
            'shorts': rsi.bottom(3),
            'revenue': Fundamentals(field='revenue_art'),
        },
        # no screen: 1 mo -> ca. 4 minutes;
        #            1 yr -> 20m

        # base_universe: ca. 1 mo. -> 3 minutes
        #screen = base_universe()

        # tradable_stocks(): 1 mo. -> ca 1h
        # 1yr -< 1h 40m
        #screen = TradableStocksUS()

        # NamedUniverse('tradable_stocks_us'): 1yr 7m
        screen=NamedUniverse('tradable_stocks_us'))
Esempio n. 17
0
def make_pipeline():
    """
    Create our pipeline.
    """

    # Base universe set to the Q1500US.

    base_universe = AverageDollarVolume(window_length=20).percentile_between(70, 100)

    latest_close = USEquityPricing.close.latest

    # 14-day RSI
    rsi_14 = RSI(
        inputs=[USEquityPricing.close],
        window_length=14,
        mask=base_universe
    )

    # 20-day, 2 standard deviation Bollinger bands
    bbLow, bbMid, bbHigh = BollingerBands(
        inputs=[USEquityPricing.close],
        window_length=10,
        k=2,
        mask=base_universe
    )

    rsiOverbought = rsi_14 > 70
    rsiOversold = rsi_14 < 30

    bbOverbought = latest_close > bbHigh
    bbOversold = latest_close < bbLow

    overbought = rsiOverbought | bbOverbought
    oversold = rsiOversold | bbOversold

    # Filter to select securities to short.
    shorts = overbought

    # Filter to select securities to long.
    longs = oversold

    # Filter for all securities that we want to trade.
    securities_to_trade = (shorts & longs)

    return Pipeline(
        columns={
            'longs': longs,
            'shorts': shorts
        },
        screen=(securities_to_trade),
    )
Esempio n. 18
0
def make_pipeline(asset_finder, algo_mode):

    private_universe = private_universe_mask(hs300.tolist(),
                                             asset_finder=asset_finder)
    #private_universe = private_universe_mask( ['000005'],asset_finder=asset_finder)
    ###private_universe = private_universe_mask( ['000002','000005'],asset_finder=asset_finder)
    #private_universe = private_universe_mask( ['000001','000002','000005'],asset_finder=asset_finder)
    #private_universe = private_universe_mask( ['000001'],asset_finder=asset_finder)

    #print private_universe_mask(['000001','000002','000005'],asset_finder=asset_finder)
    ######################################################################################################
    returns = Returns(inputs=[USEquityPricing.close],
                      window_length=5,
                      mask=private_universe)  # 预测一周数据
    ######################################################################################################
    pe = Fundamental(mask=private_universe, asset_finder=asset_finder).pe
    pb = Fundamental(mask=private_universe, asset_finder=asset_finder).pb
    bvps = Fundamental(mask=private_universe, asset_finder=asset_finder).bvps
    market = Fundamental(mask=private_universe,
                         asset_finder=asset_finder).outstanding
    totals = Fundamental(mask=private_universe,
                         asset_finder=asset_finder).totals
    totalAssets = Fundamental(mask=private_universe,
                              asset_finder=asset_finder).totalAssets
    fixedAssets = Fundamental(mask=private_universe,
                              asset_finder=asset_finder).fixedAssets
    esp = Fundamental(mask=private_universe, asset_finder=asset_finder).esp
    rev = Fundamental(mask=private_universe, asset_finder=asset_finder).rev
    profit = Fundamental(mask=private_universe,
                         asset_finder=asset_finder).profit
    gpr = Fundamental(mask=private_universe, asset_finder=asset_finder).gpr
    npr = Fundamental(mask=private_universe, asset_finder=asset_finder).npr

    rev10 = Returns(inputs=[USEquityPricing.close],
                    window_length=10,
                    mask=private_universe)
    vol10 = AverageDollarVolume(window_length=20, mask=private_universe)
    rev20 = Returns(inputs=[USEquityPricing.close],
                    window_length=20,
                    mask=private_universe)
    vol20 = AverageDollarVolume(window_length=20, mask=private_universe)
    rev30 = Returns(inputs=[USEquityPricing.close],
                    window_length=30,
                    mask=private_universe)
    vol30 = AverageDollarVolume(window_length=20, mask=private_universe)

    illiq22 = ILLIQ(window_length=22, mask=private_universe)
    illiq5 = ILLIQ(window_length=5, mask=private_universe)

    rsi5 = RSI(window_length=5, mask=private_universe)
    rsi22 = RSI(window_length=22, mask=private_universe)

    mom5 = Momentum(window_length=5, mask=private_universe)
    mom22 = Momentum(window_length=22, mask=private_universe)

    sector = get_sector(asset_finder=asset_finder, mask=private_universe)
    ONEHOTCLASS, sector_indict_keys = get_sector_by_onehot(
        asset_finder=asset_finder, mask=private_universe)

    pipe_columns = {
        'pe': pe.zscore(groupby=sector).downsample('month_start'),
        'pb': pb.zscore(groupby=sector).downsample('month_start'),
        'bvps': bvps.zscore(groupby=sector).downsample('month_start'),
        'market_cap': market.zscore(groupby=sector).downsample('month_start'),
        'totals': totals.zscore(groupby=sector).downsample('month_start'),
        'totalAssets':
        totalAssets.zscore(groupby=sector).downsample('month_start'),
        'fixedAssets':
        fixedAssets.zscore(groupby=sector).downsample('month_start'),
        'esp': esp.zscore(groupby=sector).downsample('month_start'),
        'rev': rev.zscore(groupby=sector).downsample('month_start'),
        'profit': profit.zscore(groupby=sector).downsample('month_start'),
        'gpr': gpr.zscore(groupby=sector).downsample('month_start'),
        'npr': npr.zscore(groupby=sector).downsample('month_start'),
        'vol10': vol10.zscore(groupby=sector).downsample('week_start'),
        'rev10': rev10.zscore(groupby=sector).downsample('week_start'),
        'vol20': vol20.zscore(groupby=sector).downsample('week_start'),
        'rev20': rev20.zscore(groupby=sector).downsample('week_start'),
        'vol30': vol30.zscore(groupby=sector).downsample('week_start'),
        'rev30': rev30.zscore(groupby=sector).downsample('week_start'),
        'ILLIQ5': illiq5.zscore(groupby=sector).downsample('week_start'),
        'ILLIQ22': illiq22.zscore(groupby=sector).downsample('week_start'),
        'mom5': mom5.zscore(groupby=sector).downsample('week_start'),
        'mom22': mom22.zscore(groupby=sector).downsample('week_start'),
        'rsi5': rsi5.zscore(groupby=sector).downsample('week_start'),
        'rsi22': rsi22.zscore(groupby=sector).downsample('week_start'),
    }

    from collections import OrderedDict
    factors_pipe = OrderedDict()

    factors_pipe['Returns'] = returns
    factors_pipe['Returns'].window_safe = True
    idx = 0

    sort_keys = sorted(pipe_columns)
    for key in sort_keys:
        #print(key)
        factors_pipe[key] = pipe_columns[key]
        factors_pipe[key].window_safe = True
        idx += 1
        if idx == 100:
            break

    #for name, f in pipe_columns.items():
    #    f.window_safe = True
    #    factors_pipe[name] = f
    #    print (name,f)
    #    idx += 1
    #    if idx == 1:
    #       break

    i = 0
    for c in ONEHOTCLASS:
        c.window_safe = True
        factors_pipe[sector_indict_keys[i]] = c
        #print (c,sector_indict_keys[i])
        i += 1

    predict = BasicFactorRegress(inputs=factors_pipe.values(),
                                 window_length=252,
                                 mask=private_universe,
                                 n_fwd_days=5,
                                 algo_mode=algo_mode,
                                 cross=False)
    predict_rank = predict.rank(mask=private_universe)

    longs = predict_rank.top(NUM_LONG_POSITIONS)
    shorts = predict_rank.bottom(NUM_SHORT_POSITIONS)
    long_short_screen = (longs | shorts)
    #TODO sector onehot
    pipe_final_columns = {
        'Predict Factor': predict.downsample('week_start'),
        'longs': longs.downsample('week_start'),
        'shorts': shorts.downsample('week_start'),
        'predict_rank': predict_rank.downsample('week_start'),
    }
    pipe = Pipeline(
        columns=pipe_final_columns,
        screen=long_short_screen,
    )
    return pipe
Esempio n. 19
0
def make_pipeline(underly_sid, shortable_sid):#,DAY_HACK_ENABLED=True,BB_WIN_LEN=126,WIN_LEN=20):
    sid = SidFactor() 
    pipeline_underly_sid = sid.eq(underly_sid[0])
    print("jzzz:", type(pipeline_underly_sid))
    print("MNAME:", MNAME)
    for i in underly_sid:
        pipeline_underly_sid = pipeline_underly_sid | sid.eq(i)
        print('jzzz:', pipeline_underly_sid)
    pipeline_shortable_sid = sid.eq(shortable_sid[0])
    for i in shortable_sid:
        pipeline_shortable_sid  = pipeline_shortable_sid  | sid.eq(i)
    #Filter for our choice of assets.
    bbands = BollingerBands(window_length=BB_WIN_LEN, k=sqrt(BB_WIN_LEN/5),mask = pipeline_underly_sid)
    lower, middle, upper = bbands
    #cud = Cud()#mask(pipeline underly_sid)
    returns_1D = Returns(window_length = 2, mask = pipeline_underly_sid)
    returns_6M = Returns(window_length = WIN_LEN, mask = pipeline_underly_sid)
    returns_6M = returns_6M if DAY_HACK_ENABLED else returns_6M - returns_1D
    returns_3M = Returns(window_length = 60, mask = pipeline_underly_sid)
    returns_3M = returns_3M if DAY_HACK_ENABLED else returns_3M - returns_1D
    returns_5M = Returns(window_length = WIN_LEN, mask = pipeline_underly_sid)#for es only
    returns_5M = returns_5M if DAY_HACK_ENABLED else returns_5M - returns_1D
    
    returns_1M = Returns(window_length = 20, mask = pipeline_underly_sid)#for es only
    returns_1M = returns_1M if DAY_HACK_ENABLED else returns_1M - returns_1D
    
    returns_5D = Returns(window_length =W_WIN_LEN,mask = pipeline_underly_sid)
    returns_5D = returns_5D if DAY_HACK_ENABLED else returns_5D - returns_1D
    returns_6D = Returns(window_length =7,mask = pipeline_underly_sid) - returns_1D
    annualizedVolatility_6M = AnnualizedVolatility(window_length = WIN_LEN,mask = pipeline_underly_sid)
    annualizedVolatility_3M = AnnualizedVolatility(window_length = int(WIN_LEN/2), mask = pipeline_underly_sid)
    annualizedVolatility_1M = AnnualizedVolatility(window_length = int(WIN_LEN/6), mask = pipeline_underly_sid)
    #annualizedVolatility_6M = ComputeVol6M(mask = pipeline_underly_sid)
    #annualizedVolatility_3M = ComputeVol3M(mask = pipeline_underly_sid)
    #annualizedVolatility_1M = ComputeVol1M(mask = pipeline_underly_sid)
    annualizedVolatility = max(annualizedVolatility_6M, annualizedVolatility_3M,annualizedVolatility_1M)
    sharpes_6M = returns_6M/annualizedVolatility_6M
    raw_signals = None
    if SHARPE:
        raw_signals = sharpes_6M
    else:
        raw_signals = returns_6M
    signals = raw_signals if LONG_ONLY else (raw_signals*raw_signals)
    #positive_return = (returns_6M > 0)
    #trigger = (returns 5D > -trigger_level) if LONG_ONLY else ((returns_5D < trigger_level)

    sigtop = signals.top(NUM_TOP_POSITIONS)
    raw_sig_top = raw_signals.top(NUM_TOP_POSITIONS)
    raw_sig_bot = raw_signals.bottom(NUM_TOP_POSITIONS)

    alongs = sigtop & raw_sig_top & (raw_signals > 0) & (returns_5D > -TRIGGER_LEVEL) # & (cud >= 13)
    ashorts = sigtop & raw_sig_bot &(raw_signals <= 0 ) & (returns_5D < TRIGGER_LEVEL) & pipeline_shortable_sid
    #alongs = (annualizedVolatility_6M> 0) #shorts# signals.top(NUN TOP POSITIONS)

    if not PIPE_ENABLED:
        alongs = (annualizedVolatility_6M > 0)
        ashorts = (annualizedVolatility_6M < 0)# if LONG ONLY else longs
    long_short_screen = alongs if LONG_ONLY else (alongs | ashorts)

    my_screen = (annualizedVolatility_6M > 0) if MNAME in ['es','bd','dm','ed','md']  else long_short_screen 
    #my_screen = long_short_screen if False else (annualizedVolatility_6M > 0)#hlw
    print('finger1',MNAME)
    rsi = RSI(window_length=10,mask = pipeline_underly_sid)
    print('rsipipe',annualizedVolatility_6M)
    print('fxxxDAY_HACK_ENABLED',DAY_HACK_ENABLED)
    #Only compute volatilities for assets that satisfy the requirements of our rolling strategy.
    return Pipeline(
        columns= {
            #'cud' : cud,
            'volatility' : annualizedVolatility,
            'sharpes_6W' : sharpes_6M,
            'drets': returns_1D,
            'wrets': returns_5D,
            'returns_6D': returns_6D,
            'returns_1M': returns_1M,
            'returns_3M': returns_3M,
            'returns_5M': returns_5M,
            'returns_6M': returns_6M,
            #'signals': (signals)*signals,
           'shorts' : ashorts,
            #'wrets' : returns_5D,
            'lower' : lower,
            'middle' :middle,
            'upper' :upper,
            #'rsi':rsi.top(3),
            'rsi_longs': rsi.top(3),
            'rsi_shorts': rsi.bottom(3),
            #'annualizedVolatility :annualizedVolatility_6M,
        },
        screen = my_screen
    )
Esempio n. 20
0
def make_pipeline(asset_finder):
    hs300 = ts.get_hs300s()['code']
    private_universe = private_universe_mask(hs300.tolist(),
                                             asset_finder=asset_finder)
    #private_universe =  private_universe_mask(['000001','000002','000005'],asset_finder=asset_finder)
    ######################################################################################################
    returns = Returns(inputs=[USEquityPricing.close],
                      window_length=5,
                      mask=private_universe)  # 预测一周数据
    ######################################################################################################
    ep = 1 / Fundamental(mask=private_universe, asset_finder=asset_finder).pe
    bp = 1 / Fundamental(mask=private_universe, asset_finder=asset_finder).pb
    bvps = Fundamental(mask=private_universe, asset_finder=asset_finder).bvps
    market = Fundamental(mask=private_universe,
                         asset_finder=asset_finder).outstanding
    totals = Fundamental(mask=private_universe,
                         asset_finder=asset_finder).totals
    totalAssets = Fundamental(mask=private_universe,
                              asset_finder=asset_finder).totalAssets
    fixedAssets = Fundamental(mask=private_universe,
                              asset_finder=asset_finder).fixedAssets
    esp = Fundamental(mask=private_universe, asset_finder=asset_finder).esp
    rev = Fundamental(mask=private_universe, asset_finder=asset_finder).rev
    profit = Fundamental(mask=private_universe,
                         asset_finder=asset_finder).profit
    gpr = Fundamental(mask=private_universe, asset_finder=asset_finder).gpr
    npr = Fundamental(mask=private_universe, asset_finder=asset_finder).npr

    rev10 = Returns(inputs=[USEquityPricing.close],
                    window_length=10,
                    mask=private_universe)
    vol10 = AverageDollarVolume(window_length=20, mask=private_universe)
    rev20 = Returns(inputs=[USEquityPricing.close],
                    window_length=20,
                    mask=private_universe)
    vol20 = AverageDollarVolume(window_length=20, mask=private_universe)
    rev30 = Returns(inputs=[USEquityPricing.close],
                    window_length=30,
                    mask=private_universe)
    vol30 = AverageDollarVolume(window_length=20, mask=private_universe)

    illiq22 = ILLIQ(window_length=22, mask=private_universe)
    illiq5 = ILLIQ(window_length=5, mask=private_universe)

    rsi5 = RSI(window_length=5, mask=private_universe)
    rsi22 = RSI(window_length=22, mask=private_universe)

    mom5 = Momentum(window_length=5, mask=private_universe)
    mom22 = Momentum(window_length=22, mask=private_universe)

    sector = get_sector(asset_finder=asset_finder, mask=private_universe)
    ONEHOTCLASS, sector_indict_keys = get_sector_by_onehot(
        asset_finder=asset_finder, mask=private_universe)

    pipe_columns = {
        'ep': ep.zscore(groupby=sector).downsample('month_start'),
        'bp': bp.zscore(groupby=sector).downsample('month_start'),
        'bvps': bvps.zscore(groupby=sector).downsample('month_start'),
        'market_cap': market.zscore(groupby=sector).downsample('month_start'),
        'totals': totals.zscore(groupby=sector).downsample('month_start'),
        'totalAssets':
        totalAssets.zscore(groupby=sector).downsample('month_start'),
        'fixedAssets':
        fixedAssets.zscore(groupby=sector).downsample('month_start'),
        'esp': esp.zscore(groupby=sector).downsample('month_start'),
        'rev': rev.zscore(groupby=sector).downsample('month_start'),
        'profit': profit.zscore(groupby=sector).downsample('month_start'),
        'gpr': gpr.zscore(groupby=sector).downsample('month_start'),
        'npr': npr.zscore(groupby=sector).downsample('month_start'),
        'vol10': vol10.zscore(groupby=sector).downsample('week_start'),
        'rev10': rev10.zscore(groupby=sector).downsample('week_start'),
        'vol20': vol20.zscore(groupby=sector).downsample('week_start'),
        'rev20': rev20.zscore(groupby=sector).downsample('week_start'),
        'vol30': vol30.zscore(groupby=sector).downsample('week_start'),
        'rev30': rev30.zscore(groupby=sector).downsample('week_start'),
        'ILLIQ5': illiq5.zscore(groupby=sector).downsample('week_start'),
        'ILLIQ22': illiq22.zscore(groupby=sector).downsample('week_start'),
        'mom5': mom5.zscore(groupby=sector).downsample('week_start'),
        'mom22': mom22.zscore(groupby=sector).downsample('week_start'),
        'rsi5': rsi5.zscore(groupby=sector).downsample('week_start'),
        'rsi22': rsi22.zscore(groupby=sector).downsample('week_start'),
        #'rsi22': rsi22.zscore(groupby=sector, mask=rsi22.percentile_between(1, 99)),

        #######################################################################################################################
        # 'ILLIQ5-2' : illiq5.zscore(groupby=quantiles([illiq5],bins = 10,mask = private_universe)).downsample('week_start'),
        # 'ILLIQ22-2': illiq22.zscore(groupby=quantiles([illiq22],bins = 10,mask = private_universe)).downsample('week_start'),
        # 'ILLIQ5-2': illiq5.zscore(groupby=market.quantiles(bins=10, mask=private_universe)).downsample('week_start'),
        # 'ILLIQ22-2': illiq22.zscore(groupby=market.quantiles(bins=10, mask=private_universe)).downsample('week_start'),
        #############################################################################################################################
        'returns': returns.downsample('week_start'),
    }
    pipe = Pipeline(
        columns=pipe_columns,
        screen=private_universe,
    )
    i = 0
    for c in ONEHOTCLASS:
        pipe.add(c, sector_indict_keys[i])
        i += 1
    return pipe
Esempio n. 21
0
def STR():
    return -RSI()
Esempio n. 22
0
def rsi_sector_neutral(window_length, universe, sector):
    returns = Returns(window_length=window_length, mask=universe) \
        .demean(groupby=sector) \
        .rank() \
        .zscore()
    return RSI(inputs=[returns], window_length=window_length).rank().zscore()