apriori2 java_怎么用java实现apriori算法

展开全部

from operator import and_from itertools import combinationsclass AprioriAssociationRule:

def __init__(self, inputfile):

self.transactions = []

self.itemSet = set([])

inf = open(inputfile, 'rb')

for line in inf.readlines():

elements = set(filter(lambda entry: len(entry)>0, line.strip().split(',')))

if len(elements)>0:

self.transactions.append(elements)

for element in elements:

self.itemSet.add(element)

inf.close()

self.toRetItems = {}

self.associationRules = []

def getSupport(self, itemcomb):

if type(itemcomb) != frozenset:

itemcomb = frozenset([itemcomb])

within_transaction = lambda transaction: reduce(and_, [(item in transaction) for item in itemcomb])

count = len(filter(within_transaction, self.transactions))

return float(count)/float(len(self.transactions))

def runApriori(self, minSupport=0.15, minConfidence=0.6):

itemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,

map(lambda item: (frozenset([item]), self.getSupport(item)), self.itemSet))

currentLset = set(map(lambda freqpair: freqpair[0], itemCombSupports))

k = 2

while len(currentLset)>0:

currentCset = set([i.union(j) for i in currentLset for j in currentLset if len(i.union(j))==k])

currentItemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,

map(lambda item: (item, self.getSupport(item)), currentCset))

currentLset = set(map(lambda freqpair: freqpair[0], currentItemCombSupports))

itemCombSupports.extend(currentItemCombSupports)

k += 1

for key, supportVal in itemCombSupports:

self.toRetItems[key] = supportVal

self.calculateAssociationRules(minConfidence=minConfidence)

def calculateAssociationRules(self, minConfidence=0.6):

for key in self.toRetItems:

subsets = [frozenset(item) for k in range(1, len(key)) for item in combinations(key, k)]

for subset in subsets:

confidence = self.toRetItems[key] / self.toRetItems[subset]

if confidence > minConfidence:

self.associationRules.append([subset, key-subset, confidence])用Scala也大概六十多行：

import scala.io.Sourceimport scala.collection.immutable.Listimport scala.collection.immutable.Setimport java.io.Fileimport scala.collection.mutable.Mapclass AprioriAlgorithm(inputFile: File) {

var transactions : List[Set[String]] = List()

var itemSet : Set[String] = Set()

for (line

val elementSet = line.trim.split(',').toSet

if (elementSet.size > 0) {

transactions = transactions :+ elementSet

itemSet = itemSet ++ elementSet

}

}

var toRetItems : Map[Set[String], Double] = Map()

var associationRules : List[(Set[String], Set[String], Double)] = List()

def getSupport(itemComb : Set[String]) : Double = {

def withinTransaction(transaction : Set[String]) : Boolean = itemComb

.map( x => transaction.contains(x))

.reduceRight((x1, x2) => x1 && x2)

val count = transactions.filter(withinTransaction).size

count.toDouble / transactions.size.toDouble

}

def runApriori(minSupport : Double = 0.15, minConfidence : Double = 0.6) = {

var itemCombs = itemSet.map( word => (Set(word), getSupport(Set(word))))

.filter( wordSupportPair => (wordSupportPair._2 > minSupport))

var currentLSet : Set[Set[String]] = itemCombs.map( wordSupportPair => wordSupportPair._1).toSet

var k : Int = 2

while (currentLSet.size > 0) {

val currentCSet : Set[Set[String]] = currentLSet.map( wordSet => currentLSet.map(wordSet1 => wordSet | wordSet1))

.reduceRight( (set1, set2) => set1 | set2)

.filter( wordSet => (wordSet.size==k))

val currentItemCombs = currentCSet.map( wordSet => (wordSet, getSupport(wordSet)))

.filter( wordSupportPair => (wordSupportPair._2 > minSupport))

currentLSet = currentItemCombs.map( wordSupportPair => wordSupportPair._1).toSet

itemCombs = itemCombs | currentItemCombs

k += 1

}

for (itemComb

toRetItems += (itemComb._1 -> itemComb._2)

}

calculateAssociationRule(minConfidence)

}

def calculateAssociationRule(minConfidence : Double = 0.6) = {

toRetItems.keys.foreach(item =>

item.subsets.filter( wordSet => (wordSet.size0))

.foreach( subset => {associationRules = associationRules :+ (subset, item diff subset,

toRetItems(item).toDouble/toRetItems(subset).toDouble)

}

)

)

associationRules = associationRules.filter( rule => rule._3>minConfidence)

}}

我不建议用Java，应改用Python或Scala一类的语言32313133353236313431303231363533e4b893e5b19e31333363393634。如果用Python，代码大概50行左右，但可以想像用Java便看起来复杂得多。看如下：