apriori演算法的java
㈠ 誰有java實現數據挖掘APRIORI演算法的代碼急用！
要比較好的實現的話去WEKA源碼裡面找，或者http://www.helsinki.fi/~holler/datamining/algorithms.html也有~
不過其實要把人家寫的讀懂也挺煩的，Apriori是很基本的，Java也有很多好用的集合類，加把勁一天就能寫個能用的出來~
㈡ 急需C++實現的Apriori演算法代碼
用C++ 實現的 可以 到http://download.csdn.net/down/188143/chanjuanzz下載 不過要注冊扣積分的
演算法實現
（一）核心類
Apriori演算法的核心實現類為AprioriAlgorithm，實現的Java代碼如下所示：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* <B>關聯規則挖掘：Apriori演算法</B>
*
* <P>該演算法基本上按照Apriori演算法的基本思想來實現的。
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class AprioriAlgorithm {
private Map<Integer, Set<String>> txDatabase; // 事務資料庫
private Float minSup; // 最小支持度
private Float minConf; // 最小置信度
private Integer txDatabaseCount; // 事務資料庫中的事務數
private Map<Integer, Set<Set<String>>> freqItemSet; // 頻繁項集集合
private Map<Set<String>, Set<Set<String>>> assiciationRules; // 頻繁關聯規則集合
public AprioriAlgorithm(
Map<Integer, Set<String>> txDatabase,
Float minSup,
Float minConf) {
this.txDatabase = txDatabase;
this.minSup = minSup;
this.minConf = minConf;
this.txDatabaseCount = this.txDatabase.size();
freqItemSet = new TreeMap<Integer, Set<Set<String>>>();
assiciationRules = new HashMap<Set<String>, Set<Set<String>>>();
}
/**
* 掃描事務資料庫，計算頻繁1-項集
* @return
*/
public Map<Set<String>, Float> getFreq1ItemSet() {
Map<Set<String>, Float> freq1ItemSetMap = new HashMap<Set<String>, Float>();
Map<Set<String>, Integer> candFreq1ItemSet = this.getCandFreq1ItemSet();
Iterator<Map.Entry<Set<String>, Integer>> it = candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Set<String>, Integer> entry = it.next();
// 計算支持度
Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supported>=minSup) {
freq1ItemSetMap.put(entry.getKey(), supported);
}
}
return freq1ItemSetMap;
}
/**
* 計算候選頻繁1-項集
* @return
*/
public Map<Set<String>, Integer> getCandFreq1ItemSet() {
Map<Set<String>, Integer> candFreq1ItemSetMap = new HashMap<Set<String>, Integer>();
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計支持數，生成候選頻繁1-項集
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Set<String> itemSet = entry.getValue();
for(String item : itemSet) {
Set<String> key = new HashSet<String>();
key.add(item.trim());
if(!candFreq1ItemSetMap.containsKey(key)) {
Integer value = 1;
candFreq1ItemSetMap.put(key, value);
}
else {
Integer value = 1+candFreq1ItemSetMap.get(key);
candFreq1ItemSetMap.put(key, value);
}
}
}
return candFreq1ItemSetMap;
}
/**
* 根據頻繁(k-1)-項集計算候選頻繁k-項集
*
* @param m 其中m=k-1
* @param freqMItemSet 頻繁(k-1)-項集
* @return
*/
public Set<Set<String>> aprioriGen(int m, Set<Set<String>> freqMItemSet) {
Set<Set<String>> candFreqKItemSet = new HashSet<Set<String>>();
Iterator<Set<String>> it = freqMItemSet.iterator();
Set<String> originalItemSet = null;
while(it.hasNext()) {
originalItemSet = it.next();
Iterator<Set<String>> itr = this.getIterator(originalItemSet, freqMItemSet);
while(itr.hasNext()) {
Set<String> identicalSet = new HashSet<String>(); // 兩個項集相同元素的集合(集合的交運算)
identicalSet.addAll(originalItemSet);
Set<String> set = itr.next();
identicalSet.retainAll(set); // identicalSet中剩下的元素是identicalSet與set集合中公有的元素
if(identicalSet.size() == m-1) { // (k-1)-項集中k-2個相同
Set<String> differentSet = new HashSet<String>(); // 兩個項集不同元素的集合(集合的差運算)
differentSet.addAll(originalItemSet);
differentSet.removeAll(set); // 因為有k-2個相同，則differentSet中一定剩下一個元素，即differentSet大小為1
differentSet.addAll(set); // 構造候選k-項集的一個元素(set大小為k-1,differentSet大小為k)
candFreqKItemSet.add(differentSet); // 加入候選k-項集集合
}
}
}
return candFreqKItemSet;
}
/**
* 根據一個頻繁k-項集的元素(集合)，獲取到頻繁k-項集的從該元素開始的迭代器實例
* @param itemSet
* @param freqKItemSet 頻繁k-項集
* @return
*/
private Iterator<Set<String>> getIterator(Set<String> itemSet, Set<Set<String>> freqKItemSet) {
Iterator<Set<String>> it = freqKItemSet.iterator();
while(it.hasNext()) {
if(itemSet.equals(it.next())) {
break;
}
}
return it;
}
/**
* 根據頻繁(k-1)-項集，調用aprioriGen方法，計算頻繁k-項集
*
* @param k
* @param freqMItemSet 頻繁(k-1)-項集
* @return
*/
public Map<Set<String>, Float> getFreqKItemSet(int k, Set<Set<String>> freqMItemSet) {
Map<Set<String>, Integer> candFreqKItemSetMap = new HashMap<Set<String>, Integer>();
// 調用aprioriGen方法，得到候選頻繁k-項集
Set<Set<String>> candFreqKItemSet = this.aprioriGen(k-1, freqMItemSet);
// 掃描事務資料庫
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計支持數
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Iterator<Set<String>> kit = candFreqKItemSet.iterator();
while(kit.hasNext()) {
Set<String> kSet = kit.next();
Set<String> set = new HashSet<String>();
set.addAll(kSet);
set.removeAll(entry.getValue()); // 候選頻繁k-項集與事務資料庫中元素做差元算
if(set.isEmpty()) { // 如果拷貝set為空，支持數加1
if(candFreqKItemSetMap.get(kSet) == null) {
Integer value = 1;
candFreqKItemSetMap.put(kSet, value);
}
else {
Integer value = 1+candFreqKItemSetMap.get(kSet);
candFreqKItemSetMap.put(kSet, value);
}
}
}
}
// 計算支持度，生成頻繁k-項集，並返回
return support(candFreqKItemSetMap);
}
/**
* 根據候選頻繁k-項集，得到頻繁k-項集
*
* @param candFreqKItemSetMap 候選k項集(包含支持計數)
*/
public Map<Set<String>, Float> support(Map<Set<String>, Integer> candFreqKItemSetMap) {
Map<Set<String>, Float> freqKItemSetMap = new HashMap<Set<String>, Float>();
Iterator<Map.Entry<Set<String>, Integer>> it = candFreqKItemSetMap.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Set<String>, Integer> entry = it.next();
// 計算支持度
Float supportRate = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supportRate<minSup) { // 如果不滿足最小支持度，刪除
it.remove();
}
else {
freqKItemSetMap.put(entry.getKey(), supportRate);
}
}
return freqKItemSetMap;
}
/**
* 挖掘全部頻繁項集
*/
public void mineFreqItemSet() {
// 計算頻繁1-項集
Set<Set<String>> freqKItemSet = this.getFreq1ItemSet().keySet();
freqItemSet.put(1, freqKItemSet);
// 計算頻繁k-項集(k>1)
int k = 2;
while(true) {
Map<Set<String>, Float> freqKItemSetMap = this.getFreqKItemSet(k, freqKItemSet);
if(!freqKItemSetMap.isEmpty()) {
this.freqItemSet.put(k, freqKItemSetMap.keySet());
freqKItemSet = freqKItemSetMap.keySet();
}
else {
break;
}
k++;
}
}
/**
* <P>挖掘頻繁關聯規則
* <P>首先挖掘出全部的頻繁項集，在此基礎上挖掘頻繁關聯規則
*/
public void mineAssociationRules() {
freqItemSet.remove(1); // 刪除頻繁1-項集
Iterator<Map.Entry<Integer, Set<Set<String>>>> it = freqItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Integer, Set<Set<String>>> entry = it.next();
for(Set<String> itemSet : entry.getValue()) {
// 對每個頻繁項集進行關聯規則的挖掘
mine(itemSet);
}
}
}
/**
* 對從頻繁項集集合freqItemSet中每迭代出一個頻繁項集元素，執行一次關聯規則的挖掘
* @param itemSet 頻繁項集集合freqItemSet中的一個頻繁項集元素
*/
public void mine(Set<String> itemSet) {
int n = itemSet.size()/2; // 根據集合的對稱性，只需要得到一半的真子集
for(int i=1; i<=n; i++) {
// 得到頻繁項集元素itemSet的作為條件的真子集集合
Set<Set<String>> properSubset = ProperSubsetCombination.getProperSubset(i, itemSet);
// 對條件的真子集集合中的每個條件項集，獲取到對應的結論項集，從而進一步挖掘頻繁關聯規則
for(Set<String> conditionSet : properSubset) {
Set<String> conclusionSet = new HashSet<String>();
conclusionSet.addAll(itemSet);
conclusionSet.removeAll(conditionSet); // 刪除條件中存在的頻繁項
confide(conditionSet, conclusionSet); // 調用計算置信度的方法，並且挖掘出頻繁關聯規則
}
}
}
/**
* 對得到的一個條件項集和對應的結論項集，計算該關聯規則的支持計數，從而根據置信度判斷是否是頻繁關聯規則
* @param conditionSet 條件頻繁項集
* @param conclusionSet 結論頻繁項集
*/
public void confide(Set<String> conditionSet, Set<String> conclusionSet) {
// 掃描事務資料庫
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計關聯規則支持計數
int conditionToConclusionCnt = 0; // 關聯規則(條件項集推出結論項集)計數
int conclusionToConditionCnt = 0; // 關聯規則(結論項集推出條件項集)計數
int supCnt = 0; // 關聯規則支持計數
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Set<String> txSet = entry.getValue();
Set<String> set1 = new HashSet<String>();
Set<String> set2 = new HashSet<String>();
set1.addAll(conditionSet);
set1.removeAll(txSet); // 集合差運算：set-txSet
if(set1.isEmpty()) { // 如果set為空，說明事務資料庫中包含條件頻繁項conditionSet
// 計數
conditionToConclusionCnt++;
}
set2.addAll(conclusionSet);
set2.removeAll(txSet); // 集合差運算：set-txSet
if(set2.isEmpty()) { // 如果set為空，說明事務資料庫中包含結論頻繁項conclusionSet
// 計數
conclusionToConditionCnt++;
}
if(set1.isEmpty() && set2.isEmpty()) {
supCnt++;
}
}
// 計算置信度
Float conditionToConclusionConf = new Float(supCnt)/new Float(conditionToConclusionCnt);
if(conditionToConclusionConf>=minConf) {
if(assiciationRules.get(conditionSet) == null) { // 如果不存在以該條件頻繁項集為條件的關聯規則
Set<Set<String>> conclusionSetSet = new HashSet<Set<String>>();
conclusionSetSet.add(conclusionSet);
assiciationRules.put(conditionSet, conclusionSetSet);
}
else {
assiciationRules.get(conditionSet).add(conclusionSet);
}
}
Float conclusionToConditionConf = new Float(supCnt)/new Float(conclusionToConditionCnt);
if(conclusionToConditionConf>=minConf) {
if(assiciationRules.get(conclusionSet) == null) { // 如果不存在以該結論頻繁項集為條件的關聯規則
Set<Set<String>> conclusionSetSet = new HashSet<Set<String>>();
conclusionSetSet.add(conditionSet);
assiciationRules.put(conclusionSet, conclusionSetSet);
}
else {
assiciationRules.get(conclusionSet).add(conditionSet);
}
}
}
/**
* 經過挖掘得到的頻繁項集Map
*
* @return 挖掘得到的頻繁項集集合
*/
public Map<Integer, Set<Set<String>>> getFreqItemSet() {
return freqItemSet;
}
/**
* 獲取挖掘到的全部的頻繁關聯規則的集合
* @return 頻繁關聯規則集合
*/
public Map<Set<String>, Set<Set<String>>> getAssiciationRules() {
return assiciationRules;
}
}
（二）輔助類
ProperSubsetCombination類是一個輔助類，在挖掘頻繁關聯規則的過程中，用於生成一個頻繁項集元素的非空真子集，實現代碼如下：
package org.shirdrn.datamining.association;
import java.util.BitSet;
import java.util.HashSet;
import java.util.Set;
/**
* <B>求頻繁項集元素(集合)的非空真子集集合</B>
* <P>從一個集合（大小為n）中取出m(m屬於2~n/2的閉區間)個元素的組合實現類，獲取非空真子集的集合
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class ProperSubsetCombination {
private static String[] array;
private static BitSet startBitSet; // 比特集合起始狀態
private static BitSet endBitSet; // 比特集合終止狀態，用來控制循環
private static Set<Set<String>> properSubset; // 真子集集合
/**
* 計算得到一個集合的非空真子集集合
*
* @param n 真子集的大小
* @param itemSet 一個頻繁項集元素
* @return 非空真子集集合
*/
public static Set<Set<String>> getProperSubset(int n, Set<String> itemSet) {
String[] array = new String[itemSet.size()];
ProperSubsetCombination.array = itemSet.toArray(array);
properSubset = new HashSet<Set<String>>();
startBitSet = new BitSet();
endBitSet = new BitSet();
// 初始化startBitSet，左側占滿1
for (int i=0; i<n; i++) {
startBitSet.set(i, true);
}
// 初始化endBit，右側占滿1
for (int i=array.length-1; i>=array.length-n; i--) {
endBitSet.set(i, true);
}
// 根據起始startBitSet，將一個組合加入到真子集集合中
get(startBitSet);
while(!startBitSet.equals(endBitSet)) {
int zeroCount = 0; // 統計遇到10後，左邊0的個數
int oneCount = 0; // 統計遇到10後，左邊1的個數
int pos = 0; // 記錄當前遇到10的索引位置
// 遍歷startBitSet來確定10出現的位置
for (int i=0; i<array.length; i++) {
if (!startBitSet.get(i)) {
zeroCount++;
}
if (startBitSet.get(i) && !startBitSet.get(i+1)) {
pos = i;
oneCount = i - zeroCount;
// 將10變為01
startBitSet.set(i, false);
startBitSet.set(i+1, true);
break;
}
}
// 將遇到10後，左側的1全部移動到最左側
int counter = Math.min(zeroCount, oneCount);
int startIndex = 0;
int endIndex = 0;
if(pos>1 && counter>0) {
pos--;
endIndex = pos;
for (int i=0; i<counter; i++) {
startBitSet.set(startIndex, true);
startBitSet.set(endIndex, false);
startIndex = i+1;
pos--;
if(pos>0) {
endIndex = pos;
}
}
}
get(startBitSet);
}
return properSubset;
}
/**
* 根據一次移位操作得到的startBitSet，得到一個真子集
* @param bitSet
*/
private static void get(BitSet bitSet) {
Set<String> set = new HashSet<String>();
for(int i=0; i<array.length; i++) {
if(bitSet.get(i)) {
set.add(array[i]);
}
}
properSubset.add(set);
}
}
測試用例
對上述Apriori演算法的實現進行了簡單的測試，測試用例如下所示：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.shirdrn.datamining.association.AprioriAlgorithm;
import junit.framework.TestCase;
/**
* <B>Apriori演算法測試類</B>
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class TestAprioriAlgorithm extends TestCase {
private AprioriAlgorithm apriori;
private Map<Integer, Set<String>> txDatabase;
private Float minSup = new Float("0.50");
private Float minConf = new Float("0.70");
@Override
protected void setUp() throws Exception {
create(); // 構造事務資料庫
apriori = new AprioriAlgorithm(txDatabase, minSup, minConf);
}
/**
* 構造模擬事務資料庫txDatabase
*/
public void create() {
txDatabase = new HashMap<Integer, Set<String>>();
Set<String> set1 = new TreeSet<String>();
set1.add("A");
set1.add("B");
set1.add("C");
set1.add("E");
txDatabase.put(1, set1);
Set<String> set2 = new TreeSet<String>();
set2.add("A");
set2.add("B");
set2.add("C");
txDatabase.put(2, set2);
Set<String> set3 = new TreeSet<String>();
set3.add("C");
set3.add("D");
txDatabase.put(3, set3);
Set<String> set4 = new TreeSet<String>();
set4.add("A");
set4.add("B");
set4.add("E");
txDatabase.put(4, set4);
}
/**
* 測試挖掘頻繁1-項集
*/
public void testFreq1ItemSet() {
System.out.println("挖掘頻繁1-項集 : " + apriori.getFreq1ItemSet());
}
/**
* 測試aprioriGen方法，生成候選頻繁項集
*/
public void testAprioriGen() {
System.out.println(
"候選頻繁2-項集 ： " +
this.apriori.aprioriGen(1, this.apriori.getFreq1ItemSet().keySet())
);
}
/**
* 測試挖掘頻繁2-項集
*/
public void testGetFreq2ItemSet() {
System.out.println(
"挖掘頻繁2-項集 ：" +
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet())
);
}
/**
* 測試挖掘頻繁3-項集
*/
public void testGetFreq3ItemSet() {
System.out.println(
"挖掘頻繁3-項集 ：" +
this.apriori.getFreqKItemSet(
3,
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet()).keySet()
)
);
}
/**
* 測試挖掘全部頻繁項集
*/
public void testGetFreqItemSet() {
this.apriori.mineFreqItemSet(); // 挖掘頻繁項集
System.out.println("挖掘頻繁項集 ：" + this.apriori.getFreqItemSet());
}
/**
* 測試挖掘全部頻繁關聯規則
*/
public void testMineAssociationRules() {
this.apriori.mineFreqItemSet(); // 挖掘頻繁項集
this.apriori.mineAssociationRules();
System.out.println("挖掘頻繁關聯規則 ：" + this.apriori.getAssiciationRules());
}
}
測試結果：
挖掘頻繁1-項集 : {[E]=0.5, [A]=0.75, [B]=0.75, [C]=0.75}
候選頻繁2-項集 ： [[E, C], [A, B], [B, C], [A, C], [E, B], [E, A]]
挖掘頻繁2-項集 ：{[A, B]=0.75, [B, C]=0.5, [A, C]=0.5, [E, B]=0.5, [E, A]=0.5}
挖掘頻繁3-項集 ：{[E, A, B]=0.5, [A, B, C]=0.5}
挖掘頻繁項集 ：{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}
挖掘頻繁關聯規則 ：{[E]=[[A], [B], [A, B]], [A]=[[B]], [B]=[[A]], [B, C]=[[A]], [A, C]=[[B]], [E, B]=[[A]], [E, A]=[[B]]}
從測試結果看到，使用Apriori演算法挖掘得到的全部頻繁項集為：
{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}
使用Apriori演算法挖掘得到的全部頻繁關聯規則為：
{E}→{A}、{E}→{B}、{E}→{A,B}、{A}→{B}、{B}→{A}、{B,C}→{A}、{A,C}→{B}、{B,E}→{A}、{A,E}→{B}。
㈢ 怎麼用java實現apriori演算法
作者：何史提
鏈接：https://www.hu.com/question/22590018/answer/26646688
來源：知乎
著作權歸作者所有。商業轉載請聯系作者獲得授權，非商業轉載請註明出處。
Apriori演算法的理念其實很簡單，可是實現起上來卻復雜無比，因為當中無可避免用Set和Hash Table等高階的數據結構，而且有很多loop用以讀取數據。
我不建議用Java，應改用Python或Scala一類的語言。如果用Python，代碼大概50行左右，但可以想像用Java便看起來復雜得多。看如下：
from operator import and_
from itertools import combinations
class 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: rece(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])
㈣ 大數據分析工具詳盡介紹&數據分析演算法
大數據分析工具詳盡介紹&數據分析演算法
1、 Hadoop
Hadoop 是一個能夠對大量數據進行分布式處理的軟體框架。但是 Hadoop 是以一種可靠、高效、可伸縮的方式進行處理的。Hadoop 是可靠的，因為它假設計算元素和存儲會失敗，因此它維護多個工作數據副本，確保能夠針對失敗的節點重新分布處理。Hadoop 是高效的，因為它以並行的方式工作，通過並行處理加快處理速度。Hadoop 還是可伸縮的，能夠處理 PB 級數據。此外，Hadoop 依賴於社區伺服器，因此它的成本比較低，任何人都可以使用。
Hadoop是一個能夠讓用戶輕松架構和使用的分布式計算平台。用戶可以輕松地在Hadoop上開發和運行處理海量數據的應用程序。它主要有以下幾個優點：
⒈高可靠性。Hadoop按位存儲和處理數據的能力值得人們信賴。
⒉高擴展性。Hadoop是在可用的計算機集簇間分配數據並完成計算任務的，這些集簇可以方便地擴展到數以千計的節點中。
⒊高效性。Hadoop能夠在節點之間動態地移動數據，並保證各個節點的動態平衡，因此處理速度非常快。
⒋高容錯性。Hadoop能夠自動保存數據的多個副本，並且能夠自動將失敗的任務重新分配。
Hadoop帶有用 Java 語言編寫的框架，因此運行在 Linux 生產平台上是非常理想的。Hadoop 上的應用程序也可以使用其他語言編寫，比如 C++。
2、 HPCC
HPCC，High Performance Computing and Communications（高性能計算與通信）的縮寫。1993年，由美國科學、工程、技術聯邦協調理事會向國會提交了「重大挑戰項目：高性能計算與 通信」的報告，也就是被稱為HPCC計劃的報告，即美國總統科學戰略項目，其目的是通過加強研究與開發解決一批重要的科學與技術挑戰問題。HPCC是美國 實施信息高速公路而上實施的計劃，該計劃的實施將耗資百億美元，其主要目標要達到：開發可擴展的計算系統及相關軟體，以支持太位級網路傳輸性能，開發千兆 比特網路技術，擴展研究和教育機構及網路連接能力。
該項目主要由五部分組成：
1、高性能計算機系統（HPCS），內容包括今後幾代計算機系統的研究、系統設計工具、先進的典型系統及原有系統的評價等；
2、先進軟體技術與演算法（ASTA），內容有巨大挑戰問題的軟體支撐、新演算法設計、軟體分支與工具、計算計算及高性能計算研究中心等；
3、國家科研與教育網格（NREN），內容有中接站及10億位級傳輸的研究與開發；
4、基本研究與人類資源（BRHR），內容有基礎研究、培訓、教育及課程教材，被設計通過獎勵調查者-開始的，長期 的調查在可升級的高性能計算中來增加創新意識流，通過提高教育和高性能的計算訓練和通信來加大熟練的和訓練有素的人員的聯營，和來提供必需的基礎架構來支 持這些調查和研究活動；
5、信息基礎結構技術和應用（IITA ），目的在於保證美國在先進信息技術開發方面的領先地位。
3、 Storm
Storm是自由的開源軟體，一個分布式的、容錯的實時計算系統。Storm可以非常可靠的處理龐大的數據流，用於處理Hadoop的批量數據。Storm很簡單，支持許多種編程語言，使用起來非常有趣。Storm由Twitter開源而來，其它知名的應用企業包括Groupon、淘寶、支付寶、阿里巴巴、樂元素、Admaster等等。
Storm有許多應用領域：實時分析、在線機器學習、不停頓的計算、分布式RPC（遠過程調用協議，一種通過網路從遠程計算機程序上請求服務）、 ETL（Extraction-Transformation-Loading的縮寫，即數據抽取、轉換和載入）等等。Storm的處理速度驚人：經測 試，每個節點每秒鍾可以處理100萬個數據元組。Storm是可擴展、容錯，很容易設置和操作。
4、 Apache Drill
為了幫助企業用戶尋找更為有效、加快Hadoop數據查詢的方法，Apache軟體基金會近日發起了一項名為「Drill」的開源項目。Apache Drill 實現了 Google』s Dremel.
據Hadoop廠商MapR Technologies公司產品經理Tomer Shiran介紹，「Drill」已經作為Apache孵化器項目來運作，將面向全球軟體工程師持續推廣。
該項目將會創建出開源版本的谷歌Dremel Hadoop工具（谷歌使用該工具來為Hadoop數據分析工具的互聯網應用提速）。而「Drill」將有助於Hadoop用戶實現更快查詢海量數據集的目的。
「Drill」項目其實也是從谷歌的Dremel項目中獲得靈感：該項目幫助谷歌實現海量數據集的分析處理，包括分析抓取Web文檔、跟蹤安裝在Android Market上的應用程序數據、分析垃圾郵件、分析谷歌分布式構建系統上的測試結果等等。
通過開發「Drill」Apache開源項目，組織機構將有望建立Drill所屬的API介面和靈活強大的體系架構，從而幫助支持廣泛的數據源、數據格式和查詢語言。
5、 RapidMiner
RapidMiner是世界領先的數據挖掘解決方案，在一個非常大的程度上有著先進技術。它數據挖掘任務涉及范圍廣泛，包括各種數據藝術，能簡化數據挖掘過程的設計和評價。
功能和特點
免費提供數據挖掘技術和庫
100%用Java代碼（可運行在操作系統）
數據挖掘過程簡單，強大和直觀
內部XML保證了標准化的格式來表示交換數據挖掘過程
可以用簡單腳本語言自動進行大規模進程
多層次的數據視圖，確保有效和透明的數據
圖形用戶界面的互動原型
命令行（批處理模式）自動大規模應用
Java API（應用編程介面）
簡單的插件和推廣機制
強大的可視化引擎，許多尖端的高維數據的可視化建模
400多個數據挖掘運營商支持
耶魯大學已成功地應用在許多不同的應用領域，包括文本挖掘，多媒體挖掘，功能設計，數據流挖掘，集成開發的方法和分布式數據挖掘。
6、 Pentaho BI
Pentaho BI 平台不同於傳統的BI 產品，它是一個以流程為中心的，面向解決方案（Solution）的框架。其目的在於將一系列企業級BI產品、開源軟體、API等等組件集成起來，方便商務智能應用的開發。它的出現，使得一系列的面向商務智能的獨立產品如Jfree、Quartz等等，能夠集成在一起，構成一項項復雜的、完整的商務智能解決方案。
Pentaho BI 平台，Pentaho Open BI 套件的核心架構和基礎，是以流程為中心的，因為其中樞控制器是一個工作流引擎。工作流引擎使用流程定義來定義在BI 平台上執行的商業智能流程。流程可以很容易的被定製，也可以添加新的流程。BI 平台包含組件和報表，用以分析這些流程的性能。目前，Pentaho的主要組成元素包括報表生成、分析、數據挖掘和工作流管理等等。這些組件通過 J2EE、WebService、SOAP、HTTP、Java、JavaScript、Portals等技術集成到Pentaho平台中來。 Pentaho的發行，主要以Pentaho SDK的形式進行。
Pentaho SDK共包含五個部分：Pentaho平台、Pentaho示例資料庫、可獨立運行的Pentaho平台、Pentaho解決方案示例和一個預先配製好的 Pentaho網路伺服器。其中Pentaho平台是Pentaho平台最主要的部分，囊括了Pentaho平台源代碼的主體；Pentaho資料庫為 Pentaho平台的正常運行提供的數據服務，包括配置信息、Solution相關的信息等等，對於Pentaho平台來說它不是必須的，通過配置是可以用其它資料庫服務取代的；可獨立運行的Pentaho平台是Pentaho平台的獨立運行模式的示例，它演示了如何使Pentaho平台在沒有應用伺服器支持的情況下獨立運行；
Pentaho解決方案示例是一個Eclipse工程，用來演示如何為Pentaho平台開發相關的商業智能解決方案。
Pentaho BI 平台構建於伺服器，引擎和組件的基礎之上。這些提供了系統的J2EE 伺服器，安全，portal，工作流，規則引擎，圖表，協作，內容管理，數據集成，分析和建模功能。這些組件的大部分是基於標準的，可使用其他產品替換之。
7、 SAS Enterprise Miner
§ 支持整個數據挖掘過程的完備工具集
§ 易用的圖形界面,適合不同類型的用戶快速建模
§ 強大的模型管理和評估功能
§ 快速便捷的模型發布機制, 促進業務閉環形成
數據分析演算法
大數據分析主要依靠機器學習和大規模計算。機器學習包括監督學習、非監督學習、強化學習等，而監督學習又包括分類學習、回歸學習、排序學習、匹配學習等（見圖1）。分類是最常見的機器學習應用問題，比如垃圾郵件過濾、人臉檢測、用戶畫像、文本情感分析、網頁歸類等，本質上都是分類問題。分類學習也是機器學習領域，研究最徹底、使用最廣泛的一個分支。
最近、Fernández-Delgado等人在JMLR（Journal of Machine Learning Research，機器學習頂級期刊）雜志發表了一篇有趣的論文。他們讓179種不同的分類學習方法（分類學習演算法）在UCI 121個數據集上進行了「大比武」（UCI是機器學習公用數據集，每個數據集的規模都不大）。結果發現Random Forest（隨機森林）和SVM（支持向量機）名列第一、第二名，但兩者差異不大。在84.3%的數據上、Random Forest壓倒了其它90%的方法。也就是說，在大多數情況下，只用Random Forest 或 SVM事情就搞定了。
KNN
K最近鄰演算法。給定一些已經訓練好的數據，輸入一個新的測試數據點，計算包含於此測試數據點的最近的點的分類情況，哪個分類的類型佔多數，則此測試點的分類與此相同，所以在這里,有的時候可以復制不同的分類點不同的權重。近的點的權重大點，遠的點自然就小點。詳細介紹鏈接
Naive Bayes
樸素貝葉斯演算法。樸素貝葉斯演算法是貝葉斯演算法裡面一種比較簡單的分類演算法，用到了一個比較重要的貝葉斯定理，用一句簡單的話概括就是條件概率的相互轉換推導。詳細介紹鏈接
樸素貝葉斯分類是一種十分簡單的分類演算法，叫它樸素貝葉斯分類是因為這種方法的思想真的很樸素，樸素貝葉斯的思想基礎是這樣的：對於給出的待分類項，求解在此項出現的條件下各個類別出現的概率，哪個最大，就認為此待分類項屬於哪個類別。通俗來說，就好比這么個道理，你在街上看到一個黑人，我問你你猜這哥們哪裡來的，你十有八九猜非洲。為什麼呢？因為黑人中非洲人的比率最高，當然人家也可能是美洲人或亞洲人，但在沒有其它可用信息下，我們會選擇條件概率最大的類別，這就是樸素貝葉斯的思想基礎。
SVM
支持向量機演算法。支持向量機演算法是一種對線性和非線性數據進行分類的方法，非線性數據進行分類的時候可以通過核函數轉為線性的情況再處理。其中的一個關鍵的步驟是搜索最大邊緣超平面。詳細介紹鏈接
Apriori
Apriori演算法是關聯規則挖掘演算法，通過連接和剪枝運算挖掘出頻繁項集，然後根據頻繁項集得到關聯規則，關聯規則的導出需要滿足最小置信度的要求。詳細介紹鏈接
PageRank
網頁重要性/排名演算法。PageRank演算法最早產生於Google,核心思想是通過網頁的入鏈數作為一個網頁好快的判定標准，如果1個網頁內部包含了多個指向外部的鏈接，則PR值將會被均分，PageRank演算法也會遭到LinkSpan攻擊。詳細介紹鏈接
RandomForest
隨機森林演算法。演算法思想是決策樹+boosting.決策樹採用的是CART分類回歸數,通過組合各個決策樹的弱分類器,構成一個最終的強分類器,在構造決策樹的時候採取隨機數量的樣本數和隨機的部分屬性進行子決策樹的構建,避免了過分擬合的現象發生。詳細介紹鏈接
Artificial Neural Network
「神經網路」這個詞實際是來自於生物學，而我們所指的神經網路正確的名稱應該是「人工神經網路（ANNs）」。
人工神經網路也具有初步的自適應與自組織能力。在學習或訓練過程中改變突觸權重值，以適應周圍環境的要求。同一網路因學習方式及內容不同可具有不同的功能。人工神經網路是一個具有學習能力的系統，可以發展知識，以致超過設計者原有的知識水平。通常，它的學習訓練方式可分為兩種，一種是有監督或稱有導師的學習，這時利用給定的樣本標准進行分類或模仿；另一種是無監督學習或稱無為導師學習，這時，只規定學習方式或某些規則，則具體的學習內容隨系統所處環境 （即輸入信號情況）而異，系統可以自動發現環境特徵和規律性，具有更近似人腦的功能。
㈤ apriori演算法是什麼
經典的關聯規則挖掘演算法包括Apriori演算法和FP-growth演算法。
apriori演算法多次掃描交易資料庫，每次利用候選頻繁集產生頻繁集；而FP-growth則利用樹形結構，無需產生候選頻繁集而是直接得到頻繁集，大大減少掃描交易資料庫的次數，從而提高了演算法的效率，但是apriori的演算法擴展性較好，可以用於並行計算等領域。
基本演算法：
Apriori algorithm是關聯規則里一項基本演算法
Apriori演算法將發現關聯規則的過程分：
第一通過迭代，檢索出事務資料庫1中的所有頻繁項集，即支持度不低於用戶設定的閾值的項集；
第二利用頻繁項集構造出滿足用戶最小信任度的規則。其中，挖掘或識別出所有頻繁項集是該演算法的核心，占整個計算量的大部分。
㈥ 怎麼用java實現apriori演算法
fromoperatorimportand_:
def__init__(self,inputfile):
self.transactions=[]
self.itemSet=set([])
inf=open(inputfile,'rb')
forlineininf.readlines():
elements=set(filter(lambdaentry:len(entry)>0,line.strip().split(',')))
iflen(elements)>0:
self.transactions.append(elements)
forelementinelements:
self.itemSet.add(element)
inf.close()
self.toRetItems={}
self.associationRules=[]
defgetSupport(self,itemcomb):
iftype(itemcomb)!=frozenset:
itemcomb=frozenset([itemcomb])
within_transaction=lambdatransaction:rece(and_,[(itemintransaction)foriteminitemcomb])
count=len(filter(within_transaction,self.transactions))
returnfloat(count)/float(len(self.transactions))
defrunApriori(self,minSupport=0.15,minConfidence=0.6):
itemCombSupports=filter(lambdafreqpair:freqpair[1]>=minSupport,
map(lambdaitem:(frozenset([item]),self.getSupport(item)),self.itemSet))
currentLset=set(map(lambdafreqpair:freqpair[0],itemCombSupports))
k=2
whilelen(currentLset)>0:
currentCset=set([i.union(j)(i.union(j))==k])
currentItemCombSupports=filter(lambdafreqpair:freqpair[1]>=minSupport,
map(lambdaitem:(item,self.getSupport(item)),currentCset))
currentLset=set(map(lambdafreqpair:freqpair[0],currentItemCombSupports))
itemCombSupports.extend(currentItemCombSupports)
k+=1
forkey,supportValinitemCombSupports:
self.toRetItems[key]=supportVal
self.calculateAssociationRules(minConfidence=minConfidence)
defcalculateAssociationRules(self,minConfidence=0.6):
forkeyinself.toRetItems:
subsets=[frozenset(item)forkinrange(1,len(key))foritemincombinations(key,k)]
forsubsetinsubsets:
confidence=self.toRetItems[key]/self.toRetItems[subset]
ifconfidence>minConfidence:
self.associationRules.append([subset,key-subset,confidence])
用Scala也大概六十多行：
importscala.io.Sourceimportscala.collection.immutable.Listimportscala.collection.immutable.Setimportjava.io.Fileimportscala.collection.mutable.MapclassAprioriAlgorithm(inputFile:File){
vartransactions:List[Set[String]]=List()
varitemSet:Set[String]=Set()
for(line<-Source.fromFile(inputFile).getLines()){
valelementSet=line.trim.split(',').toSet
if(elementSet.size>0){
transactions=transactions:+elementSet
itemSet=itemSet++elementSet
}
}
vartoRetItems:Map[Set[String],Double]=Map()
varassociationRules:List[(Set[String],Set[String],Double)]=List()
defgetSupport(itemComb:Set[String]):Double={
defwithinTransaction(transaction:Set[String]):Boolean=itemComb
.map(x=>transaction.contains(x))
.receRight((x1,x2)=>x1&&x2)
valcount=transactions.filter(withinTransaction).size
count.toDouble/transactions.size.toDouble
}
defrunApriori(minSupport:Double=0.15,minConfidence:Double=0.6)={
varitemCombs=itemSet.map(word=>(Set(word),getSupport(Set(word))))
.filter(wordSupportPair=>(wordSupportPair._2>minSupport))
varcurrentLSet:Set[Set[String]]=itemCombs.map(wordSupportPair=>wordSupportPair._1).toSet
vark:Int=2
while(currentLSet.size>0){
valcurrentCSet:Set[Set[String]]=currentLSet.map(wordSet=>currentLSet.map(wordSet1=>wordSet|wordSet1))
.receRight((set1,set2)=>set1|set2)
.filter(wordSet=>(wordSet.size==k))
valcurrentItemCombs=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<-itemCombs){
toRetItems+=(itemComb._1->itemComb._2)
}
calculateAssociationRule(minConfidence)
}
defcalculateAssociationRule(minConfidence:Double=0.6)={
toRetItems.keys.foreach(item=>
item.subsets.filter(wordSet=>(wordSet.size<item.size&wordSet.size>0))
.foreach(subset=>{associationRules=associationRules:+(subset,itemdiffsubset,
toRetItems(item).toDouble/toRetItems(subset).toDouble)
}
)
)
associationRules=associationRules.filter(rule=>rule._3>minConfidence)
}}
我不建議用Java，應改用Python或Scala一類的語言。如果用Python，代碼大概50行左右，但可以想像用Java便看起來復雜得多。看如下：