示例#1
0
    def volatility(
        self,
        n,
        freq=None,
        which="close",
        ann=True,
        model="ln",
        min_periods=1,
        rolling="simple",
    ):
        """Return the annualized volatility series. N is the number of lookback periods.

        :param n: int, number of lookback periods
        :param freq: resample frequency or None
        :param which: price series to use
        :param ann: If True then annualize
        :param model: {'ln', 'pct', 'bbg'}
                        ln - use logarithmic price changes
                        pct - use pct price changes
                        bbg - use logarithmic price changes but Bloomberg uses actual business days
        :param rolling:{'simple', 'exp'}, if exp, use ewmstd. if simple, use rolling_std
        :return:
        """
        if model not in ("bbg", "ln", "pct"):
            raise ValueError("model must be one of (bbg, ln, pct), not %s" %
                             model)
        if rolling not in ("simple", "exp"):
            raise ValueError("rolling must be one of (simple, exp), not %s" %
                             rolling)

        px = self.frame[which]
        px = px if not freq else px.resample(freq, how="last")
        if model == "bbg" and periods_in_year(px) == 252:
            # Bloomberg uses business days, so need to convert and reindex
            orig = px.index
            px = px.resample("B").ffill()
            chg = np.log(px / px.shift(1))
            chg[chg.index - orig] = np.nan
            if rolling == "simple":
                vol = pd.rolling_std(chg, n,
                                     min_periods=min_periods).reindex(orig)
            else:
                vol = pd.ewmstd(chg, span=n, min_periods=n)
            return vol if not ann else vol * np.sqrt(260)
        else:
            chg = px.pct_change() if model == "pct" else np.log(px /
                                                                px.shift(1))
            if rolling == "simple":
                vol = pd.rolling_std(chg, n, min_periods=min_periods)
            else:
                vol = pd.ewmstd(chg, span=n, min_periods=n)
            return vol if not ann else vol * np.sqrt(periods_in_year(vol))
示例#2
0
def zscore_ranked(div, library):
    lookback = 5
    markets = 3
    data = pd.DataFrame()
    for mkt in library.list_symbols():
        try:
            data[mkt] = library.read(mkt).data.Price
        except:
            print mkt
    zscores = (data - pd.ewma(data, 20)) / pd.ewmstd(data, 20)
    latest = zscores.tail(lookback)
    zscore_ranked = latest.T.sort_values(
        by=latest.T.columns[0]).dropna()[:markets]
    zscore_ranked = zscore_ranked.append(
        latest.T.sort_values(by=latest.T.columns[0]).dropna()[-markets:])
    final_data = pd.DataFrame()
    i = 1
    for d in zscore_ranked.columns:
        final_data['T+' + str(i)] = zscore_ranked[d]
        i = i + 1
    return serialize(final_data,
                     render_to=div,
                     kind="bar",
                     title="Noteable market moves",
                     output_type='json')
示例#3
0
def robust_vol_calc(x,
                    days=35,
                    min_periods=10,
                    vol_abs_min=0.0000000001,
                    vol_floor=True,
                    floor_min_quant=0.05,
                    floor_min_periods=100,
                    floor_days=500):

    # Standard deviation will be nan for first 10 non nan values
    vol = pd.ewmstd(x, span=days, min_periods=min_periods)

    vol[vol < vol_abs_min] = vol_abs_min

    if vol_floor:
        # Find the rolling 5% quantile point to set as a minimum
        vol_min = pd.rolling_quantile(vol, floor_days, floor_min_quant,
                                      floor_min_periods)
        # set this to zero for the first value then propogate forward, ensures
        # we always have a value
        vol_min.set_value(vol_min.index[0], 0.0)
        vol_min = vol_min.ffill()

        # apply the vol floor
        vol_with_min = pd.concat([vol, vol_min], axis=1)
        vol_floored = vol_with_min.max(axis=1, skipna=False)
    else:
        vol_floored = vol

    return vol_floored
示例#4
0
文件: algos.py 项目: cymond/sysy
def vol_estimator(x, using_exponent=True, min_periods=20, ew_lookback=250):
    """
    Generic vol estimator used for optimisation, works on data frames, produces a single answer

    :param x: data
    :type x: Tx1 pd.DataFrame

    :param using_exponent: Use exponential or normal vol (latter recommended for bootstrapping)
    :type using_exponent: bool

    :param min_periods: The minimum number of observations (*default* 10)
    :type min_periods: int


    :returns: pd.DataFrame -- volatility measure

    """
    if using_exponent:
        vol = pd.ewmstd(x, span=ew_lookback,
                        min_periods=min_periods).iloc[-1, :].values[0]

    else:
        with warnings.catch_warnings():
            warnings.simplefilter("ignore", category=RuntimeWarning)
            vol = x.apply(apply_with_min_periods,
                          axis=0,
                          min_periods=min_periods,
                          my_func=np.nanstd)

    stdev_list = list(vol)

    return stdev_list
示例#5
0
def vol_estimator(x, using_exponent=True, min_periods=20, ew_lookback=250):
    """
    Generic vol estimator used for optimisation, works on data frames, produces a single answer

    :param x: data
    :type x: Tx1 pd.DataFrame

    :param using_exponent: Use exponential or normal vol (latter recommended for bootstrapping)
    :type using_exponent: bool

    :param min_periods: The minimum number of observations (*default* 10)
    :type min_periods: int


    :returns: pd.DataFrame -- volatility measure

    """
    if using_exponent:
        vol = pd.ewmstd(x, span=ew_lookback, min_periods=min_periods).iloc[-1,:].values[0]
        
    else:
        vol=x.apply(apply_with_min_periods,axis=0,min_periods=min_periods, my_func=np.nanstd) 
    
    stdev_list=list(vol)
    
    return stdev_list
示例#6
0
def robust_vol_calc(x, days=35, min_periods=10, vol_abs_min=0.0000000001, vol_floor=True,
                    floor_min_quant=0.05, floor_min_periods=100,
                    floor_days=500):

    # Standard deviation will be nan for first 10 non nan values
    vol = pd.ewmstd(x, span=days, min_periods=min_periods)

    vol[vol < vol_abs_min] = vol_abs_min

    if vol_floor:
        # Find the rolling 5% quantile point to set as a minimum
        vol_min = pd.rolling_quantile(
            vol, floor_days, floor_min_quant, floor_min_periods)
        # set this to zero for the first value then propogate forward, ensures
        # we always have a value
        vol_min.set_value(vol_min.index[0], 0.0)
        vol_min = vol_min.ffill()

        # apply the vol floor
        vol_with_min = pd.concat([vol, vol_min], axis=1)
        vol_floored = vol_with_min.max(axis=1, skipna=False)
    else:
        vol_floored = vol

    return vol_floored
示例#7
0
def portfolio_return(asset_returns, cash_weights):

    index_returns = asset_returns.cumsum().ffill().diff()

    cash_align = cash_weights.reindex(asset_returns.index, method="ffill")
    cash_align[np.isnan(index_returns)] = 0.0
    cash_align[np.isnan(cash_align)] = 0.0

    vols = pd.ewmstd(asset_returns, span=100, min_periods=1)
    riskweights = pd.DataFrame(cash_align.values / vols.values,
                               index=vols.index)
    riskweights.columns = asset_returns.columns

    riskweights[np.isnan(riskweights)] = 0.0

    def _rowfix(x):
        if all([y == 0.0 for y in x]):
            return x
        sumx = sum(x)
        return [y / sumx for y in x]

    riskweights = riskweights.apply(_rowfix, axis=1)

    portfolio_returns = asset_returns * riskweights

    portfolio_returns[np.isnan(portfolio_returns)] = 0.0

    portfolio_returns = portfolio_returns.sum(axis=1)

    return portfolio_returns
def standardize(data):
    log_return = np.log(data).diff()
    std = pd.ewmstd(log_return, 10)
    ewma = pd.ewma(log_return, 10)
    data_standardized = 1 / (1 + np.exp((log_return - ewma) / std))

    return data_standardized
示例#9
0
def macro_factors(div, library):
    factors = {
        'Risk on': ['Russell 2000', 'DAX'],
        'Quantitative Easing':
        ['Gold', 'German Bund', 'Gilts', 'US Treasuries 10 Yr'],
        'Emerging Markets':
        ['Copper', 'MXN', 'BRL', 'Ibovespa', 'Taiwan (SIMEX)'],
        'EU': ['DAX', 'FTSE 100', 'German Bund', 'Italian 10 year bonds'],
        'Energies': ['Crude', 'Rotterdam Coal', 'Natural Gas'],
        'Industrials':
        ['Copper', 'Rotterdam Coal', 'Crude', 'Shanghai  Rebar']
    }
    factor_data = pd.DataFrame()
    for f in factors.keys():
        df = pd.DataFrame()
        for m in factors[f]:
            try:
                df[m] = library.read(m).data.Price.replace(to_replace=0,
                                                           method='ffill')
            except:
                print m
        factor_data[f] = df.resample(
            rule='d', how='last').dropna(how='all').pct_change().mean(axis=1)
    lookback = 5
    zscores = (factor_data.cumsum() - pd.ewma(
        factor_data.cumsum(), 60)) / pd.ewmstd(factor_data.cumsum(), 60)
    y = zscores.tail(1).T.columns[0].year
    return serialize(zscores[str(y)].ffill(),
                     render_to=div,
                     title='Factors',
                     output_type='json')
示例#10
0
文件: algos.py 项目: cymond/sysy
def robust_vol_calc(x,
                    days=35,
                    min_periods=10,
                    vol_abs_min=0.0000000001,
                    vol_floor=True,
                    floor_min_quant=0.05,
                    floor_min_periods=100,
                    floor_days=500):
    """
    Robust exponential volatility calculation, assuming daily series of prices
    We apply an absolute minimum level of vol (absmin);
    and a volfloor based on lowest vol over recent history

    :param x: data
    :type x: Tx1 pd.Series

    :param days: Number of days in lookback (*default* 35)
    :type days: int

    :param min_periods: The minimum number of observations (*default* 10)
    :type min_periods: int

    :param vol_abs_min: The size of absolute minimum (*default* =0.0000000001) 0.0= not used
    :type absmin: float or None

    :param vol_floor Apply a floor to volatility (*default* True)
    :type vol_floor: bool
    :param floor_min_quant: The quantile to use for volatility floor (eg 0.05 means we use 5% vol) (*default 0.05)
    :type floor_min_quant: float
    :param floor_days: The lookback for calculating volatility floor, in days (*default* 500)
    :type floor_days: int
    :param floor_min_periods: Minimum observations for floor - until reached floor is zero (*default* 100)
    :type floor_min_periods: int

    :returns: pd.DataFrame -- volatility measure


    """

    # Standard deviation will be nan for first 10 non nan values
    vol = pd.ewmstd(x, span=days, min_periods=min_periods)

    vol[vol < vol_abs_min] = vol_abs_min

    if vol_floor:
        # Find the rolling 5% quantile point to set as a minimum
        vol_min = pd.rolling_quantile(vol, floor_days, floor_min_quant,
                                      floor_min_periods)
        # set this to zero for the first value then propogate forward, ensures
        # we always have a value
        vol_min.set_value(vol_min.index[0], 0.0)
        vol_min = vol_min.ffill()

        # apply the vol floor
        vol_with_min = pd.concat([vol, vol_min], axis=1)
        vol_floored = vol_with_min.max(axis=1, skipna=False)
    else:
        vol_floored = vol

    return vol_floored
示例#11
0
def tsmom_improved(data, months):
    vol = pd.ewmstd(data.pct_change(), 500) * math.sqrt(12)
    data = data.resample(rule='m', how='last')
    signal = data / data.shift(months) - 1
    signal = signal / abs(signal)
    position = signal / vol
    return position
示例#12
0
 def expected_ewmstd(self, window_length, decay_rate):
     alpha = 1 - decay_rate
     span = (2 / alpha) - 1
     return rolling_apply(
         self.raw_data,
         window_length,
         lambda window: ewmstd(window, span=span)[-1],
     )[window_length:]
示例#13
0
def tsmom_daily(data, signal_lookback, vol_lookback=20):
    mul = get_contract_multipliers()[data.columns]
    vol = pd.ewmstd(data, vol_lookback,
                    min_periods=vol_lookback) * math.sqrt(256)
    signal = pd.rolling_mean(data, signal_lookback)
    signal = signal / abs(signal)
    position = (signal / (vol * mul))
    return position.shift(1)
示例#14
0
文件: utils.py 项目: rhouck/re
 def ts(df, panel):
     hl = TS_HALFLIFE
     min_per = 12
     if panel:
          hl = hl * df.index.levels[1].shape[0]
          min_per = min_per * df.index.levels[1].shape[0]
     m = pd.ewma(df, halflife=hl, min_periods=min_per)
     std = pd.ewmstd(df, halflife=hl, min_periods=min_per)
     return (df - m) / std
def calc_std(returns):
    downside_only = False
    if (downside_only):
        returns = returns.copy()
        returns[returns > 0.0] = np.nan
    b = pd.ewmstd(
        returns, halflife=20, adjust=True,
        ignore_na=True).dropna()  #halflife = 20 four week half life - mid-term
    return b.iloc[-1]
示例#16
0
 def devol(self, _lambda=0.06, n_days=1):
     _com = (1 - _lambda) / _lambda
     self.df['LogReturns'] = np.log(
         self.df.Close.pct_change(periods=n_days) + 1)
     self.df['Vola'] = pd.ewmstd(self.df.LogReturns,
                                 com=_com,
                                 ignore_na=True)[2:]
     self.df['DevolLogReturns'] = self.df.LogReturns / self.df.Vola
     self.df.set_index('Date', inplace=True)
示例#17
0
    def trend(self,
              tags,
              top_n=None,
              other=False,
              resample='D',
              cumulative=False,
              ewmaspan=None):
        """ show the supplied tags summed up per day """
        if top_n is not None:
            tags = self.top_n_tags(top_n, tags)
        D = self.D[tags] if tags is not None else self.D
        if other:
            D['other'] = self.D[[t for t in self.D.keys()
                                 if t not in tags]].sum(axis=1)
        D = D.resample(resample, how='sum', label='left')
        self._obfuscate(D)
        D = D.fillna(0)
        if ewmaspan is not None:
            ewma = pd.ewma(D, span=ewmaspan)
            ewmstd = pd.ewmstd(D, span=2 * ewmaspan)
            if cumulative:
                ewmstd = ewmstd * 3
                ewma = ewma.cumsum()
        if cumulative:
            D = D.cumsum()

        alpha = 0.5 if not cumulative and ewmaspan is not None else 1
        ax = D.plot(linewidth=2,
                    colormap=self.cmapname,
                    legend=False,
                    alpha=alpha)
        if ewmaspan is not None:
            colors = self.cmap(np.linspace(0., 1., len(D.keys())))
            if cumulative:
                for idx, k in enumerate(tags):
                    ax.fill_between(D.index,
                                    np.array(ewma[k] + ewmstd[k]).ravel(),
                                    np.array(ewma[k] - ewmstd[k]).ravel(),
                                    facecolor=colors[idx],
                                    alpha=0.2,
                                    linewidth=1)
            ewma.plot(style='--',
                      legend=False,
                      ax=ax,
                      colormap=self.cmapname,
                      linewidth=2)
        ax.legend(ax.lines[:len(D.keys())],
                  map(lambda x: x.get_label(), ax.lines[:len(D.keys())]),
                  loc='best')
        ax.grid(True)
        ax.set_ylim(0, D.max().max())
        if cumulative:
            plt.ylabel('Time Spent (h)')
        else:
            plt.ylabel('Time Spent (h) per Interval (%s)' % resample)
        plt.xlabel('Interval ID')
示例#18
0
def robust_vol_calc(x, days=35, min_periods=10, vol_abs_min=0.0000000001, vol_floor=True,
                    floor_min_quant=0.05, floor_min_periods=100,
                    floor_days=500):
    """
    Robust exponential volatility calculation, assuming daily series of prices
    We apply an absolute minimum level of vol (absmin);
    and a volfloor based on lowest vol over recent history

    :param x: data
    :type x: Tx1 pd.DataFrame

    :param days: Number of days in lookback (*default* 35)
    :type days: int

    :param min_periods: The minimum number of observations (*default* 10)
    :type min_periods: int

    :param vol_abs_min: The size of absolute minimum (*default* =0.0000000001) 0.0= not used
    :type absmin: float or None

    :param vol_floor Apply a floor to volatility (*default* True)
    :type vol_floor: bool
    :param floor_min_quant: The quantile to use for volatility floor (eg 0.05 means we use 5% vol) (*default 0.05)
    :type floor_min_quant: float
    :param floor_days: The lookback for calculating volatility floor, in days (*default* 500)
    :type floor_days: int
    :param floor_min_periods: Minimum observations for floor - until reached floor is zero (*default* 100)
    :type floor_min_periods: int

    :returns: pd.DataFrame -- volatility measure


    """

    # Standard deviation will be nan for first 10 non nan values
    vol = pd.ewmstd(x, span=days, min_periods=min_periods)

    vol[vol < vol_abs_min] = vol_abs_min

    if vol_floor:
        # Find the rolling 5% quantile point to set as a minimum
        vol_min = pd.rolling_quantile(
            vol, floor_days, floor_min_quant, floor_min_periods)
        # set this to zero for the first value then propogate forward, ensures
        # we always have a value
        vol_min.set_value(vol_min.index[0], vol_min.columns[0], 0.0)
        vol_min = vol_min.ffill()

        # apply the vol floor
        vol_with_min = pd.concat([vol, vol_min], axis=1)
        vol_floored = vol_with_min.max(axis=1, skipna=False).to_frame()
    else:
        vol_floored = vol

    vol_floored.columns = ["vol"]
    return vol_floored
示例#19
0
 def __init__( self, 
               prices, 
               volFunc = lambda returns: pd.ewmstd( returns, span = 252 ), 
               name = 'Empirical'  ):
     self.name = name
     self.dates = prices.index
     self.returns = prices.pct_change()
     self.vol = volFunc( self.returns )
     self.volDyad = dict( ( today, self.dyad( self.vol.ix[ today.date() ] ) ) for today in self.dates )
     self.empCov = dict( ( today, self.returns[ 1:today.date() ].corr().as_matrix() * self.volDyad[ today ] )
                           for today in self.dates[1:] )
示例#20
0
def ewma_mom_daily(data, short_lookback, long_lookback, vol_lookback=20):
    mkts = data.columns
    mul = get_contract_multipliers()[mkts]
    vol = pd.ewmstd(data, vol_lookback,
                    min_periods=vol_lookback) * math.sqrt(256)
    signal = signal = pd.ewma(data, short_lookback) - pd.ewma(
        data, long_lookback)
    # Rolling z secore using longer lookback
    zscore = calc_zscore(signal, long_lookback)
    position = (zscore / (vol * mul))
    return position.shift(1)
示例#21
0
 def get_raw_value(self):
     rtns = wind.get_wind_data("AShareEODPrices", "s_dq_pctchange").loc["2005-01-01":] / 100
     beta = Descriptor.Beta().get_raw_value()
     resid = {}
     common_index = sorted(set(rtns.index) & set(beta.index))
     R = get_estimation_universe().get_returns()
     for idx in common_index:
         row = rtns.loc[idx]
         resid[idx] = row - beta.loc[idx] * R.loc[idx]
     resid = pd.DataFrame(resid).T
     sigma = pd.ewmstd(resid, halflife=self.T)
     return sigma
示例#22
0
def ewma_mom_daily_signal(data,
                          short_lookback,
                          long_lookback,
                          vol_lookback=20):
    vol = pd.ewmstd(data, vol_lookback,
                    min_periods=vol_lookback) * math.sqrt(256)
    signal = signal = pd.ewma(data, short_lookback) - pd.ewma(
        data, long_lookback)
    # Rolling z secore using longer lookback
    zscore = calc_zscore(signal, long_lookback)
    position = (zscore / (vol))
    return position.shift(1)
示例#23
0
    def volatility(self, n, freq=None, which='close', ann=True, model='ln', min_periods=1, rolling='simple'):
        """Return the annualized volatility series. N is the number of lookback periods.

        :param n: int, number of lookback periods
        :param freq: resample frequency or None
        :param which: price series to use
        :param ann: If True then annualize
        :param model: {'ln', 'pct', 'bbg'}
                        ln - use logarithmic price changes
                        pct - use pct price changes
                        bbg - use logarithmic price changes but Bloomberg uses actual business days
        :param rolling:{'simple', 'exp'}, if exp, use ewmstd. if simple, use rolling_std
        :return:
        """
        if model not in ('bbg', 'ln', 'pct'):
            raise ValueError('model must be one of (bbg, ln, pct), not %s' % model)
        if rolling not in ('simple', 'exp'):
            raise ValueError('rolling must be one of (simple, exp), not %s' % rolling)

        px = self.frame[which]
        px = px if not freq else px.resample(freq, how='last')
        if model == 'bbg' and periods_in_year(px) == 252:
            # Bloomberg uses business days, so need to convert and reindex
            orig = px.index
            px = px.resample('B').ffill()
            chg = np.log(px / px.shift(1))
            chg[chg.index - orig] = np.nan
            if rolling == 'simple':
                vol = pd.rolling_std(chg, n, min_periods=min_periods).reindex(orig)
            else:
                vol = pd.ewmstd(chg, span=n, min_periods=n)
            return vol if not ann else vol * np.sqrt(260)
        else:
            chg = px.pct_change() if model == 'pct' else np.log(px / px.shift(1))
            if rolling == 'simple':
                vol = pd.rolling_std(chg, n, min_periods=min_periods)
            else:
                vol = pd.ewmstd(chg, span=n, min_periods=n)
            return vol if not ann else vol * np.sqrt(periods_in_year(vol))
示例#24
0
def robust_vol_calc(x, days=35, min_periods=10, vol_abs_min=0.0000000001, vol_floor=True,
                    floor_min_quant=0.05, floor_min_periods=100,
                    floor_days=500):
    vol = pd.ewmstd(x, span=days, min_periods=min_periods)
    vol[vol < vol_abs_min] = vol_abs_min
    if vol_floor:
        vol_min = pd.rolling_quantile(
            vol, floor_days, floor_min_quant, floor_min_periods)
        vol_min.set_value(vol_min.index[0], 0.0)
        vol_min = vol_min.ffill()
        vol_with_min = pd.concat([vol, vol_min], axis=1)
        vol_floored = vol_with_min.max(axis=1, skipna=False)
    else:
        vol_floored = vol

    return vol_floored
示例#25
0
    def trend(self, tags, top_n=None, other=False, resample='D', cumulative=False, ewmaspan=None):
        """ show the supplied tags summed up per day """
        if top_n is not None:
            tags = self.top_n_tags(top_n, tags)
        D = self.D[tags] if tags is not None else self.D
        if other:
            D['other'] = self.D[[t for t in self.D.keys()
                                 if t not in tags]].sum(axis=1)
        D = D.resample(resample, how='sum', label='left')
        self._obfuscate(D)
        D = D.fillna(0)
        if ewmaspan is not None:
            ewma = pd.ewma(D, span=ewmaspan)
            ewmstd = pd.ewmstd(D, span=2 * ewmaspan)
            if cumulative:
                ewmstd = ewmstd * 3
                ewma = ewma.cumsum()
        if cumulative:
            D = D.cumsum()

        alpha = 0.5 if not cumulative and ewmaspan is not None else 1
        ax = D.plot(linewidth=2, colormap=self.cmapname,
                    legend=False, alpha=alpha)
        if ewmaspan is not None:
            colors = self.cmap(np.linspace(0., 1., len(D.keys())))
            if cumulative:
                for idx, k in enumerate(tags):
                    ax.fill_between(D.index, np.array(ewma[k] + ewmstd[k]).ravel(),
                                    np.array(ewma[k] - ewmstd[k]).ravel(),
                                    facecolor=colors[idx], alpha=0.2,
                                    linewidth=1)
            ewma.plot(style='--', legend=False, ax=ax,
                      colormap=self.cmapname, linewidth=2)
        ax.legend(ax.lines[:len(D.keys())],
                    map(lambda x:x.get_label(), ax.lines[:len(D.keys())]), loc='best')
        ax.grid(True)
        ax.set_ylim(0, D.max().max())
        if cumulative:
            plt.ylabel('Time Spent (h)')
        else:
            plt.ylabel('Time Spent (h) per Interval (%s)' % resample)
        plt.xlabel('Interval ID')
示例#26
0
def reversal_pl(btc_ret, long_only=True):
    model = pd.ols(y=btc_ret,
                   x=btc_ret.shift(1),
                   window=12 * 24 * 5,
                   window_type='rolling')
    betas = model.beta['x']
    signal = timing_curve(betas * zscore(btc_ret))
    sigma = np.sqrt(365 * 24 * 12) * pd.ewmstd(
        btc_ret, com=12 * 24 * 5, min_periods=12 * 24 * 5)
    if long_only:
        view = (.3 * (signal) / sigma).clip(0, 9999999)
    else:
        view = (.3 * (signal) / sigma)
    t_cost = (view.diff()).abs() * .005
    pl = view.shift(1) * btc_ret
    net_pl = view.shift(1) * (btc_ret) - t_cost
    turnover = 365 * 12 * 24 * view.diff().abs().mean()
    print calc_sharpe(pl)
    print calc_sharpe(net_pl)
    print turnover
    return pd.DataFrame({'view': view, 'pl': pl, 'net_pl': net_pl})
示例#27
0
def emstd(data, window):
    """Exponential Moving Standard Deviation: The exponentially weighted
    standard deviation of the price of a security over a specific number of
    periods.

    'data' is a pandas Series or DataFrame of prices. A ValueError is raised
    if 'data' is of different data type.

    'window' is the number of observations.
    It must be a positive integer less than or equal to the length of the data.
    Otherwise a ValueError will be raised.
    """

    # todo: maybe add 'long' too?
    if not isinstance(window, int) or not 0 < window <= len(data):
        raise ValueError("'window' must be an integer " +
                         "between 1 and %d." % len(data))

    if not isinstance(data, (pd.Series, pd.DataFrame)):
        raise ValueError("'data' must be a pandas Series or DataFrame.")

    return pd.ewmstd(data, span = window)
示例#28
0
def emstd(data, window):
    """Exponential Moving Standard Deviation: The exponentially weighted
    standard deviation of the price of a security over a specific number of
    periods.

    'data' is a pandas Series or DataFrame of prices. A ValueError is raised
    if 'data' is of different data type.

    'window' is the number of observations.
    It must be a positive integer less than or equal to the length of the data.
    Otherwise a ValueError will be raised.
    """

    # todo: maybe add 'long' too?
    if not isinstance(window, int) or not 0 < window <= len(data):
        raise ValueError("'window' must be an integer " +
                         "between 1 and %d." % len(data))

    if not isinstance(data, (pd.Series, pd.DataFrame)):
        raise ValueError("'data' must be a pandas Series or DataFrame.")

    return pd.ewmstd(data, span=window)
示例#29
0
plt.show()



#d1=pd.datetime(2007,1,1)
#d2=pd.datetime(2009,12,31)


nerpu=data.apply(find_datediff, axis=1)
nerpu.plot()
plt.title("Nerpu")
plt.show()

## Shouldn't need changing
vol_lookback=25
stdev_returns=pd.ewmstd(price - price.shift(1), span=vol_lookback)
ann_stdev=stdev_returns*ROOT_DAYS_IN_YEAR

raw_carry=nerpu/ann_stdev
f_scalar=30.0

raw_carry.plot()
plt.title("Raw carry")
plt.show()

forecast=raw_carry*f_scalar

c_forecast=cap_series(forecast)

data_to_plot=pd.concat([forecast,c_forecast], axis=1)
data_to_plot.columns=['Forecast','Capped forecast']
示例#30
0
def calc_zscore(df,
                mean_halflife=21,
                mean_seed_period=21,
                std_halflife=21,
                std_seed_period=21,
                smth_halflife=0,
                ewm=True,
                subtract_mean=True,
                cap=3.0,
                lag=0):
    """
    Calculate timeseries z-score (assuming normal distribution of input data)

    Parameters
    ----------
    df : DataFrame or Series
        DataFrame or Series object containing timeseries data
    mean_halflife : int, optional
        Half-life period (periodicity determined by index of df) for computing mean
    mean_seed_period : int, optional
        Seeding period (periodicity determined by index of df) for computing mean
    std_halflife : int, optional
        Half-life period (periodicity determined by index of df) for computing standard deviation
    std_seed_period : int, optional
        Seeding period (periodicity determined by index of df) for computing standard deviation
    smth_halflife : int, optional
        Smoothing half-life period (periodicity determined by index of df) for smoothing input data before computing z-score
    ewm : bool, optional
        If True, compute z-score based on ewm mean and standard deviation. If False, compute z-score based on simple mean and standard deviation.
    subtract_mean : bool, optional
        If True, subtract mean while computing z-score. If False, normalize the value by dividing by standard deviation.
    cap : float, optional
        Absolute cap for z-score
    lag : int, optional
        Periods (periodicity determined by index of df) by which to lag the z-score

    Returns
    -------
    score_df : DataFrame or Series
        DataFrame or Series object containing z-score

    """

    is_series = False
    if isinstance(df, pd.Series):
        df = pd.DataFrame(df)
        is_series = True
    elif not isinstance(df, pd.DataFrame):
        raise ValueError('df should be either a DataFrame or Series object')

    if mean_halflife < 0:
        raise ValueError('%d is not a valid mean half-life' % mean_halflife)
    if mean_halflife > df.shape[0]:
        raise ValueError('mean_halflife can not be larger than length of index of df')
    if mean_seed_period < 0:
        raise ValueError('%d is not a valid mean seed period' % mean_seed_period)
    if mean_seed_period > df.shape[0]:
        raise ValueError('mean_seed_period can not be larger than length of index of df')
    if std_halflife < 0:
        raise ValueError('%d is not a valid standard deviation half-life' % std_halflife)
    if std_halflife > df.shape[0]:
        raise ValueError('std_halflife can not be larger than length of index of df')
    if std_seed_period < 0:
        raise ValueError('%d is not a valid standard deviation seed period' % std_seed_period)
    if std_seed_period > df.shape[0]:
        raise ValueError('std_seed_period can not be larger than length of index of df')
    if smth_halflife < 0:
        raise ValueError('%d is not a valid smoothing half-life' % smth_halflife)
    if smth_halflife > df.shape[0]:
        raise ValueError('smth_halflife can not be larger than length of index of df')
    if not isinstance(ewm, bool):
        raise ValueError('ewm should be either True of False')
    if not isinstance(subtract_mean, bool):
        raise ValueError('subtract_mean should be either True of False')
    if cap <= 0:
        raise ValueError('%f is not a valid score cap' % cap)
    if lag < 0:
        raise ValueError('%d is not a valid lag period' % lag)
    if lag > df.shape[0]:
        raise ValueError('lag can not be larger than length of index of df')

    # apply smoothing
    if smth_halflife > 0:
        df = pd.ewma(df, halflife=smth_halflife, min_periods=smth_halflife, adjust=False)

    # compute mean and standard deviation
    if ewm:
        mean_df = pd.ewma(df, halflife=mean_halflife, min_periods=mean_seed_period, adjust=False)
        std_df = pd.ewmstd(df, halflife=std_halflife, min_periods=std_seed_period, adjust=False)
    else:
        mean_df = pd.rolling_mean(df, window=mean_halflife, min_periods=mean_seed_period)
        std_df = pd.rolling_std(df, window=std_halflife, min_periods=std_seed_period)

    # compute score
    if subtract_mean:
        score_df = (df - mean_df) / std_df
    else:
        score_df = df / std_df

    # cap score
    score_df = score_df.clip(-cap, cap)

    # lag score
    if lag > 0:
        score_df = score_df.shift(lag)

    if is_series:
        return pd.Series(score_df.squeeze())
    else:
        return score_df
 def devol(self, _lambda=0.06, n_days=1):
     _com = (1 - _lambda) / _lambda
     self.df['LogReturns'] = np.log(self.df.Close.pct_change(periods=n_days) + 1)
     self.df['Vola'] = pd.ewmstd( self.df.LogReturns, com=_com, ignore_na=True)[2:]
     self.df['DevolLogReturns'] = self.df.LogReturns / self.df.Vola
     self.df.set_index('Date', inplace=True)
示例#32
0
def volatility(price, vol_lookback=25):
    return pd.ewmstd(price - price.shift(1), span=vol_lookback, min_periods=vol_lookback)    
示例#33
0
 def addEWSDev(self, fromIndex, addedSeriesName = 'ewstdev', win_length = 1):
     
     self[addedSeriesName] = pd.ewmstd(self[fromIndex], win_length)
示例#34
0
 def smoothSeriesEwmvar(self, series, span=5.0, adjust=True, halflife=None, min_periods=0):
     return pandas.ewmstd(
         series, com=None, span=span, halflife=halflife, min_periods=min_periods, adjust=adjust, ignore_na=True
     )
def spread_crossover(data_df,slow=1,fast=12):
    
    
    
    spread_log = pd.DataFrame(np.log(data_df.ix[:,0] * 100))
    
    
    data_df['spread_z_ma'] = (spread_log - pd.expanding_mean(spread_log, min_periods=24))/  pd.expanding_std(spread_log, min_periods=24)
    
    data_df['spread_z_ema'] = (spread_log - pd.ewma(spread_log, min_periods = 24, halflife=12)) / pd.ewmstd(spread_log, halflife=12)
    
    
    data_df['spread_z_ema'] = pd.rolling_mean(data_df['spread_z_ema'], window=3)
     
    data_df['slow'] = pd.rolling_mean(data_df['US HY Spread'],slow)

    data_df['fast'] = pd.rolling_mean(data_df['US HY Spread'],fast)
    
    data_df['diff'] = (data_df['slow'] - data_df['fast']) * -1
    
    data_df['diff'] = data_df['diff'] + 1
    
    data_df['diff'] = np.log(data_df['diff'])
    
    data_df['tren_z_ma'] = (data_df['diff'] - pd.expanding_mean(data_df['diff'], min_periods=24))/  pd.expanding_std(data_df['diff'], min_periods=24)
    
    data_df['tren_z_ma']  = pd.rolling_mean(data_df['tren_z_ma'], window=3)
    trend_valuation_df = pd.concat([data_df['spread_z_ema'],data_df['tren_z_ma']], axis=1)

    
    trend_valuation_df.dropna(inplace=True)
    trend_valuation_df.plot()
    plt.show()
    
    algo_wghts_df = pd.DataFrame()
    wghts_array = []
    
    valuation_threshold_cheap = 1
    valuation_threshold_rich = -1.0
    trend_threshold_tightening = 0.1
    trend_threshold_widening = -0.1
    
    data_df['spread_z_ma'].plot()
    plt.show()
    
    

    for score in trend_valuation_df.values:
        valuation_score = score[0]
        trend_score = score[1]
        
        if (trend_score >= -0.2 and valuation_score >= -1):
            wghts_array.append(min(1,abs(trend_score-valuation_score) / 1))
        else:
            wghts_array.append(0)
        #elif trend_score <= -0.1 and valuation_score <= valuation_threshold_cheap:
        #    wghts_array.append(-1)
        #elif valuation_score >= valuation_threshold_cheap:
        #    wghts_array.append(1)
        #else:
        #    wghts_array.append(0)   
    
    wghts_df = pd.DataFrame(wghts_array, index = trend_valuation_df.index)
    
 

    long = wghts_df[wghts_df == 1].count()[0] / len(trend_valuation_df)
    neutral = wghts_df[wghts_df == 0].count()[0] / len(trend_valuation_df)
    short = wghts_df[wghts_df == -1].count()[0] / len(trend_valuation_df)
    
    wghts_df.columns = [data_df.columns.values[1]]
    
    wghts_df = wghts_df.shift(1)
    
    
    s1 = bt.Strategy('Valuation & Trend ', [bt.algos.WeighTarget(wghts_df),
                               bt.algos.Rebalance()])
    
    return_data = data_df.ix[:,1].to_frame()
    return_data.columns = [data_df.columns.values[1]]

    strategy = bt.Backtest(s1, return_data)
    
    res = bt.run(strategy)
    
    res.plot(logy=True)
    res.display()
    print(long,neutral,short)
"""Now let's get some real data using quandl"""

startDate = "2017-01-01"
endDate = "2017-12-31"

df = qd.get("WIKI/F", start_date=startDate, end_date=endDate)

time = np.linspace(1, len(df['Adj. Close']), len(df['Adj. Close']))
returns = pd.Series.diff(df['Adj. Close']) / df['Adj. Close']

# Shift so that we're predicting today's close price from yesterday's returns:
returns = returns.shift(-1)[:-1]

k = 5  # Rolling average length

sigma = pd.ewmstd(returns, span=k) * k  # 'diffusion' coefficient
mu = pd.ewma(returns, span=k) * k  # 'drift' coefficient

#del sigma.index.name

# New length:
N = len(df['Adj. Close'])
# Number of sims to run:
M = 100
XN = np.zeros([M, N])
# New time steps:
dt = 1. / N
""" NOT USED """
#xn = np.zeros(N)
#xn[k] = df['Adj. Close'][k]
#
示例#37
0
def parse(date, mode):
    conn = sqlite3.connect('data/orderbook_' + date + '.db')
    freq = '5S'
    cursor = conn.cursor()
    # resLst=cursor.execute(SELECT_SQL, (exchange,pair))
    okex_df = pd.read_sql_query(SELECT_SQL,
                                conn,
                                params=('okex', ),
                                index_col='timestamp')
    # df = pd.read_sql_table('trades',conn,)
    okex_df.index = pd.to_datetime(okex_df.index / 1000, unit='s')
    # print(df['price'].resample('1H').ohlc().tail())
    # print(df['amount'].resample('1H').sum().tail())
    # print(df['price'].resample('1H').mean().tail())
    # okex_mean_serial= okex_df['price'].resample(freq).mean()
    # okex_mean_serial.name='okex'

    poloniex_df = pd.read_sql_query(SELECT_SQL,
                                    conn,
                                    params=('poloniex', ),
                                    index_col='timestamp')
    poloniex_df.index = pd.to_datetime(poloniex_df.index / 1000, unit='s')
    conn.close()
    if mode == 1:
        res_df = pd.concat([okex_df, poloniex_df], axis=1)
        res_df.apply(exchange, axis=1)
        print(x)
    elif mode == 2:

        profit_ok_sell = 2 * (
            okex_df['bid1'] - poloniex_df['ask1'] -
            (okex_df['bid1'] * 0.002 + poloniex_df['ask1'] * 0.0025)) / (
                okex_df['bid1'] + poloniex_df['ask1'])
        # first=okex_df['bid1']-poloniex_df['ask1']
        profit_ok_sell.name = 'ok sell and poloniex buy'
        profit_ok_buy = 2 * (
            poloniex_df['bid1'] - okex_df['ask1'] -
            (okex_df['ask1'] * 0.002 + poloniex_df['bid1'] * 0.0025)) / (
                poloniex_df['bid1'] + okex_df['ask1'])
        # second=poloniex_df['bid1']-okex_df['ask1']
        profit_ok_buy.name = 'poloniex sell and ok buy'
        res_df = pd.concat([profit_ok_sell, profit_ok_buy], axis=1)
        # res_df.plot()
        # plt.figure();
        res_df.plot.hist(bins=20, alpha=0.5)
        # cost_ok_sell=okex_df['bid1']*0.001+poloniex_df['ask1']*0.0015
        # cost_ok_sell.name='cost_ok_sell'
        # cost_ok_buy=okex_df['ask1']*0.001+poloniex_df['bid1']*0.0015
        # cost_ok_buy='cost_ok_buy'
        # # res_df=pd.concat([cosk_ok_sell,cost_ok_buy],axis=1)
        # res_df=cost_ok_sell/profit_ok_sell
        # res_df.plot()

        plt.show()
    elif mode == 3:
        profit_ok_sell = okex_df['bid1'] - poloniex_df['ask1'] - (
            okex_df['bid1'] * 0.002 + poloniex_df['ask1'] * 0.0025)
        profit_ok_sell.name = 'ok sell and poloniex buy'
        profit_ok_buy = poloniex_df['bid1'] - okex_df['ask1'] - (
            okex_df['ask1'] * 0.002 + poloniex_df['bid1'] * 0.0025)
        # second=poloniex_df['bid1']-okex_df['ask1']
        profit_ok_buy.name = 'poloniex sell and ok buy'
        res_df = pd.concat([profit_ok_sell, profit_ok_buy], axis=1)
        res_df.plot()
        plt.show()
        # plt.figure();
        # res_df.plot.hist(bins=20,alpha=0.5)
    elif mode == 4:  #EWMA
        profit_ok_sell = okex_df['bid1'] - poloniex_df['ask1']
        profit_ok_sell.name = 'ok sell and poloniex buy'
        profit_ok_sell.name = 'ok sell and poloniex buy'
        profit_ok_buy = poloniex_df['bid1'] - okex_df['ask1']
        # second=poloniex_df['bid1']-okex_df['ask1']
        profit_ok_buy.name = 'poloniex sell and ok buy'

        span = 20
        freq = '1H'
        ewma = pd.ewma(profit_ok_sell, span=span, freq=freq, adjust=True)
        ewma.name = 'oloniex buy ewma1'
        ewmstd = pd.ewmstd(profit_ok_sell, span=span, freq=freq)
        ewmstd.name = 'oloniex buy ewmstd1'

        ewma2 = pd.ewma(profit_ok_buy, span=span, freq=freq, adjust=True)
        ewma2.name = 'ok buy  ewma2'
        ewmstd2 = pd.ewmstd(profit_ok_buy, span=span, freq=freq)
        ewmstd2.name = 'ok buy ewmstd2'
        upper = ewma + 1.5 * ewmstd
        upper.name = 'poloniex buy'
        lower = ewma2 + 1.5 * ewmstd2
        lower.name = 'ok buy thres'
        res_df = pd.concat([ewma, upper, ewma2, lower], axis=1)
        res_df.plot()
        plt.show()
示例#38
0
def calc_zscore_ew(df, lookback=24):
    return (df - pd.ewma(df, lookback, min_periods=12)) / pd.ewmstd(
        df, lookback, min_periods=12)
示例#39
0
def calc_zscore(df,
                mean_halflife=21,
                mean_seed_period=21,
                std_halflife=21,
                std_seed_period=21,
                smth_halflife=0,
                ewm=True,
                subtract_mean=True,
                cap=3.0,
                lag=0):
    """
    Calculate timeseries z-score (assuming normal distribution of input data)

    Parameters
    ----------
    df : DataFrame or Series
        DataFrame or Series object containing timeseries data
    mean_halflife : int, optional
        Half-life period (periodicity determined by index of df) for computing mean
    mean_seed_period : int, optional
        Seeding period (periodicity determined by index of df) for computing mean
    std_halflife : int, optional
        Half-life period (periodicity determined by index of df) for computing standard deviation
    std_seed_period : int, optional
        Seeding period (periodicity determined by index of df) for computing standard deviation
    smth_halflife : int, optional
        Smoothing half-life period (periodicity determined by index of df) for smoothing input data before computing z-score
    ewm : bool, optional
        If True, compute z-score based on ewm mean and standard deviation. If False, compute z-score based on simple mean and standard deviation.
    subtract_mean : bool, optional
        If True, subtract mean while computing z-score. If False, normalize the value by dividing by standard deviation.
    cap : float, optional
        Absolute cap for z-score
    lag : int, optional
        Periods (periodicity determined by index of df) by which to lag the z-score

    Returns
    -------
    score_df : DataFrame or Series
        DataFrame or Series object containing z-score

    """

    is_series = False
    if isinstance(df, pd.Series):
        df = pd.DataFrame(df)
        is_series = True
    elif not isinstance(df, pd.DataFrame):
        raise ValueError('df should be either a DataFrame or Series object')

    if mean_halflife < 0:
        raise ValueError('%d is not a valid mean half-life' % mean_halflife)
    if mean_halflife > df.shape[0]:
        raise ValueError(
            'mean_halflife can not be larger than length of index of df')
    if mean_seed_period < 0:
        raise ValueError('%d is not a valid mean seed period' %
                         mean_seed_period)
    if mean_seed_period > df.shape[0]:
        raise ValueError(
            'mean_seed_period can not be larger than length of index of df')
    if std_halflife < 0:
        raise ValueError('%d is not a valid standard deviation half-life' %
                         std_halflife)
    if std_halflife > df.shape[0]:
        raise ValueError(
            'std_halflife can not be larger than length of index of df')
    if std_seed_period < 0:
        raise ValueError('%d is not a valid standard deviation seed period' %
                         std_seed_period)
    if std_seed_period > df.shape[0]:
        raise ValueError(
            'std_seed_period can not be larger than length of index of df')
    if smth_halflife < 0:
        raise ValueError('%d is not a valid smoothing half-life' %
                         smth_halflife)
    if smth_halflife > df.shape[0]:
        raise ValueError(
            'smth_halflife can not be larger than length of index of df')
    if not isinstance(ewm, bool):
        raise ValueError('ewm should be either True of False')
    if not isinstance(subtract_mean, bool):
        raise ValueError('subtract_mean should be either True of False')
    if cap <= 0:
        raise ValueError('%f is not a valid score cap' % cap)
    if lag < 0:
        raise ValueError('%d is not a valid lag period' % lag)
    if lag > df.shape[0]:
        raise ValueError('lag can not be larger than length of index of df')

    # apply smoothing
    if smth_halflife > 0:
        df = pd.ewma(df,
                     halflife=smth_halflife,
                     min_periods=smth_halflife,
                     adjust=False)

    # compute mean and standard deviation
    if ewm:
        mean_df = pd.ewma(df,
                          halflife=mean_halflife,
                          min_periods=mean_seed_period,
                          adjust=False)
        std_df = pd.ewmstd(df,
                           halflife=std_halflife,
                           min_periods=std_seed_period,
                           adjust=False)
    else:
        mean_df = pd.rolling_mean(df,
                                  window=mean_halflife,
                                  min_periods=mean_seed_period)
        std_df = pd.rolling_std(df,
                                window=std_halflife,
                                min_periods=std_seed_period)

    # compute score
    if subtract_mean:
        score_df = (df - mean_df) / std_df
    else:
        score_df = df / std_df

    # cap score
    score_df = score_df.clip(-cap, cap)

    # lag score
    if lag > 0:
        score_df = score_df.shift(lag)

    if is_series:
        return pd.Series(score_df.squeeze())
    else:
        return score_df
		# print playerData
		total_points = [] 
		total_salary = []
		unadjusted_points = []
		for row in playerData.iterrows():
			oppt = row[1]['Oppt']
			week = row[1]['Week']
			year = row[1]['Year']
			pos = row[1]['Pos']
			if oppt == '-':
				continue
			#FFPG[int(row[0])] = np.mean(total_points[-win_size:])
			if EWMA and len(total_points) > 0:
				FFPG[int(row[0])] = pd.ewma(pd.Series(total_points), span = win_size).values[-1]
				price[int(row[0])] = pd.ewma(pd.Series(total_salary), span = win_size).values[-1]
				FDStd[int(row[0])] = pd.ewmstd(pd.Series(unadjusted_points), span = win_size).values[-1]
			# ARIMA models need at least 6 points to adequately fit the data
			elif ARIMA and len(total_points) >= 6 and np.mean(total_points) > 10:
				# the input mathematica string needs to be 
				# formatted like {a,b,c}
				cmdString = '{'
				for elem in total_points:
					cmdString += str(elem) + ','
				cmdString = cmdString[:-1]
				cmdString += '}'
				# calls the mathematica script
				command = '/usr/local/bin/MathematicaScript -script ~/FSA/1iaFantasy/mathTimeseries.sh %s' %cmdString
				# reads the output of the mathematica script
				# that is printed to the terminal
				output = os.popen(command).read().split('\n')
				print output
示例#41
0
country="US"
yearband=5 ## blocks to divide data into
    


#datatype="Three_assets"
datatype="Developed_equities"

if datatype=="Three_assets":
    data, initial_stdev, initial_risk_weights, yields = get_some_crossasset_data()
elif datatype=="Developed_equities":
    data, initial_stdev, initial_risk_weights, yields = get_equities_data(case="devall")
else:
    raise Exception()
## rolling stdev for estimates if used
stdevest=pd.ewmstd(data, halflife=12)*(12**.5)
for idx in range(12):
    stdevest.iloc[idx,:]=initial_stdev

stdevest[stdevest==0]=np.nan

#bootstrapped_weights=optimise_over_periods(data, "rolling", "bootstrap", rollyears=5, equalisemeans=True, equalisevols=True, 
#                                  monte_carlo=50, monte_length=12*5)

bootstrapped_weights=optimise_over_periods(data, "rolling", "shrinkage", rollyears=5,  equalisevols=True, 
                                  shrinkage_factors=(1.0, 0.8))


avg_size=1.0/len(data.columns)

#windowsizes=[0.5]
示例#42
0
ABuMarketDrawing.plot_candle_form_klpd(tsla_df, html_bk=True)

# 使用 Pandas 可视化数据
demo_list = np.array([2, 4, 16, 20])
demo_window = 3
pd.rolling_std(demo_list, window=demo_window,
               center=False) * np.sqrt(demo_window)

tsla_df_copy = tsla_df.copy()
# 计算投资回报
tsla_df_copy['return'] = np.log(tsla_df['close'] / tsla_df['close'].shift(1))
# 移动收益标准差
tsla_df_copy['mov_std'] = pd.rolling_std(
    tsla_df_copy['return'], window=20, center=False) * np.sqrt(20)
# 加权移动收益标准差
tsla_df_copy['std_ewm'] = pd.ewmstd(
    tsla_df_copy['return'], span=20, min_periods=20, adjust=True) * np.sqrt(20)

tsla_df_copy[['close', 'mov_std', 'std_ewm', 'return']].plot(subplots=True,
                                                             grid=True)

# 绘制均线
tsla_df.close.plot()
# ma 30
pd.rolling_mean(tsla_df.close, window=30).plot()
# ma 60
pd.rolling_mean(tsla_df.close, window=60).plot()
# ma 90
pd.rolling_mean(tsla_df.close, window=90).plot()
plt.legend(['close', '30 mv', '60 mv', '90 mv'], loc='best')

# 验证低开高走第二天趋势
示例#43
0
NBER_rec.index.name='date'

for ticker in ticker_list:
    
    if ticker != 'USURTOT Index':
        continue
    
    NBER_rec_temp = NBER_rec.copy()
 
    temp_tick_data = bl_data[ticker].to_frame()
    temp_tick_data.dropna(inplace=True)
    
    look_back_sma = 24
    hl_ewm = 6
    ticker_ma = (temp_tick_data-pd.rolling_mean(temp_tick_data,window=look_back_sma))/pd.rolling_std(temp_tick_data,window=look_back_sma)
    ticker_z_ema = (temp_tick_data-pd.ewma(temp_tick_data,halflife=hl_ewm))/pd.ewmstd(temp_tick_data,halflife=hl_ewm)
    
    
    recession_level, expansion_level  = scenario(ticker,NBER_rec_temp, temp_tick_data)
    recession_ma, expansion_ma  = scenario(ticker,NBER_rec_temp, ticker_ma)
    recession_ema, expansion_ema  = scenario(ticker,NBER_rec_temp, ticker_z_ema)
    
 
    #plot
 
    
    new_idx = pd.date_range(temp_tick_data.index.to_datetime()[0],pd.datetime.today().date(),freq='B')
    temp_tick_data = temp_tick_data.reindex(new_idx,method='ffill')
    
    NBER_rec_temp = NBER_rec_temp.reindex(new_idx,method='ffill')
    
def spread_val_score(data_df):  

    data_df = np.log(data_df * 100)
    data_df['spread_z_ema'] = (data_df - pd.ewma(data_df, min_periods = 60, halflife=60)) / pd.ewmstd(data_df, halflife=60)
    
    data_df['spread_z_ema'].dropna(inplace=True)
    
    data_df['spread_z_ema'].plot()
    plt.show()
    
    return data_df['spread_z_ema']
示例#45
0
data_index = pd.DataFrame()
for m in mkts.keys():
    try:
        data_index[m] = quandl.get(mkts[m], authtoken=token).Last
    except:
        try:
            data_index[m] = quandl.get(mkts[m], authtoken=token).Settle
        except:
            try:
                data_index[m] = quandl.get(mkts[m], authtoken=token).Value
            except:
                try:
                    data_index[m] = quandl.get(mkts[m], authtoken=token).value
                except:
                    try:
                        data_index[m] = quandl.get(mkts[m],
                                                   authtoken=token).Rate
                    except:
                        print(m)
data_pct = data_index.pct_change()

mu = pd.ewma(data_pct, 260)
sd = pd.ewmstd(data_pct, 260)
zscores = (data_pct - mu) / sd
last = zscores.iloc[-2].dropna().sort_values()
last.plot(kind='barh', colormap='jet',
          ylim=[-3, 3]).get_figure().savefig('zscore.png', bbox_inches='tight')

e = Email(subject='Morning Update: Macro Dashboard')
e.add_attachment('zscore.png')
e.send()
def volatility(price, vol_lookback):
    price['volatility'] = 0
    price['volatility'] = pd.ewmstd((price['Close'] - price['Close'].shift(1)), span=vol_lookback)
    price['volatility'] = price['volatility'].fillna(0)
    return price 
示例#47
0
 def devol(self, _lambda=0.06):
     _com = (1 - _lambda) / _lambda
     self.ts['Vola'] = pd.ewmstd( self.ts.LogReturns, com=_com, ignore_na=True)
     self.ts['DevolLogReturns'] = self.ts.LogReturns / self.ts.Vola
示例#48
0
 def addBollBand_EW(self, fromIndex, addedSeriesName = 'BBand', scale=1,win_length = 1):
     
     self[addedSeriesName+'upper'] = scale*pd.ewmstd(self[fromIndex], win_length) + self[fromIndex]
     self[addedSeriesName+'lower'] = -scale*pd.ewmstd(self[fromIndex], win_length) + self[fromIndex]
示例#49
0
	def ewbband(self, halflife):
		'''Create Expontenial Weighted Bollinger Band.'''
		self.df[self.symbol+'.ewma'] = pd.ewma(self.df[self.close_index].shift(1), halflife)
		self.df[self.symbol+'.ewmstd'] = pd.ewmstd(self.df[self.close_index].shift(1), halflife)
		self.df[self.symbol+'.ewbb_upper'] = self.df[self.symbol+'.ewma'] + self.df[self.symbol+'.ewmstd']
		self.df[self.symbol+'.ewbb_lower'] = self.df[self.symbol+'.ewma'] - self.df[self.symbol+'.ewmstd']
示例#50
0
fast_ewma = pd.ewma(price, span=Lfast)
slow_ewma = pd.ewma(price, span=Lslow)
raw_ewmac = fast_ewma - slow_ewma

data_to_plot = pd.concat([price, fast_ewma, slow_ewma], axis=1)
data_to_plot.columns = ['Price', 'Fast', 'Slow']

data_to_plot[d1:d2].plot()
plt.show()

raw_ewmac[d1:d2].plot()
plt.title("Raw EWMAC")
plt.show()

## volatility adjustment
stdev_returns = pd.ewmstd(price - price.shift(1), span=vol_lookback)
vol_adj_ewmac = raw_ewmac / stdev_returns

vol_adj_ewmac[d1:d2].plot()
plt.title("Vol adjusted")
plt.show()

## scaling adjustment
f_scalar = ewmac_forecast_scalar(Lfast, Lslow)

forecast = vol_adj_ewmac * f_scalar

cap_forecast = cap_series(forecast, capmin=-20.0, capmax=20.0)

data_to_plot = pd.concat([forecast, cap_forecast], axis=1)
data_to_plot.columns = ['Scaled Forecast', 'Capped forecast']
示例#51
0
def std_space(s, years):
    return pd.ewmstd(s, halflife=360*years)