步步為營KDD：FP-Growth算法

2020-04-02 23:25:20 老李頭的小研究

Apriori算法的缺陷

雖然Apriori算法使用先驗性質去除了很多的候選項集，但Apriori算法還是有兩個大問題：

1.可能產生大量的候選項集。例如，當頻繁1項集的個數達到1000個時，產生的候選2項集的個數達到C(2,1000)。C(2,1000) = 1000! / (2! * 9998!) = (1000 * 999 * 998!) / (2 * 998!) = (1000 * 999) / 2 = 499500。這還只是由頻繁1項集獲取候選2項集產生的項集個數。

2.可能需要多次迭代數據庫。在每次獲取候選項集後都需要迭代數據庫，獲取支持度計數。

FP-Growth

為此，Han JiaWei 提出了一個不需要產生候選項集的算法：FP-Growth。

FP-Growth算法主要分2步：先將所有數據庫事務壓縮到一個樹結構(FP-Tree)中，該結構保留了項與項之間的關聯信息；然後對樹結構進行挖掘。

以下是詳細過程：

1.創建FP-Tree

1.1遍歷數據庫（第1次），獲取所有頻繁1項集及其支持度計數，將頻繁1項集按遞減支持度計數排列。

1.2首先創建值為null的根節點，然後遍歷數據庫（第2次），將每個事務中的項集按頻繁1項集的順序排列（按遞減支持度計數排列），將排序後的最大支持度的項作為null根節點的子節點，將第2項作為第1項的子節點，以此類推。如果是創建新節點則設置新節點的SupportCount等於1，同時讓項頭表（ItemHeaderTable）記住該節點的地址；如果路徑中的節點已經存在，則讓該節點的SupportCount遞增1。最終形成具有項關聯信息的FP-Tree和完整的項頭表。

2.挖掘FP-Tree

2.1挖掘FP-Tree的主要思想就是讓項頭表中的每一個項與後綴模式合併形成新的模式，創建該項的子樹和與子樹對應的子項頭表，然後讓子項頭表中的每一個項與後綴模式（即上層遞歸形成的新模式）合併形成新的模式，創建該項的子子樹和與子子樹對應的子子項頭表。如此遞歸下去，直到無法形成樹為止。每層遞歸都會讓項頭表中的項與後綴模式（suffixpattern）合併成新的模式，新的模式將作為下層遞歸的後綴模式，這就是算法名稱中的“Growth”。針對只有單一路徑的樹，則可以對樹中的所有節點進行組合形成新的模式，提升算法性能。

代碼實現

以下是FP-Growth的C++實現，只貼出FP-Growth算法的核心部分：

FPGrowth.h：

<code>#ifndef ILANEVER_PATTERN_FPGROWTH_H
#define ILANEVER_PATTERN_FPGROWTH_H

#include <iostream>
#include <memory>
#include 
#include <vector>

using namespace std;

namespace ilanever 

{
    namespace pattern
    {
        class ItemSet;
        class ItemSetList;
        class TransactionList;
        class ItemHeader;
        class ItemHeaderTable;
        class TreeNode;
        class TreeNodePtrList;
        class FPGrowth
        {
        public:
            FPGrowth(TransactionList& trans, int min_sup);
        
        public:
            /*
                get the map of frequent itemsets.
                key: k
                value: frequent itemsets.
            */
            map& get_frequent_itemsets();
        
        private:
            /*
                get frequent 1 itemsets.
            */
            ItemSetList* get_frequent_1_itemsets();
            
            /*
                get table of ItemHeader from frequents 1 itemsets.
            */
            ItemHeaderTable* get_item_header_table(ItemSetList* p_frequents_1_itemsets);
            /*
                get the fp tree.
            */
            TreeNode* get_FPTree(ItemHeaderTable* headerTable,ItemSetList* sortedFrequents);
            /*
                @<tree> the entire tree or the conditional tree.
                @<headertable> the item header table cosrespond to tree.
                @<suffixpattern> suffixpattern is null when the tree is entire tree, 
                    pattern is suffixpattern when the tree is conditional tree.
            */
            void fp_growth(TreeNode* tree,ItemHeaderTable* headerTable, ItemSet* suffixpattern);
            /*
                get patterns from the tree when the tree has only one path.
            */
            ItemSetList* get_patterns_from_singlepath_tree(TreeNode* tree, ItemSet* suffixpattern);
            /* 

                get condition pattern base.
            */
            vector<treenodeptrlist> get_condition_patternbase(ItemHeader* itemHeader);
            /*
                get condition item header table.
            */
            ItemHeaderTable* get_condition_headertable(vector<treenodeptrlist> patternbase);
            /*
                get condition FPTree.
            */
            TreeNode* get_condition_FPTree
                (vector<treenodeptrlist>& conditionPatternBase, ItemHeaderTable& headerTable);
            /*
                prune the tree branches and table items.
            */
            void prune_tree_and_table(TreeNode* tree, ItemHeaderTable& headerTable);
            
        private:
            // all transactions in database.
            TransactionList& tranList;
            // absolute minimum support. 
            int min_sup;
            // map of frequents
            map map_frequents;
            
        };
    }
}

#endif/<treenodeptrlist>/<treenodeptrlist>/<treenodeptrlist>/<suffixpattern>/<headertable>/<tree>/<vector>/<memory>/<iostream>/<code>

FPGrowth.cpp:

<code>#include "FPGrowth.h"
#include <memory>
#include 
#include <iostream>
#include <vector>
#include "models/ItemSet.h" 

#include "models/ItemSetList.h"
#include "models/TransactionList.h"
#include "models/ItemHeader.h"
#include "models/ItemHeaderTable.h"
#include "models/ItemSetSorter.h"
#include "models/TreeNode.h"
#include "models/TreeNodePtrList.h"
#include "../utils/set_utils.h"

namespace ilanever
{
    namespace pattern
    {
        FPGrowth::FPGrowth(TransactionList& trans, int min_sup):
            tranList(trans),min_sup(min_sup)
        {}
        
        map& FPGrowth::get_frequent_itemsets()
        {
            // get frequent 1 itemsets.
            ItemSetList* frequent_1_itemsets = this->get_frequent_1_itemsets();
            // sort by support count.
            ItemSetSorterBySupportCount<:iterator> sorter;
            sorter.sort(frequent_1_itemsets->begin(), frequent_1_itemsets->end());
            // init map
            for(int i = 1; i <= frequent_1_itemsets->size(); ++i)
            {
                this->map_frequents.insert(pair(i, new ItemSetList()));
            }
            // get item header table.
            ItemHeaderTable* headerTable = this->get_item_header_table(frequent_1_itemsets);
            // get FP tree.
            TreeNode* fptree = this->get_FPTree(headerTable, frequent_1_itemsets);
            // execute FP-Growth mining.
            this->fp_growth(fptree, headerTable ,nullptr);
            return this->map_frequents;
        }
        
        void FPGrowth::fp_growth(TreeNode* tree, ItemHeaderTable* headerTable, ItemSet* suffixpattern)
        {
            if(isSinglePath(tree))
            {
                ItemSetList* patterns = this->get_patterns_from_singlepath_tree(tree, suffixpattern);
                for(ItemSet set : *patterns)
                {
                    this->map_frequents[set.size()]->push_back(set);
                } 

            }
            else
            {
                for(auto begin = headerTable->rbegin(); begin != headerTable->rend(); ++begin)
                {
                    ItemHeader* header = *begin;
                    ItemSet* pattern = new ItemSet({header->item}); 
                    if(suffixpattern != nullptr)
                    {
                        for(auto begin = suffixpattern->begin(); begin != suffixpattern->end(); ++begin)
                        {
                            pattern->push_back(*begin);
                        }
                    }
                    pattern->support_count = header->supportCount;
                    this->map_frequents[pattern->size()]->push_back(*pattern);
                    
                    // get condition pattern base.
                    vector<treenodeptrlist> conditionPatternBase = this->get_condition_patternbase(header);
                    // get condition header table.
                    ItemHeaderTable* conditionHeaderTable = this->get_condition_headertable(conditionPatternBase);
                    // get condition FPTree.
                    TreeNode* conditionFPTree = this->get_condition_FPTree(conditionPatternBase, *conditionHeaderTable);
                    // prune tree and table.
                    this->prune_tree_and_table(conditionFPTree, *conditionHeaderTable);
                    
                    if(conditionFPTree->children->size() > 0)
                    {
                        this->fp_growth(conditionFPTree, conditionHeaderTable, pattern);
                    }
                }
            }
        }
        
        void FPGrowth::prune_tree_and_table(TreeNode* tree, ItemHeaderTable& headerTable)
        {
            vector<:iterator> toDelHeaders;
            for(auto begin = headerTable.begin(); begin != headerTable.end(); ++begin)
            {
                ItemHeader* header = *begin;
                if(header->supportCount < this->min_sup)
                {
                    toDelHeaders.push_back(begin);
                    for(TreeNode* node : *(header->nodes))
                    {
                        if(node->parent != nullptr)
                        {
                            node->parent->children->remove(node->value);
                        } 

                    }
                }
            }
            for(auto& iter : toDelHeaders)
            {
                headerTable.erase(iter);
            }
        }
        
        TreeNode* FPGrowth::get_condition_FPTree
            (vector<treenodeptrlist>& conditionPatternBase, ItemHeaderTable& headerTable)
        {
            TreeNode* root = new TreeNode("");
            for(TreeNodePtrList* treeNodes : conditionPatternBase)
            {
                TreeNode* parent = root;
                for(TreeNode* treeNode : *treeNodes)
                {
                    TreeNode* found = nullptr;
                    if(parent->children->contains(treeNode->value))
                    {
                        found = parent->children->get(treeNode->value);
                        found->passedtimes += treeNode->passedtimes;
                    }
                    else
                    {
                        found = new TreeNode(treeNode->value, treeNode->passedtimes, parent);
                        parent->children->push_back(found);
                    }
                    headerTable.get(treeNode->value)->nodes->push_back(found);
                    parent = found;
                }
            }
            return root;
        }
        
        ItemHeaderTable* FPGrowth::get_condition_headertable(vector<treenodeptrlist> patternbase)
        {
            ItemHeaderTable* headerTable = new ItemHeaderTable();
            for(TreeNodePtrList* nodes : patternbase)
            {
                for(TreeNode* node : *nodes)
                {
                    if(!headerTable->contains(node->value))
                    {
                        ItemHeader* header = new ItemHeader(node->value, node->passedtimes);
                        headerTable->push_back(header);
                    }
                    else
                    { 

                        ItemHeader* header = headerTable->get(node->value);
                        header->supportCount = header->supportCount + node->passedtimes;
                    }
                }
            }
            return headerTable;
        }
        
        vector<treenodeptrlist> FPGrowth::get_condition_patternbase(ItemHeader* itemHeader)
        {
            vector<treenodeptrlist> conditionPatternBase;
            for(TreeNode* node : *(itemHeader->nodes))
            {
                TreeNodePtrList* conditionPattern = new TreeNodePtrList();
                TreeNode* parent = node->parent;
                while(parent != nullptr && !parent->isRoot())
                {
                    TreeNode* ptnNode = new TreeNode(parent->value, node->passedtimes);
                    conditionPattern->insert(conditionPattern->begin(), ptnNode);
                    parent = parent->parent;
                }
                conditionPatternBase.push_back(conditionPattern);
            }
            return conditionPatternBase;
        }
        
        ItemSetList* FPGrowth::get_patterns_from_singlepath_tree(TreeNode* tree, ItemSet* suffixpattern)
        {
            ItemSetList* patterns = new ItemSetList();
            
            // get all nodes in the tree.
            TreeNodePtrList* allnodes = new TreeNodePtrList();
            TreeNode* node = tree;
            while(node->children->size() == 1)
            {
                TreeNode* child = (*node->children)[0];
                if(child->passedtimes >= this->min_sup)
                {
                    allnodes->push_back(child);
                    node = child;
                }
                else
                {
                    break;
                }
            }
            // get subsets.
            vector<vector>*> subsets = ilanever::utils::get_subsets<treenode>(*allnodes);
            // combine patterns.
            for(vector<treenode>* subset : subsets) 

            {
                if(subset->size() != 0)
                {
                    ItemSet* pattern = new ItemSet();
                    int supportcount = -1;
                    for(TreeNode* node : *subset)
                    {
                        if(supportcount == -1) 
                        {
                            supportcount = node->passedtimes;
                        }
                        else if(node->passedtimes < supportcount)
                        {
                            supportcount = node->passedtimes;
                        }
                        pattern->push_back(node->value);
                    }
                    pattern->support_count = supportcount;
                    // add suffix pattern.
                    for(auto beg = suffixpattern->begin(); beg != suffixpattern->end(); ++beg)
                    {
                        pattern->push_back(*beg);
                    }
                    patterns->push_back(*pattern);
                }
            }
            return patterns;
        }
        
        TreeNode* FPGrowth::get_FPTree(ItemHeaderTable* headerTable,ItemSetList* sortedFrequents)
        {
            TreeNode* root = new TreeNode("");
            for(auto begin = this->tranList.begin(); begin != this->tranList.end(); ++begin)
            {
                // get pruned and sorted set of the transaction.
                ItemSet sortedSet;
                ItemSet setOfTran = begin->getItemSet();
                for(auto beg = sortedFrequents->begin(); beg != sortedFrequents->end(); ++beg)
                {
                    string item = (*beg)[0];
                    for(auto b = setOfTran.begin(); b != setOfTran.end(); ++b)
                    {
                        if(*b == item)
                        {
                            sortedSet.push_back(*b);
                            break;
                        }
                    }
                }
                 

                // build tree.
                TreeNode* parent = root;
                for(string& item : sortedSet)
                {
                    if(parent->children != nullptr && parent->children->contains(item))
                    {
                        TreeNode* child = parent->children->get(item);
                        ++(child->passedtimes);
                        parent = child;
                    }
                    else
                    {
                        TreeNode* child = new TreeNode(item,1,parent);
                        parent->children->push_back(child);
                        ItemHeader* itemHeader = headerTable->get(item);
                        itemHeader->nodes->push_back(child);
                        parent = child;
                    }
                }
            }
            return root;
        }
        
        ItemHeaderTable* FPGrowth::get_item_header_table(ItemSetList* p_frequents_1_itemsets)
        {
            ItemHeaderTable* headerTab = new ItemHeaderTable();
            for(auto beg = p_frequents_1_itemsets->begin(); beg != p_frequents_1_itemsets->end(); ++beg)
            {
                ItemHeader* header = new ItemHeader((*beg)[0], beg->support_count);
                headerTab->push_back(header);
            }
            return headerTab;
        }
        
        ItemSetList* FPGrowth::get_frequent_1_itemsets()
        {
            // get candidate 1 itemsets.
            ItemSetList* p_c_1_itemsets = new ItemSetList();
            for(Transaction& t : this->tranList)
            {
                for(string& s : t.getItemSet())
                {
                    ItemSet c_1_itemset(1);
                    c_1_itemset.add(s);
                    ItemSet* found_itemset = p_c_1_itemsets->find_equal_set(c_1_itemset);
                    if(found_itemset == nullptr)
                    {
                        c_1_itemset.support_count = 1;
                        p_c_1_itemsets->add(c_1_itemset);
                    } 

                    else
                    {
                        ++(found_itemset->support_count);
                    }
                }
            }
            
            // remove the itemsets of unreach threshold.
            vector<:iterator> toDels;
            for(auto begin = p_c_1_itemsets->begin(); begin != p_c_1_itemsets->end(); ++begin)
            {
                if(begin->support_count < this->min_sup)
                {
                    toDels.push_back(begin);
                }
            }
            for(auto iter : toDels)
            {
                p_c_1_itemsets->erase(iter);
            }
            return p_c_1_itemsets;
        }
    }
}/<treenode>/<treenode>/<vector>/<treenodeptrlist>/<treenodeptrlist>/<treenodeptrlist>/<treenodeptrlist>/<treenodeptrlist>/<vector>/<iostream>/<memory>/<code>

分享到:

閱讀更多 老李頭的小研究 的文章

關鍵字: 算法步步為營牆棋

商湯提出基於空間修剪的 NAS 算法

Learning To Rank 算法 RankNet

【算法】排序算法之基數排序

【算法】排序算法之桶排序

【算法】排序算法之計數排序

【算法】排序算法之堆排序

數據結構與算法：算法

【算法】位運算與經典八皇后問題

什麼是算力？算法？一文看懂算法學習拓撲圖

查找-hash 算法

爭取能讓大家都能看懂的 DFA 算法

視頻分析與對象跟蹤-CamShift 算法

史上最全GAN綜述2020版：算法、理論及應用

人工智能的靈魂——算法

Rust入坑指南：步步為營

阿里2020年內部PPT全棧分享：架構、大數據、算法

深入理解 React diff 算法

03.03 史上最全GAN綜述2020版：算法、理論及應用

圖像分割實戰-分水嶺分割方法和GrabCut 算法

03.02 分佈式系統ID的生成方法之UUID、數據庫、算法、Redis、Leaf方案

Python 算法 10 -- 廣度優先搜索（BFS）

一文讀懂 MD5 算法

Python 算法 09 -- 散列表

Python 算法 08 -- 快速排序

淺顯介紹“二進制枚舉”算法

分佈式系統ID的生成方法之UUID、數據庫、算法、Redis、Leaf方案

01.20 Python 算法 08 -- 冒泡排序及其優化

01.17 Python 算法 06 --“又愛又恨”的遞歸算法

01.16 Python 算法 05 -- 3+4*5-6=？在棧中的調用

Python 算法 01--二分查找

C++基礎知識-算法

palindrome(迴文)算法

12.07 面試又被問到一致性 Hash 算法？這樣回答秒殺面試官

算法--我的紅黑樹學習過程

用講故事的辦法幫你理解 SMO 算法

漫畫說什麼是 LRU 算法？

算法--平衡二叉樹AVL原理分析以及代碼實現

算法-二叉查找樹BST

10.12 CPK的“另類”算法

「分佈式」看完這個動畫秒懂 Raft 算法

貝葉斯個性化排序(BPR)算法

01.10 路徑規劃之 A* 算法

算法：時間複雜度+二分查找法(Java

算法：加權輪詢算法

算法：分治算法

06.29 「算法」如何判斷鏈表有環

06.19 算法——初級排序算法

第二章 IoC容器和Bean配置

bean是一個對象，它是由Spring

運算裡不得不說的python模塊—math

Help

Devops度量--DevOps 現狀快速檢查表

今天主要分享一個DevOps

SOP是什麼（解讀）

SOP不是單個的，是一個體系，雖然我們可以單獨地定義每一個SOP，但真正從企業管理來看，SOP不可能只是單個的，必然是一個整體和體系，也是企業不可或缺的。

還不知道交換機上如何配置DHCP，趕緊過來圍觀吧，一分鐘包你學會

隨著終端設備的越來越多，人工干預配置IP地址，不僅工作效率低，而且，還很容易導致IP衝突，影響正常的網絡訪問。到此已經完成了，DHCP服務的配置了，我們可以在終端驗證。

還在手動配置IP地址嗎？太Low了，一分鐘教會您如何配置DHCP

Python爬蟲自學筆記：分析頭條文章網頁源文件

這兩天分析了一下頭條文章網頁的源文件，現在將分析的結果分享給大家。首先以一篇文章為例，其網址如下：https://www.toutiao.com/i6822245428176617998/如上圖網頁所示，文章中包含文字和圖片。

DNS偵查工具

我們只需要打開瀏覽器輸入例如:www.baidu.com就可以解析到該網站.為了便於記住不需要輸入長長的IP地址去訪問這就是DNS域名解析.關於域名域名的層次劃分用點來分割這時DNS把相對應的域名解析成IP地址高的在右邊.例如:www. NS簡介訪問某網站的時候最低在左邊

國人開源的異步 Python ORM：GINO

程序測評：Create React App 3.3中有哪些酷炫新功能？

Create

“明學”的魅力？我只要我覺得：駕馭終端，提高生產力

最後一個要介紹的命令是

（必收藏系列）Linux面試題——命令集

關注，後臺私信【Linux】分享Linux入門到進階電子書、Linux入門到精通視頻教程（免費）。文件管理命令cat

五分鐘學會如何在 IPFS 上部署網站

原文標題:五分鐘學會如何在

「正點原子NANO STM32F103開發板資料連載」第29章內存管理實驗

1）實驗平臺：【正點原子】

小白怎麼學Web前端開發如何成為技術達人

Web前端開發工程師已經成為了很多年輕人心中的理想工作，不僅入行門檻低、而且薪資待遇和發展前景都不錯，自然吸引了大批人加入行業。

如何開發一個web靜態服務器

我們都知道如今的web服務器有很多，比如著名的有apache，有nginx，有tomcat，有resin服務器，有sphere，有iis服務器等等，這些服務器都能提供web服務，並且幾乎都能和多種語言進行搭配使用，那麼一個web服務器都需要那些功能，開發一個web服務器都需要那些

學Java編程還有前景嗎如何才能拿到高薪

需求大、薪資高似乎是Java開發人員的標籤，不過學Java編程還有前景嗎？它架構在操作系統之上，屏蔽了底層的差異，真正實現了“Writeonce run

Python網絡爬蟲之配置篇（一）

pip

SpringBoot 整合SpringSecurity示例實現前後分離權限註解+JWT登錄認證

serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertTo&useSSL=falseusername:rootpassword:

Python的運行效率太低？幾行代碼快速提升！

return的就是是你所需要的結果2.3、運行這一步就是最後一步了，只要像下面一樣輸入上述函數名，賦予參數值，點擊運行Run，就能得到你想要的結果arg1=5

python的優點是什麼？最新Python400集視頻（附教程）

2020，最新Python零基礎到精通資料教材，乾貨分享，新基礎Python教材，穩穩找到過萬工作，看這裡，這裡有你想要的所有資源哦，最強筆記，教你怎麼入門提升！獲取方式：私信小編“

MySQL中OOM故障應如何下手-愛可生

作者：孫祚龍愛可生南區分公司交付服務部成員，實習工程師。負責公司產品問題排查及日常運維工作。本文來源：原創投稿*愛可生開源社區出品，原創內容未經授權不得隨意使用，轉載請聯繫小編並註明來源。

像專家一樣使用 panic

|go

30種不同的編程語言怎麼寫“Hello, World”

printfn

percona QAN 介紹

一、背景QAN慢查詢日誌分析工具是PMM

面試官：你可以用純CSS判斷鼠標進入的方向嗎？

雖然沒什麼軟用，但是對付面試官應該是夠用了。感謝面試官提出的問題，讓我實現了這個功能，對CSS

網絡工程師職業生涯中，哪兩點是最重要的？

網絡工程師最重要的技能是紮實的基礎和非常開放的思維，微觀知識紮實、宏觀能力突出。項目經驗也會讓網絡工程師基礎更牢靠，網絡工程師是要實戰的，要避免紙上談兵，我認為對基礎理論的理解，比你清楚配置更重要。

交換機中相關術語代表什麼意思，有必要弄清楚

由淺入深瞭解以太坊 2.0：最常見問題和最全學習清單

有關以太坊2.0

【Linux簡單實用小命令001】CentOS 7、8的防火牆端口開放

yuminstall

吃透這些IPFS硬核知識點，日後搶頭礦隨時“彎道超車”

今天的你捉住IPFS機遇了嗎？我們都知道在Filecoin網絡中作為一名存儲礦工，信譽對於我們是非常重要的——信譽越高，爆塊幾率越大。那麼信譽系統現在怎麼樣了呢？

Hive分桶表

fieldsterminated

Spring中資源的加載原來是這麼一回事啊！

自己動手搭建郵件系統：怎樣讓Exchange Server 發出第一封郵件？

編輯Exchange

$【MySQL】RDS物理備份文件(.idb\.frm)恢復到MySQL自建數據庫$

【MySQL】RDS物理備份文件(.idb\.frm)恢復到MySQL自建數據庫

在阿里雲控制檯，我們能下載的文件是一個壓縮包，解壓之後，是.idb和.frm文件，你可能要問了，我可以直接把解壓好的問題件覆蓋到MySQL的data目錄下嗎？

NLP算法入門系列：隱含馬爾可夫鏈(HMM)模型的簡單介紹

即，最大化

第一章 Spring Framework概述

您可以在任何web

opencv人工智能深度學習這樣實現人臉的年齡檢測

前期的文章我們分享了人臉的識別以及如何進行人臉數據的訓練，本期文章我們結合人臉識別的模型進行人臉年齡的檢測人臉年齡的檢測步驟1、首先需要進行人臉的檢測2、把檢測到的人臉數據給年齡檢測模型去檢測3、把檢測結果呈現到圖片上人臉年齡檢測import

嵌入式linux網絡編程之——5年程序員給你深度講解socket套接字

圖8-1

深入瞭解ProcessFunction的狀態操作(Flink-1.10)

先反思為何會有上述疑惑上述疑惑產生的原因，應該是受到平時使用HashMap的影響，HashMap獲取值就是在調用get方法時指定key，設置值也是在put時指定key，所以看到state.value，看懂了這些，其實也是在瞭解DataStream/DataSetAPI的設計思路：

Redis內存分析工具--rdr安裝與使用

分析Redis

資深架構師教你源碼講解zookeeper實現分佈式鎖以及集群搭建步驟

//getData發現前一個子節點被刪除，拋出異常

一行代碼提升遷移性能

論文原址：https://arxiv.org/pdf/2003.12237.pdf開源地址：https://github.com/cuishuhao/BNM在發表在CVPR2020

利用相似幾何信息，做可泛化3D形狀分割模型

更具體的有以下三種典型的分割方案：FullyConvolutional-Like

這麼好用的開源計算器SpeedCrunch，沒有不嘗試一下的道理

介紹SpeedCrunch是一款高精度科學計算器，具有快速，鍵盤驅動的用戶界面。獲取方式在GitHub上搜索SpeedCrunch，就可以去到

分佈式緩存，真香

他是前易寶支付架構師、阿里雲MVP、騰訊雲

特徵工程的力量

在本文中，我希望教給您一些有關特徵工程的知識，以及如何使用它來對非線性決策邊界進行建模。為了說明這一點，假設恢復時間與身高和體重具有以下關係：Y=β₀+β₁+β2+β₃+noise從第三項來看，我們可以看到Y與身高和體重沒有線性關係。

java架構：天天寫面向接口編程，你考慮過性能嗎？大神都是這麼寫

public

SpringBoot如何優雅的使用RocketMQ

源碼編譯需要Maven3.2x，JDK8在根目錄進行打包:Copymvn-Prelease-all

css代碼規範工具stylelint

"mixin"