Exemple #1
0
 def depen(self, rows):
     mod = rforest(
         self.train,
         self.test,
         tunings=rows  # n_est, max_feat, mss, msl
         ,
         smoteit=True)
     g = _Abcd(before=Bugs(self.test), after=mod, show=False)[-1]
     return g
Exemple #2
0
 def depen(self, row):
   # My where2pred() takes data in string format. Ex: '../Data/ant/ant-1.6.csv'
   self.where = defaults().update(minSize = row[4]
                                , depthMin = int(row[5])
                                , depthMax = int(row[6])
                                , prune = row[7]>0.5)
   self.tree.infoPrune = row[1]
   self.tree.m = int(row[2])
   self.tree.n = int(row[3])
   self.tree.prune = row[8]>0.5
   actual = Bugs(createTbl([self.test], isBin = True))
   preds = where2prd(self.train, [self.test], tunings = [self.where, self.tree], thresh = row[0])
   return _Abcd(before = actual, after = preds, show = False)[-1]
Exemple #3
0
 def depen(self, rows):
     mod = CART(self.train, self.test, tunings=rows, smoteit=True)
     g = _Abcd(before=Bugs(self.test), after=mod, show=False)[-1]
     return g
Exemple #4
0
 def depen(self, rows):
     mod = rforest(self.train, self.test, tunings=rows, smoteit=True)
     prec = ABCD(before=Bugs(self.test), after=mod).all()[2]
     pdpf = ABCD(before=Bugs(self.test), after=mod).all()[:2]
     return prec
Exemple #5
0
    def go(self):
        rseed(1)
        for planner in ['xtrees', 'cart', 'HOW', 'baseln0', 'baseln1']:
            out = [planner]
            predRows = []
            train_DF = createTbl(self.train[self._n], isBin=True)
            test_df = createTbl(self.test[self._n], isBin=True)
            actual = np.array(Bugs(test_df))
            before = self.pred(train_DF,
                               test_df,
                               tunings=self.tunedParams,
                               smoteit=True)

            base = lambda X: sorted(X)[-1] - sorted(X)[0]
            newRows = lambda newTab: map(lambda Rows: Rows.cells[:-1], newTab.
                                         _rows)
            after = lambda newTab: self.pred(
                train_DF, newTab, tunings=self.tunedParams, smoteit=True)
            frac = lambda aft: sum([0 if a < 1 else 1 for a in aft]) / sum(
                [0 if b < 1 else 1 for b in before])
            predRows = [
                row.cells for predicted, row in zip(
                    before,
                    createTbl(self.test[self._n], isBin=False)._rows)
                if predicted > 0
            ]

            predTest = genTable(test_df, rows=predRows)

            for _ in xrange(self.reps):
                "Apply Different Planners"
                if planner == 'xtrees':
                    newTab = xtrees(train=self.train[-1],
                                    test_DF=predTest,
                                    bin=False,
                                    majority=True).main()

                elif planner == 'cart' or planner == 'CART':
                    newTab = xtrees(train=self.train[-1],
                                    test_DF=predTest,
                                    bin=False,
                                    majority=False).main()

                elif planner == 'HOW':
                    newTab = HOW(train=self.train[-1],
                                 test=self.test[-1],
                                 test_df=predTest).main()

                elif planner == 'baseln0':
                    newTab = strawman(train=self.train[-1],
                                      test=self.test[-1]).main()

                elif planner == 'baseln1':
                    newTab = strawman(train=self.train[-1],
                                      test=self.test[-1],
                                      prune=True).main()

                out.append(frac(after(newTab)))

            self.logResults(out)
            yield out