Skip to content
Snippets Groups Projects
Commit 68587dfc authored by Muhammad Raufu Miah's avatar Muhammad Raufu Miah
Browse files

Add new file

parent f889681c
No related branches found
No related tags found
No related merge requests found
import de.learnlib.acex.AcexAnalyzer;
import de.learnlib.algorithm.kv.dfa.KearnsVaziraniDFA;
import de.learnlib.algorithm.kv.dfa.KearnsVaziraniDFABuilder;
import de.learnlib.algorithm.lstar.dfa.ClassicLStarDFABuilder;
import de.learnlib.algorithm.observationpack.dfa.OPLearnerDFA;
import de.learnlib.algorithm.observationpack.dfa.OPLearnerDFABuilder;
import de.learnlib.algorithm.rivestschapire.RivestSchapireDFA;
import de.learnlib.algorithm.ttt.base.AbstractTTTLearner;
import de.learnlib.algorithm.ttt.dfa.TTTLearnerDFA;
import de.learnlib.algorithm.ttt.dfa.TTTLearnerDFABuilder;
import de.learnlib.filter.statistic.oracle.DFACounterOracle;
import de.learnlib.oracle.EquivalenceOracle;
import de.learnlib.oracle.MembershipOracle;
import de.learnlib.oracle.equivalence.DFASimulatorEQOracle;
import de.learnlib.oracle.equivalence.WMethodEQOracle;
import de.learnlib.oracle.membership.DFASimulatorOracle;
import de.learnlib.query.DefaultQuery;
import net.automatalib.alphabet.Alphabet;
import net.automatalib.alphabet.Alphabets;
import net.automatalib.automaton.fsa.DFA;
import de.learnlib.algorithm.lstar.dfa.ClassicLStarDFA;
import de.learnlib.algorithm.rivestschapire.RivestSchapireDFABuilder;
import net.automatalib.word.Word;
import org.knowm.xchart.QuickChart;
import org.knowm.xchart.SwingWrapper;
import org.knowm.xchart.XYChart;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class ExperimentsAcceptanceRatio {
public static void main(String[] args) {
// Define configurations
int[] yValues = { 5 };
int[] zValues = { 100 };
double[] xValues = { 0.01,0.02,0.03,0.04,0.05,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.95,0.96,0.97,0.98,0.99 };
// Declare arrays to store the average membership queries and average equivalence queries
double[] avgMemQueriesLstar = new double[xValues.length];
double[] avgMemQueriesRS = new double[xValues.length];
double[] avgMemQueriesKV = new double[xValues.length];
double[] avgMemQueriesOP = new double[xValues.length];
double[] avgMemQueriesTTT = new double[xValues.length];
double[] avgEqQueriesLstar = new double[xValues.length];
double[] avgEqQueriesRS = new double[xValues.length];
double[] avgEqQueriesKV = new double[xValues.length];
double[] avgEqQueriesOP = new double[xValues.length];
double[] avgEqQueriesTTT = new double[xValues.length];
// Iterate over each configuration: y denotes the size of the alphabet of the target DFA, z denotes the size of the target DFA, x denotes the acceptance ratio of the target DFA
for(int y:yValues) {
for (int z : zValues) {
int k=0;
for (double x : xValues) {
// Create the alphabet
Alphabet<Integer> alphabet = Alphabets.integers(0, y - 1);
int memCounterLstar = 0;
int memCounterRS = 0;
int memCounterKV = 0;
int memCounterOP = 0;
int memCounterTTT = 0;
int eqCounterLstar = 0;
int eqCounterRS = 0;
int eqCounterKV = 0;
int eqCounterOP = 0;
int eqCounterTTT = 0;
// Generate 100 random DFAs for each configuration
for (int i = 0; i < 100; i++) {
System.out.println("Generating random DFA " + i + " for configuration (x,y,z):" + x + "," + y + "," + z);
Random rand = new Random();
ExampleRandomDFA example = new ExampleRandomDFA(rand, y, z, x, alphabet);
DFA<?, Integer> dfa = example.getReferenceAutomaton();
// Initialize the Query Counters and the Oracles - we used the white-box oracles
EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleLstar = new DFASimulatorEQOracle<>(dfa);
EQCounterOracle<DFA<?, Integer>, Integer, Boolean> eqCounterOracleLstar = new EQCounterOracle<>(eqOracleLstar);
MembershipOracle.DFAMembershipOracle<Integer> memOracleLstar = new DFASimulatorOracle<>(dfa);
DFACounterOracle<Integer> memCounterOracleLstar = new DFACounterOracle<>(memOracleLstar);
EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleRS = new DFASimulatorEQOracle<>(dfa);
EQCounterOracle<DFA<?, Integer>, Integer, Boolean> eqCounterOracleRS = new EQCounterOracle<>(eqOracleRS);
MembershipOracle.DFAMembershipOracle<Integer> memOracleRS = new DFASimulatorOracle<>(dfa);
DFACounterOracle<Integer> memCounterOracleRS = new DFACounterOracle<>(memOracleRS);
EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleKV = new DFASimulatorEQOracle<>(dfa);
EQCounterOracle<DFA<?, Integer>, Integer, Boolean> eqCounterOracleKV = new EQCounterOracle<>(eqOracleKV);
MembershipOracle.DFAMembershipOracle<Integer> memOracleKV = new DFASimulatorOracle<>(dfa);
DFACounterOracle<Integer> memCounterOracleKV = new DFACounterOracle<>(memOracleKV);
EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleOP = new DFASimulatorEQOracle<>(dfa);
EQCounterOracle<DFA<?, Integer>, Integer, Boolean> eqCounterOracleOP = new EQCounterOracle<>(eqOracleOP);
MembershipOracle.DFAMembershipOracle<Integer> memOracleOP = new DFASimulatorOracle<>(dfa);
DFACounterOracle<Integer> memCounterOracleOP = new DFACounterOracle<>(memOracleOP);
EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleTTT = new DFASimulatorEQOracle<>(dfa);
EQCounterOracle<DFA<?, Integer>, Integer, Boolean> eqCounterOracleTTT = new EQCounterOracle<>(eqOracleTTT);
MembershipOracle.DFAMembershipOracle<Integer> memOracleTTT = new DFASimulatorOracle<>(dfa);
DFACounterOracle<Integer> memCounterOracleTTT = new DFACounterOracle<>(memOracleTTT);
// Learn the DFA using each learning algorithm
learnWithClassicLStarDFA(dfa, alphabet, eqCounterOracleLstar, memCounterOracleLstar);
learnWithRivestShapireDFA(dfa, alphabet, eqCounterOracleRS, memCounterOracleRS);
learnWithKearnsVauiraniDFA(dfa, alphabet, eqCounterOracleKV, memCounterOracleKV);
learnWithOPLearnerDFA(dfa, alphabet, eqCounterOracleOP, memCounterOracleOP);
learnWithTTTLearnerDFA(dfa, alphabet, eqCounterOracleTTT, memCounterOracleTTT);
// Update the counters
memCounterLstar += memCounterOracleLstar.getQueryCounter().getCount();
memCounterRS += memCounterOracleRS.getQueryCounter().getCount();
memCounterKV += memCounterOracleKV.getQueryCounter().getCount();
memCounterOP += memCounterOracleOP.getQueryCounter().getCount();
memCounterTTT += memCounterOracleTTT.getQueryCounter().getCount();
eqCounterLstar += eqCounterOracleLstar.getCounter();
eqCounterRS += eqCounterOracleRS.getCounter();
eqCounterKV += eqCounterOracleKV.getCounter();
eqCounterOP += eqCounterOracleOP.getCounter();
eqCounterTTT += eqCounterOracleTTT.getCounter();
}
//Calculate average for configuration (x,y,z) for the counters
System.out.println("For configuration (x,y,z):" + x + "," + y + "," + z + " :");
System.out.println("Average memCounterLstar: " + memCounterLstar/100);
System.out.println("Average memCounterRS: " + memCounterRS/100);
System.out.println("Average memCounterKV: " + memCounterKV/100);
System.out.println("Average memCounterOP: " + memCounterOP/100);
System.out.println("Average memCounterTTT: " + memCounterTTT/100);
System.out.println("Average eqCounterLstar: " + eqCounterLstar/100);
System.out.println("Average eqCounterRS: " + eqCounterRS/100);
System.out.println("Average eqCounterKV: " + eqCounterKV/100);
System.out.println("Average eqCounterOP: " + eqCounterOP/100);
System.out.println("Average eqCounterTTT: " + eqCounterTTT/100);
// Calculate the averages and store them in the arrays
avgMemQueriesLstar[k] = memCounterLstar / 100.0;
avgMemQueriesRS[k] = memCounterRS / 100.0;
avgMemQueriesKV[k] = memCounterKV / 100.0;
avgMemQueriesOP[k] = memCounterOP / 100.0;
avgMemQueriesTTT[k] = memCounterTTT / 100.0;
avgEqQueriesLstar[k] = eqCounterLstar / 100.0;
avgEqQueriesRS[k] = eqCounterRS / 100.0;
avgEqQueriesKV[k] = eqCounterKV / 100.0;
avgEqQueriesOP[k] = eqCounterOP / 100.0;
avgEqQueriesTTT[k] = eqCounterTTT / 100.0;
k++;
}
}
}
String[] seriesNames = {"LStar","RS","KV", "OP", "TTT"};
// Create the first XY chart (membership queries)
XYChart chart1 = QuickChart.getChart("Average Membership Queries", "Acceptance Ratio", "Queries", seriesNames, xValues, new double[][]{avgMemQueriesLstar,avgMemQueriesRS, avgMemQueriesKV, avgMemQueriesOP, avgMemQueriesTTT});
new SwingWrapper(chart1).displayChart();
// Create the second XY chart (equivalence queries)
XYChart chart2 = QuickChart.getChart("Average Equivalence Queries", "Acceptance Ratio", "Queries", seriesNames, xValues, new double[][]{avgEqQueriesLstar, avgEqQueriesRS,avgEqQueriesKV, avgEqQueriesOP, avgEqQueriesTTT});
new SwingWrapper(chart2).displayChart();
}
// Define the learning methods
public static void learnWithClassicLStarDFA(DFA<?, Integer> dfa, Alphabet<Integer> alphabet, EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleLstar, MembershipOracle.DFAMembershipOracle<Integer> memOracleLstar) {
// Create an instance of the ClassicLStar algorithm
ClassicLStarDFA<Integer> learner =
new ClassicLStarDFABuilder<Integer>().withAlphabet(alphabet) // input alphabet
.withOracle(memOracleLstar) // membership oracle
.create();
// Start the learning process
learner.startLearning();
// Perform equivalence queries until no counterexample is found
DefaultQuery<Integer, Boolean> counterexample;
while ((counterexample = eqOracleLstar.findCounterExample(learner.getHypothesisModel(), alphabet)) != null) {
learner.refineHypothesis(counterexample);
}
}
public static void learnWithRivestShapireDFA(DFA<?, Integer> dfa, Alphabet<Integer> alphabet, EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleRS, MembershipOracle.DFAMembershipOracle<Integer> memOracleRS) {
// Implement learning with RivestShapireDFA
RivestSchapireDFABuilder<Integer> rsBuilder = new RivestSchapireDFABuilder<>();
rsBuilder.withAlphabet(alphabet); // input alphabet
rsBuilder.withOracle(memOracleRS); // membership oracle
RivestSchapireDFA<Integer> learner = rsBuilder.create();
learner.startLearning();
DefaultQuery<Integer, Boolean> counterexample;
while ((counterexample = eqOracleRS.findCounterExample(learner.getHypothesisModel(), alphabet)) != null) {
learner.refineHypothesis(counterexample);
}
}
public static void learnWithKearnsVauiraniDFA(DFA<?, Integer> dfa, Alphabet<Integer> alphabet, EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleKV, MembershipOracle.DFAMembershipOracle<Integer> memOracleKV) {
KearnsVaziraniDFABuilder<Integer> kol= new KearnsVaziraniDFABuilder<Integer>();
kol.withAlphabet(alphabet);
kol.withOracle(memOracleKV);
kol.withRepeatedCounterexampleEvaluation(true);
KearnsVaziraniDFA<Integer> learner = kol.create();
learner.startLearning();
DefaultQuery<Integer, Boolean> counterexample;
while ((counterexample = eqOracleKV.findCounterExample(learner.getHypothesisModel(), alphabet)) != null) {
learner.refineHypothesis(counterexample);
}
}
public static void learnWithOPLearnerDFA(DFA<?, Integer> dfa, Alphabet<Integer> alphabet, EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> eqOracleOP, MembershipOracle.DFAMembershipOracle<Integer> memOracleOP) {
OPLearnerDFABuilder<Integer> opBuilder = new OPLearnerDFABuilder<>();
opBuilder.withAlphabet(alphabet);
opBuilder.withOracle(memOracleOP);
opBuilder.setRepeatedCounterexampleEvaluation(true);
OPLearnerDFA<Integer> learner = opBuilder.create();
// Perform equivalence queries until no counterexample is found
DefaultQuery<Integer, Boolean> counterexample;
learner.startLearning();
while ((counterexample = eqOracleOP.findCounterExample(learner.getHypothesisModel(), alphabet)) != null) {
learner.refineHypothesis(counterexample);
}
}
public static void learnWithTTTLearnerDFA(DFA<?, Integer> dfa, Alphabet<Integer> alphabet, EquivalenceOracle<DFA<?, Integer>, Integer, Boolean> oracle, MembershipOracle.DFAMembershipOracle<Integer> mem) {
TTTLearnerDFA<Integer> learner =
new TTTLearnerDFABuilder<Integer>().withAlphabet(alphabet)
.withOracle(mem)
.create();
learner.startLearning();
// Perform equivalence queries until no counterexample is found
DefaultQuery counterexample;
while ((counterexample = oracle.findCounterExample(learner.getHypothesisModel(), alphabet)) != null) {
learner.refineHypothesis(counterexample);
}
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment