Пример #1
0
 def main(self,
          name='Apache',
          reps=20,
          fSel=True,
          ext=0.5,
          _prune=False,
          _info=0.25):
     effectSize = []
     Accuracy = []
     out_auc = [name + self.figname(fSel, ext, _prune, _info)[0]]
     out_md = [name + self.figname(fSel, ext, _prune, _info)[0]]
     out_acc = [name]
     for _ in xrange(reps):
         data = self.explorer(name)
         # self.preamble()
         for d in data:
             #       print("\\subsection{%s}\n \\begin{figure}\n \\centering" %
             #             (d[0].strip().split('/')[-1]))
             if name == d[0].strip().split('/')[-2]:
                 #           set_trace()
                 train = createTbl([d[0] + '/' + d[1][1]], isBin=False)
                 test = createTbl([d[0] + '/' + d[1][0]], isBin=False)
                 actual, before, after = self.planner(train,
                                                      test,
                                                      fSel,
                                                      ext,
                                                      _prune,
                                                      _info,
                                                      method='best')
                 cliffsdelta = cliffs(lst1=actual, lst2=after).delta()
                 out_auc.append(sum(after) / sum(before))
                 out_md.append(median(after) / median(before))
                 out_acc.extend([(1 - abs(b - a) / a) * 100
                                 for b, a in zip(before, actual)])
     return out_acc, out_auc, out_md
Пример #2
0
 def main(self, name='Apache', reps=20, fSel=True,
          ext=0.5, _prune=False, _info=0.25):
   effectSize = []
   Accuracy = []
   out_auc = [name + self.figname(fSel, ext, _prune, _info)[0]]
   out_md = [name + self.figname(fSel, ext, _prune, _info)[0]]
   out_acc = [name]
   for _ in xrange(reps):
     data = self.explorer(name)
     # self.preamble()
     for d in data:
       #       print("\\subsection{%s}\n \\begin{figure}\n \\centering" %
       #             (d[0].strip().split('/')[-1]))
       if name == d[0].strip().split('/')[-2]:
         #           set_trace()
         train = createTbl([d[0] + '/' + d[1][1]], isBin=False)
         test = createTbl([d[0] + '/' + d[1][0]], isBin=False)
         actual, before, after = self.planner(
             train, test, fSel, ext, _prune, _info, method='best')
         cliffsdelta = cliffs(lst1=actual, lst2=after).delta()
         out_auc.append(sum(after) / sum(before))
         out_md.append(median(after) / median(before))
         out_acc.extend(
             [(1 - abs(b - a) / a) * 100 for b, a in zip(before, actual)])
   return out_acc, out_auc, out_md
Пример #3
0
  def go(self):

    for _ in xrange(self.reps):
      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)

      predRows = [row.cells for predicted
                  , row in zip(before, test_df._rows) if predicted > 0]
      predTest = clone(test_df, rows=predRows)

      newTab = xtrees(train=self.train[self._n]
                          , test_DF=predTest, bin=False).main()

      after = self.pred(train_DF, newTab,
                        tunings=self.tunedParams,
                        smoteit=True)

      self.out_pred.append(_Abcd(before=actual, after=before))
      # set_trace()
      delta = cliffs(lst2=Bugs(predTest), lst1=after).delta()
      frac = sum([0 if a < 1 else 1 for a in after]) / \
          sum([0 if b < 1 else 1 for b in before])
      self.out.append(frac)
    print(self.out)
Пример #4
0
    def go(self):

        for _ in xrange(self.reps):
            predRows = []
            train_DF = createTbl(self.train[self._n][-2:], isBin=True)
            test_df = createTbl(self.test[self._n], isBin=True)
            actual = Bugs(test_df)
            before = self.pred(train_DF,
                               test_df,
                               tunings=self.tunedParams,
                               smoteit=True)

            for predicted, row in zip(before, test_df._rows):
                tmp = row.cells
                tmp[-2] = predicted
                if predicted > 0:
                    predRows.append(tmp)

            predTest = clone(test_df, rows=predRows)

            if predRows:
                newTab = treatments2(train=self.train[self._n][-2:],
                                     test=self.test[self._n],
                                     test_df=predTest,
                                     extent=self.extent,
                                     far=False,
                                     smote=True,
                                     resample=False,
                                     infoPrune=self.infoPrune,
                                     Prune=self.Prune).main()
            else:
                newTab = treatments2(train=self.train[self._n][-2:],
                                     test=self.test[self._n],
                                     far=False,
                                     smote=True,
                                     resample=False,
                                     extent=self.extent,
                                     infoPrune=self.infoPrune,
                                     Prune=self.Prune).main()

            after = self.pred(train_DF,
                              newTab,
                              tunings=self.tunedParams,
                              smoteit=True)

            self.out_pred.append(_Abcd(before=actual, after=before))
            delta = cliffs(lst1=Bugs(predTest), lst2=after).delta()
            self.out.append(delta)
        if self.extent == 0:
            append = 'Base'
        else:
            if self.Prune:
                append = str(self.extent) + '_iP(' + str(
                    int(self.infoPrune *
                        100)) + r'%)' if not self.fSelect else str(
                            self.extent) + '_w_iP(' + str(
                                int(self.infoPrune * 100)) + r'%)'
            else:
                append = str(self.extent) if not self.fSelect else str(
                    self.extent) + '_w'

        self.out.insert(0, self.dataName + '_' + append)
        self.out_pred.insert(0, self.dataName)
        print(self.out)
Пример #5
0
  def go(self):

    for _ in xrange(self.reps):
      predRows = []
      train_DF = createTbl(self.train[self._n][-2:], isBin=True)
      test_df = createTbl(self.test[self._n], isBin=True)
      actual = Bugs(test_df)
      before = self.pred(train_DF, test_df,
                         tunings=self.tunedParams,
                         smoteit=True)

      for predicted, row in zip(before, test_df._rows):
        tmp = row.cells
        tmp[-2] = predicted
        if predicted > 0:
          predRows.append(tmp)

      predTest = clone(test_df, rows=predRows)

      if predRows:
        newTab = treatments2(
            train=self.train[self._n][-2:],
            test=self.test[self._n],
            test_df=predTest,
            extent=self.extent,
            far=False,
            smote=True,
            resample=False,
            infoPrune=self.infoPrune,
            Prune=self.Prune).main()
      else:
        newTab = treatments2(
            train=self.train[
                self._n][-2:],
            test=self.test[
                self._n],
            far=False,
            smote=True,
            resample=False,
            extent=self.extent,
            infoPrune=self.infoPrune,
            Prune=self.Prune).main()

      after = self.pred(train_DF, newTab,
                        tunings=self.tunedParams,
                        smoteit=True)

      self.out_pred.append(_Abcd(before=actual, after=before))
      delta = cliffs(lst1=Bugs(predTest), lst2=after).delta()
      self.out.append(delta)
    if self.extent == 0:
      append = 'Base'
    else:
      if self.Prune:
        append = str(
            self.extent) + '_iP(' + str(
            int(self.infoPrune * 100)) + r'%)' if not self.fSelect else str(
            self.extent) + '_w_iP(' + str(
            int(self.infoPrune * 100)) + r'%)'
      else:
        append = str(
            self.extent) if not self.fSelect else str(
            self.extent) + '_w'

    self.out.insert(0, self.dataName + '_' + append)
    self.out_pred.insert(0, self.dataName)
    print(self.out)