/** @param args the command line arguments */
  public static void main(String[] args) throws IOException {
    String outputPath = ".//output.txt";

    // Load a sequence database
    double support = 0.5;

    boolean keepPatterns = true;
    boolean verbose = false;

    AbstractionCreator abstractionCreator = AbstractionCreator_Qualitative.getInstance();
    boolean dfs = true;

    IdListCreator idListCreator = IdListCreator_StandardMap.getInstance();

    CandidateGenerator candidateGenerator = CandidateGenerator_Qualitative.getInstance();

    SequenceDatabase sequenceDatabase = new SequenceDatabase(abstractionCreator, idListCreator);

    sequenceDatabase.loadFile(fileToPath("contextPrefixSpan.txt"), support);

    System.out.println(sequenceDatabase.toString());

    AlgoSPADE algorithm = new AlgoSPADE(support, dfs, abstractionCreator);

    algorithm.runAlgorithm(sequenceDatabase, candidateGenerator, keepPatterns, verbose, outputPath);
    System.out.println("Minimum support (relative) = " + support);
    System.out.println(algorithm.getNumberOfFrequentPatterns() + " frequent patterns.");

    System.out.println(algorithm.printStatistics());
  }
Beispiel #2
0
  /**
   * Actual call to SPAM algorithm. The output can be either kept or ignore. Whenever we choose to
   * keep the patterns found, we can keep them in a file or in the main memory
   *
   * @param database Original database in where we want to search for the frequent patterns.
   * @param keepPatterns Flag indicating if we want to keep the output or not
   * @param verbose Flag for debugging purposes
   * @param outputFilePath Path of the file in which we want to store the frequent patterns. If this
   *     value is null, we keep the patterns in the main memory. This argument is taken into account
   *     just when keepPatterns is activated.
   * @throws IOException
   */
  public void runAlgorithm(
      SequenceDatabase database, boolean keepPatterns, boolean verbose, String outputFilePath)
      throws IOException {
    // If we do no have any file path
    if (outputFilePath == null) {
      // The user wants to save the results in memory
      saver = new SaverIntoMemory();
    } else {
      // Otherwise, the user wants to save them in the given file
      saver = new SaverIntoFile(outputFilePath);
    }

    this.minSupAbsolute = (int) Math.ceil(minSupRelative * database.size());
    if (this.minSupAbsolute == 0) { // protection
      this.minSupAbsolute = 1;
    }
    // reset the stats about memory usage
    MemoryLogger.getInstance().reset();
    // keeping the starting time
    start = System.currentTimeMillis();
    // We run SPAM algorithm
    runSPAM(database, (long) minSupAbsolute, keepPatterns, verbose);
    // keeping the ending time
    end = System.currentTimeMillis();
    // Search for frequent patterns: Finished
    saver.finish();
  }
Beispiel #3
0
  /**
   * The actual method for extracting frequent sequences.
   *
   * @param database The original database
   * @param minSupportAbsolute the absolute minimum support
   * @param keepPatterns flag indicating if we are interested in keeping the output of the algorithm
   * @param verbose Flag for debugging purposes
   */
  protected void runSPAM(
      SequenceDatabase database, long minSupportAbsolute, boolean keepPatterns, boolean verbose) {

    // We get the equivalence classes formed by the frequent 1-patterns
    frequentItems = database.frequentItems();
    // We extract their patterns
    Collection<Pattern> size1sequences = getPatterns(frequentItems);
    // If we want to keep the output
    if (keepPatterns) {
      for (Pattern atom : size1sequences) {
        // We keep all the frequent 1-patterns
        saver.savePattern(atom);
      }
    }

    database = null;

    // We define the root class
    EquivalenceClass rootClass = new EquivalenceClass(null);
    /*And we insert the equivalence classes corresponding to the frequent
    1-patterns as its members*/
    for (EquivalenceClass atom : frequentItems) {
      rootClass.addClassMember(atom);
    }

    // Inizialitation of the class that is in charge of find the frequent patterns
    FrequentPatternEnumeration_SPAM frequentPatternEnumeration =
        new FrequentPatternEnumeration_SPAM(minSupAbsolute, saver);
    // We execute the search
    frequentPatternEnumeration.execute(rootClass, keepPatterns, verbose);

    // Once we had finished, we keep the number of frequent patterns that we found
    numberOfFrequentPatterns = frequentPatternEnumeration.getFrequentPatterns();
    // check the memory usage for statistics
    MemoryLogger.getInstance().checkMemory();
  }