Examples of ResultsTable

bg.smoc.model.web.ResultsTable
ij.measure.ResultsTable
This is a table for storing measurement results as columns of numeric values. Call the static ResultsTable.getResultsTable() method to get a reference to the ResultsTable used by the Analyze/Measure command. @see ij.plugin.filter.Analyzer#getResultsTable
jmt.gui.exact.table.ResultsTable
A "reduced" ExactTable for showing unmodifiable results
org.data2semantics.exp.utils.ResultsTable

Examples of org.data2semantics.exp.utils.ResultsTable




    LibSVMParameters parms = new LibSVMParameters(LibSVMParameters.C_SVC, cs);
    //parms.setEvalFunction(LibSVMParameters.F1);


    ResultsTable resTable = new ResultsTable();


    


    boolean inference = false;
    for (int i = 1; i <= depth; i++) {
      resTable.newRow("WL RDF, no inference, depth=" + i);
      for (int it : iterations) {
        ECML2013RDFWLSubTreeKernel k = new ECML2013RDFWLSubTreeKernel(it, i, inference, true, blankLabels);
                
        KernelExperiment<RDFGraphKernel> exp = new RDFOldKernelExperiment(k, seeds, parms, dataset, instances, labels, blackList);


        System.out.println("Running WL RDF: " + i + " " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
      }
    }
    saveResults(resTable, "affiliation.ser");






    inference = true;
    for (int i = 1; i <= depth; i++) {
      resTable.newRow("WL RDF, inference, depth=" + i);
      for (int it : iterations) {
        ECML2013RDFWLSubTreeKernel k = new ECML2013RDFWLSubTreeKernel(it, i, inference, true, blankLabels);
                
        KernelExperiment<RDFGraphKernel> exp = new RDFOldKernelExperiment(k, seeds, parms, dataset, instances, labels, blackList);


        System.out.println("Running WL RDF: " + i + " " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
      }
    }
    saveResults(resTable, "affiliation.ser");




    inference = false;
    for (int i = 1; i <= depth; i++) {
      resTable.newRow("IST, no inference, depth=" + i);
      KernelExperiment<RDFGraphKernel> exp = new RDFOldKernelExperiment(new RDFIntersectionSubTreeKernel(i, 1, inference, true, blankLabels), seeds, parms, dataset, instances, labels, blackList);


      System.out.println("Running IST: " + i + " ");
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    saveResults(resTable, "affiliation.ser");


    inference = true;
    for (int i = 1; i <= depth; i++) {
      resTable.newRow("IST, inference, depth=" + i);
      KernelExperiment<RDFGraphKernel> exp = new RDFOldKernelExperiment(new RDFIntersectionSubTreeKernel(i, 1, inference, true, blankLabels), seeds, parms, dataset, instances, labels, blackList);


      System.out.println("Running IST: " + i + " ");
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    saveResults(resTable, "affiliation.ser");




    inference = false;
    for (int i = 1; i <= depth; i++) {
      resTable.newRow("IPST, no inference, depth=" + i);
      KernelExperiment<RDFGraphKernel> exp = new RDFOldKernelExperiment(new RDFIntersectionPartialSubTreeKernel(i, 0.01, inference, true, blankLabels), seeds, parms, dataset, instances, labels, blackList);


      System.out.println("Running IPST: " + i + " ");
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    saveResults(resTable, "affiliation.ser");


    inference = true;
    for (int i = 1; i <= depth; i++) {
      resTable.newRow("IPST, inference, depth=" + i);
      KernelExperiment<RDFGraphKernel> exp = new RDFOldKernelExperiment(new RDFIntersectionPartialSubTreeKernel(i, 0.01, inference, true, blankLabels), seeds, parms, dataset, instances, labels, blackList);


      System.out.println("Running IPST: " + i + " ");
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    saveResults(resTable, "affiliation.ser");








    List<GeneralPredictionDataSetParameters> dataSetsParams = new ArrayList<GeneralPredictionDataSetParameters>();


    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 1, false, false));
    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 2, false, false));
    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 3, false, false));


    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 1, false, true));
    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 2, false, true));
    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 3, false, true));




    int[] iterationsIG = {1,2};
    long tic, toc;


    for (GeneralPredictionDataSetParameters params : dataSetsParams) {
      tic = System.currentTimeMillis();
      PropertyPredictionDataSet ds = DataSetFactory.createPropertyPredictionDataSet(params);
      toc = System.currentTimeMillis();


      if (blankLabels) {
        ds.removeVertexAndEdgeLabels();
      }


      resTable.newRow("WL");
      for (int it : iterations) {
        KernelExperiment<GraphKernel> exp = new GraphKernelExperiment(new ECML2013WLSubTreeKernel(it), seeds, parms, ds.getGraphs(), labels);


        System.out.println("Running WL: " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }


        double[] comps =  {0,0};
        comps[0] = toc-tic;
        comps[1] = toc-tic;
        Result resC = new Result(comps,"comp time 2");
        resTable.addResult(resC);


      }
    }
    saveResults(resTable, "affiliation.ser");






    /*
    dataSetsParams = new ArrayList<GeneralPredictionDataSetParameters>();


    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 1, false, false));
    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 2, false, false));


    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 1, false, true));
    dataSetsParams.add(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 2, false, true));
     */




    for (GeneralPredictionDataSetParameters params : dataSetsParams) {
      tic = System.currentTimeMillis();
      PropertyPredictionDataSet ds = DataSetFactory.createPropertyPredictionDataSet(params);
      toc = System.currentTimeMillis();


      if (blankLabels) {
        ds.removeVertexAndEdgeLabels();
      }


      resTable.newRow("IGP");
      for (int it : iterationsIG) {
        KernelExperiment<GraphKernel> exp = new GraphKernelExperiment(new ECML2013IntersectionGraphPathKernel(it,1), seeds, parms, ds.getGraphs(), labels);


        System.out.println("Running IGP: " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }


        double[] comps =  {0,0};
        comps[0] = toc-tic;
        comps[1] = toc-tic;
        Result resC = new Result(comps,"comp time 2");
        resTable.addResult(resC);
      }
    }
    saveResults(resTable, "affiliation.ser");




    
    for (GeneralPredictionDataSetParameters params : dataSetsParams) {
      tic = System.currentTimeMillis();
      PropertyPredictionDataSet ds = DataSetFactory.createPropertyPredictionDataSet(params);
      toc = System.currentTimeMillis();


      if (blankLabels) {
        ds.removeVertexAndEdgeLabels();
      }


      resTable.newRow("IGW");
      for (int it : iterationsIG) {
        KernelExperiment<GraphKernel> exp = new GraphKernelExperiment(new ECML2013IntersectionGraphWalkKernel(it,1), seeds, parms, ds.getGraphs(), labels);


        System.out.println("Running IGW: " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }


        double[] comps =  {0,0};
        comps[0] = toc-tic;
        comps[1] = toc-tic;
        Result resC = new Result(comps,"comp time 2");
        resTable.addResult(resC);


      }
    }
    
    
    saveResults(resTable, "affiliation.ser");




    resTable.addCompResults(resTable.getBestResults());
    System.out.println(resTable);
    saveResults(resTable.toString(), "affiliation" + blankLabels + ".txt");


  }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable

    List<EvaluationFunction> evalFuncs = new ArrayList<EvaluationFunction>();
    evalFuncs.add(new Accuracy());
    evalFuncs.add(new F1());




    ResultsTable resTable = new ResultsTable();
    resTable.setDigits(2);
    //resTable.setManWU(0.05);
    
    
    ///*
    for (int it : iterations) {
      resTable.newRow("WL, it: " + it);
      MoleculeGraphExperiment<UGraph<String>> exp = new MoleculeGraphExperiment<UGraph<String>>(new WLUSubTreeKernel(it, true), seeds, svmParms, graphs, labels, evalFuncs);


      System.out.println("Running WL, it: " + it);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    //*/


    /*
    for (int it : iterations2) {
      resTable.newRow("WL separate RDF, it: " + it);
      MoleculeLinearGraphExperiment<DTGraph<String,String>> exp = new MoleculeLinearGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, true), seeds, linParms, rdfGraphs, labels, evalFuncs);


      System.out.println("Running WL separate RDF, it: " + it);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    //*/


    
    for (int d = 1; d < 4; d++) {
      for (int it : iterations2) {    
        resTable.newRow("WL RDF, " + d + ", " + it);
        
        RDFWLSubTreeKernel k = new RDFWLSubTreeKernel(it, d, false, true, true, false);
        
        RDFGraphKernelExperiment exp = new RDFGraphKernelExperiment(k, seeds, svmParms, ts, instances, labels, new ArrayList<Statement>(), evalFuncs);


        System.out.println("Running WL RDF, it: " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
      }
      System.out.println(resTable);
    }




    for (int d = 1; d < 4; d++) {
      resTable.newRow("WL RDF type, d " + d);
      for (int it : iterations2) {    


        RDFWLSubTreeSlashBurnKernel k = new RDFWLSubTreeSlashBurnKernel(it, d, false, true, true);
        k.setHubMap(GraphUtils.createRDFTypeHubMap(ts, false));


        RDFGraphKernelExperiment exp = new RDFGraphKernelExperiment(k, seeds, svmParms, ts, instances, labels, new ArrayList<Statement>(), evalFuncs);


        System.out.println("Running WL RDF, type it: " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
      }
      System.out.println(resTable);
    }
    //*/


    int[] hf = {0,1,2,3,4,5,6,7};


    for (int h : hf) {
      for (int i : depths) {      
        resTable.newRow("RDF WL NonSig " + h);
        for (int it : iterations2) {
          RDFWLSubTreeSlashBurnKernel k = new RDFWLSubTreeSlashBurnKernel(it, i, false, true, true);
          k.setHubMap(GraphUtils.createNonSigHubMap(nonSigDegreeHubs, h));


          //KernelExperiment<RDFFeatureVectorKernel> exp = new RDFLinearKernelExperiment(k, seeds, linParms, dataset, instances, target, blackList, evalFuncs);
          KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, ts, instances, labels, new ArrayList<Statement>(), evalFuncs);




          System.out.println("Running WL RDF NonSig: " + i + " " + it + " " + h);
          exp.run();


          for (Result res : exp.getResults()) {
            resTable.addResult(res);
          }  
        }
      }
      System.out.println(resTable);
    }
    
    for (int h : hf) {
      for (int i : depths) {      
        resTable.newRow("RDF WL SB " + h);
        for (int it : iterations2) {
          RDFWLSubTreeSlashBurnKernel k = new RDFWLSubTreeSlashBurnKernel(it, i, false, true, true);
          k.setHubMap(GraphUtils.createHubMap(hubs, h));


          //KernelExperiment<RDFFeatureVectorKernel> exp = new RDFLinearKernelExperiment(k, seeds, linParms, dataset, instances, target, blackList, evalFuncs);
          KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, ts, instances, labels, new ArrayList<Statement>(), evalFuncs);




          System.out.println("Running WL RDF SB: " + i + " " + it + " " + h);
          exp.run();


          for (Result res : exp.getResults()) {
            resTable.addResult(res);
          }  
        }
      }
      System.out.println(resTable);
    }




    /*
    for (int h : hf) {
      for (int i : depths) {      
        resTable.newRow("RDF IST SB " + h);
          RDFIntersectionSubTreeSlashBurnKernel k = new RDFIntersectionSubTreeSlashBurnKernel(i, 1, false, true);
          k.setHubThreshold(h);


          //KernelExperiment<RDFFeatureVectorKernel> exp = new RDFLinearKernelExperiment(k, seeds, linParms, dataset, instances, target, blackList, evalFuncs);
          KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, ts, instances, labels, new ArrayList<Statement>(), evalFuncs);




          System.out.println("Running RDF IST SB: " + i + " " + h);
          exp.run();


          for (Result res : exp.getResults()) {
            resTable.addResult(res);
          }  
        }
    }
    System.out.println(resTable);
     */






    resTable.addCompResults(resTable.getBestResults());
    System.out.println(resTable);


  }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable

    svmParms.setWeights(EvaluationUtils.computeWeights(target));
    //---------


    //---------
    // Results Table
    ResultsTable resTable = new ResultsTable();
    resTable.setDigits(3);
    //---------


    //-------
    //Data graph, with the label information
    List<Statement> allStmts3 = GraphUtils.getStatements4Depth(dataset, instances, 4, false);
    List<Statement> allStmts4;
    if (fullGraph) {
      allStmts4 = dataset.getStatements(null, null, null, false);
    } else {
      allStmts4 = GraphUtils.getStatements4Depth(dataset, instances, 5, false);
    }


    allStmts3.removeAll(blackList);
    allStmts4.removeAll(blackList);
    DTGraph<String,String> graph3 = org.nodes.data.RDF.createDirectedGraph(allStmts3, null, null); //used to generate instances
    DTGraph<String,String> graph4 = org.nodes.data.RDF.createDirectedGraph(allStmts4, null, null); //Used to find hubs
    System.out.println("Total nodes d3: " + graph3.nodes().size() + ", total nodes d4: " + graph4.nodes().size());


    List<DTNode<String,String>> instanceNodes3 = new ArrayList<DTNode<String,String>>();
    List<DTNode<String,String>> instanceNodes4 = new ArrayList<DTNode<String,String>>();
    for (Resource i : instances) {
      instanceNodes3.add(graph3.node(i.toString()));
      instanceNodes4.add(graph4.node(i.toString()));
    }
    //--------




    //--------
    // Get the different hub lists
    int maxHubs = 1000;


    // RDF.Type hubs
    List<DTNode<String,String>> RDFTypeHubs = GraphUtils.getTypeHubs(graph4);


    // Regular Degree
    Comparator<Node<String>> compRegDeg = new DegreeComparator<String>();
    MaxObserver<Node<String>> obsRegDeg = new MaxObserver<Node<String>>(maxHubs + instances.size(), compRegDeg);
    obsRegDeg.observe(graph4.nodes());
    List<DTNode<String,String>> regDegreeHubs = new ArrayList<DTNode<String,String>>();
    for (Node<String> n : obsRegDeg.elements()) {
      regDegreeHubs.add((DTNode<String,String>) n);
    }


    // Signature Degree
    Comparator<DTNode<String,String>> compSigDeg = new SlashBurn.SignatureComparator<String,String>();
    MaxObserver<DTNode<String,String>> obsSigDeg = new MaxObserver<DTNode<String,String>>(maxHubs + instances.size(), compSigDeg);        
    obsSigDeg.observe(graph4.nodes());
    List<DTNode<String,String>> sigDegreeHubs = new ArrayList<DTNode<String,String>>(obsSigDeg.elements());


    // Informed Degree
    List<Integer> classes = new ArrayList<Integer>();
    for (double d : target) {
      classes.add((int) d);
    }
    Classified<DTNode<String, String>> classified = Classification.combine(instanceNodes4, classes);


    InformedAvoidance ia = new InformedAvoidance(graph4, classified, 4);  


    Comparator<DTNode<String, String>> compUnInformed = ia.uninformedComparator(4);
    MaxObserver<DTNode<String,String>> obsUnInformed = new MaxObserver<DTNode<String,String>>(maxHubs + instances.size(), compUnInformed);
    obsUnInformed.observe(graph4.nodes());
    List<DTNode<String,String>> unInformedDegreeHubs = new ArrayList<DTNode<String,String>>(obsUnInformed.elements());


    Iterator<DTNode<String, String>> ite = unInformedDegreeHubs.iterator();
    while(ite.hasNext())
      if(! ia.viableHub(ite.next(), 4, 4))
        ite.remove();


    Comparator<DTNode<String, String>> compInformed = ia.informedComparator(4);
    MaxObserver<DTNode<String,String>> obsInformed = new MaxObserver<DTNode<String,String>>(maxHubs + instances.size(), compInformed);
    obsInformed.observe(graph4.nodes());
    List<DTNode<String,String>> informedDegreeHubs = new ArrayList<DTNode<String,String>>(obsInformed.elements());


    ite = informedDegreeHubs.iterator();
    while(ite.hasNext())
      if(! ia.viableHub(ite.next(), 4, 4))
        ite.remove();


    // Remove hubs from list that are root nodes
    List<DTNode<String,String>> rn = new ArrayList<DTNode<String,String>>();
    Set<String> is = new HashSet<String>();
    for (Resource r : instances) {
      is.add(r.toString());
    }
    for (DTNode<String,String> n : graph4.nodes()) {
      if (is.contains(n.label())) {
        rn.add(n);
      }
    }
    RDFTypeHubs.removeAll(rn);
    regDegreeHubs.removeAll(rn);
    sigDegreeHubs.removeAll(rn);
    unInformedDegreeHubs.removeAll(rn);
    informedDegreeHubs.removeAll(rn);


    List<List<DTNode<String,String>>> hubLists = new ArrayList<List<DTNode<String,String>>>();
    hubLists.add(RDFTypeHubs);
    hubLists.add(regDegreeHubs);
    hubLists.add(sigDegreeHubs);
    //hubLists.add(unInformedDegreeHubs);
    //hubLists.add(informedDegreeHubs);




    boolean forward = true;
    int it = 6;
    int depth = 3;
    int[] hubThs = {0,1,2,3,4,5,10,20,30,40,50,100};
    //int[] hubThs = {};


    MoleculeGraphExperiment<DTGraph<String,String>> exp;


    /*
    int[] iterations = {0,1,2,3,4,5,6};


    for (int i : iterations) {
      resTable.newRow("Baseline: " + i);
      List<DTNode<String,String>> newIN = new ArrayList<DTNode<String,String>>(instanceNodes3);


      exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(i, true, forward), 
          seeds, svmParms, GraphUtils.getSubGraphs(graph3, newIN, depth), target, evalFuncs);


      System.out.println("running baseline, it: " + i);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
     */


    for (int th : hubThs) {
      resTable.newRow("Hub Threshold: " + th);


      for (List<DTNode<String,String>> hubList : hubLists) {


        List<List<DTNode<String,String>>> newIN = new ArrayList<List<DTNode<String,String>>>();
        List<DTGraph<String,String>> newGs = GraphUtils.simplifyGraph3Way(graph3, GraphUtils.createHubMap(hubList, th), instanceNodes3, newIN);


        ///*
        //List<DTNode<String,String>> newIN = new ArrayList<DTNode<String,String>>(instanceNodes3);
        //DTGraph<String,String> newG = GraphUtils.simplifyGraph(graph3, GraphUtils.createHubMap(hubList, th), newIN, false, true);
        //System.out.println("New #links: "+ newG.numLinks() + ", old #links: " + graph3.numLinks());


        exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, forward), 
            seeds, svmParms, GraphUtils.getSubGraphs(newGs.get(0), newIN.get(0), depth), target, evalFuncs);


        System.out.println("running, remove hubs, th: " + th);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }


        //newIN = new ArrayList<DTNode<String,String>>(instanceNodes3);
        //newG = GraphUtils.simplifyGraph(graph3, GraphUtils.createHubMap(hubList, th), newIN, true, false);
        //System.out.println("New #links: "+ newG.numLinks() + ", old #links: " + graph3.numLinks());


        exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, forward), 
            seeds, svmParms, GraphUtils.getSubGraphs(newGs.get(1), newIN.get(1), depth), target, evalFuncs);


        System.out.println("running, relabel hubs, th: " + th);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }


        //newIN = new ArrayList<DTNode<String,String>>(instanceNodes3);
        //newG = GraphUtils.simplifyGraph(graph3, GraphUtils.createHubMap(hubList, th), newIN, true, true);
        //System.out.println("New #links: "+ newG.numLinks() + ", old #links: " + graph3.numLinks());


        exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, forward), 
            seeds, svmParms, GraphUtils.getSubGraphs(newGs.get(2), newIN.get(2), depth), target, evalFuncs);


        System.out.println("running, relabel+remove hubs, th: " + th);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
        //*/


      }
      System.out.println(resTable);
    }


    resTable.addCompResults(resTable.getBestResults());
    System.out.println(resTable);    
    System.out.println(resTable.allScoresToString());


    saveResults(resTable.toString(), "results_simp_" + System.currentTimeMillis() + ".txt");
    saveResults(resTable.allScoresToString(), "results_full_simp_" + System.currentTimeMillis() + ".txt");


/*
 * INSTANCE EXTRACTION!!!!! ah yeah ;)
 * 
 */
    
    // Discover average size
    List<DTGraph<String,String>> sg = GraphUtils.getSubGraphs(graph3, new ArrayList<DTNode<String,String>>(instanceNodes3), 3);
    double avg = 0;
    for (DTGraph<String,String> sgp : sg) {
      avg += sgp.size();
    }
    avg /= sg.size();
    System.out.println("Average Number of nodes: " + avg);
    
    // Results Table
    ResultsTable resTable2 = new ResultsTable();
    resTable2.setDigits(3);


    double[] fracs = {0.25, 0.5, 0.75, 1.0, 1.5, 2.0};


    for (double frac : fracs) {
      resTable2.newRow("Fraction: " + frac);
      
      List<DTGraph<String,String>> ihDepth = InstanceHelper.getInstances(graph4, instanceNodes4, target, InstanceHelper.Method.DEPTH, (int) Math.round(frac*avg), 4, true);  
      
      exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, forward), seeds, svmParms, ihDepth, target, evalFuncs);
      
      System.out.println("running, Depth: " + frac);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable2.addResult(res);
      }
      
      List<DTGraph<String,String>> ihUnInformed = InstanceHelper.getInstances(graph4, instanceNodes4, target, InstanceHelper.Method.UNINFORMED, (int) Math.round(frac*avg), 4, true);
      
      exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, forward), seeds, svmParms, ihUnInformed, target, evalFuncs);
      
      System.out.println("running, UnInformed: " + frac);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable2.addResult(res);
      }
      
      List<DTGraph<String,String>> ihInformed = InstanceHelper.getInstances(graph4, instanceNodes4, target, InstanceHelper.Method.INFORMED, (int) Math.round(frac*avg), 4, true);


      exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, forward), seeds, svmParms, ihInformed, target, evalFuncs);
      
      System.out.println("running, Informed: " + frac);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable2.addResult(res);
      }
      System.out.println(resTable2);  
    }
    
    resTable2.addCompResults(resTable2.getBestResults());
    System.out.println(resTable2);    
    System.out.println(resTable2.allScoresToString());


    saveResults(resTable2.toString(), "results_ie_" + System.currentTimeMillis() + ".txt");
    saveResults(resTable2.allScoresToString(), "results_full_ie_" + System.currentTimeMillis() + ".txt");
  }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable




    PropertyPredictionDataSet dataset;
    PropertyPredictionExperiment exp;


    ResultsTable resultsWL  = new ResultsTable();
    ResultsTable resultsSTF = new ResultsTable();
    ResultsTable resultsSTP = new ResultsTable();
    ResultsTable resultsIGW = new ResultsTable();
    ResultsTable resultsIGP = new ResultsTable();


    Experimenter experimenter = new Experimenter(NUMBER_OF_PROC);
    Thread expT = new Thread(experimenter);
    expT.setDaemon(true);
    expT.start();






    try {
      for (BinaryPropertyPredictionDataSetParameters params : dataSetsParams) {
        dataset = DataSetFactory.createPropertyPredictionDataSet(params);
        dataset.removeSmallClasses(5);
        dataset.setLabels(labels);
        //dataset.removeVertexAndEdgeLabels();


        resultsWL.newRow(dataset.getLabel() + " WLSubTreeKernel");


        for (int i = 0; i < 4; i++) {
          if (experimenter.hasSpace()) {    
            int fileId = (int) (Math.random() * 100000000);  
            File file = new File(DATA_DIR + fileId + "_" + "WL" + "_" + i + ".txt");
            exp = new PropertyPredictionExperiment(new PropertyPredictionDataSet(dataset), new WLSubTreeKernel(i), seeds, cs, maxClassSize, new FileOutputStream(file));
            experimenter.addExperiment(exp);
            resultsWL.addResult(exp.getResults().getAccuracy());
            resultsWL.addResult(exp.getResults().getF1());
            
            System.out.println("Running WL, it " + i + " on " + dataset.getLabel());
          }
        }


        
        resultsSTF.newRow(dataset.getLabel() + " IntersectionFullSubTree");
        for (int i = 0; i < 3; i++) {


          if (experimenter.hasSpace()) {    
            int fileId = (int) (Math.random() * 100000000);  
            File file = new File(DATA_DIR + fileId + "_" + "IntersectionFullSubTree" + "_" + i + ".txt");
            exp = new PropertyPredictionExperiment(new PropertyPredictionDataSet(dataset), new IntersectionSubTreeKernel(i, 1), seeds, cs, maxClassSize, new FileOutputStream(file));
            experimenter.addExperiment(exp);
            resultsSTF.addResult(exp.getResults().getAccuracy());
            resultsSTF.addResult(exp.getResults().getF1());
            
            System.out.println("Running STF, it " + i + " on " + dataset.getLabel());
          }
        }


        resultsSTP.newRow(dataset.getLabel() + " IntersectionPartialSubTree");
        for (int i = 0; i < 3; i++) {
          if (experimenter.hasSpace()) {    
            int fileId = (int) (Math.random() * 100000000);  
            File file = new File(DATA_DIR + fileId + "_" + "IntersectionPartialSubTree" + "_" + i + ".txt");
            exp = new PropertyPredictionExperiment(new PropertyPredictionDataSet(dataset), new IntersectionPartialSubTreeKernel(i, 0.01), seeds, cs, maxClassSize, new FileOutputStream(file));
            experimenter.addExperiment(exp);
            resultsSTP.addResult(exp.getResults().getAccuracy());
            resultsSTP.addResult(exp.getResults().getF1());
            
            System.out.println("Running STP, it " + i + " on " + dataset.getLabel());
          }
        }




        
        resultsIGP.newRow(dataset.getLabel() + " IntersectionGraphPath");
        for (int i = 1; i < 3; i++) {
          if (experimenter.hasSpace()) {    
            int fileId = (int) (Math.random() * 100000000);  
            File file = new File(DATA_DIR + fileId + "_" + "IntersectionGraphPath" + "_" + i + ".txt");
            exp = new PropertyPredictionExperiment(new PropertyPredictionDataSet(dataset), new IntersectionGraphPathKernel(i, 1), seeds, cs, maxClassSize, new FileOutputStream(file));
            experimenter.addExperiment(exp);
            resultsIGP.addResult(exp.getResults().getAccuracy());
            resultsIGP.addResult(exp.getResults().getF1());
            
            System.out.println("Running IGP, it " + i + " on " + dataset.getLabel());
          }
        }        


        resultsIGW.newRow(dataset.getLabel() + " IntersectionGraphWalk");
        for (int i = 1; i < 3; i++) {
          if (experimenter.hasSpace()) {    
            int fileId = (int) (Math.random() * 100000000);  
            File file = new File(DATA_DIR + fileId + "_" + "IntersectionGraphWalk" + "_" + i + ".txt");
            exp = new PropertyPredictionExperiment(new PropertyPredictionDataSet(dataset), new IntersectionGraphWalkKernel(i, 1), seeds, cs, maxClassSize, new FileOutputStream(file));
            experimenter.addExperiment(exp);
            resultsIGW.addResult(exp.getResults().getAccuracy());
            resultsIGW.addResult(exp.getResults().getF1());
            
            System.out.println("Running IGW, it " + i + " on " + dataset.getLabel());
          }
        }
        //*/




      }
    } catch (Exception e) {
      e.printStackTrace();
    }


    experimenter.stop();


    while (expT.isAlive()) {
      try {
        Thread.sleep(1000);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }


    try {
      int fileId = (int) (Math.random() * 100000000);  
      File file = new File(DATA_DIR + fileId + "_" + "all_results" + ".txt");
      PrintWriter fileOut = new PrintWriter(new FileOutputStream(file));


      List<Result> bestResults = new ArrayList<Result>();
      
      bestResults = resultsWL.getBestResults(bestResults);
      bestResults = resultsSTF.getBestResults(bestResults);
      bestResults = resultsSTP.getBestResults(bestResults);
      bestResults = resultsIGW.getBestResults(bestResults);
      bestResults = resultsIGP.getBestResults(bestResults);
      
      resultsWL.addCompResults(bestResults);
      resultsSTF.addCompResults(bestResults);
      resultsSTP.addCompResults(bestResults);
      resultsIGW.addCompResults(bestResults);
      resultsIGP.addCompResults(bestResults);
            
      
      fileOut.println(resultsWL);
      fileOut.println(resultsSTF);
      fileOut.println(resultsSTP);
      fileOut.println(resultsIGW);
      fileOut.println(resultsIGP);


      fileOut.println(resultsWL.allScoresToString());
      fileOut.println(resultsSTF.allScoresToString());
      fileOut.println(resultsSTP.allScoresToString());
      fileOut.println(resultsIGW.allScoresToString());
      fileOut.println(resultsIGP.allScoresToString());


      System.out.println(resultsWL);
      System.out.println(resultsSTF);
      System.out.println(resultsSTP);
      System.out.println(resultsIGW);
      System.out.println(resultsIGP);


      System.out.println(resultsWL.allScoresToString());
      System.out.println(resultsSTF.allScoresToString());
      System.out.println(resultsSTP.allScoresToString());
      System.out.println(resultsIGW.allScoresToString());
      System.out.println(resultsIGP.allScoresToString());




    } catch (Exception e) {
      e.printStackTrace();
    }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable

    svmParms.setNumFolds(10);


    svmParms.setWeightLabels(EvaluationUtils.computeWeightLabels(target));
    svmParms.setWeights(EvaluationUtils.computeWeights(target));


    ResultsTable resTable = new ResultsTable();
    resTable.setDigits(2);


    List<Statement> allStmts = dataset.getStatements(null, null, null, inference);
    allStmts.removeAll(blackList);
    DTGraph<String,String> sGraph = org.nodes.data.RDF.createDirectedGraph(allStmts, null, null);
    System.out.println("Total nodes: " + sGraph.nodes().size());
    List<DTNode<String,String>> hubs = SlashBurn.getHubs(sGraph, 1, true);


    Comparator<DTNode<String,String>> comp = new SlashBurn.SignatureComparator<String,String>();
    MaxObserver<DTNode<String,String>> obs = new MaxObserver<DTNode<String,String>>(hubs.size() + instances.size(), comp);    
    obs.observe(sGraph.nodes());
    List<DTNode<String,String>> degreeHubs = new ArrayList<DTNode<String,String>>(obs.elements());


    Comparator<Node<String>> comp2 = new DegreeComparator<String>();
    MaxObserver<Node<String>> obs2 = new MaxObserver<Node<String>>(hubs.size() + instances.size(), comp2);
    obs2.observe(sGraph.nodes());
    List<DTNode<String,String>> nonSigDegreeHubs = new ArrayList<DTNode<String,String>>();
    for (Node<String> n : obs2.elements()) {
      nonSigDegreeHubs.add((DTNode<String,String>) n);
    }


    List<DTNode<String,String>> in = new ArrayList<DTNode<String,String>>();
    
    for (Resource i : instances) {
      in.add(sGraph.node(i.toString()));
    }
    
    
    /*
    List<DTGraph<String,String>> ihDepth = InstanceHelper.getInstances(sGraph, in, target, InstanceHelper.Method.DEPTH, 200, 4);  
    List<DTGraph<String,String>> ihUnInformed = InstanceHelper.getInstances(sGraph, in, target, InstanceHelper.Method.UNINFORMED, 200, 4);
    List<DTGraph<String,String>> ihInformed = InstanceHelper.getInstances(sGraph, in, target, InstanceHelper.Method.INFORMED, 200, 4);
    //*/


    // Remove hubs from list that are root nodes
    List<DTNode<String,String>> rn = new ArrayList<DTNode<String,String>>();
    Set<String> is = new HashSet<String>();
    for (Resource r : instances) {
      is.add(r.toString());
    }
    for (DTNode<String,String> n : sGraph.nodes()) {
      if (is.contains(n.label())) {
        rn.add(n);
      }
    }
    hubs.removeAll(rn);        
    degreeHubs.removeAll(rn);
    nonSigDegreeHubs.removeAll(rn);


    System.out.println("Total SB hubs: " + hubs.size());
    System.out.println(hubs);  
    System.out.println(degreeHubs);
    System.out.println(nonSigDegreeHubs);


    /*
    for (int i = 0; i < degreeHubs.size() && i < nonSigDegreeHubs.size(); i++) {
      if (!nonSigDegreeHubs.get(i).equals(degreeHubs.get(i))) {
        System.out.println(i + " " + nonSigDegreeHubs.get(i).label() + " " + degreeHubs.get(i).label());
      }
    }
     */




    /*
    Map<String,Integer> dMap  = GraphUtils.createDegreeHubMap(degreeHubs, 300);
    Map<String,Integer> sbMap = GraphUtils.createHubMap(hubs, 300);


    for (String k : dMap.keySet()) {
      int l = dMap.get(k);
      if (sbMap.get(k) != l) {
        System.out.println("fail in level: " + l + " " + sbMap.get(k));
      }


    }
     */




    //int[] hf = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};


    int[] hf = new int[1];
    for (int i = 0; i < hf.length; i++) {
      hf[i] = i+21;
    }


    /*
    for (int it : iterations) {
      resTable.newRow("WL DEPTH, it: " + it);
      MoleculeGraphExperiment<DTGraph<String,String>> exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, true), seeds, svmParms, ihDepth, target, evalFuncs);


      System.out.println("Running WL DEPTH, it: " + it);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    
    for (int it : iterations) {
      resTable.newRow("WL UN IN, it: " + it);
      MoleculeGraphExperiment<DTGraph<String,String>> exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, true), seeds, svmParms, ihUnInformed, target, evalFuncs);


      System.out.println("Running WL UN IN, it: " + it);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    
    for (int it : iterations) {
      resTable.newRow("WL INF, it: " + it);
      MoleculeGraphExperiment<DTGraph<String,String>> exp = new MoleculeGraphExperiment<DTGraph<String,String>>(new WLSubTreeKernel(it, true, true), seeds, svmParms, ihInformed, target, evalFuncs);


      System.out.println("Running WL INF, it: " + it);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    //*/
    
    
    
    
    ///*  
    for (int i : depths) {      
      for (int it : iterations) {
        resTable.newRow("RDF WL, " + i + ", " + it);


        RDFWLSubTreeKernel k = new RDFWLSubTreeKernel(it, i, inference, true, forward, false);


        KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


        System.out.println("Running WL RDF: " + i + " " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }  
      }
    }
    System.out.println(resTable);
    //*/




    ///*
    for (int i : depths) {      
      for (int it : iterations) {
        resTable.newRow("RDF WL TYPE, " + i + ", " + it);


        RDFWLSubTreeSlashBurnKernel k = new RDFWLSubTreeSlashBurnKernel(it, i, inference, true, forward);
        k.setHubMap(GraphUtils.createRDFTypeHubMap(dataset, inference));
        k.setRelabel(relabel);
        
        KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


        System.out.println("Running WL RDF TYPE: " + i + " " + it);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }  
      }
    }
    System.out.println(resTable);




    ///*
    for (int h : hf) {
      for (int i : depths) {      
        for (int it : iterations) {
          resTable.newRow("RDF WL Regular Degree, " + h + ", " + i + ", " + it);


          RDFWLSubTreeSlashBurnKernel k = new RDFWLSubTreeSlashBurnKernel(it, i, inference, true, forward);
          k.setHubMap(GraphUtils.createNonSigHubMap(nonSigDegreeHubs, h));
          k.setRelabel(relabel);


          KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


          System.out.println("Running WL RDF Regular Degree: " + i + " " + it + " " + h);
          exp.run();


          for (Result res : exp.getResults()) {
            resTable.addResult(res);
          }  
        }
      }
    }
    System.out.println(resTable);
    //*/




    ///*
    for (int h : hf) {
      for (int i : depths) {      
        for (int it : iterations) {
          resTable.newRow("RDF WL Signature Degree (SB), " + h + ", " + i + ", " + it);


          RDFWLSubTreeSlashBurnKernel k = new RDFWLSubTreeSlashBurnKernel(it, i, inference, true, forward);
          k.setHubMap(GraphUtils.createHubMap(hubs, h));
          k.setRelabel(relabel);


          KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


          System.out.println("Running WL RDF fwd SB: " + i + " " + it + " " + h);
          exp.run();


          for (Result res : exp.getResults()) {
            resTable.addResult(res);
          }  
        }
      }
    }
    System.out.println(resTable);
    //*/


    ///*
    for (int i : depths) {      
      resTable.newRow("RDF IST, " + i);
      RDFIntersectionSubTreeKernel k = new RDFIntersectionSubTreeKernel(i, 1, inference, true);
      
      KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


      System.out.println("Running RDF IST: " + i);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }  
    }
    System.out.println(resTable);
    //*/


    ///*
    for (int i : depths) {      
      resTable.newRow("RDF IST TYPE, " + i);
      RDFIntersectionSubTreeSlashBurnKernel k = new RDFIntersectionSubTreeSlashBurnKernel(i, 1, inference, true);
      k.setHubMap(GraphUtils.createRDFTypeHubMap(dataset, inference));


      KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


      System.out.println("Running RDF IST TYPE: " + i);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }  
    }
    System.out.println(resTable);
    //*/




    ///*
    for (int h : hf) {
      for (int i : depths) {      
        resTable.newRow("RDF IST Regular Degree, " + h + ", " + i);
        RDFIntersectionSubTreeSlashBurnKernel k = new RDFIntersectionSubTreeSlashBurnKernel(i, 1, inference, true);
        k.setHubMap(GraphUtils.createNonSigHubMap(nonSigDegreeHubs, h));


        KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


        System.out.println("Running RDF IST Regular Degree: " + i + " " + h);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }  
      }
    }
    System.out.println(resTable);
    //*/




    ///*
    for (int h : hf) {
      for (int i : depths) {      
        resTable.newRow("RDF IST Signature Degree (SB), " + h + ", " + i);
        RDFIntersectionSubTreeSlashBurnKernel k = new RDFIntersectionSubTreeSlashBurnKernel(i, 1, inference, true);
        k.setHubMap(GraphUtils.createHubMap(hubs, h));


        KernelExperiment<RDFGraphKernel> exp = new RDFGraphKernelExperiment(k, seeds, svmParms, dataset, instances, target, blackList, evalFuncs);


        System.out.println("Running RDF IST Signature Degree (SB): " + i + " " + h);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }  
      }
    }
    System.out.println(resTable);
    //*/




  


    resTable.addCompResults(resTable.getBestResults());
    //resTable.addCompResults(table2.getBestResults());
    System.out.println(resTable);
    
    System.out.println(resTable.allScoresToString());
  }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable

    int[] iterations = {0,2,4,6};
    
    createCommitteeMemberPredictionDataSet();
    


    ResultsTable resTable = new ResultsTable();
    resTable.setManWU(0.05);
    resTable.setDigits(3);
    
    boolean inference = true;
    for (int i : depths) {      
      for (int it : iterations) {
        resTable.newRow("");
        
        
        LibSVMParameters parms = new LibSVMParameters(LibSVMParameters.C_SVC, cs);
        KernelExperiment<RDFGraphKernel> exp = new RDFOldKernelExperiment(new RDFWLSubTreeKernel(it, i, inference, true), seeds, parms, dataset, instances, labels, blackList);
        
        System.out.println("Running WL RDF: " + i + " " + it);
        exp.run();
        
        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }  
      }
    }
    
    saveResults(resTable, "cmp.ser");
    
    resTable.addCompResults(resTable.getBestResults());
    System.out.println(resTable);
    saveResults(resTable.toString(), "cmp_full.txt");
    
  }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable


    double[] fractions = {0.2, 0.4, 0.6, 0.8, 1};
    double[] fractionsSlow = {0.2, 0.4, 0.6, 0.8, 1};


    
    ResultsTable resTable = new ResultsTable();
    
    
    resTable.newRow("WLRDF FV");
    for (double frac : fractions) {
      createGeoDataSet((int)(1000 * frac), frac, seed, "http://data.bgs.ac.uk/ref/Lexicon/hasUnitClass");    


      RDFFeatureVectorKernel k = new RDFWLSubTreeKernel(6,3,false, true);
      
      System.out.println("RDF WL FV: " + frac);
      tic = System.currentTimeMillis();
      k.computeFeatureVectors(dataset, instances, blackList);
      toc = System.currentTimeMillis();
      double[] comp = {toc-tic};
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
    }  
    System.out.println(resTable);
    
    resTable.newRow("WLRDF Kernel");
    for (double frac : fractions) {
      createGeoDataSet((int)(1000 * frac), frac, seed, "http://data.bgs.ac.uk/ref/Lexicon/hasUnitClass");    


      RDFGraphKernel k = new RDFWLSubTreeKernel(6,3,false, true);
      
      System.out.println("RDF WL Kernel: " + frac);
      tic = System.currentTimeMillis();
      k.compute(dataset, instances, blackList);
      toc = System.currentTimeMillis();
      double[] comp = {toc-tic};
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
    }  
    System.out.println(resTable);
    
    resTable.newRow("WLRDF String FV");
    for (double frac : fractions) {
      createGeoDataSet((int)(1000 * frac), frac, seed, "http://data.bgs.ac.uk/ref/Lexicon/hasUnitClass");    
      RDFFeatureVectorKernel k = new RDFWLSubTreeKernelString(6,3, false, true);
  
      
      System.out.println("RDF WL String FV: " + frac);
      tic = System.currentTimeMillis();
      k.computeFeatureVectors(dataset, instances, blackList);
      toc = System.currentTimeMillis();
      double[] comp = {toc-tic};
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
    }
    System.out.println(resTable);
    
    resTable.newRow("WLRDF String Kernel");
    for (double frac : fractions) {
      createGeoDataSet((int)(1000 * frac), frac, seed, "http://data.bgs.ac.uk/ref/Lexicon/hasUnitClass");    
      RDFGraphKernel k = new RDFWLSubTreeKernelString(6,3, false, true);
  
      
      System.out.println("RDF WL String: " + frac);
      tic = System.currentTimeMillis();
      k.compute(dataset, instances, blackList);
      toc = System.currentTimeMillis();
      double[] comp = {toc-tic};
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
    }
    System.out.println(resTable);
  
    
    
    resTable.newRow("RDF IST");
    for (double frac : fractions) {
      createGeoDataSet((int)(1000 * frac), frac, seed, "http://data.bgs.ac.uk/ref/Lexicon/hasUnitClass");    
      RDFGraphKernel k = new RDFIntersectionSubTreeKernel(3,1, false, true);
  
      
      System.out.println("RDF IST: " + frac);
      tic = System.currentTimeMillis();
      k.compute(dataset, instances, blackList);
      toc = System.currentTimeMillis();
      double[] comp = {toc-tic};
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
    }
    System.out.println(resTable);
    
    
    
    
    resTable.newRow("WL FV");
    for (double frac : fractionsSlow) {
      createGeoDataSet((int)(1000 * frac), frac, seed, "http://data.bgs.ac.uk/ref/Lexicon/hasUnitClass");    
      tic = System.currentTimeMillis();
      PropertyPredictionDataSet ds = DataSetFactory.createPropertyPredictionDataSet(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 3, false, true));
      toc = System.currentTimeMillis();
      double dsComp = toc-tic;
      
      FeatureVectorKernel k = new WLSubTreeKernel(6,true);
      
      System.out.println("WL: " + frac);
      tic = System.currentTimeMillis();
      k.computeFeatureVectors(ds.getGraphs());
      toc = System.currentTimeMillis();
      double[] comp = {(toc-tic) + dsComp};
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
    }    
    System.out.println(resTable);
    
    
    resTable.newRow("WL Kernel");
    for (double frac : fractionsSlow) {
      createGeoDataSet((int)(1000 * frac), frac, seed, "http://data.bgs.ac.uk/ref/Lexicon/hasUnitClass");    
      tic = System.currentTimeMillis();
      PropertyPredictionDataSet ds = DataSetFactory.createPropertyPredictionDataSet(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 3, false, true));
      toc = System.currentTimeMillis();
      double dsComp = toc-tic;
      
      GraphKernel k = new WLSubTreeKernel(6,true);
      
      System.out.println("WL: " + frac);
      tic = System.currentTimeMillis();
      k.compute(ds.getGraphs());
      toc = System.currentTimeMillis();
      double[] comp = {(toc-tic) + dsComp};
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
    }    
    System.out.println(resTable);

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable

    System.out.println(resTable);
     */


    //---------
    // Results Tables
    ResultsTable resTableWL = new ResultsTable();
    resTableWL.setDigits(3);
    ResultsTable resTableIST = new ResultsTable();
    resTableIST.setDigits(3);
    //---------
      
    MoleculeListMultiGraphExperiment<DTGraph<String,String>> expWL;
    MoleculeListSingleGraphExperiment expIST;
    
    
    ///*
    
    for (int th : hubThs) {
      resTableWL.newRow("Hub Threshold: " + th);
      resTableIST.newRow("Hub Threshold: " + th);


      for (List<DTNode<String,String>> hubList : hubLists) {
        boolean regDegree = false;
        int maxSize = hubList.size();
        if (hubList == regDegreeHubs) {
          regDegree = true;
        }


        List<List<DTNode<String,String>>> newIN = new ArrayList<List<DTNode<String,String>>>();
        List<DTGraph<String,String>> newGs = GraphUtils.simplifyGraph3Way(graph3, GraphUtils.createHubMap(hubList.subList(0, Math.min(maxSize, th)), 10000, regDegree), instanceNodes3, newIN);


        ///*
        
        // 1
        List<WLSubTreeKernel> kernelsWL = new ArrayList<WLSubTreeKernel>();
        
        for (int iti : it) {
          kernelsWL.add(new WLSubTreeKernel(iti, true, forward));
        }    
        
        expWL = new MoleculeListMultiGraphExperiment<DTGraph<String,String>>(kernelsWL,  seeds, svmParms, GraphUtils.getSubGraphs(newGs.get(0), newIN.get(0), depth), target, evalFuncs);


        System.out.println("WL running, remove hubs, th: " + th);
        expWL.run();


        for (Result res : expWL.getResults()) {
          resTableWL.addResult(res);
        }


        // 2
        kernelsWL = new ArrayList<WLSubTreeKernel>();
        for (int iti : it) {
          kernelsWL.add(new WLSubTreeKernel(iti, true, forward));
        }
  
        expWL = new MoleculeListMultiGraphExperiment<DTGraph<String,String>>(kernelsWL, 
            seeds, svmParms, GraphUtils.getSubGraphs(newGs.get(1), newIN.get(1), depth), target, evalFuncs);


        System.out.println("WL running, relabel hubs, th: " + th);
        expWL.run();


        for (Result res : expWL.getResults()) {
          resTableWL.addResult(res);
        }
        
        


        // 3
        kernelsWL = new ArrayList<WLSubTreeKernel>();
        for (int iti : it) {
          kernelsWL.add(new WLSubTreeKernel(iti, true, forward));
        }
        
        expWL = new MoleculeListMultiGraphExperiment<DTGraph<String,String>>(kernelsWL, 
            seeds, svmParms, GraphUtils.getSubGraphs(newGs.get(2), newIN.get(2), depth), target, evalFuncs);


        System.out.println("WL running, relabel+remove hubs, th: " + th);
        expWL.run();


        for (Result res : expWL.getResults()) {
          resTableWL.addResult(res);
        }
        
        //*/
        
        ///*
        //-------
        // IST
        //-------
        
        // 1
        List<RDFDTGraphIntersectionSubTreeKernel> kernelsIST = new ArrayList<RDFDTGraphIntersectionSubTreeKernel>();
        kernelsIST.add(new RDFDTGraphIntersectionSubTreeKernel(depth,1,true));


        expIST = new MoleculeListSingleGraphExperiment(kernelsIST, seeds, svmParms, newGs.get(0), newIN.get(0), target, evalFuncs);


        System.out.println("IST running, remove hubs, th: " + th);
        expIST.run();


        for (Result res : expIST.getResults()) {
          resTableIST.addResult(res);
        }


        // 2
        kernelsIST = new ArrayList<RDFDTGraphIntersectionSubTreeKernel>();
        kernelsIST.add(new RDFDTGraphIntersectionSubTreeKernel(depth,1,true));
  
        expIST = new MoleculeListSingleGraphExperiment(kernelsIST, seeds, svmParms, newGs.get(1), newIN.get(1), target, evalFuncs);


        System.out.println("IST running, relabel hubs, th: " + th);
        expIST.run();


        for (Result res : expIST.getResults()) {
          resTableIST.addResult(res);
        }


        // 3
        kernelsIST = new ArrayList<RDFDTGraphIntersectionSubTreeKernel>();
        kernelsIST.add(new RDFDTGraphIntersectionSubTreeKernel(depth,1,true));
        
        expIST = new MoleculeListSingleGraphExperiment(kernelsIST, seeds, svmParms, newGs.get(2), newIN.get(2), target, evalFuncs);


        System.out.println("IST running, relabel+remove hubs, th: " + th);
        expIST.run();


        for (Result res : expIST.getResults()) {
          resTableIST.addResult(res);
        }
        
        //*/


      }
      System.out.println(resTableWL);
      System.out.println(resTableIST);
    }


    resTableWL.addCompResults(resTableWL.getBestResults(resTableIST.getBestResults()));
    resTableIST.addCompResults(resTableIST.getBestResults(resTableWL.getBestResults()));
    System.out.println(resTableWL);    
    System.out.println(resTableWL.allScoresToString());
    System.out.println(resTableIST);    
    System.out.println(resTableIST.allScoresToString());


    saveResults(resTableWL.toString() + "\n" + resTableIST.toString(), "results_simp_" + System.currentTimeMillis() + ".txt");
    saveResults(resTableWL.allScoresToString() + "\n" + resTableIST.allScoresToString(), "results_full_simp_" + System.currentTimeMillis() + ".txt");
    
    //*/


  }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable

      weights[(int) label - 1] = 1 / counts.get(label);
    }
    linParms.setWeightLabels(wLabels);
    linParms.setWeights(weights);


    ResultsTable resTable = new ResultsTable();
    resTable.setDigits(3);


    /*
    for (int depth : depths2) {
      resTable.newRow("");
      
      
      RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(new RDFSimpleTextKernel(depth, inference, normalize), seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


      System.out.println("Running Simple Text RDF: " + depth);
      exp.setDoCV(true);
      exp.setDoTFIDF(tfidf);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);


    
    for (int depth : depths2) {
      resTable.newRow("");
      
      
      RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(new RDFIntersectionTreeEdgeVertexPathKernel(depth, false, inference, normalize), seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


      System.out.println("Running EdgeVertex RDF: " + depth);
      exp.setDoCV(true);
      exp.setDoTFIDF(tfidf);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    
    
    for (int depth : depths2) {
      resTable.newRow("");
      
      
      RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(new RDFIntersectionTreeEdgeVertexPathWithTextKernel(depth, false, inference, normalize), seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


      System.out.println("Running EdgeVertex with Text RDF: " + depth);
      exp.setDoCV(true);
      exp.setDoTFIDF(tfidf);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    */
    
    for (int depth : depths) {
      resTable.newRow("");
      for (int it : iterations) {
        RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(new RDFWLSubTreeKernel(it, depth, inference, normalize), seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


        System.out.println("Running WL RDF: " + depth + " " + it);
        exp.setDoCV(true);
        exp.setDoTFIDF(tfidf);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
      }
    }
    System.out.println(resTable);


    
System.out.println(resTable);
    
    for (int depth : depths) {
      resTable.newRow("");
      for (int it : iterations) {
        List<RDFFeatureVectorKernel> kernels = new ArrayList<RDFFeatureVectorKernel>();
        RDFWLSubTreeKernel k = new RDFWLSubTreeKernel(it, depth, inference, normalize);
        
        kernels.add(k);
        kernels.add(new RDFSimpleTextKernel(depth, inference, normalize));


        RDFFeatureVectorKernel kernel = new RDFCombinedKernel(kernels, normalize);


        
        RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(kernel, seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


        System.out.println("Running WL RDF  + text: " + depth + " " + it);
        exp.setDoCV(true);
        exp.setDoTFIDF(tfidf);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
      }
    }
    System.out.println(resTable);


    /*


    for (int depth : depths2) {
      resTable.newRow("");
      RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(new RDFIntersectionTreeEdgePathKernel(depth, inference, true), seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


      System.out.println("Running ITEP RDF: " + depth);
      exp.setDoCV(true);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);


    for (int depth : depths2) {
      resTable.newRow("");
      RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(new RDFIntersectionTreeEdgeVertexPathKernel(depth, inference, true), seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


      System.out.println("Running ITEVP RDF: " + depth);
      exp.setDoCV(true);
      exp.run();


      for (Result res : exp.getResults()) {
        resTable.addResult(res);
      }
    }
    System.out.println(resTable);
    
    
    for (int depth : depths) {
      resTable.newRow("");
      for (int it : iterations) {
        RDFLinearKernelExperiment exp = new RDFLinearKernelExperiment(new RDFWLSubTreeKernel(it, depth, inference, true), seeds, linParms, dataset, instances, targets, blackList, evalFuncs);


        System.out.println("Running WL RDF: " + depth + " " + it);
        exp.setDoCV(true);
        exp.run();


        for (Result res : exp.getResults()) {
          resTable.addResult(res);
        }
      }
    }


  */
    
    resTable.addCompResults(resTable.getBestResults());
    System.out.println(resTable);




  }

View Full Code Here

Examples of org.data2semantics.exp.utils.ResultsTable


    double[] fractions = {0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1};
    double[] fractionsSlow = {0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1};




    ResultsTable resTable = new ResultsTable();


    for (double frac : fractions) {
      resTable.newRow("");


      //resTable.newRow("WLRDF FV");
      //for (double frac : fractions) {
      double[] comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    


        RDFFeatureVectorKernel k = new RDFWLSubTreeKernel(6,3,false, true);


        System.out.println("RDF WL FV: " + frac);
        tic = System.currentTimeMillis();
        k.computeFeatureVectors(dataset, instances, blackList);
        toc = System.currentTimeMillis();
        comp[i] = toc-tic;
      }
      Result res = new Result(comp, "comp time");
      resTable.addResult(res);
      //}
      //System.out.println(resTable);


      //resTable.newRow("WLRDF Kernel");
      //for (double frac : fractions) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    


        RDFGraphKernel k = new RDFWLSubTreeKernel(6,3,false, true);


        System.out.println("RDF WL Kernel: " + frac);
        tic = System.currentTimeMillis();
        k.compute(dataset, instances, blackList);
        toc = System.currentTimeMillis();
        comp[i] = toc-tic;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
      //}  
      //System.out.println(resTable);


      //resTable.newRow("WLRDF text FV");
      //for (double frac : fractions) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    


        RDFFeatureVectorKernel k = new RDFWLSubTreeWithTextKernel(6,3,false, false);


        System.out.println("RDF WL text FV: " + frac);
        tic = System.currentTimeMillis();
        TextUtils.computeTFIDF(Arrays.asList(k.computeFeatureVectors(dataset, instances, blackList)));        
        toc = System.currentTimeMillis();
        comp[i] = toc-tic;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
      //}
      //System.out.println(resTable);




      //resTable.newRow("EVP FV");
      //for (double frac : fractions) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    


        RDFFeatureVectorKernel k = new RDFIntersectionTreeEdgeVertexPathKernel(3,false, false, true);


        System.out.println("RDF EVP FV: " + frac);
        tic = System.currentTimeMillis();
        k.computeFeatureVectors(dataset, instances, blackList);
        toc = System.currentTimeMillis();
        comp[i] = toc-tic;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
      //}
      //System.out.println(resTable);


      //resTable.newRow("EVP Kernel");
      //for (double frac : fractions) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    


        RDFGraphKernel k = new RDFIntersectionTreeEdgeVertexPathKernel(3,false, false, true);


        System.out.println("RDF EVP Kernel: " + frac);
        tic = System.currentTimeMillis();
        k.compute(dataset, instances, blackList);
        toc = System.currentTimeMillis();
        comp[i] = toc-tic;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
      //}
      //System.out.println(resTable);


      //resTable.newRow("EVP text FV");
      //for (double frac : fractions) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    


        RDFFeatureVectorKernel k = new RDFIntersectionTreeEdgeVertexPathWithTextKernel(3,false, false, false);


        System.out.println("EVP text FV: " + frac);
        tic = System.currentTimeMillis();
        TextUtils.computeTFIDF(Arrays.asList(k.computeFeatureVectors(dataset, instances, blackList)));        
        toc = System.currentTimeMillis();
        comp[i] = toc-tic;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
      //}
      //System.out.println(resTable);








      //resTable.newRow("RDF IST");
      //for (double frac : fractions) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    
        RDFGraphKernel k = new RDFIntersectionSubTreeKernel(3,1, false, true);




        System.out.println("RDF IST: " + frac);
        tic = System.currentTimeMillis();
        k.compute(dataset, instances, blackList);
        toc = System.currentTimeMillis();
        comp[i] = toc-tic;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
      //}
      //System.out.println(resTable);






      
    //resTable.newRow("WL FV");
    //for (double frac : fractionsSlow) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    
        tic = System.currentTimeMillis();
        PropertyPredictionDataSet ds = DataSetFactory.createPropertyPredictionDataSet(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 3, false, true));
        toc = System.currentTimeMillis();
        double dsComp = toc-tic;


        FeatureVectorKernel k = new WLSubTreeKernel(6,true);


        System.out.println("WL: " + frac);
        tic = System.currentTimeMillis();
        k.computeFeatureVectors(ds.getGraphs());
        toc = System.currentTimeMillis();
        comp[i] = (toc-tic) + dsComp;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
    //}    
    //System.out.println(resTable);




    //resTable.newRow("WL Kernel");
    //for (double frac : fractionsSlow) {
      comp = new double[seeds.length];
      for (int i = 0; i < seeds.length; i++) {
        createGeoDataSet((int)(1000 * frac), frac, seeds[i], "http://data.bgs.ac.uk/ref/Lexicon/hasTheme");    
        tic = System.currentTimeMillis();
        PropertyPredictionDataSet ds = DataSetFactory.createPropertyPredictionDataSet(new GeneralPredictionDataSetParameters(dataset, blackLists, instances, 3, false, true));
        toc = System.currentTimeMillis();
        double dsComp = toc-tic;


        GraphKernel k = new WLSubTreeKernel(6,true);


        System.out.println("WL: " + frac);
        tic = System.currentTimeMillis();
        k.compute(ds.getGraphs());
        toc = System.currentTimeMillis();
        comp[i] = (toc-tic) + dsComp;
      }
      res = new Result(comp, "comp time");
      resTable.addResult(res);
    }    
    //}
    System.out.println(resTable);
  }

View Full Code Here

0 1 2 3 4

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.