public static void main(String[] arg) throws IOException { // Load a sequence database SequenceDatabase sequenceDatabase = new SequenceDatabase(); sequenceDatabase.loadFile(fileToPath("contextPrefixSpan.txt")); sequenceDatabase.print(); // Create an instance of the algorithm AlgoMaxSP algo = new AlgoMaxSP(); // if you set the following parameter to true, the sequence ids of the sequences where // each pattern appears will be shown in the result boolean showSequenceIdentifiers = false; // execute the algorithm SequentialPatterns patterns = algo.runAlgorithm(sequenceDatabase, null, 2); algo.printStatistics(sequenceDatabase.size()); patterns.printFrequentPatterns(sequenceDatabase.size(), showSequenceIdentifiers); }
public static void main(String[] arg) throws IOException { // Load a sequence database SequenceDatabase sequenceDatabase = new SequenceDatabase(); sequenceDatabase.loadFile(fileToPath("contextPrefixSpan.txt")); sequenceDatabase.print(); int minsup = 2; // we use a minsup of 2 sequences (50 % of the database size) AlgoBIDEPlus algo = new AlgoBIDEPlus(); // // execute the algorithm algo.runAlgorithm(sequenceDatabase, "C://patterns//closed_sequential_patterns.txt", minsup); algo.printStatistics(sequenceDatabase.size()); }
public static void main(String[] arg) throws IOException { String outputPath = ".//output.txt"; // Load a sequence database SequenceDatabase sequenceDatabase = new SequenceDatabase(); sequenceDatabase.loadFile(fileToPath("contextPrefixSpan.txt")); // print the database to console sequenceDatabase.print(); // Create an instance of the algorithm with minsup = 50 % AlgoPrefixSpan algo = new AlgoPrefixSpan(); int minsup = 2; // we use a minimum support of 2 sequences. // execute the algorithm algo.runAlgorithm(sequenceDatabase, outputPath, minsup); algo.printStatistics(sequenceDatabase.size()); }
public static void main(String[] arg) throws IOException { // Load a sequence database SequenceDatabase sequenceDatabase = new SequenceDatabase(); sequenceDatabase.loadFile(fileToPath("contextPrefixSpan.txt")); // sequenceDatabase.print(); int minsup = 2; // we use a minsup of 2 sequences (50 % of the database size) AlgoMaxSP algo = new AlgoMaxSP(); // // if you set the following parameter to true, the sequence ids of the sequences where // each pattern appears will be shown in the result algo.setShowSequenceIdentifiers(false); // execute the algorithm algo.runAlgorithm(sequenceDatabase, ".//output.txt", minsup); algo.printStatistics(sequenceDatabase.size()); }
public static void main(String[] arg) throws IOException { // Load a sequence database SequenceDatabase sequenceDatabase = new SequenceDatabase(); sequenceDatabase.loadFile(fileToPath("contextPrefixSpan.txt")); // print the database to console sequenceDatabase.print(); // Create an instance of the algorithm AlgoFSGP algo = new AlgoFSGP(); // algo.setMaximumPatternLength(3); // execute the algorithm with minsup = 50 % boolean performPruning = true; // to activate pruning of search space List<SequentialPattern> patterns = algo.runAlgorithm(sequenceDatabase, 0.5, performPruning); algo.printStatistics(sequenceDatabase.size()); System.out.println(" == PATTERNS =="); for (SequentialPattern pattern : patterns) { System.out.println(pattern + " support : " + pattern.getAbsoluteSupport()); } }
/** * This is the main method for the BIDE+ algorithm. * * @param database a sequence database * @throws IOException exception if some error occurs while writing the output file. */ private void bide(SequenceDatabase database, String outputFilePath) throws IOException { // if the user want to keep the result into memory if (outputFilePath == null) { writer = null; patterns = new SequentialPatterns("FREQUENT SEQUENTIAL PATTERNS"); } else { // if the user want to save the result to a file patterns = null; writer = new BufferedWriter(new FileWriter(outputFilePath)); } // The algorithm first scan the database to find all frequent items // The algorithm note the sequences in which these items appear. // This is stored in a map: Key: item Value : IDs of sequences containing the item Map<Integer, Set<Integer>> mapSequenceID = findSequencesContainingItems(database); // WE CONVERT THE DATABASE TO A PSEUDO-DATABASE, AND REMOVE // THE ITEMS OF SIZE 1 THAT ARE NOT FREQUENT, SO THAT THE ALGORITHM // WILL NOT CONSIDER THEM ANYMORE. // we create a database initialDatabase = new ArrayList<PseudoSequenceBIDE>(database.size()); // for each sequence of the original database for (Sequence sequence : database.getSequences()) { // we make a copy of the sequence while removing infrequent items Sequence optimizedSequence = sequence.cloneSequenceMinusItems(mapSequenceID, minsuppAbsolute); if (optimizedSequence.size() != 0) { // if this sequence has size >0, we add it to the new database initialDatabase.add(new PseudoSequenceBIDE(optimizedSequence, 0, 0)); } else { initialDatabase.add(null); } } // For each frequent item loop1: for (Entry<Integer, Set<Integer>> entry : mapSequenceID.entrySet()) { // if the item is frequent if (entry.getValue().size() >= minsuppAbsolute) { // build the projected database with this item Integer item = entry.getKey(); List<PseudoSequenceBIDE> projectedContext = buildProjectedContextSingleItem(item, initialDatabase, false, entry.getValue()); // Create the prefix with this item SequentialPattern prefix = new SequentialPattern(); prefix.addItemset(new Itemset(item)); // set the sequence IDS of this prefix prefix.setSequenceIDs(entry.getValue()); // variable to store the largest support of patterns // that will be found starting with this prefix if (entry.getValue().size() >= minsuppAbsolute) { // MODIF2015 IMPORTANT int successorSupport = 0; if (!checkBackScanPruning(prefix, projectedContext)) { successorSupport = recursion(prefix, projectedContext); // r�cursion; } // Finally, because this prefix has support > minsup // and passed the backscan pruning, // we check if it has no sucessor with support >= minsup // (a forward extension) // IF no forward extension if (successorSupport != entry.getValue().size()) { // ######### MODIFICATION #### // IF there is also no backward extension if (!checkBackwardExtension(prefix, projectedContext)) { // the pattern is closed and we save it savePattern(prefix); } } } else { if (!checkBackwardExtension(prefix, projectedContext)) { // the pattern is closed and we save it savePattern(prefix); } } } } // check the memory usage for statistics MemoryLogger.getInstance().checkMemory(); }