title: AttributeError: 'bool' object has no attribute 'ndim'
body: <pre><code>from quantopian.pipeline import Pipeline
  from quantopian.algorithm import attach_pipeline, pipeline_output
  from quantopian.pipeline.data.builtin import USEquityPricing
  from quantopian.pipeline.factors import SimpleMovingAverage
  from quantopian.pipeline.filters.morningstar import Q1500US
  from quantopian.pipeline.factors import AnnualizedVolatility
  from quantopian.pipeline.factors.morningstar import MarketCap
  from quantopian.pipeline import factors, filters, classifiers
  
  Market_Cap=(MarketCap &gt; 1000000000)
  
  def lowvolport():
      return filters.make_us_equity_universe(
      target_size=50,
      rankby=factors.AnnualizedVolatility(window_length=90),
      mask=Market_Cap,
      )
  
  def initialize(context):
      # Schedule our rebalance function to run at the start of each week.
      schedule_function(my_rebalance, date_rules.week_start(),             time_rules.market_open(hours=1))
  
      # Record variables at the end of each day.
      schedule_function(my_record_vars, date_rules.every_day(), time_rules.market_close())
  
      # Create our pipeline and attach it to our algorithm.
      my_pipe = make_pipeline()
      attach_pipeline(my_pipe, 'my_pipeline')
  
  def make_pipeline():
      """
      Create our pipeline.
      """
  
      # Base universe set to the Q1500US.
      base_universe = Q1500US()
  
      Market_Cap = (MarketCap &gt; 1000000000)
      # Filter to select securities to long.
      volatility_bottom = AnnualizedVolatility(inputs=[USEquityPricing.close], window_length=90, mask=base_universe)
  
      volatility_bottom_50=volatility_bottom.bottom(50)
  
      # Filter for all securities that we want to trade.
      securities_to_trade = (Market_Cap &amp; volatility_bottom_50)
  
      return Pipeline(
      columns={
          'Market_Cap': Market_Cap
      },
      screen=(securities_to_trade),
      )
  
  def my_compute_weights(context):
      """
      Compute ordering weights.
      """
      # Compute even target weights for our long positions and short positions.
      long_weight = 0.5 / len(context.longs)
      short_weight = -0.5 / len(context.shorts)
  
      return long_weight, short_weight
  
  def before_trading_start(context, data):
      # Gets our pipeline output every day.
      context.output = pipeline_output('my_pipeline')
  
      # Go long in securities for which the 'longs' value is True.
      context.longs = context.output[context.output['longs']].index.tolist()
  
      # Go short in securities for which the 'shorts' value is True.
      context.shorts = context.output[context.output['shorts']].index.tolist()
  
      context.long_weight, context.short_weight = my_compute_weights(context)
  
  def my_rebalance(context, data):
      """
      Rebalance weekly.
      """
      for security in context.portfolio.positions:
      if security not in context.longs and security not in context.shorts and data.can_trade(security):
          order_target_percent(security, 0)
  
      for security in context.longs:
      if data.can_trade(security):
          order_target_percent(security, context.long_weight)
  
      for security in context.shorts:
      if data.can_trade(security):
          order_target_percent(security, context.short_weight)
  
  def my_record_vars(context, data):
      """
      Record variables at the end of each day.
      """
      longs = shorts = 0
      for position in context.portfolio.positions.itervalues():
          if position.amount &gt; 0:
              longs += 1
          elif position.amount &lt; 0:
              shorts += 1
  
      # Record our variables.
      record(leverage=context.account.leverage, long_count=longs, short_count=shorts)
  </code></pre>
  
  <p>Hi everyone, I'm new to python with some Matlab experience. The code is what I recently did in Quantopian. The error message is </p>
  
  <pre><code>    AttributeError: 'bool' object has no attribute 'ndim'
      There was a runtime error on line 27.
  </code></pre>
  
  <p>the 27th line is</p>
  
  <pre><code>        my_pipe = make_pipeline()
  </code></pre>
  
  <p>The above is my first question.
  My second question is that, based on the existing algorithm, how can I perform VAR model over every three months using the formula</p>
  
  <pre><code>    Yt = a0 + a1Yt-1 + ..... + apYt-p + b1Xt-1 + ..... + bpXt-p + ut
  </code></pre>
  
  <p>with Yt being the return over 90 days and Xt-1,...,Xt-p being lags of volatility? </p>
  
  <p>Thank in advance! Please let me know if any details need to be specified.</p>