示例#1
0
    def testCategoryEncoder(self):
        categories = ["ES", "GB", "US"]

        # forced: is not recommended, but is used here for readability.
        # see scalar.py
        e = CategoryEncoder(w=3, categoryList=categories, forced=True)
        output = e.encode("US")
        expected = numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
                               dtype=defaultDtype)
        self.assertTrue(numpy.array_equal(output, expected))

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldNames), 1)
        self.assertEqual(len(fieldsDict), 1)
        self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
        (ranges, desc) = fieldsDict.values()[0]
        self.assertEqual(desc, "US")
        self.assertEqual(len(ranges), 1)
        self.assertTrue(numpy.array_equal(ranges[0], [3, 3]))

        # Test topdown compute
        for v in categories:
            output = e.encode(v)
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, v)
            self.assertEqual(topDown.scalar, e.getScalars(v)[0])

            bucketIndices = e.getBucketIndices(v)
            topDown = e.getBucketInfo(bucketIndices)[0]
            self.assertEqual(topDown.value, v)
            self.assertEqual(topDown.scalar, e.getScalars(v)[0])
            self.assertTrue(numpy.array_equal(topDown.encoding, output))
            self.assertEqual(topDown.value,
                             e.getBucketValues()[bucketIndices[0]])

        # ---------------------
        # unknown category
        output = e.encode("NA")
        expected = numpy.array([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                               dtype=defaultDtype)
        self.assertTrue(numpy.array_equal(output, expected))

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldNames), 1)
        self.assertEqual(len(fieldsDict), 1)
        self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
        (ranges, desc) = fieldsDict.values()[0]
        self.assertEqual(len(ranges), 1)
        self.assertTrue(numpy.array_equal(ranges[0], [0, 0]))

        # Test topdown compute
        topDown = e.topDownCompute(output)
        self.assertEqual(topDown.value, UNKNOWN)
        self.assertEqual(topDown.scalar, 0)

        # --------------------------------
        # ES
        output = e.encode("ES")
        expected = numpy.array([0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
                               dtype=defaultDtype)
        self.assertTrue(numpy.array_equal(output, expected))

        # MISSING VALUE
        outputForMissing = e.encode(SENTINEL_VALUE_FOR_MISSING_DATA)
        self.assertEqual(sum(outputForMissing), 0)

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldNames), 1)
        self.assertEqual(len(fieldsDict), 1)
        self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
        (ranges, desc) = fieldsDict.values()[0]
        self.assertEqual(len(ranges), 1)
        self.assertTrue(numpy.array_equal(ranges[0], [1, 1]))

        # Test topdown compute
        topDown = e.topDownCompute(output)
        self.assertEqual(topDown.value, "ES")
        self.assertEqual(topDown.scalar, e.getScalars("ES")[0])

        # --------------------------------
        # Multiple categories
        output.fill(1)

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldNames), 1)
        self.assertEqual(len(fieldsDict), 1)
        self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
        (ranges, desc) = fieldsDict.values()[0]
        self.assertEqual(len(ranges), 1)
        self.assertTrue(numpy.array_equal(ranges[0], [0, 3]))

        # -------------------------------------------------------------
        # Test with width = 1
        categories = ["cat1", "cat2", "cat3", "cat4", "cat5"]
        # forced: is not recommended, but is used here for readability.
        # see scalar.py
        e = CategoryEncoder(w=1, categoryList=categories, forced=True)
        for cat in categories:
            output = e.encode(cat)
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

        # -------------------------------------------------------------
        # Test with width = 9, removing some bits end the encoded output
        categories = ["cat%d" % (x) for x in range(1, 10)]
        # forced: is not recommended, but is used here for readability.
        # see scalar.py
        e = CategoryEncoder(w=9, categoryList=categories, forced=True)
        for cat in categories:
            output = e.encode(cat)
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 1 bit on the left
            outputNZs = output.nonzero()[0]
            output[outputNZs[0]] = 0
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 1 bit on the right
            output[outputNZs[0]] = 1
            output[outputNZs[-1]] = 0
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 4 bits on the left
            output.fill(0)
            output[outputNZs[-5:]] = 1
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 4 bits on the right
            output.fill(0)
            output[outputNZs[0:5]] = 1
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

        # OR together the output of 2 different categories, we should not get
        #  back the mean, but rather one or the other
        output1 = e.encode("cat1")
        output2 = e.encode("cat9")
        output = output1 + output2
        topDown = e.topDownCompute(output)
        self.assertTrue(topDown.scalar == e.getScalars("cat1")[0] \
                or topDown.scalar == e.getScalars("cat9")[0])
示例#2
0
  def testCategoryEncoder(self):
    categories = ["ES", "GB", "US"]

    # forced: is not recommended, but is used here for readability.
    # see scalar.py
    e = CategoryEncoder(w=3, categoryList=categories, forced=True)
    output = e.encode("US")
    expected = numpy.array([0,0,0,0,0,0,0,0,0,1,1,1], dtype=defaultDtype)
    self.assertTrue(numpy.array_equal(output, expected))

    # Test reverse lookup
    decoded = e.decode(output)
    (fieldsDict, fieldNames) = decoded
    self.assertEqual(len(fieldNames), 1)
    self.assertEqual(len(fieldsDict), 1)
    self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
    (ranges, desc) = fieldsDict.values()[0]
    self.assertEqual(desc, "US")
    self.assertEqual(len(ranges), 1)
    self.assertTrue(numpy.array_equal(ranges[0], [3, 3]))

    # Test topdown compute
    for v in categories:
      output = e.encode(v)
      topDown = e.topDownCompute(output)
      self.assertEqual(topDown.value, v)
      self.assertEqual(topDown.scalar, e.getScalars(v)[0])

      bucketIndices = e.getBucketIndices(v)
      topDown = e.getBucketInfo(bucketIndices)[0]
      self.assertEqual(topDown.value, v)
      self.assertEqual(topDown.scalar, e.getScalars(v)[0])
      self.assertTrue(numpy.array_equal(topDown.encoding, output))
      self.assertEqual(topDown.value, e.getBucketValues()[bucketIndices[0]])



    # ---------------------
    # unknown category
    output = e.encode("NA")
    expected = numpy.array([1,1,1,0,0,0,0,0,0,0,0,0], dtype=defaultDtype)
    self.assertTrue(numpy.array_equal(output, expected))

    # Test reverse lookup
    decoded = e.decode(output)
    (fieldsDict, fieldNames) = decoded
    self.assertEqual(len(fieldNames), 1)
    self.assertEqual(len(fieldsDict), 1)
    self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
    (ranges, desc) = fieldsDict.values()[0]
    self.assertEqual(len(ranges), 1)
    self.assertTrue(numpy.array_equal(ranges[0], [0, 0]))

    # Test topdown compute
    topDown = e.topDownCompute(output)
    self.assertEqual(topDown.value, UNKNOWN)
    self.assertEqual(topDown.scalar, 0)


    # --------------------------------
    # ES
    output = e.encode("ES")
    expected = numpy.array([0,0,0,1,1,1,0,0,0,0,0,0], dtype=defaultDtype)
    self.assertTrue(numpy.array_equal(output, expected))

    # MISSING VALUE
    outputForMissing = e.encode(SENTINEL_VALUE_FOR_MISSING_DATA)
    self.assertEqual(sum(outputForMissing), 0)

    # Test reverse lookup
    decoded = e.decode(output)
    (fieldsDict, fieldNames) = decoded
    self.assertEqual(len(fieldNames), 1)
    self.assertEqual(len(fieldsDict), 1)
    self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
    (ranges, desc) = fieldsDict.values()[0]
    self.assertEqual(len(ranges), 1)
    self.assertTrue(numpy.array_equal(ranges[0], [1, 1]))

    # Test topdown compute
    topDown = e.topDownCompute(output)
    self.assertEqual(topDown.value, "ES")
    self.assertEqual(topDown.scalar, e.getScalars("ES")[0])


    # --------------------------------
    # Multiple categories
    output.fill(1)

    # Test reverse lookup
    decoded = e.decode(output)
    (fieldsDict, fieldNames) = decoded
    self.assertEqual(len(fieldNames), 1)
    self.assertEqual(len(fieldsDict), 1)
    self.assertEqual(fieldNames[0], fieldsDict.keys()[0])
    (ranges, desc) = fieldsDict.values()[0]
    self.assertEqual(len(ranges), 1)
    self.assertTrue(numpy.array_equal(ranges[0], [0, 3]))


    # -------------------------------------------------------------
    # Test with width = 1
    categories = ["cat1", "cat2", "cat3", "cat4", "cat5"]
      # forced: is not recommended, but is used here for readability.
      # see scalar.py
    e = CategoryEncoder(w=1, categoryList=categories, forced=True)
    for cat in categories:
      output = e.encode(cat)
      topDown = e.topDownCompute(output)
      self.assertEqual(topDown.value, cat)
      self.assertEqual(topDown.scalar, e.getScalars(cat)[0])


    # -------------------------------------------------------------
    # Test with width = 9, removing some bits end the encoded output
    categories = ["cat%d" % (x) for x in range(1, 10)]
     # forced: is not recommended, but is used here for readability.
     # see scalar.py
    e = CategoryEncoder(w=9, categoryList=categories, forced=True)
    for cat in categories:
      output = e.encode(cat)
      topDown = e.topDownCompute(output)
      self.assertEqual(topDown.value, cat)
      self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

      # Get rid of 1 bit on the left
      outputNZs = output.nonzero()[0]
      output[outputNZs[0]] = 0
      topDown = e.topDownCompute(output)
      self.assertEqual(topDown.value, cat)
      self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

      # Get rid of 1 bit on the right
      output[outputNZs[0]] = 1
      output[outputNZs[-1]] = 0
      topDown = e.topDownCompute(output)
      self.assertEqual(topDown.value, cat)
      self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

      # Get rid of 4 bits on the left
      output.fill(0)
      output[outputNZs[-5:]] = 1
      topDown = e.topDownCompute(output)
      self.assertEqual(topDown.value, cat)
      self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

      # Get rid of 4 bits on the right
      output.fill(0)
      output[outputNZs[0:5]] = 1
      topDown = e.topDownCompute(output)
      self.assertEqual(topDown.value, cat)
      self.assertEqual(topDown.scalar, e.getScalars(cat)[0])


    # OR together the output of 2 different categories, we should not get
    #  back the mean, but rather one or the other
    output1 = e.encode("cat1")
    output2 = e.encode("cat9")
    output = output1 + output2
    topDown = e.topDownCompute(output)
    self.assertTrue(topDown.scalar == e.getScalars("cat1")[0] \
            or topDown.scalar == e.getScalars("cat9")[0])
示例#3
0
    def testCategoryEncoder(self):
        verbosity = 0

        print "Testing CategoryEncoder...",
        categories = ["ES", "GB", "US"]

        e = CategoryEncoder(w=3, categoryList=categories)
        output = e.encode("US")
        self.assertTrue(
            (output == numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
                                   dtype=defaultDtype)).all())

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldsDict), 1)
        (ranges, desc) = fieldsDict.values()[0]
        self.assertTrue(
            len(ranges) == 1 and numpy.array_equal(ranges[0], [3, 3]))
        print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)

        # Test topdown compute
        for v in categories:
            output = e.encode(v)
            topDown = e.topDownCompute(output)
            self.assertEqual(topDown.value, v)
            self.assertEqual(topDown.scalar, e.getScalars(v)[0])

            bucketIndices = e.getBucketIndices(v)
            print "bucket index =>", bucketIndices[0]
            topDown = e.getBucketInfo(bucketIndices)[0]
            self.assertEqual(topDown.value, v)
            self.assertEqual(topDown.scalar, e.getScalars(v)[0])
            self.assertTrue((topDown.encoding == output).all())
            self.assertEqual(topDown.value,
                             e.getBucketValues()[bucketIndices[0]])

        # ---------------------
        # unknown category
        output = e.encode("NA")
        self.assertTrue(
            (output == numpy.array([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                                   dtype=defaultDtype)).all())

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldsDict), 1)
        (ranges, desc) = fieldsDict.values()[0]
        self.assertTrue(
            len(ranges) == 1 and numpy.array_equal(ranges[0], [0, 0]))
        print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)

        # Test topdown compute
        topDown = e.topDownCompute(output)
        self.assertEqual(topDown.value, "<UNKNOWN>")
        self.assertEqual(topDown.scalar, 0)

        # --------------------------------
        # ES
        output = e.encode("ES")
        self.assertTrue(
            (output == numpy.array([0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
                                   dtype=defaultDtype)).all())

        # MISSING VALUE
        outputForMissing = e.encode(SENTINEL_VALUE_FOR_MISSING_DATA)
        self.assertEqual(sum(outputForMissing), 0)

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldsDict), 1)
        (ranges, desc) = fieldsDict.values()[0]
        self.assertTrue(
            len(ranges) == 1 and numpy.array_equal(ranges[0], [1, 1]))
        print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)

        # Test topdown compute
        topDown = e.topDownCompute(output)
        self.assertEqual(topDown.value, "ES")
        self.assertEqual(topDown.scalar, e.getScalars("ES")[0])

        # --------------------------------
        # Multiple categories
        output.fill(1)

        # Test reverse lookup
        decoded = e.decode(output)
        (fieldsDict, fieldNames) = decoded
        self.assertEqual(len(fieldsDict), 1)
        (ranges, desc) = fieldsDict.values()[0]
        self.assertTrue(
            len(ranges) == 1 and numpy.array_equal(ranges[0], [0, 3]))
        print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)

        # -------------------------------------------------------------
        # Test with width = 1
        categories = ["cat1", "cat2", "cat3", "cat4", "cat5"]
        e = CategoryEncoder(w=1, categoryList=categories)
        for cat in categories:
            output = e.encode(cat)
            topDown = e.topDownCompute(output)
            if verbosity >= 1:
                print cat, "->", output, output.nonzero()[0]
                print " scalarTopDown:", e.encoder.topDownCompute(output)
                print " topdown:", topDown
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

        # -------------------------------------------------------------
        # Test with width = 9, removing some bits end the encoded output
        categories = ["cat%d" % (x) for x in range(1, 10)]
        e = CategoryEncoder(w=9, categoryList=categories)
        for cat in categories:
            output = e.encode(cat)
            topDown = e.topDownCompute(output)
            if verbosity >= 1:
                print cat, "->", output, output.nonzero()[0]
                print " scalarTopDown:", e.encoder.topDownCompute(output)
                print " topdown:", topDown
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 1 bit on the left
            outputNZs = output.nonzero()[0]
            output[outputNZs[0]] = 0
            topDown = e.topDownCompute(output)
            if verbosity >= 1:
                print "missing 1 bit on left:", output, output.nonzero()[0]
                print " scalarTopDown:", e.encoder.topDownCompute(output)
                print " topdown:", topDown
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 1 bit on the right
            output[outputNZs[0]] = 1
            output[outputNZs[-1]] = 0
            topDown = e.topDownCompute(output)
            if verbosity >= 1:
                print "missing 1 bit on right:", output, output.nonzero()[0]
                print " scalarTopDown:", e.encoder.topDownCompute(output)
                print " topdown:", topDown
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 4 bits on the left
            output.fill(0)
            output[outputNZs[-5:]] = 1
            topDown = e.topDownCompute(output)
            if verbosity >= 1:
                print "missing 4 bits on left:", output, output.nonzero()[0]
                print " scalarTopDown:", e.encoder.topDownCompute(output)
                print " topdown:", topDown
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

            # Get rid of 4 bits on the right
            output.fill(0)
            output[outputNZs[0:5]] = 1
            topDown = e.topDownCompute(output)
            if verbosity >= 1:
                print "missing 4 bits on right:", output, output.nonzero()[0]
                print " scalarTopDown:", e.encoder.topDownCompute(output)
                print " topdown:", topDown
            self.assertEqual(topDown.value, cat)
            self.assertEqual(topDown.scalar, e.getScalars(cat)[0])

        # OR together the output of 2 different categories, we should not get
        #  back the mean, but rather one or the other
        output1 = e.encode("cat1")
        output2 = e.encode("cat9")
        output = output1 + output2
        topDown = e.topDownCompute(output)
        if verbosity >= 1:
            print "cat1 + cat9 ->", output, output.nonzero()[0]
            print " scalarTopDown:", e.encoder.topDownCompute(output)
            print " topdown:", topDown
        self.assertTrue(topDown.scalar == e.getScalars("cat1")[0] \
                or topDown.scalar == e.getScalars("cat9")[0])

        print "passed"
示例#4
0
  def testCategoryEncoder(self):
      verbosity = 0

      print "Testing CategoryEncoder...",
      categories = ["ES", "GB", "US"]

      e = CategoryEncoder(w=3, categoryList=categories)
      output = e.encode("US")
      assert (output == numpy.array([0,0,0,0,0,0,0,0,0,1,1,1], dtype=defaultDtype)).all()

      # Test reverse lookup
      decoded = e.decode(output)
      (fieldsDict, fieldNames) = decoded
      assert len(fieldsDict) == 1
      (ranges, desc) = fieldsDict.values()[0]
      assert len(ranges) == 1 and numpy.array_equal(ranges[0], [3,3])
      print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)

      # Test topdown compute
      for v in categories:
        output = e.encode(v)
        topDown = e.topDownCompute(output)
        assert topDown.value == v
        assert topDown.scalar == e.getScalars(v)[0]

        bucketIndices = e.getBucketIndices(v)
        print "bucket index =>", bucketIndices[0]
        topDown = e.getBucketInfo(bucketIndices)[0]
        assert topDown.value == v
        assert topDown.scalar == e.getScalars(v)[0]
        assert (topDown.encoding == output).all()
        assert topDown.value == e.getBucketValues()[bucketIndices[0]]



      # ---------------------
      # unknown category
      output = e.encode("NA")
      assert (output == numpy.array([1,1,1,0,0,0,0,0,0,0,0,0], dtype=defaultDtype)).all()

      # Test reverse lookup
      decoded = e.decode(output)
      (fieldsDict, fieldNames) = decoded
      assert len(fieldsDict) == 1
      (ranges, desc) = fieldsDict.values()[0]
      assert len(ranges) == 1 and numpy.array_equal(ranges[0], [0,0])
      print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)

      # Test topdown compute
      topDown = e.topDownCompute(output)
      assert topDown.value == "<UNKNOWN>"
      assert topDown.scalar == 0


      # --------------------------------
      # ES
      output = e.encode("ES")
      assert (output == numpy.array([0,0,0,1,1,1,0,0,0,0,0,0], dtype=defaultDtype)).all()

      # MISSING VALUE
      outputForMissing = e.encode(SENTINEL_VALUE_FOR_MISSING_DATA)
      assert sum(outputForMissing) == 0

      # Test reverse lookup
      decoded = e.decode(output)
      (fieldsDict, fieldNames) = decoded
      assert len(fieldsDict) == 1
      (ranges, desc) = fieldsDict.values()[0]
      assert len(ranges) == 1 and numpy.array_equal(ranges[0], [1,1])
      print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)

      # Test topdown compute
      topDown = e.topDownCompute(output)
      assert topDown.value == "ES"
      assert topDown.scalar == e.getScalars("ES")[0]


      # --------------------------------
      # Multiple categories
      output.fill(1)

      # Test reverse lookup
      decoded = e.decode(output)
      (fieldsDict, fieldNames) = decoded
      assert len(fieldsDict) == 1
      (ranges, desc) = fieldsDict.values()[0]
      assert len(ranges) == 1 and numpy.array_equal(ranges[0], [0,3])
      print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded)



      # -------------------------------------------------------------
      # Test with width = 1
      categories = ["cat1", "cat2", "cat3", "cat4", "cat5"]
      e = CategoryEncoder(w=1, categoryList=categories)
      for cat in categories:
        output = e.encode(cat)
        topDown = e.topDownCompute(output)
        if verbosity >= 1:
          print cat, "->", output, output.nonzero()[0]
          print " scalarTopDown:", e.encoder.topDownCompute(output)
          print " topdown:", topDown
        assert topDown.value == cat
        assert topDown.scalar == e.getScalars(cat)[0]


      # -------------------------------------------------------------
      # Test with width = 9, removing some bits end the encoded output
      categories = ["cat%d" % (x) for x in range(1, 10)]
      e = CategoryEncoder(w=9, categoryList=categories)
      for cat in categories:
        output = e.encode(cat)
        topDown = e.topDownCompute(output)
        if verbosity >= 1:
          print cat, "->", output, output.nonzero()[0]
          print " scalarTopDown:", e.encoder.topDownCompute(output)
          print " topdown:", topDown
        assert topDown.value == cat
        assert topDown.scalar == e.getScalars(cat)[0]

        # Get rid of 1 bit on the left
        outputNZs = output.nonzero()[0]
        output[outputNZs[0]] = 0
        topDown = e.topDownCompute(output)
        if verbosity >= 1:
          print "missing 1 bit on left:", output, output.nonzero()[0]
          print " scalarTopDown:", e.encoder.topDownCompute(output)
          print " topdown:", topDown
        assert topDown.value == cat
        assert topDown.scalar == e.getScalars(cat)[0]

        # Get rid of 1 bit on the right
        output[outputNZs[0]] = 1
        output[outputNZs[-1]] = 0
        topDown = e.topDownCompute(output)
        if verbosity >= 1:
          print "missing 1 bit on right:", output, output.nonzero()[0]
          print " scalarTopDown:", e.encoder.topDownCompute(output)
          print " topdown:", topDown
        assert topDown.value == cat
        assert topDown.scalar == e.getScalars(cat)[0]

        # Get rid of 4 bits on the left
        output.fill(0)
        output[outputNZs[-5:]] = 1
        topDown = e.topDownCompute(output)
        if verbosity >= 1:
          print "missing 4 bits on left:", output, output.nonzero()[0]
          print " scalarTopDown:", e.encoder.topDownCompute(output)
          print " topdown:", topDown
        assert topDown.value == cat
        assert topDown.scalar == e.getScalars(cat)[0]

        # Get rid of 4 bits on the right
        output.fill(0)
        output[outputNZs[0:5]] = 1
        topDown = e.topDownCompute(output)
        if verbosity >= 1:
          print "missing 4 bits on right:", output, output.nonzero()[0]
          print " scalarTopDown:", e.encoder.topDownCompute(output)
          print " topdown:", topDown
        assert topDown.value == cat
        assert topDown.scalar == e.getScalars(cat)[0]


      # OR together the output of 2 different categories, we should not get
      #  back the mean, but rather one or the other
      output1 = e.encode("cat1")
      output2 = e.encode("cat9")
      output = output1 + output2
      topDown = e.topDownCompute(output)
      if verbosity >= 1:
        print "cat1 + cat9 ->", output, output.nonzero()[0]
        print " scalarTopDown:", e.encoder.topDownCompute(output)
        print " topdown:", topDown
      assert topDown.scalar == e.getScalars("cat1")[0] \
              or topDown.scalar == e.getScalars("cat9")[0]



      print "passed"