Package statechum.analysis.learning.rpnicore.AbstractLearnerGraph

Examples of statechum.analysis.learning.rpnicore.AbstractLearnerGraph.StatesToConsider

621
622
623
624
625
626
627
628
629
630
631
  {
    LearnerGraphND graph = buildLearnerGraphND("A-a->B-a->C\nA<-c-B-b-#D\nB-d->A-c->C\nU-b->V-a->U",
      "testConvertToND6",config,converter);
   
    LearnerGraphND actual = new LearnerGraphND(Configuration.getDefaultConfiguration());actual.initEmpty();
    AbstractPathRoutines.buildInverse(graph, new StatesToConsider() {

      @Override
      public boolean stateToConsider(@SuppressWarnings("unused") CmpVertex vert) {
        return false;
      }
View Full Code Here
640
641
642
643
644
645
646
647
648
649
650
    LearnerGraphND graph = buildLearnerGraphND("A-a->B-a->C\nA<-c-B-b-#D\nB-d->A-c->C\nU-b->V-a->U","testConvertToND6",config,converter);
    LearnerGraphND expected = buildLearnerGraphND("A-c->C\nU-b->V-a->U","testBuildForward7",config,converter);
    expected.transitionMatrix.put(AbstractLearnerGraph.generateNewCmpVertex(VertexID.parseID("D"), graph.config), graph.createNewRow());
   
    LearnerGraphND actual = new LearnerGraphND(Configuration.getDefaultConfiguration());actual.initEmpty();
    AbstractPathRoutines.buildForward(graph, new StatesToConsider() {

      @Override
      public boolean stateToConsider(CmpVertex vert) {
        return !vert.getStringId().equals("B");
      }
View Full Code Here
658
659
660
661
662
663
664
665
666
667
668
  public final void testBuildForward8()
  {
    final LearnerGraphND graph = buildLearnerGraphND("A-a->B-a->C\nA<-c-B-b-#D\nB-d->A-c->C\nU-b->V-a->U","testConvertToND6",config,converter);
    final LearnerGraphND actual = new LearnerGraphND(Configuration.getDefaultConfiguration());actual.initEmpty();
   
    AbstractPathRoutines.buildForward(graph, new StatesToConsider() {
      @Override
      public boolean stateToConsider(@SuppressWarnings("unused") CmpVertex vert) {
        return false;
      }
    },actual);
View Full Code Here
674
675
676
677
678
679
680
681
682
683
684
   *
   * @return an instance of filter.
   */
  public static StatesToConsider createInstanceOfFilter(Class<? extends StatesToConsider> filterClass,LearnerGraph gr)
  {
    StatesToConsider filter = null;
    try {
      java.lang.reflect.Constructor<? extends StatesToConsider> constructor = filterClass.getConstructor(new Class []{});
      filter = constructor.newInstance(new Object[]{});
    } catch (Exception e) {
      // if we failed, filter stays at null, we'll try again.
View Full Code Here
703
704
705
706
707
708
709
710
711
712
713
   */
  private final void checkConsideringIgnoredStates(String graph, String graphName, Class<? extends StatesToConsider> filterClass, String [] expectedToRemain)
  {
    Configuration conf = Configuration.getDefaultConfiguration().copy();conf.setTransitionMatrixImplType(STATETREE.STATETREE_SLOWTREE);
    LearnerGraph gr=buildLearnerGraph(graph,graphName,conf,null);
    StatesToConsider filter = createInstanceOfFilter(filterClass, gr);
    for(boolean direction:new boolean[]{false,true})
    {
      GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, direction);
      Map<CmpVertex,Integer> state_to_int_map = new TreeMap<CmpVertex,Integer>();
      CmpVertex [] numberToStateNoReject = gr.buildStateToIntegerMap(filter,state_to_int_map);
View Full Code Here
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
           
            // Perhaps I should be numbering states directly here instead of using numberNonNegativeElements afterwards,
            // but this is not simple to do: I have to give numbers in the order in which triangular traversal visits states.
          }
        });
      GDLearnerGraph.performRowTasks(handlerList, ThreadNumber, grCombined.transitionMatrix,new StatesToConsider() {
        @Override public boolean stateToConsider(CmpVertex vert) {
          return statesOfA.contains(vert);
        }
      }, GDLearnerGraph.partitionWorkLoadLinear(ThreadNumber,statesOfA.size()));
      final int numberOfPairs = GDLearnerGraph.numberNonNegativeElements(pairScores);
View Full Code Here
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
            assert highState != null;
            wave.add(new PairScore(entryA.getKey(),highState,(int)(multiplier*scoreHigh),(int)(multiplier*scoreLow)));
          }
        });
      }
      GDLearnerGraph.performRowTasks(handlerList, ThreadNumber, grCombined.transitionMatrix,new StatesToConsider() {
        @Override public boolean stateToConsider(CmpVertex vert) {
          return statesOfA.contains(vert);
        }
      }, GDLearnerGraph.partitionWorkLoadLinear(ThreadNumber,statesOfA.size()));
     
View Full Code Here
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
           
            // Perhaps I should be numbering states directly here instead of using numberNonNegativeElements afterwards,
            // but this is not simple to do: I have to give numbers in the order in which triangular traversal visits states.
          }
        });
      GDLearnerGraph.performRowTasks(handlerList, ThreadNumber, grCombined.transitionMatrix,new StatesToConsider() {
        @Override public boolean stateToConsider(CmpVertex vert) {
          return statesOfA.contains(vert);
        }
      }, GDLearnerGraph.partitionWorkLoadLinear(ThreadNumber,statesOfA.size()));
      final int numberOfPairs = GDLearnerGraph.numberNonNegativeElements(pairScores);
View Full Code Here
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
            assert highState != null;
            wave.add(new PairScore(entryA.getKey(),highState,(int)(multiplier*scoreHigh),(int)(multiplier*scoreLow)));
          }
        });
      }
      GDLearnerGraph.performRowTasks(handlerList, ThreadNumber, grCombined.transitionMatrix,new StatesToConsider() {
        @Override public boolean stateToConsider(CmpVertex vert) {
          return statesOfA.contains(vert);
        }
      }, GDLearnerGraph.partitionWorkLoadLinear(ThreadNumber,statesOfA.size()));
     
View Full Code Here
127
128
129
130
131
132
133
134
135
136
137
 
  protected DoubleMatrix1D getExpectedMatrix1DSlowly(LearnerGraph gr)
  {
    int size=gr.getStateNumber()*(gr.getStateNumber()+1)/2;
    DoubleMatrix1D result = DoubleFactory1D.dense.make(size);
    StatesToConsider filter = LearnerGraphND.ignoreRejectStates;
    GDLearnerGraph ndGraph = new GDLearnerGraph(gr,filter, false);
    DetermineDiagonalAndRightHandSide ddrhInstance = ndGraph.new DDRH_default();
    for(Entry<CmpVertex,Map<Label,List<CmpVertex>>> entryA:ndGraph.matrixForward.transitionMatrix.entrySet())
    {
      // Now iterate through states
View Full Code Here
TOP

Related Classes of statechum.analysis.learning.rpnicore.AbstractLearnerGraph.StatesToConsider

  • statechum.analysis.learning.experiments.PairSelection.PairQualityLearner
  • statechum.analysis.learning.linear.GD
  • statechum.analysis.learning.linear.TestLinear
  • statechum.analysis.learning.linear.TestLinearWithMultipleThreads
  • statechum.analysis.learning.linear.TestMatrixComputationWithMultipleThreads
  • statechum.analysis.learning.rpnicore.AbstractPathRoutines
  • statechum.analysis.learning.rpnicore.GD
  • statechum.analysis.learning.rpnicore.TestLearnerGraphND
  • statechum.analysis.learning.rpnicore.TestLinear
  • statechum.analysis.learning.rpnicore.TestLinearWithMultipleThreads
    • Copyright © 2018 www.massapicom. All rights reserved.
    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.