kissfsmexperiment_1.java~

Java遗传算法库

/*
 * KISSFSMExperiment.java
 *
 * Created on May 30, 2003, 3:11 PM
 */

package es.pj.circuits.experiment;

import es.BitSet;
import es.SampleData;
import es.experiment.*;

import java.util.Hashtable;
import java.util.StringTokenizer;
import java.util.Random;
import java.util.Enumeration;
import java.util.HashSet;

import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;

/**
 *
 * @author  Michael Garvie
 * @version 
 */
public class KISSFSMExperiment_1 implements ConfigurableRandomInputExperiment, SequentialCircuitExperiment {

    protected double tSetup;
    protected Random rnd = new Random();
    protected boolean refreshTestV = true;
    protected SampleData[] lastInput;
    protected int lastInputSampleSeparation = -1;
    
    protected int nrInputs, nrOutputs, nrEdges;
    protected MealyFSMNode resetState;
    protected int resetIterations = 1;
    protected MealyFSMNode[] allStates;
    protected MealyFSMEdge[] resetDummyEdges;
    protected String kissFileName;
    
    protected int[] stateEnterPos;
    protected int rndStatePos;

    public KISSFSMExperiment_1(double tSetup, File kissFile, String resetStateName, String[] resetInputs, int[] permEdgeLines, int resetRepeats) throws IOException
    {
        this( tSetup, kissFile, resetStateName, resetInputs, permEdgeLines );
        this.resetIterations = resetIterations;
    }
    
    /** Creates new KISSFSMExperiment */
    public KISSFSMExperiment_1(double tSetup, File kissFile, String resetStateName, String[] resetInputs, int[] permEdgeLines) throws IOException
    {
        kissFileName = kissFile.toString();
        this.tSetup = tSetup;
        nrEdges = 0;
        BufferedReader bur = new BufferedReader( new FileReader( kissFile ) );
        Hashtable states = null;
        int lineCount = 0;
        String line;
        
        while( ( line = bur.readLine() ) != null )
        {
            lineCount++;
            StringTokenizer stk = new StringTokenizer( line );
            String t0;
            if( stk.hasMoreTokens() )
            {
                t0 = stk.nextToken();
            }else
            {
                t0 = "";
            }
            
            if( t0.equals( ".i" ) )
            {
                nrInputs = Integer.parseInt( stk.nextToken() );
                //System.out.println("Inputs:" + nrInputs ); // debug
                states = buildStateTable( kissFile );
            }else if( t0.equals( ".o" ) )
            {
                nrOutputs = Integer.parseInt( stk.nextToken() );
                //System.out.println("Outputs:" + nrOutputs );
            }else if( t0.startsWith( "." ) )
            {
                // ignore
            }else if( t0.equals("") )
            {
                //ignore empty line
            }
            else
            {
                String srcStateName = stk.nextToken();
                String destStateName = stk.nextToken();
                MealyFSMNode srcState = ( MealyFSMNode ) states.get( srcStateName );
                MealyFSMNode destState = ( MealyFSMNode ) states.get( destStateName );
                boolean permanentEdge = ( es.ESLib.indexOf( lineCount, permEdgeLines ) >= 0 );
                nrEdges += srcState.addEdge( destState, t0, stk.nextToken(), permanentEdge );
            }
        }
        resetState = ( MealyFSMNode ) states.get( resetStateName );
        
        allStates = new MealyFSMNode[ states.size() ];
        Enumeration statesEnum = states.elements();
        for( int sl = 0; sl < allStates.length; sl++ )
        {
            allStates[ sl ] = ( MealyFSMNode ) statesEnum.nextElement();
        }
        
        stateEnterPos = new int[ allStates.length ];
        
        // set up reset dummy edges
        resetDummyEdges = new MealyFSMEdge[ resetInputs.length ];
        for( int rl=0; rl < resetInputs.length; rl++ )
        {
            resetDummyEdges[ rl ] = new MealyFSMEdge( null, resetInputs[ rl ], "" );
        }
        
        //printNodes();//debug
    }
    
    protected void printNodes(  )//debug
    {
        for( int sl = 0; sl < allStates.length; sl++ )
        {
            MealyFSMNode node = allStates[ sl ];
            node.resetWalk();
            System.out.println( "node " + sl + ": " );
            for( int el = 0; el < node.vNextStates.size(); el++ )
            {
                MealyFSMEdge edge = ( MealyFSMEdge ) node.vNextStates.get( el );
                System.out.println("\tedge " + el + " with ins " + es.ESLib.boolArr2String( edge.inputs ) + " and outs " + es.ESLib.boolArr2String( edge.outputs ) );
                System.out.println("\t\t going to " + es.ESLib.indexOf( edge.dest, allStates ) );
                if( edge.permanent ) System.out.println("\t\t\t is permanent");
            }
        }
    }
    
    public Hashtable buildStateTable( File kissFile ) throws IOException //pub for testing
    {
        BufferedReader bur = new BufferedReader( new FileReader( kissFile ) );
        String line;
        Hashtable rv = new Hashtable();
        while( ( line = bur.readLine() ) != null )
        {
            if( !line.startsWith( "." ) && !line.equals( "" ) )
            {
                StringTokenizer stk = new StringTokenizer( line );
                stk.nextToken();
                String stateName = stk.nextToken();
                if( !rv.containsKey( stateName ) )
                {
                    rv.put( stateName, new MealyFSMNode( nrInputs, rnd ) );
                    //System.out.println( stateName ); //debug
                }
            }
        }
        return rv;
    }
    
    
    public void set( Object rndSeed )
    {
        seed = rndSeed;
        rnd.setSeed( ( ( Long ) rndSeed ).longValue() );
        refreshTestV = true;
    }
    
    protected Object seed;
    
    public Object get( Object p )
    {
        return seed;
    }
        
    
    
    /** returns a fitness associated to a given input/output pair for
     * this experiment.  The fitness is a double and is in adjusted
     * fitness format.  From 0 to 1, 1 being perfectly fit.
     * @param in array of inputs
     * @param out array of outputs
     */
    public double getFitness(SampleData[] in,SampleData[] out) {
        //System.out.println("Get Fitness called");//debug
        int iss = in[ 0 ].getSampleSeparation();
        int nrSamples = in[ 0 ].length();
        int Cix = nrInputs;
        SampleData[] desQ = new SampleData[ nrOutputs ];
        for( int ol = 0; ol < nrOutputs; ol++ )
        {
            desQ[ ol ] = new SampleData( 1, out[ 0 ].length() );
        }
        
        // Take first input sample block as OK
        for( int ql = 0; ql < nrOutputs; ql++ )
        {
            for( int odl = 0; odl < iss; odl++ )
            {
                desQ[ ql ].setTo( odl, out[ ql ].get( odl ) );
            }
        }
        
        MealyFSMNode currNode = resetState; // assume we started reset
        boolean[] currDesQ = new boolean[ nrOutputs ];
        for( int idl = 1; idl < nrSamples; idl++ )
        {
            boolean risingEdge = in[ Cix ].get( idl ) && !in[ Cix ].get( idl - 1 );
            int baseOdl = idl * iss;
            if( risingEdge )
            {
                MealyFSMEdge trans = currNode.nextStates[ es.ESLib.getLine( in, idl, 0, nrInputs - 1 ) ];
                currNode = trans.dest;
                currDesQ = trans.outputs;                        
            }
            MealyFSMEdge nextTrans = currNode.nextStates[ es.ESLib.getLine( in, idl, 0, nrInputs - 1 ) ];
            currDesQ = nextTrans.outputs;
            for( int ql = 0; ql < nrOutputs; ql++ )
            {
                boolean isDefinite = ( nextTrans.outputXPos == null ) ||
                                     ( es.ESLib.indexOf( ql, nextTrans.outputXPos ) < 0 );
                
                for( int odl = 0; odl < iss; odl++ )
                {
                    if( isDefinite )
                    {
                        desQ[ ql ].setTo( baseOdl + odl, currDesQ[ ql ] );
                    }else
                    {
                        desQ[ ql ].setTo( baseOdl + odl, out[ ql ].get( baseOdl + odl ) );
                    }
                }
            }
        }
        
        double rv = 0;
        
        /*System.out.println( es.ESLib.sampleDatasToString( in, out ) );
        System.out.println("\n\n\n");
        System.out.println( es.ESLib.sampleDatasToString( in, desQ ) );*/ // debug
        
        for( int ql = 0; ql < nrOutputs; ql++ )
        {
            rv += Math.abs( ExperimentLib.getCorrelationFitness( tSetup, nrSamples, iss, desQ[ ql ], out[ ql ] ) );
        }
        rv /= nrOutputs;
        
        return rv;
    }

    /** generates an array of inputs suitable for this experiment
     * using default input sample separation.
     */
    public SampleData[] generateInput() {
        final int DEF_ISS = 30;
        return generateInput( DEF_ISS );
    }

    /** generates an array of inputs suitable for this experiment.
     * @param inputSampleSeparation relative frequency of input to output samples.  If this is n, then n outputs will be sampled for every change in inputs.
     */
    public SampleData[] generateInput(int inputSampleSeparation) {
        final int NON_RND_TEST_PROP = 1;
        if( inputSampleSeparation != lastInputSampleSeparation )
        {
            refreshTestV = true;
            lastInputSampleSeparation = inputSampleSeparation;
        }
        
        if( refreshTestV )
        {
            resetWalkedStates();
            BitSet[] inpPatterns = new BitSet[ nrInputs + 1 ];
            int Cix = nrInputs;
            int testLength = 0;
            MealyFSMNode currNode = null;
            MealyFSMEdge currEdge = null;
            
            // 0. Initialize data structures
            for( int il = 0; il < nrInputs; il++ )
            {
                inpPatterns[ il ] = new BitSet();
            }
            inpPatterns[ Cix ] = new BitSet();    
            
            // 1. Initialize to Reset state
            int resetInpIx = rnd.nextInt( resetDummyEdges.length );
            currEdge = resetDummyEdges[ resetInpIx ];
            for( int rl = 0; rl < resetIterations; rl++ )
            {
                for( int il = 0; il < nrInputs; il++ )
                {
                    inpPatterns[ il ].setTo( rl * 2, currEdge.inputs[ il ] );
                    inpPatterns[ il ].setTo( rl * 2 + 1, currEdge.inputs[ il ] );
                }
                inpPatterns[ Cix ].setTo( rl * 2, false );
                inpPatterns[ Cix ].setTo( rl * 2 + 1, true );
            }
            
            // 1.1 Clock this reset state in
            
            testLength = resetIterations * 2;
            currNode = resetState;
            
            HashSet enteredStates = new HashSet();
            int stateEnteredArrayIx = 0;
            stateEnterPos[ stateEnteredArrayIx++ ] = testLength;
            enteredStates.add( currNode );
            
            // 2. Walk along edges
            int pathsLeft = nrEdges;
            
            while( pathsLeft > 0 )
            {
                boolean Cbefore = rnd.nextBoolean();
                int startAt = 0;
                if( Cbefore )
                {
                    for( int il = 0; il < nrInputs; il++ )
                    {
                        inpPatterns[ il ].setTo( testLength, currEdge.inputs[ il ] ); // old edge
                    }
                    startAt = 1;
                    inpPatterns[ Cix ].setTo( testLength, false );
                }else
                {
                    inpPatterns[ Cix ].setTo( testLength, true );
                }
                
                currEdge = currNode.pick();
                
                for( int rl = startAt; rl < 3; rl++ )
                {
                    for( int il = 0; il < nrInputs; il++ )
                    {
                        inpPatterns[ il ].setTo( testLength + rl, currEdge.inputs[ il ] );
                    }
                }
                inpPatterns[ Cix ].setTo( testLength + 1, false );
                inpPatterns[ Cix ].setTo( testLength + 2, true ); // clock
                
                testLength += 3;
                
                if( currNode.remove( currEdge ) )
                {
                    pathsLeft--;
                }
                
                currNode = currEdge.dest;
                
                if( !enteredStates.contains( currNode ) )
                {
                    stateEnterPos[ stateEnteredArrayIx++ ] = testLength;
                    enteredStates.add( currNode );
                }
            }
            
            for( int il = 0; il < nrInputs + 1; il++ )
            {
                inpPatterns[ il ].setLength( testLength );
            }
            refreshTestV = false;
            lastInput = ExperimentLib.generateInputFromTest( inpPatterns , NON_RND_TEST_PROP, testLength, inputSampleSeparation );
            
            rndStatePos = stateEnterPos[ rnd.nextInt( stateEnterPos.length ) ];
        }
        return lastInput;
    }
    
    protected void resetWalkedStates()
    {
        for( int sl = 0; sl < allStates.length; sl++ )
        {
            allStates[ sl ].resetWalk();
        }
    }
    
    public int getNumOfInputs() {
        return nrInputs + 1; // CLK
    }
    public int getNumOfOutputs() {
        return nrOutputs;
    }
    
    public String toString()
    {
        String rv = "KISSFSMExperiment with:<ul>\n";
        rv += "<li>KISS file name = " + kissFileName + "</li>\n";
        rv += "<li># inputs = " + nrInputs + "</li>\n";
        rv += "<li># outputs = " + nrOutputs + "</li>\n";
        rv += "</ul>\n";
        return rv;
    }
    
    /** @return Array of positions in last test pattern generated of when the tested FSM - if perfect -
     * would enter each state.  So State N is entered at input data position rv[ N ]
     */
    public int[] getStateEnterPos() {
        return stateEnterPos;
    }
    
    public int rndStatePos()
    {
        return rndStatePos;
    }
    
}