diff --git a/src/main/java/de/mpii/frequentrulesminning/AssociationRuleMiningSPMF.java b/src/main/java/de/mpii/frequentrulesminning/AssociationRuleMiningSPMF.java index df7ff53..7449377 100644 --- a/src/main/java/de/mpii/frequentrulesminning/AssociationRuleMiningSPMF.java +++ b/src/main/java/de/mpii/frequentrulesminning/AssociationRuleMiningSPMF.java @@ -173,7 +173,7 @@ public AssocRulesExtended getFrequentAssociationRules(String inputRDFFile, Strin } - revisetedRuleQuality(rules,transactionsDB); + revisedRuleQuality(rules,transactionsDB); long estimatedTime = System.nanoTime() - startTime; System.out.println("Done! ----------------------------------------------------- estimatedTime= "+estimatedTime); @@ -224,7 +224,7 @@ public void ruleAtTimeExceptionRanking(TransactionsDatabase transactionsDB, Asso } - private void revisetedRuleQuality(AssocRulesExtended rules, TransactionsDatabase transactionsDB) { + private void revisedRuleQuality(AssocRulesExtended rules, TransactionsDatabase transactionsDB) { Evaluator eval=new Evaluator(transactionsDB); rules.getRules().parallelStream().forEach((r)->{ final ExceptionItem e=r.getTopException(); @@ -232,6 +232,8 @@ private void revisetedRuleQuality(AssocRulesExtended rules, TransactionsDatabase r.setRevisedLift(e==null? r.getLift():eval.lift(r,e)); r.setRevisedJaccardCoefficient(e==null? r.getJaccardCoefficient():eval.JaccardCoefficient(r,e)); r.setRevisedBodyCoverage(e==null? r.getBodyCoverage():eval.bodyCoverage(r,e)); + r.setRevisedConviction(e==null? r.getConviction():eval.conviction(r,e)); + }); } @@ -267,6 +269,7 @@ private void rulesQuality(AssocRulesExtended rules, TransactionsDatabase transac r.setNegConfidence(eval.negativeRuleConfidence(r)); r.setJaccardCoefficient(eval.JaccardCoefficient(r)); r.setBodyCoverage(eval.bodyCoverage(r)); + r.setConviction(eval.conviction(r)); }); @@ -651,7 +654,7 @@ public void showStatisticsRevisedRules(AssocRulesExtended rules,boolean export, - st.append("topK\ttype\tAvgConfRO\tdiff\tAvgLIFTRO\tdiff\tAvgJaccardCofRO\tdiff\tBodyCoverageRO\tdiff"); + st.append("topK\ttype\tAvgConfRO\tdiff\tAvgLIFTRO\tdiff\tAvgJaccardCofRO\tdiff\tBodyCoverageRO\tdiff\tConvictionRO\tdiff"); st.append('\n'); StringBuilder stAll=new StringBuilder(); @@ -666,6 +669,7 @@ public void showStatisticsRevisedRules(AssocRulesExtended rules,boolean export, double orgAvgLiftRO = rules.getRevisedRulesLiftStats(k, false).getAverage(); double orgAvgJaccardCoefficientRO = rules.getRevisedRulesJaccardCoefficientStats(k, false).getAverage(); double orgAvgBodyCoverageRO = rules.getRevisedRulesBodyCoverageStats(k, false).getAverage(); + double orgAvgConvRO= rules.getRevisedRulesConvictionStats(k, false).getAverage(); st.append(k+"\tBefore\t"); @@ -673,6 +677,7 @@ public void showStatisticsRevisedRules(AssocRulesExtended rules,boolean export, st.append(String.format("%.6f", orgAvgLiftRO)+"\t__\t"); st.append(String.format("%.5f", orgAvgJaccardCoefficientRO)+"\t__\t"); st.append(String.format("%.6f", orgAvgBodyCoverageRO) + "\t__\t"); + st.append(String.format("%.6f", orgAvgConvRO) + "\t__\t"); st.append('\n'); @@ -682,7 +687,7 @@ public void showStatisticsRevisedRules(AssocRulesExtended rules,boolean export, double newAvgJaccardCoefficientRO = rules.getRevisedRulesJaccardCoefficientStats(k, true).getAverage();; double newAvgLiftRO = rules.getRevisedRulesLiftStats(k, true).getAverage(); double newAvgBodyCoverageRO = rules.getRevisedRulesBodyCoverageStats(k, true).getAverage(); - ; + double newAvgConvRO = rules.getRevisedRulesConvictionStats(k, true).getAverage(); st.append(k+"\tAfter\t"); st.append(String.format("%.6f", newAvgConfidenceRO)+"\t"); @@ -693,6 +698,8 @@ public void showStatisticsRevisedRules(AssocRulesExtended rules,boolean export, st.append(String.format("%.6f", newAvgJaccardCoefficientRO-orgAvgJaccardCoefficientRO)+"\t"); st.append(String.format("%.6f", newAvgBodyCoverageRO) + "\t"); st.append(String.format("%.6f", orgAvgBodyCoverageRO-newAvgBodyCoverageRO)+"\t"); + st.append(String.format("%.6f", newAvgConvRO)+"\t"); + st.append(String.format("%.6f", newAvgConvRO-orgAvgConvRO)+"\t"); st.append('\n'); @@ -721,6 +728,8 @@ public void showStatisticsRevisedRules(AssocRulesExtended rules,boolean export, stAll.append("\tBodyCov\t"); stAll.append(rules.getRevisedRulesBodyCoverageDiffStats(k).toString().replaceAll("DoubleSummaryStatistics","")+"\n"); + + // int[] numArray=rules.getRules().stream().filter(AssocRuleWithExceptions::hasExceptions).mapToInt(AssocRuleWithExceptions::getExceptionCandidatesSize).toArray(); // Arrays.sort(numArray); // double median; diff --git a/src/main/java/de/mpii/frequentrulesminning/Evaluator.java b/src/main/java/de/mpii/frequentrulesminning/Evaluator.java index 5e1f9ab..dd87c7b 100644 --- a/src/main/java/de/mpii/frequentrulesminning/Evaluator.java +++ b/src/main/java/de/mpii/frequentrulesminning/Evaluator.java @@ -170,7 +170,11 @@ public double lift(AssocRuleWithExceptions rule, ExceptionItem exceptionItem) { public double lift(AssocRuleWithExceptions rule, Set ruleTransactions, Set bodyTransactions, Set headTransactions, ExceptionItem exceptionItem) { double ruleSupport = TransactionsDatabase.getTransactionsCount(ruleTransactions, rule.getBodyAndHead(), ExceptionItem.toArray(exceptionItem), this.useWeights); double bodySupport = TransactionsDatabase.getTransactionsCount(bodyTransactions, rule.getBody(), ExceptionItem.toArray(exceptionItem), this.useWeights); - double headSupport = TransactionsDatabase.getTransactionsCount(headTransactions, rule.getHead(), ExceptionItem.toArray(exceptionItem), this.useWeights); + + + // TODO: we do not want to capture exceptions in head + // double headSupport = TransactionsDatabase.getTransactionsCount(headTransactions, rule.getHead(), ExceptionItem.toArray(exceptionItem), this.useWeights); + double headSupport = TransactionsDatabase.getTransactionsCount(headTransactions, rule.getHead(), null, this.useWeights); return computeLift(ruleSupport, bodySupport, headSupport); @@ -273,30 +277,6 @@ public void setUseWeights(boolean useWeights) { this.useWeights = useWeights; } -// public void setUseOrder(boolean useOrder) { -// this.useOrder = useOrder; -// } - -// /** -// * Computes the average confidence of (head <-body, not exceptionItem) and (not head <- body, exceptionItem) -// * -// * @param rule -// * @param exceptionItem -// */ -// public double computePosNegConfidence(AssocRuleWithExceptions rule, ExceptionItem exceptionItem) { -// -// double positiveConf = this.confidence(rule, exceptionItem); -// -// double negConf = negativeRuleConfidence(rule, exceptionItem); -// -// return computePosNegConfidence(positiveConf,negConf); -// -// -// } -// -// public static double computePosNegConfidence(double positiveConf,double negConf){ -// return (positiveConf + negConf) / 2; -// } public double negativeRuleConfidence(AssocRuleWithExceptions rule) { @@ -373,172 +353,81 @@ public double bodyCoverage(AssocRuleWithExceptions rule, ExceptionItem exception } -//TODO Commented as they do not handle weights + public double conviction(AssocRuleWithExceptions rule){ + return conviction(null); + } - // /** - // * Coverage of set of rules R with same head using coverage = (1/E) * ((supp(r1)* supp(r2)..sup(rn))^(1/|R|) ) - // * - // * @param head - // * @param rules - // * @param withExceptions - // */ -// public void groupCoverage(HeadGroup head, Collection rules, boolean withExceptions) { -// -// //TODO Exception Handling is not yet implemented -// Set containsBodyOrHead = transactionsDB.getTransactions(head.getHeadItemsIds(), null, false); -// -// //ArrayList rulesTransactionsCount=new ArrayList<>(); -// BigDecimal coverageMultiplication = BigDecimal.ONE; -// for (AssocRuleWithExceptions rule : rules) { -// -// -// Set bodyTransactions = rule.getBodyTransactions(); -// double bodyTransactionsCount = TransactionsDatabase.getTransactionsCount(bodyTransactions); -// -// if (bodyTransactionsCount == 0 || coverageMultiplication.equals(BigDecimal.ZERO)) -// System.out.println(rule + " " + bodyTransactions.size() + " " + bodyTransactionsCount + " " + coverageMultiplication); -// coverageMultiplication.multiply(BigDecimal.valueOf(bodyTransactionsCount)); -// -// -// // combine to all bodies transactions -// -// containsBodyOrHead = Sets.union(containsBodyOrHead, bodyTransactions); -// -// + + public double conviction(AssocRuleWithExceptions rule, ExceptionItem exceptionItem){ + Set ruleTransactions = transactionsDB.getTransactions(rule.getBodyAndHead(), ExceptionItem.toArray(exceptionItem), this.countPrediction); + Set bodyTransactions = transactionsDB.getTransactions(rule.getBody(), ExceptionItem.toArray(exceptionItem), this.countPrediction); + Set headTransactions = transactionsDB.getTransactions(rule.getHead(), null, this.countPrediction); + +// if (this.useOrder) { +// ruleTransactions = TransactionsDatabase.filterBetterQualityRulesPredictions(ruleTransactions, rule); +// bodyTransactions = TransactionsDatabase.filterBetterQualityRulesPredictions(bodyTransactions, rule); +// headTransactions = TransactionsDatabase.filterBetterQualityRulesPredictions(headTransactions, rule); // } -// -// -// //int coverageMultiplication=rulesTransactionsCount.stream().reduce((i,j)-> i*j).get(); -// double allTransactionsCount = TransactionsDatabase.getTransactionsCount(containsBodyOrHead); -// int rSize = rules.size(); -// -// double groupCoverage = Math.pow((coverageMultiplication.doubleValue()), (1.0D / (double) rSize)) / ((double) allTransactionsCount); -//// double groupCoverage= coverageMultiplication.pow((1.0D/(double)rSize))/((double)allTransactionsCount); -// if (groupCoverage == 0 || allTransactionsCount == 0) -// System.out.print("groupCoverage = " + groupCoverage + " coverageMultiplication = " + coverageMultiplication + " rSize: = " + rSize + " all Transactions Count = " + allTransactionsCount); -// head.setCoverage(groupCoverage); -//// head.setAllTransactionsCount(allTransactionsCount); -// } + ruleTransactions = filterTransactions(ruleTransactions, rule); + bodyTransactions = filterTransactions(bodyTransactions, rule); + headTransactions =filterTransactions(headTransactions, rule); -// public void groupCoverage(HeadGroup head, Collection assocRuleWithExceptionses) { -// groupCoverage(head, assocRuleWithExceptionses, false); -// -// } + return conviction(rule, ruleTransactions, bodyTransactions, headTransactions, exceptionItem); -// public double groupConfidence(HeadGroup head, Collection assocRuleWithExceptionses) { -// return groupConfidence(head, assocRuleWithExceptionses, false); -// } + } + public double conviction(AssocRuleWithExceptions rule, Set ruleTransactions, Set bodyTransactions, Set headTransactions, ExceptionItem exceptionItem) { -// /** -// * Measures a set of rule confidence by computing the support of all rules union over the union of the bodies supp(all rules)/supp(bodies) -// * -// * @param head -// * @param rules -// * @param withExceptions -// */ -// public double groupConfidence(HeadGroup head, Collection rules, boolean withExceptions) { -// -// Set containsBody = new HashSet<>(); -// -// -// for (AssocRuleWithExceptions rule : rules) { -//// Set bodyTransactions = transactionsDB.getTransactions(rule.getItemset1(), null); -// Set bodyTransactions = rule.getBodyTransactions(); -// //containsBody.addAll(bodyTransactions); -// containsBody = Sets.union(containsBody, bodyTransactions); -// } -// -// double bodyTransactionsCount = TransactionsDatabase.getTransactionsCount(containsBody); -// -// double rulesBodyandHeadCount = TransactionsDatabase.getTransactionsCount(transactionsDB.filterTransactionsWith(containsBody, head.getHeadItemsIds(), false)); -// -// //head.setConfidence((double) rulesBodyandHeadCount / bodyTransactionsCount); -// return (double) rulesBodyandHeadCount / bodyTransactionsCount; -// -// } + double ruleSupport = TransactionsDatabase.getTransactionsCount(ruleTransactions, rule.getBodyAndHead(), ExceptionItem.toArray(exceptionItem), this.useWeights); + double bodySupport = TransactionsDatabase.getTransactionsCount(bodyTransactions, rule.getBody(), ExceptionItem.toArray(exceptionItem), this.useWeights); + double headSupport = TransactionsDatabase.getTransactionsCount(headTransactions, rule.getHead(), null, this.useWeights); + return computeConviction(ruleSupport,bodySupport,headSupport, transactionsDB.getSize()); -// public void exceptionsConflictScore(AssocRuleWithExceptions targetRule, Set groupRules, AssocRulesExtended rulesSource) { -// // compute intersection score for each exception -// for (ExceptionItem e : targetRule.getExceptionCandidates()) { -// // TODO compute score for each exception -// double conflictScore = 0; -// int conflictTransactionsCount = 0; -// for (AssocRuleWithExceptions rule : groupRules) { -// if (targetRule.equals(rule)) { -// continue; -// } -// -// // filter transactions that contains the body and the excpetion -//// Set transactionsWithBodyandException=transactionsDB.filterTransactionsWith(predictableTransactions.get(rule), ArrayUtils.addAll(e.getItems(),targetRule.getBody())); -// Set transactionsWithBodyandException = transactionsDB.filterTransactionsWith(rule.getSafePredictableTransactions(), ArrayUtils.addAll(e.getItems(), targetRule.getBody()), false); -// double singleConflictTransactionsCount = TransactionsDatabase.getTransactionsCount(transactionsWithBodyandException); -// conflictScore += (singleConflictTransactionsCount * rule.getConfidence()); -// conflictTransactionsCount += singleConflictTransactionsCount; -// -// -// } -// e.setConflictScore(conflictTransactionsCount == 0 ? 0 : (conflictScore / conflictTransactionsCount)); -// e.setConflictCount(conflictTransactionsCount); -// -// // ComputeInverted conflict -// if (rulesSource != null) -// invertedConflictScore(targetRule, e, rulesSource.getRules(e.getItems(), null)); -// -// } -// } -// public void conflict(HeadGroup group, AssocRulesExtended rulesSource) { -// -// Set groupRules = group.getRules(); -// for (AssocRuleWithExceptions rule : groupRules) { -//// exceptionsConflictScore(rule,predictableTransactions,rulesSource); -// exceptionsConflictScore(rule, groupRules, rulesSource); -// } -// -// } + } + private double computeConviction(double ruleSupport, double bodySupport, double headSupport, double kbSize) { + + double confidence=computeConfidence(ruleSupport,bodySupport); + + return ((kbSize-headSupport)/kbSize)/(1-confidence); + + } + + + public double negativeRuleConviction(AssocRuleWithExceptions rule) { + return negativeRuleConviction(rule,null); + } + + public double negativeRuleConviction(AssocRuleWithExceptions rule, ExceptionItem exceptionItem){ + + + Set bodyWithExceptionTransactions = transactionsDB.getTransactions(ArrayUtils.addAll(rule.getBody(), ExceptionItem.toArray(exceptionItem)), null, this.countPrediction); + Set ruleTransactions = transactionsDB.getTransactions(ArrayUtils.addAll(rule.getBody(), ExceptionItem.toArray(exceptionItem)), rule.getHead(), this.countPrediction); + //TODO check again this.countPrediction can cause problems in case of switching it on in filterOutTransactionsWith(transactions, withoutItems, 0, false/*!withPredictions*/); + Set notHeadTransactions= transactionsDB.getTransactions(null, rule.getHead(), this.countPrediction); + + + ruleTransactions = filterTransactions(ruleTransactions, rule); + bodyWithExceptionTransactions = filterTransactions(bodyWithExceptionTransactions, rule); + //TODO error: when removing less quality rules predictions we will loose some transactions + notHeadTransactions= filterTransactions(notHeadTransactions, rule); + + return negativeRuleConviction(rule, bodyWithExceptionTransactions, notHeadTransactions,ruleTransactions, exceptionItem); + + } + + private double negativeRuleConviction(AssocRuleWithExceptions rule, Set bodyWithExceptionTransactions, Set notHeadTransactions, Set ruleTransactions, ExceptionItem exceptionItem) { + double ruleSupport = TransactionsDatabase.getTransactionsCount(ruleTransactions, ArrayUtils.addAll(rule.getBody(), ExceptionItem.toArray(exceptionItem)), rule.getHead(), this.useWeights); + double bodySupport = TransactionsDatabase.getTransactionsCount(bodyWithExceptionTransactions, ArrayUtils.addAll(rule.getBody(), ExceptionItem.toArray(exceptionItem)), null, this.useWeights); + double headSupport = TransactionsDatabase.getTransactionsCount(notHeadTransactions,null,rule.getHead() , this.useWeights); + + return computeConviction(ruleSupport,bodySupport,headSupport, transactionsDB.getSize()); + + } -// /** -// * Computes the conflict score between the Exception Candidate generated from rules and positive examples. -// * -// * @param targetRule -// * @param exceptionCandidate -// * @param exceptionRules -// * @return -// */ -// public void invertedConflictScore(AssocRuleWithExceptions targetRule, ExceptionItem exceptionCandidate, Set exceptionRules) { -// -// -// // positive examples of the rule that fo not contain the target exception -// Set ruleTransactionsWithoutException = transactionsDB.filterOutTransactionsWith(targetRule.getHornRuleTransactions(), exceptionCandidate.getItems(), false); -// -//// HashMap> predictableTransactions=new HashMap<>(exceptionRules.size()); -// double conflictScore = 0; -// int conflictTransactionsCount = 0; -// for (AssocRuleWithExceptions rule : exceptionRules) { -// if (!targetRule.isBodySubsetOf(rule)) -// continue; -// -// // transactions with the body but neither the exceptions nor the head ... they are predictable with this rule -//// Set rulePredictableTransactions=rule.getPredicatableTransactions(transactionsDB,true); -// Set rulePredictableTransactions = rule.getSafePredictableTransactions(); -//// predictableTransactions.put (rule, rulePredictableTransactions); -// -// // Count the intersection between the exception predection and the target rule positive examples -// double predicatableExceptionCount = TransactionsDatabase.getTransactionsCount(Sets.intersection(rulePredictableTransactions, ruleTransactionsWithoutException)); -// conflictScore += (predicatableExceptionCount * rule.getConfidence()); -// conflictTransactionsCount += predicatableExceptionCount; -// -// } -// -//// return conflictTransactionsCount==0? 0:(conflictScore/conflictTransactionsCount); -// exceptionCandidate.setInvertedConflictScore(conflictTransactionsCount == 0 ? 0 : (conflictScore / conflictTransactionsCount)); -// exceptionCandidate.setInvertedConflictCount(conflictTransactionsCount); -// -// } } diff --git a/src/main/java/de/mpii/frequentrulesminning/ExceptionRanker.java b/src/main/java/de/mpii/frequentrulesminning/ExceptionRanker.java index 3cccc51..afbbf4a 100644 --- a/src/main/java/de/mpii/frequentrulesminning/ExceptionRanker.java +++ b/src/main/java/de/mpii/frequentrulesminning/ExceptionRanker.java @@ -15,7 +15,7 @@ public class ExceptionRanker { - public enum Order{LIFT,PNCONF,SUPP,CONF,PNJACC}; + public enum Order{LIFT,PNCONF,SUPP,CONF, PNCONV, PNJACC}; private Evaluator evaluator; private Order orderingType; @@ -58,6 +58,8 @@ public void rankExceptions(AssocRuleWithExceptions rule) { case SUPP: comparator=Comparator.comparing(ExceptionItem::getAbsoluteSupport).reversed(); break; + case PNCONV: + comparator=Comparator.comparing(ExceptionItem::getPosNegConviction).reversed(); } exceptionCandidates.sort(comparator); @@ -72,6 +74,8 @@ public void computeScores(AssocRuleWithExceptions rule) { exc.setNegConfidence(evaluator.negativeRuleConfidence(rule,exc)); exc.setJaccardCoefficient(evaluator.JaccardCoefficient(rule,exc)); exc.setNegJaccardCoefficient(evaluator.negativeRuleJaccardCoefficient(rule,exc)); + exc.setConviction(evaluator.conviction(rule,exc)); + exc.setNegConviction(evaluator.negativeRuleConviction(rule,exc)); }); } diff --git a/src/main/java/de/mpii/frequentrulesminning/utils/AssocRuleWithExceptions.java b/src/main/java/de/mpii/frequentrulesminning/utils/AssocRuleWithExceptions.java index 9a0f455..26a9e11 100644 --- a/src/main/java/de/mpii/frequentrulesminning/utils/AssocRuleWithExceptions.java +++ b/src/main/java/de/mpii/frequentrulesminning/utils/AssocRuleWithExceptions.java @@ -46,6 +46,8 @@ public class AssocRuleWithExceptions {// extends AssocRule { private static int nextID; private double bodyCoverage; private double revisedBodyCoverage; + private double conviction; + private double revisedConviction; // private int[] bodyAndHead; @@ -425,4 +427,22 @@ public void setRevisedBodyCoverage(double revisedBodyCoverage) { public double getRevisedBodyCoverage() { return revisedBodyCoverage; } + + public void setConviction(double conviction) { + this.conviction = conviction; + } + + public double getConviction() { + return conviction; + } + + public void setRevisedConviction(double revisedConviction) { + this.revisedConviction = revisedConviction; + } + + public double getRevisedConviction() { + return revisedConviction; + } + + } diff --git a/src/main/java/de/mpii/frequentrulesminning/utils/AssocRulesExtended.java b/src/main/java/de/mpii/frequentrulesminning/utils/AssocRulesExtended.java index 09fc613..b00a452 100644 --- a/src/main/java/de/mpii/frequentrulesminning/utils/AssocRulesExtended.java +++ b/src/main/java/de/mpii/frequentrulesminning/utils/AssocRulesExtended.java @@ -47,7 +47,9 @@ public DoubleSummaryStatistics getRevisedRulesJaccardCoefficientDiffStats(int k) } - public enum SortingType {CONF, HEAD, BODY, LIFT, HEAD_CONF, HEAD_LIFT, NEW_LIFT} + + + public enum SortingType {CONF, HEAD, BODY, LIFT, HEAD_CONF, HEAD_LIFT, NEW_LIFT, CONV} List rules; SetMultimap head2Rules; @@ -159,6 +161,9 @@ public Comparator getRulesComparator(SortingType type) case NEW_LIFT: comparator=Comparator.comparing(AssocRuleWithExceptions::getRevisedLift).reversed(); break; + case CONV: + comparator=Comparator.comparing(AssocRuleWithExceptions::getConviction).reversed(); + break; } return comparator; } @@ -337,6 +342,15 @@ public DoubleSummaryStatistics getRevisedRulesConfidenceStats(int k, boolean exc } + + public DoubleSummaryStatistics getRevisedRulesConvictionStats(int k, boolean exception){ + if(exception) + return rules.stream().filter((r)-> r.hasExceptions()).limit(k).mapToDouble(AssocRuleWithExceptions::getRevisedConviction).summaryStatistics(); + else + return rules.stream().filter((r)-> r.hasExceptions()).limit(k).mapToDouble(AssocRuleWithExceptions::getConviction).summaryStatistics(); + + } + public DoubleSummaryStatistics getConfidenceStats(int k, boolean exception, boolean revisedOnly){ if(exception) return rules.stream().limit(k).filter((r)->(!revisedOnly)||r.hasExceptions()).mapToDouble(AssocRuleWithExceptions::getRevisedConfidence).summaryStatistics(); diff --git a/src/main/java/de/mpii/frequentrulesminning/utils/ExceptionItem.java b/src/main/java/de/mpii/frequentrulesminning/utils/ExceptionItem.java index bc63ca3..ce5d349 100644 --- a/src/main/java/de/mpii/frequentrulesminning/utils/ExceptionItem.java +++ b/src/main/java/de/mpii/frequentrulesminning/utils/ExceptionItem.java @@ -17,6 +17,8 @@ public class ExceptionItem extends ItemsetString{ private double negConfidence; private double jaccardCoefficient; private double negJaccardCoefficient; + private double negConviction; + private double conviction; public double getInvertedConflictScore() { return invertedConflictScore; @@ -147,4 +149,24 @@ public double getPosNegJaccardCoefficient() { public double getNegJaccardCoefficient() { return negJaccardCoefficient; } + + public double getPosNegConviction() { + return (getNegConviction() + getConviction()) / 2; + } + + public double getNegConviction() { + return negConviction; + } + + public double getConviction() { + return conviction; + } + + public void setConviction(double conviction) { + this.conviction = conviction; + } + + public void setNegConviction(double negConviction) { + this.negConviction = negConviction; + } } diff --git a/src/main/java/de/mpii/frequentrulesminning/utils/TransactionsDatabase.java b/src/main/java/de/mpii/frequentrulesminning/utils/TransactionsDatabase.java index b3628e1..b98221b 100644 --- a/src/main/java/de/mpii/frequentrulesminning/utils/TransactionsDatabase.java +++ b/src/main/java/de/mpii/frequentrulesminning/utils/TransactionsDatabase.java @@ -120,7 +120,7 @@ public void loadTransactions(InputStream transactionsStream) throws IOException } - System.out.println(transactionsSet.values().size()); + System.out.println(transactionsSet.values().size()+" ("+getSize()+")"); } @@ -231,6 +231,10 @@ public Set getTransactionsFromExtendedDB(int[] withItems, int[] wit } + public double getSize() { + return transactionsSet.size(); + } + static class ItemsArray { int[] items;